@xagent-ai/cli 1.2.2 → 1.3.1

package/src/session.ts

@@ -4,31 +4,59 @@ 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,
+} from './types.js';
+import type { 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';
-import { getAgentManager, DEFAULT_AGENTS, AgentManager } from './agents.js';
+import { getAgentManager, AgentManager } from './agents.js';
 import { getMemoryManager, MemoryManager } from './memory.js';
 import { getMCPManager, MCPManager } from './mcp.js';
 import { getCheckpointManager, CheckpointManager } from './checkpoint.js';
 import { getConversationManager, ConversationManager } from './conversation.js';
 import { getSessionManager, SessionManager } from './session-manager.js';
-import { SlashCommandHandler, parseInput, detectImageInput } from './slash-commands.js';
+import { SlashCommandHandler, parseInput } 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,
+} from './theme.js';
 import { getCancellationManager, CancellationManager } from './cancellation.js';
-import { getContextCompressor, ContextCompressor, CompressionResult } from './context-compressor.js';
-import { Logger, LogLevel, getLogger } from './logger.js';
+import {
+  getContextCompressor,
+  ContextCompressor,
+  CompressionResult,
+} from './context-compressor.js';
+import { getLogger } from './logger.js';
+import { ensureTtySane, setupEscKeyHandler } from './terminal.js';
+import { SdkOutputAdapter } from './sdk-output-adapter.js';
+
+// Type aliases for backward compatibility
+type AIClient = AIClientInterface;
+type RemoteAIClient = AIClientInterface;
 
 const logger = getLogger();
 
@@ -39,7 +67,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 +75,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;
@@ -56,142 +84,342 @@ export class InteractiveSession {
   private currentTaskId: string | null = null;
   private taskCompleted: boolean = false;
   private isFirstApiCall: boolean = true;
+  private sdkOutputAdapter: SdkOutputAdapter | null = null;
+  private isSdkMode: boolean = false;
+  private sdkInputBuffer: string[] = [];
+  private resolveInput: ((value: string | null) => void) | null = null;
+  private _currentRequestId: string | null = null;
+  private heartbeatTimeout: NodeJS.Timeout | null = null;
+  private heartbeatTimeoutMs: number = 300000; // 5 minutes timeout for long AI responses
+  private lastActivityTime: number = Date.now();
+
+  // SDK response handling for approvals and questions
+  private approvalPromises: Map<string, { resolve: (approved: boolean) => void; reject: (err: Error) => void }> = new Map();
+  private questionPromises: Map<string, { resolve: (answers: string[]) => void; reject: (err: Error) => void }> = new Map();
+
+  constructor(indentLevel: number = 0) {
+    this.rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+    });
 
-    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.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([]);
+    });
 
-      this.mcpManager = getMCPManager();
+    // Register MCP update callback, update system prompt
+    this.slashCommandHandler.setSystemPromptUpdateCallback(async () => {
+      await this.updateSystemPrompt();
+    });
 
-      this.checkpointManager = getCheckpointManager(process.cwd());
+    // Register config update callback, update aiClient config when /auth changes config
+    this.slashCommandHandler.setConfigUpdateCallback(() => {
+      this.updateAiClientConfig();
+    });
 
-      this.conversationManager = getConversationManager();
+    this.executionMode = ExecutionMode.DEFAULT;
 
-      this.sessionManager = getSessionManager(process.cwd());
+    this.cancellationManager = getCancellationManager();
 
-      this.slashCommandHandler = new SlashCommandHandler();
+    this.indentLevel = indentLevel;
 
-      // 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([]);
-      });
+    this.indentString = ' '.repeat(indentLevel);
 
-  
+    this.contextCompressor = getContextCompressor();
+  }
 
-      // Register MCP update callback, update system prompt
+  private getIndent(): string {
+    return this.indentString;
+  }
 
-      this.slashCommandHandler.setSystemPromptUpdateCallback(async () => {
+  setAIClient(aiClient: AIClient): void {
+    this.aiClient = aiClient;
+  }
 
-        await this.updateSystemPrompt();
+  /**
+   * 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);
+  }
 
-      this.executionMode = ExecutionMode.DEFAULT;
+  setExecutionMode(mode: ExecutionMode): void {
+    this.executionMode = mode;
+  }
 
-      this.cancellationManager = getCancellationManager();
+  /**
+   * Set SDK mode for programmatic access.
+   * In SDK mode, output is formatted as JSON to stdout.
+   */
+  setSdkMode(adapter: SdkOutputAdapter): void {
+    this.isSdkMode = true;
+    this.sdkOutputAdapter = adapter;
 
-      this.indentLevel = indentLevel;
+    // Initialize SDK mode for other modules using centralized output util
+    const { initOutputMode } = require('./output-util.js');
+    initOutputMode(true, adapter);
 
-      this.indentString = ' '.repeat(indentLevel);
+    // Initialize SmartApprovalEngine in SDK mode
+    this.initSmartApprovalSdkMode(adapter).catch(() => {
+      // Silently ignore errors - not critical
+    });
 
-      this.contextCompressor = getContextCompressor();
+    // Initialize tool registry in SDK mode (fire and forget, doesn't need to await)
+    this.initToolRegistrySdkMode(adapter).catch(() => {
+      // Silently ignore errors - tool registry init is not critical
+    });
+  }
 
-    }
+  /**
+   * Initialize SmartApprovalEngine in SDK mode.
+   */
+  private async initSmartApprovalSdkMode(adapter: SdkOutputAdapter): Promise<void> {
+    const { getSmartApprovalEngine } = await import('./smart-approval.js');
+    const approvalEngine = getSmartApprovalEngine();
+    approvalEngine.setSdkMode(true, adapter);
+  }
 
-  private getIndent(): string {
-    return this.indentString;
+  /**
+   * Initialize tool registry in SDK mode.
+   */
+  private async initToolRegistrySdkMode(adapter: SdkOutputAdapter): Promise<void> {
+    const toolRegistry = getToolRegistry();
+    await toolRegistry.setSdkMode(true, adapter);
   }
 
-  setAIClient(aiClient: AIClient): void {
-    this.aiClient = aiClient;
+  /**
+   * Get SDK mode status.
+   */
+  getIsSdkMode(): boolean {
+    return this.isSdkMode;
   }
 
-  setExecutionMode(mode: ExecutionMode): void {
-    this.executionMode = mode;
+  /**
+   * Output assistant response - handles SDK mode and normal mode differently.
+   */
+  private outputAssistant(content: string, reasoningContent?: string): void {
+    if (this.isSdkMode && this.sdkOutputAdapter) {
+      this.sdkOutputAdapter.outputAssistant(content, reasoningContent);
+    } else {
+      const indent = this.getIndent();
+      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('');
+      const renderedContent = renderMarkdown(
+        content,
+        (process.stdout.columns || 80) - indent.length * 2
+      );
+      console.log(`${indent}${renderedContent.replace(/^/gm, indent)}`);
+      console.log('');
+    }
   }
 
   /**
    * 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;
+
+    // Initialize with current state to avoid triggering update on first check
+    try {
+      const { existsSync, readFileSync } = require('fs');
+      if (existsSync(stateFilePath)) {
+        const content = readFileSync(stateFilePath, 'utf-8');
+        const state = JSON.parse(content);
+        lastUpdateTime = state.lastSkillUpdate || 0;
+      }
+    } catch {
+      // Silent fail
+    }
+
+    // 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();
+
+            if (!this.isSdkMode) {
+              console.log(colors.textMuted('  🔄 Skills updated from CLI'));
+            }
+          }
+        }
+      } catch {
+        // 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);
 
     // Initialize taskId for GUI operations
     this.currentTaskId = crypto.randomUUID();
 
-    const separator = icons.separator.repeat(60);
-    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(58) + colors.gradient('  ║'));
-    console.log(colors.gradient('╚════════════════════════════════════════════════════════════╝'));
-    console.log(colors.textMuted('  AI-powered command-line assistant'));
-    console.log('');
+    const _separator = icons.separator.repeat(60);
+
+    if (!this.isSdkMode) {
+      // Normal mode: show ASCII art welcome
+      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(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();
+
+    // SDK 模式初始化：设置输出适配器
+    if (this.isSdkMode) {
+      // Start heartbeat timeout monitoring in SDK mode
+      this.startHeartbeatMonitoring();
+    }
+
+    // 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 +432,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 +452,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 +473,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 +492,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 +521,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 +536,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();
@@ -343,25 +595,49 @@ export class InteractiveSession {
 
       const mcpServers = this.configManager.getMcpServers();
       Object.entries(mcpServers).forEach(([name, config]) => {
-        console.log(`📝 Registering MCP server: ${name} (${config.transport})`);
+        if (this.isSdkMode && this.sdkOutputAdapter) {
+          this.sdkOutputAdapter.outputMCPRegistering(name, config.transport || 'stdio');
+        } else {
+          console.log(`📝 Registering MCP server: ${name} (${config.transport})`);
+        }
         this.mcpManager.registerServer(name, config);
       });
 
       // 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)...`)}`);
+          const serverCount = Object.keys(mcpServers).length;
+          if (this.isSdkMode && this.sdkOutputAdapter) {
+            this.sdkOutputAdapter.outputMCPLoading(serverCount);
+          } else {
+            console.log(
+              `${colors.info(`${icons.brain} Connecting to ${serverCount} 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)`)}`);
+
+          if (this.isSdkMode && this.sdkOutputAdapter) {
+            this.sdkOutputAdapter.outputMCPConnected(serverCount, connectedCount, mcpTools.length);
+          } else {
+            console.log(
+              `${colors.success(`✓ ${connectedCount}/${serverCount} MCP server(s) connected (${mcpTools.length} tools available)`)}`
+            );
+          }
 
           // Register MCP tools with the tool registry (hide MCP origin from LLM)
           const toolRegistry = getToolRegistry();
           const allMcpTools = this.mcpManager.getAllTools();
           toolRegistry.registerMCPTools(allMcpTools);
         } catch (error: any) {
-          console.log(`${colors.warning(`⚠ MCP connection failed: ${error.message}`)}`);
+          if (this.isSdkMode && this.sdkOutputAdapter) {
+            this.sdkOutputAdapter.outputMCPConnectionFailed(error.message);
+          } else {
+            console.log(`${colors.warning(`⚠ MCP connection failed: ${error.message}`)}`);
+          }
         }
       }
 
@@ -375,9 +651,13 @@ 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'));
+      if (this.isSdkMode && this.sdkOutputAdapter) {
+        this.sdkOutputAdapter.outputSuccess('Initialization complete');
+      } else {
+        console.log(colors.success('✔ Initialization complete'));
+      }
     } catch (error: any) {
       const spinner = ora({ text: '', spinner: 'dots', color: 'red' }).start();
       spinner.fail(colors.error(`Initialization failed: ${error.message}`));
@@ -392,7 +672,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 +682,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 +708,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 };
@@ -439,7 +723,7 @@ export class InteractiveSession {
       } else {
         return null;
       }
-    } catch (error: any) {
+    } catch {
       return null;
     }
   }
@@ -454,11 +738,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,37 +760,118 @@ 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('');
+      if (this.isSdkMode && this.sdkOutputAdapter) {
+        this.sdkOutputAdapter.outputInfo('VLM configuration is optional. You can configure it later using the /model command if needed.');
+      } else {
+        console.log('');
+        console.log(colors.info(`${icons.info} VLM configuration is optional.`));
+        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 {
     const language = this.configManager.getLanguage();
     const separator = icons.separator.repeat(40);
 
-    console.log('');
-    console.log(colors.border(separator));
+    if (!this.isSdkMode) {
+      console.log('');
+      console.log(colors.border(separator));
 
-    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.primaryBright(`${icons.sparkles} Welcome to XAGENT CLI!`));
-      console.log(colors.textMuted('Type /help to see available commands'));
-    }
+      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.primaryBright(`${icons.sparkles} Welcome to XAGENT CLI!`));
+        console.log(colors.textMuted('Type /help to see available commands'));
+      }
 
-    console.log(colors.border(separator));
-    console.log('');
+      console.log(colors.border(separator));
+      console.log('');
+    }
 
     this.showExecutionMode();
+
+    // In SDK mode, output ready signal
+    if (this.isSdkMode && this.sdkOutputAdapter) {
+      this.sdkOutputAdapter.outputReady();
+    }
+  }
+
+  /**
+   * Start heartbeat timeout monitoring in SDK mode
+   */
+  private startHeartbeatMonitoring(): void {
+    this.stopHeartbeatMonitoring();
+
+    // Check heartbeat timeout periodically
+    this.heartbeatTimeout = setInterval(() => {
+      const elapsed = Date.now() - this.lastActivityTime;
+
+      if (elapsed > this.heartbeatTimeoutMs) {
+        // Heartbeat timeout - no activity for too long
+        this.sdkOutputAdapter?.output({
+          type: 'error',
+          subtype: 'heartbeat_timeout',
+          timestamp: Date.now(),
+          data: {
+            message: 'Heartbeat timeout - no activity detected',
+            elapsed_ms: elapsed,
+            timeout_ms: this.heartbeatTimeoutMs
+          }
+        });
+
+        // Stop monitoring
+        this.stopHeartbeatMonitoring();
+      }
+    }, 30000); // Check every 30 seconds
+  }
+
+  /**
+   * Stop heartbeat timeout monitoring
+   */
+  private stopHeartbeatMonitoring(): void {
+    if (this.heartbeatTimeout) {
+      clearInterval(this.heartbeatTimeout);
+      this.heartbeatTimeout = null;
+    }
+  }
+
+  /**
+   * Reset heartbeat timeout (called on activity)
+   */
+  private resetHeartbeatTimeout(): void {
+    this.lastActivityTime = Date.now();
+  }
+
+  /**
+   * Stop heartbeat monitoring (public method for cleanup)
+   * Used by SDK session to clean up when session ends
+   */
+  public stopHeartbeatMonitor(): void {
+    this.stopHeartbeatMonitoring();
   }
 
   private showExecutionMode(): void {
@@ -510,36 +879,75 @@ 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];
     const modeName = this.executionMode;
 
-    console.log(colors.textMuted(`${icons.info} Current Mode:`));
-    console.log(`  ${config.color(config.icon)} ${styleHelpers.text.bold(config.color(modeName))}`);
-    console.log(`  ${colors.textDim(`  ${config.description}`)}`);
+    if (!this.isSdkMode) {
+      console.log(colors.textMuted(`${icons.info} Current Mode:`));
+      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 (this.isSdkMode && this.sdkOutputAdapter) {
+      // SDK 模式：通过 adapter 输出
+      if (isRemote) {
+        const llmModel = authConfig.remote_llmModelName || 'Not set';
+        const vlmModel = authConfig.remote_vlmModelName || 'Not set';
+        this.sdkOutputAdapter.outputInfo(`Remote Models - LLM: ${llmModel}, VLM: ${vlmModel}`);
+      } else {
+        const modelName = authConfig.modelName || 'Not set';
+        const guiSubagentModel = this.configManager.get('guiSubagentModel') || 'Not set';
+        this.sdkOutputAdapter.outputInfo(`Local Models - LLM: ${modelName}, VLM: ${guiSubagentModel}`);
+      }
+      return;
+    }
+
+    // 正常模式：控制台输出
+    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('');
   }
 
@@ -549,21 +957,24 @@ export class InteractiveSession {
       return;
     }
 
+    // In SDK mode, use a different input loop
+    if (this.isSdkMode) {
+      await this.sdkPromptLoop();
+      return;
+    }
+
     // Recreate readline interface for input
     if (this.rl) {
       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('❯')} `;
@@ -583,28 +994,392 @@ export class InteractiveSession {
   }
 
   private async handleInput(input: string): Promise<void> {
+    // Reset heartbeat timeout on any input activity
+    this.resetHeartbeatTimeout();
+
     const trimmedInput = input.trim();
 
     if (!trimmedInput) {
       return;
     }
 
+    // Check for SDK JSON message format
+    if (this.isSdkMode) {
+      const { isSdkMessage, parseSdkMessage } = await import('./types.js');
+
+      if (isSdkMessage(trimmedInput)) {
+        const sdkMessage = parseSdkMessage(trimmedInput);
+
+        if (sdkMessage) {
+          if (sdkMessage.type === 'ping') {
+            // Handle ping - respond with pong
+            await this.handlePing(sdkMessage);
+            return;
+          } else if (sdkMessage.type === 'control_request') {
+            // Handle control request
+            await this.handleControlRequest(sdkMessage);
+            return;
+          } else if (sdkMessage.type === 'user') {
+            // Store request_id for tracking
+            this._currentRequestId = sdkMessage.request_id || null;
+            // Handle user message from SDK
+            await this.processUserMessage(sdkMessage.content);
+            return;
+          } else if (sdkMessage.type === 'approval_response') {
+            // Handle approval response
+            await this.handleApprovalResponse(sdkMessage);
+            return;
+          } else if (sdkMessage.type === 'question_response') {
+            // Handle question response
+            await this.handleQuestionResponse(sdkMessage);
+            return;
+          }
+        }
+      } else {
+        // Not a JSON SDK message, treat as regular text
+        await this.processUserMessage(trimmedInput);
+        return;
+      }
+    }
+
     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);
       }
       return;
     }
 
-    if (trimmedInput.startsWith('$')) {
-      await this.handleSubAgentCommand(trimmedInput);
-      return;
+    if (trimmedInput.startsWith('$')) {
+      await this.handleSubAgentCommand(trimmedInput);
+      return;
+    }
+
+    await this.processUserMessage(trimmedInput);
+  }
+
+  /**
+   * SDK prompt loop - reads input from stdin without showing prompt
+   */
+  private async sdkPromptLoop(): Promise<void> {
+    // Read input from stdin directly without outputting prompt
+    const input = await this.readSdkInput();
+
+    if ((this as any)._isShuttingDown || input === null) {
+      return;
+    }
+
+    try {
+      await this.handleInput(input);
+    } catch (err: any) {
+      this.sdkOutputAdapter?.output({
+        type: 'error',
+        subtype: 'general',
+        timestamp: Date.now(),
+        data: { message: err.message }
+      });
+    }
+
+    // Continue the loop
+    this.sdkPromptLoop();
+  }
+
+  private sdkRl: readline.Interface | null = null;
+  private sdkInputProcessing: boolean = false;
+
+  /**
+   * Check if a line is an SDK control message (approval_response, question_response)
+   */
+  private isSdkControlMessage(line: string): boolean {
+    try {
+      const parsed = JSON.parse(line);
+      return parsed.type === 'approval_response' || parsed.type === 'question_response';
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Process an SDK input line (returns true if processed)
+   */
+  private async processSdkInputLine(line: string): Promise<boolean> {
+    const { isSdkMessage, parseSdkMessage } = await import('./types.js');
+
+    if (isSdkMessage(line)) {
+      const sdkMessage = parseSdkMessage(line);
+
+      if (sdkMessage) {
+        if (sdkMessage.type === 'ping') {
+          await this.handlePing(sdkMessage);
+          return true;
+        } else if (sdkMessage.type === 'control_request') {
+          await this.handleControlRequest(sdkMessage);
+          return true;
+        } else if (sdkMessage.type === 'user') {
+          this._currentRequestId = sdkMessage.request_id || null;
+          await this.processUserMessage(sdkMessage.content);
+          return true;
+        } else if (sdkMessage.type === 'approval_response') {
+          await this.handleApprovalResponse(sdkMessage);
+          return true;
+        } else if (sdkMessage.type === 'question_response') {
+          await this.handleQuestionResponse(sdkMessage);
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+
+  /**
+   * Read a line of input from stdin (SDK mode)
+   * Uses readline 'line' event for reliable stdin reading
+   * SDK control messages (approval_response, question_response) bypass the main loop
+   */
+  private readSdkInput(): Promise<string | null> {
+    return new Promise((resolve) => {
+      // Create readline interface if not exists
+      if (!this.sdkRl) {
+        this.sdkRl = readline.createInterface({
+          input: process.stdin,
+          crlfDelay: Infinity,
+        });
+
+        // Handle line events - SDK control messages bypass normal flow
+        this.sdkRl.on('line', async (line) => {
+          const cleanLine = line
+            .replace(/^\uFEFF/, '')
+            // eslint-disable-next-line no-control-regex
+            .replace(/[\x00-\x1F\x7F-\x9F]/g, '');
+
+          // Check if this is an SDK control message
+          if (this.isSdkControlMessage(cleanLine)) {
+            // Process immediately, don't wait for main loop
+            // We need to set a flag to prevent re-entrancy issues
+            if (this.sdkInputProcessing) {
+              // Already processing, queue it
+              this.sdkInputBuffer.push(cleanLine);
+            } else {
+              this.sdkInputProcessing = true;
+              try {
+                await this.processSdkInputLine(cleanLine);
+              } finally {
+                this.sdkInputProcessing = false;
+              }
+            }
+            return;
+          }
+
+          // Regular input
+          if (this.resolveInput) {
+            // Immediate handler available, resolve immediately
+            this.resolveInput(cleanLine);
+            this.resolveInput = null;
+          } else {
+            // No handler available, queue the message
+            this.sdkInputBuffer.push(cleanLine);
+          }
+        });
+
+        // Handle close events
+        this.sdkRl.on('close', () => {
+          if (this.resolveInput) {
+            this.resolveInput(null);
+            this.resolveInput = null;
+          }
+        });
+
+        // Handle errors
+        this.sdkRl.on('error', () => {
+          if (this.resolveInput) {
+            this.resolveInput(null);
+            this.resolveInput = null;
+          }
+        });
+      }
+
+      // Check for SDK control messages in buffer first
+      for (let i = 0; i < this.sdkInputBuffer.length; i++) {
+        const line = this.sdkInputBuffer[i];
+        if (this.isSdkControlMessage(line)) {
+          this.sdkInputBuffer.splice(i, 1);
+          resolve(line);
+          return;
+        }
+      }
+
+      if (this.sdkInputBuffer.length > 0) {
+        const line = this.sdkInputBuffer.shift()!;
+        resolve(line);
+        return;
+      }
+
+      // Set up the resolve callback
+      this.resolveInput = (value: string | null) => {
+        resolve(value);
+      };
+    });
+  }
+
+  /**
+   * Handle SDK ping messages (heartbeat)
+   */
+  private async handlePing(pingMessage: any): Promise<void> {
+    const requestId = pingMessage.request_id || `ping_${Date.now()}`;
+
+    // Reset activity timestamp on ping (heartbeat activity)
+    this.lastActivityTime = Date.now();
+
+    // Send pong response through SDK adapter for consistency
+    this.sdkOutputAdapter?.output({
+      type: 'system',
+      subtype: 'pong',
+      timestamp: Date.now(),
+      data: {
+        type: 'pong',
+        request_id: requestId,
+        timestamp: Date.now()
+      }
+    });
+  }
+
+  /**
+   * Handle SDK control requests
+   */
+  private async handleControlRequest(request: any): Promise<void> {
+    // Update activity to prevent heartbeat timeout during control requests
+    this.lastActivityTime = Date.now();
+
+    const { request_id, request: req } = request;
+
+    switch (req.subtype) {
+      case 'interrupt':
+        this.sdkOutputAdapter?.outputSystem('interrupt', { request_id });
+        (this as any)._isShuttingDown = true;
+        process.exit(0);
+        break;
+
+      case 'set_permission_mode':
+        {
+          const { ExecutionMode } = await import('./types.js');
+          const modeMap: Record<string, ExecutionMode> = {
+            'default': ExecutionMode.DEFAULT,
+            'acceptEdits': ExecutionMode.ACCEPT_EDITS,
+            'plan': ExecutionMode.PLAN,
+            'bypassPermissions': ExecutionMode.YOLO,
+          };
+          const mode = modeMap[req.mode] || ExecutionMode.SMART;
+          this.executionMode = mode;
+          this.sdkOutputAdapter?.outputSystem('permission_mode_changed', {
+            request_id,
+            mode: req.mode
+          });
+        }
+        break;
+
+      case 'set_model':
+        this.sdkOutputAdapter?.outputSystem('model_changed', {
+          request_id,
+          model: req.model
+        });
+        break;
+
+      default:
+        this.sdkOutputAdapter?.outputWarning(`Unknown control request: ${req.subtype}`);
+    }
+  }
+
+  /**
+   * Handle SDK approval responses
+   */
+  private async handleApprovalResponse(response: {
+    request_id: string;
+    approved: boolean;
+  }): Promise<void> {
+    const { request_id, approved } = response;
+
+    const pending = this.approvalPromises.get(request_id);
+    if (pending) {
+      pending.resolve(approved);
+      this.approvalPromises.delete(request_id);
+    } else {
+      this.sdkOutputAdapter?.outputWarning(`Unknown approval request ID: ${request_id}`);
+    }
+  }
+
+  /**
+   * Handle SDK question responses
+   */
+  private async handleQuestionResponse(response: {
+    request_id: string;
+    answers: string[];
+  }): Promise<void> {
+    const { request_id, answers } = response;
+
+    const pending = this.questionPromises.get(request_id);
+    if (pending) {
+      pending.resolve(answers);
+      this.questionPromises.delete(request_id);
+    } else {
+      this.sdkOutputAdapter?.outputWarning(`Unknown question request ID: ${request_id}`);
     }
+  }
 
-    await this.processUserMessage(trimmedInput);
+  /**
+   * Wait for SDK approval response
+   */
+  async waitForApprovalResponse(requestId: string, timeoutMs: number = 300000): Promise<boolean> {
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        const pending = this.approvalPromises.get(requestId);
+        if (pending) {
+          pending.reject(new Error('Approval request timeout'));
+          this.approvalPromises.delete(requestId);
+        }
+        resolve(false);
+      }, timeoutMs);
+
+      this.approvalPromises.set(requestId, {
+        resolve: (approved: boolean) => {
+          clearTimeout(timeout);
+          resolve(approved);
+        },
+        reject: (err: Error) => {
+          clearTimeout(timeout);
+          reject(err);
+        }
+      });
+    });
+  }
+
+  /**
+   * Wait for SDK question response
+   */
+  async waitForQuestionResponse(requestId: string, timeoutMs: number = 300000): Promise<string[]> {
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        const pending = this.questionPromises.get(requestId);
+        if (pending) {
+          pending.reject(new Error('Question request timeout'));
+          this.questionPromises.delete(requestId);
+        }
+        resolve([]);  // Return empty array on timeout instead of rejecting
+      }, timeoutMs);
+
+      this.questionPromises.set(requestId, {
+        resolve: (answers: string[]) => {
+          clearTimeout(timeout);
+          resolve(answers);
+        },
+        reject: (err: Error) => {
+          clearTimeout(timeout);
+          reject(err);
+        }
+      });
+    });
   }
 
   private async handleSubAgentCommand(input: string): Promise<void> {
@@ -622,7 +1397,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 +1407,11 @@ export class InteractiveSession {
     await this.processUserMessage(task, agent);
   }
 
-  public async processUserMessage(message: string, agent?: any): 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');
+  public async processUserMessage(message: string, _agent?: AgentConfig): Promise<void> {
+    const inputs = await 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');
 
     if (commandInput) {
       await this.executeShellCommand(commandInput.content);
@@ -647,10 +1424,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 +1443,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 +1460,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 +1486,15 @@ 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);
+    // SDK 模式：使用 adapter 输出
+    if (this.isSdkMode && this.sdkOutputAdapter) {
+      this.sdkOutputAdapter.outputThinking(reasoningContent, displayMode);
+      return;
+    }
+
+    const separator = icons.separator.repeat(
+      Math.min(60, process.stdout.columns || 80) - indent.length
+    );
 
     console.log('');
     console.log(`${indent}${colors.border(separator)}`);
@@ -722,23 +1507,27 @@ export class InteractiveSession {
         console.log(`${indent}${colors.textDim(reasoningContent.replace(/^/gm, indent))}`);
         break;
 
-      case 'compact':
+      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('');
         console.log(`${indent}${colors.textDim(truncatedContent.replace(/^/gm, indent))}`);
         console.log(`${indent}${colors.textDim(`[${reasoningContent.length} chars total]`)}`);
         break;
+      }
 
       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 +1543,131 @@ 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();
+    if (!needsCompression) {
+      return;
+    }
+
+    // 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 (this.isSdkMode && this.sdkOutputAdapter) {
+      this.sdkOutputAdapter.outputContextCompressionTriggered(reason);
+    } else {
       console.log('');
-      console.log(`${indent}${colors.warning(`${icons.brain} Context compression triggered: ${reason}`)}`);
+      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)...`)}`
+      );
+    }
 
-      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
+    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
+    );
+
+    if (result.wasCompressed) {
+      this.conversation = result.compressedMessages;
+      const reductionPercent = Math.round((1 - result.compressedSize / result.originalSize) * 100);
+
+      if (this.isSdkMode && this.sdkOutputAdapter) {
+        this.sdkOutputAdapter.outputContextCompressionResult(
+          result.originalSize,
+          result.compressedSize,
+          reductionPercent,
+          result.originalMessageCount,
+          result.compressedMessageCount
+        );
+      } else {
+        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 (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)`)}`);
+      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,
+          };
+        }
+      }
 
-        // 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;
+      if (summaryMessage && summaryMessage.content) {
+        const maxPreviewLength = 800;
+        let summaryContent = summaryMessage.content;
+        const isTruncated = summaryContent.length > maxPreviewLength;
 
-          if (isTruncated) {
-            summaryContent = summaryContent.substring(0, maxPreviewLength) + '\n...';
-          }
+        if (isTruncated) {
+          summaryContent = summaryContent.substring(0, maxPreviewLength) + '\n...';
+        }
 
+        if (this.isSdkMode && this.sdkOutputAdapter) {
+          this.sdkOutputAdapter.outputContextCompressionSummary(
+            'Conversation compressed successfully',
+            summaryContent,
+            isTruncated,
+            summaryMessage.content.length
+          );
+        } else {
           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}${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)}`);
+          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.textMuted(`(... ${summaryMessage.content.length - maxPreviewLength} more chars hidden)`)}`
+            );
           }
           console.log(`${indent}${colors.border(separator)}`);
         }
-
-        // Restore user messages after compression, ensuring user message exists for API calls
-        if (lastUserMessage) {
-          this.conversation.push(lastUserMessage);
-        }
-
-        // Sync compressed conversation history to slashCommandHandler
-        this.slashCommandHandler.setConversationHistory(this.conversation);
       }
+
+      // Sync compressed conversation history to slashCommandHandler
+      this.slashCommandHandler.setConversationHistory(this.conversation);
     }
   }
 
@@ -826,7 +1676,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 +1698,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 +1717,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}`)}`);
@@ -892,12 +1744,24 @@ export class InteractiveSession {
   /**
    * Create remote mode LLM caller
    */
-  private createRemoteCaller(taskId: string, status: 'begin' | 'continue') {
+  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 +1771,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';
 
-    // Use custom AI client if provided, otherwise use default logic
-    let chatCompletion: (messages: ChatMessage[], options: any) => Promise<any>;
-    let isRemote = false;
+    // isFirstApiCall is reset in generateRemoteResponse for new tasks
+    // For continuation calls (existingTaskId provided), keep previous value
 
-    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;
     }
@@ -947,17 +1804,25 @@ export class InteractiveSession {
     // Mark that an operation is in progress
     (this as any)._isOperationInProgress = true;
 
-    const indent = this.getIndent();
     const thinkingText = colors.textMuted(`Thinking... (Press ESC to cancel)`);
     const icon = colors.primary(icons.brain);
     const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
     let frameIndex = 0;
 
+    // SDK 模式下不显示 spinner
+    const showThinkingSpinner = !this.isSdkMode;
+    let spinnerInterval: NodeJS.Timeout | null = null;
+
     // Custom spinner: only icon rotates, text stays static
-    const spinnerInterval = setInterval(() => {
-      process.stdout.write(`\r${colors.primary(frames[frameIndex])} ${icon} ${thinkingText}`);
-      frameIndex = (frameIndex + 1) % frames.length;
-    }, 120);
+    if (showThinkingSpinner) {
+      spinnerInterval = setInterval(() => {
+        process.stdout.write(`\r${colors.primary(frames[frameIndex])} ${icon} ${thinkingText}`);
+        frameIndex = (frameIndex + 1) % frames.length;
+      }, 120);
+    }
+
+    let content = '';
+    let reasoningContent = '';
 
     try {
       const memory = await this.memoryManager.loadMemory();
@@ -971,17 +1836,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 +1865,8 @@ export class InteractiveSession {
         chatCompletion(messages, {
           tools: availableTools,
           toolChoice: availableTools.length > 0 ? 'auto' : 'none',
-          thinkingTokens
+          thinkingTokens,
+          isFirstApiCall: this.isFirstApiCall,
         }),
         operationId
       );
@@ -997,34 +1874,27 @@ export class InteractiveSession {
       // Mark that first API call is complete
       this.isFirstApiCall = false;
 
-      clearInterval(spinnerInterval);
+      if (spinnerInterval) clearInterval(spinnerInterval);
       process.stdout.write('\r' + ' '.repeat(process.stdout.columns || 80) + '\r'); // Clear spinner line
 
       const assistantMessage = response.choices[0].message;
 
-      const content = typeof assistantMessage.content === 'string'
-        ? assistantMessage.content
-        : '';
-      const reasoningContent = assistantMessage.reasoning_content || '';
+      content = typeof assistantMessage.content === 'string' ? assistantMessage.content : '';
+      reasoningContent = assistantMessage.reasoning_content || '';
       // Display reasoning content if available and thinking mode is enabled
       if (reasoningContent && this.configManager.getThinkingConfig().enabled) {
         this.displayThinkingContent(reasoningContent);
       }
 
-      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('');
-      const renderedContent = renderMarkdown(content, (process.stdout.columns || 80) - indent.length * 2);
-      console.log(`${indent}${renderedContent.replace(/^/gm, indent)}`);
-      console.log('');
+      // Output assistant response
+      this.outputAssistant(content, reasoningContent);
 
       this.conversation.push({
         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,43 +1902,63 @@ 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]
         );
       }
 
+      // Signal request completion to SDK (no tools to execute)
+      if (this.isSdkMode && this.sdkOutputAdapter && this._currentRequestId) {
+        this.sdkOutputAdapter.outputRequestDone(this._currentRequestId, 'success');
+        this._currentRequestId = null;
+      }
+
       // Operation completed successfully, clear the flag
       (this as any)._isOperationInProgress = false;
     } catch (error: any) {
-      clearInterval(spinnerInterval);
+      if (spinnerInterval) clearInterval(spinnerInterval);
       process.stdout.write('\r' + ' '.repeat(process.stdout.columns || 80) + '\r');
 
       // Clear the operation flag
       (this as any)._isOperationInProgress = false;
 
+      // Signal request completion to SDK
+      if (this.isSdkMode && this.sdkOutputAdapter && this._currentRequestId) {
+        const status = error.message === 'Operation cancelled by user' ? 'cancelled' : 'error';
+        this.sdkOutputAdapter.outputRequestDone(this._currentRequestId, status);
+        this._currentRequestId = null;
+      }
+
       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 +1972,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 +1998,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 +2027,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');
+        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 +2057,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 +2077,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 +2093,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;
 
@@ -1198,7 +2111,7 @@ export class InteractiveSession {
       let parsedParams: any;
       try {
         parsedParams = typeof params === 'string' ? JSON.parse(params) : params;
-      } catch (e) {
+      } catch {
         parsedParams = params;
       }
 
@@ -1207,232 +2120,302 @@ export class InteractiveSession {
 
     // Display all tool calls info
     for (const { name, params } of preparedToolCalls) {
-      if (showToolDetails) {
-        console.log('');
-        console.log(`${indent}${colors.warning(`${icons.tool} Tool Call: ${name}`)}`);
-        console.log(`${indent}${colors.textDim(JSON.stringify(params, null, 2))}`);
+      // SDK mode: use adapter output
+      if (this.isSdkMode && this.sdkOutputAdapter) {
+        this.sdkOutputAdapter.outputToolStart(name, params);
       } else {
-        const toolDescription = this.getToolDescription(name, params);
-        console.log(`${indent}${colors.textMuted(`${icons.loading} ${toolDescription}`)}`);
+        // Normal mode: console output
+        if (showToolDetails) {
+          console.log('');
+          console.log(`${indent}${colors.warning(`${icons.tool} Tool Call: ${name}`)}`);
+          console.log(`${indent}${colors.textDim(JSON.stringify(params, null, 2))}`);
+        } else {
+          const toolDescription = this.getToolDescription(name, params);
+          console.log(`${indent}${colors.textMuted(`${icons.loading} ${toolDescription}`)}`);
+        }
       }
     }
 
     // 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;
         }
 
-        hasError = true;
+        _hasError = true;
 
-        console.log('');
-        console.log(`${indent}${colors.error(`${icons.cross} Tool Error: ${tool} - ${error}`)}`);
+        // SDK mode: use adapter output
+        if (this.isSdkMode && this.sdkOutputAdapter) {
+          this.sdkOutputAdapter.outputToolError(tool, error);
+        } else {
+          // Normal mode: console output
+          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 {
+        // SDK mode: output tool result via adapter
+        if (this.isSdkMode && this.sdkOutputAdapter) {
+          this.sdkOutputAdapter.outputToolResult(tool, result);
+        }
+
         // Use correct indent for gui-subagent tasks
         const isGuiSubagent = tool === 'task' && params?.subagent_type === 'gui-subagent';
         const displayIndent = isGuiSubagent ? indent + '  ' : indent;
 
-        // Always show details for todo tools so users can see their task lists
-        const isTodoTool = tool === 'todo_write' || tool === 'todo_read';
+        // Normal mode: console output (SDK mode already output via adapter above)
+        if (!this.isSdkMode || !this.sdkOutputAdapter) {
+          // Always show details for todo tools so users can see their task lists
+          const isTodoTool = tool === 'todo_write' || tool === 'todo_read';
 
-        // Special handling for edit tool with diff
-        const isEditTool = tool === 'Edit';
-        const hasDiff = isEditTool && result?.diff;
+          // Special handling for edit tool with diff
+          const isEditTool = tool === 'Edit';
+          const hasDiff = isEditTool && result?.diff;
 
-        // Special handling for Write tool with file preview
-        const isWriteTool = tool === 'Write';
-        const hasFilePreview = isWriteTool && result?.preview;
+          // Special handling for Write tool with file preview
+          const isWriteTool = tool === 'Write';
+          const hasFilePreview = isWriteTool && result?.preview;
 
-        // Special handling for DeleteFile tool
-        const isDeleteTool = tool === 'DeleteFile';
-        const hasDeleteInfo = isDeleteTool && result?.filePath;
+          // Special handling for DeleteFile tool
+          const isDeleteTool = tool === 'DeleteFile';
+          const hasDeleteInfo = isDeleteTool && result?.filePath;
 
-        // Special handling for task tool (subagent)
-        const isTaskTool = tool === 'task' && params?.subagent_type;
+          // Special handling for task tool (subagent)
+          const isTaskTool = tool === 'task' && params?.subagent_type;
 
-        // Check if tool is an MCP wrapper tool by looking up in tool registry
-        const { getToolRegistry } = await import('./tools.js');
-        const toolRegistry = getToolRegistry();
-        const toolDef = toolRegistry.get(tool);
-        const isMcpTool = toolDef && (toolDef as any)._isMcpTool === true;
-
-        if (isTodoTool) {
-          console.log('');
-          console.log(`${displayIndent}${colors.success(`${icons.check} Todo List:`)}`);
-          console.log(this.renderTodoList(result?.todos || [], displayIndent));
-          // Show summary if available
-          if (result?.message) {
-            console.log(`${displayIndent}${colors.textDim(result.message)}`);
-          }
-        } else if (hasDiff) {
-          // Show edit result with diff
-          console.log('');
-          const diffOutput = renderDiff(result.diff);
-          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
-          console.log('');
-          console.log(`${displayIndent}${colors.success(`${icons.file} ${result.filePath}`)}`);
-          console.log(`${displayIndent}${colors.textDim(`  ${result.lineCount} lines`)}`);
-          console.log('');
-          console.log(renderLines(result.preview, { maxLines: 10, indent: displayIndent + '  ' }));
-        } else if (hasDeleteInfo) {
-          // Show DeleteFile result
-          console.log('');
-          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');
-
-          if (result?.success) {
-            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.textDim(`  Task: ${subagentName}`)}`);
-          } else {
-            console.log(`${displayIndent}${colors.error(`${icons.cross} ${subagentType}: Failed`)}`);
-            console.log(`${displayIndent}${colors.textDim(`  Task: ${subagentName}`)}`);
+          // Check if tool is an MCP wrapper tool by looking up in tool registry
+          const { getToolRegistry } = await import('./tools.js');
+          const toolRegistry = getToolRegistry();
+          const toolDef = toolRegistry.get(tool);
+          const isMcpTool = toolDef && (toolDef as any)._isMcpTool === true;
+
+          if (isTodoTool) {
+            console.log('');
+            console.log(`${displayIndent}${colors.success(`${icons.check} Todo List:`)}`);
+            console.log(this.renderTodoList(result?.todos || [], displayIndent));
+            // Show summary if available
             if (result?.message) {
-              console.log(`${displayIndent}${colors.textDim(`  ${result.message}`)}`);
+              console.log(`${displayIndent}${colors.textDim(result.message)}`);
+            }
+          } else if (hasDiff) {
+            // Show edit result with diff
+            console.log('');
+            const diffOutput = renderDiff(result.diff);
+            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
+            console.log('');
+            console.log(`${displayIndent}${colors.success(`${icons.file} ${result.filePath}`)}`);
+            console.log(`${displayIndent}${colors.textDim(`  ${result.lineCount} lines`)}`);
+            console.log('');
+            console.log(renderLines(result.preview, { maxLines: 10, indent: displayIndent + '  ' }));
+          } else if (hasDeleteInfo) {
+            // Show DeleteFile result
+            console.log('');
+            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');
+
+            if (result?.success) {
+              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.textDim(`  Task: ${subagentName}`)}`);
+            } else {
+              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}`)}`);
+              }
+            }
+          } else if (isMcpTool) {
+            // Special handling for MCP tools - show friendly summary
+            console.log('');
+            // Extract server name and tool name from tool name (format: serverName__toolName)
+            let serverName = 'MCP';
+            let toolDisplayName = tool;
+            if (tool.includes('__')) {
+              const parts = tool.split('__');
+              serverName = parts[0];
+              toolDisplayName = parts.slice(1).join('__');
             }
-          }
-        } else if (isMcpTool) {
-          // Special handling for MCP tools - show friendly summary
-          console.log('');
-          // Extract server name and tool name from tool name (format: serverName__toolName)
-          let serverName = 'MCP';
-          let toolDisplayName = tool;
-          if (tool.includes('__')) {
-            const parts = tool.split('__');
-            serverName = parts[0];
-            toolDisplayName = parts.slice(1).join('__');
-          }
 
-          // Try to extract meaningful content from MCP result
-          let summary = '';
-          if (result?.content && Array.isArray(result.content) && result.content.length > 0) {
-            const firstBlock = result.content[0];
-            if (firstBlock?.type === 'text' && firstBlock?.text) {
-              const text = firstBlock.text;
-              if (typeof text === 'string') {
-                // Detect HTML content
-                if (text.trim().startsWith('<!DOCTYPE') || text.trim().startsWith('<html')) {
-                  summary = '[HTML content fetched]';
-                } else {
-                  // Try to parse if it's JSON
-                  try {
-                    const parsed = JSON.parse(text);
-                    if (Array.isArray(parsed) && parsed.length > 0 && parsed[0]?.title) {
-                      // Search results format
-                      summary = `Found ${parsed.length} result(s)`;
-                    } else if (parsed?.message) {
-                      summary = parsed.message;
-                    } else if (typeof parsed === 'string') {
-                      summary = parsed.substring(0, 100);
+            // Try to extract meaningful content from MCP result
+            let summary = '';
+            if (result?.content && Array.isArray(result.content) && result.content.length > 0) {
+              const firstBlock = result.content[0];
+              if (firstBlock?.type === 'text' && firstBlock?.text) {
+                const text = firstBlock.text;
+                if (typeof text === 'string') {
+                  // Detect HTML content
+                  if (text.trim().startsWith('<!DOCTYPE') || text.trim().startsWith('<html')) {
+                    summary = '[HTML content fetched]';
+                  } else {
+                    // Try to parse if it's JSON
+                    try {
+                      const parsed = JSON.parse(text);
+                      if (Array.isArray(parsed) && parsed.length > 0 && parsed[0]?.title) {
+                        // Search results format
+                        summary = `Found ${parsed.length} result(s)`;
+                      } else if (parsed?.message) {
+                        summary = parsed.message;
+                      } else if (typeof parsed === 'string') {
+                        summary = parsed.substring(0, 100);
+                      }
+                    } catch {
+                      // Not JSON, use as-is with truncation
+                      summary = text.substring(0, 100);
                     }
-                  } catch {
-                    // Not JSON, use as-is with truncation
-                    summary = text.substring(0, 100);
                   }
                 }
               }
+            } else if (result?.message) {
+              summary = result.message;
             }
-          } else if (result?.message) {
-            summary = result.message;
-          }
 
-          if (result?.success !== false) {
-            console.log(`${displayIndent}${colors.success(`${icons.check} ${serverName}: Success`)}`);
-            console.log(`${displayIndent}${colors.textDim(`  Tool: ${toolDisplayName}`)}`);
-            if (summary) {
-              console.log(`${displayIndent}${colors.textDim(`  ${summary}`)}`);
-            }
-          } else {
-            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}`)}`);
+            if (result?.success !== false) {
+              console.log(
+                `${displayIndent}${colors.success(`${icons.check} ${serverName}: Success`)}`
+              );
+              console.log(`${displayIndent}${colors.textDim(`  Tool: ${toolDisplayName}`)}`);
+              if (summary) {
+                console.log(`${displayIndent}${colors.textDim(`  ${summary}`)}`);
+              }
+            } else {
+              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}`)}`
+                );
+              }
             }
-          }
-        } else if (tool === 'InvokeSkill') {
-          // Special handling for InvokeSkill - show friendly summary
-          console.log('');
-          const skillName = params?.skillId || 'Unknown skill';
-          const taskDesc = params?.taskDescription || '';
-
-          if (result?.success) {
-            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;
-              console.log(`${displayIndent}${colors.textDim(`  Task: ${truncatedTask}`)}`);
+          } else if (tool === 'InvokeSkill') {
+            // Special handling for InvokeSkill - show friendly summary
+            console.log('');
+            const skillName = params?.skillId || 'Unknown skill';
+            const taskDesc = params?.taskDescription || '';
+
+            if (result?.success) {
+              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;
+                console.log(`${displayIndent}${colors.textDim(`  Task: ${truncatedTask}`)}`);
+              }
+            } else {
+              console.log(`${displayIndent}${colors.error(`${icons.cross} Skill: Failed`)}`);
+              console.log(`${displayIndent}${colors.textDim(`  Skill: ${skillName}`)}`);
+              if (result?.message) {
+                console.log(`${displayIndent}${colors.textDim(`  ${result.message}`)}`);
+              }
             }
+          } else if (showToolDetails) {
+            console.log('');
+            console.log(`${displayIndent}${colors.success(`${icons.check} Tool Result:`)}`);
+            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'}`)}`
+            );
+          } 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;
+            // Indent the preview
+            const indentedPreview = truncatedPreview
+              .split('\n')
+              .map((line) => `${displayIndent}  ${line}`)
+              .join('\n');
+            console.log(`${indentedPreview}`);
           } else {
-            console.log(`${displayIndent}${colors.error(`${icons.cross} Skill: Failed`)}`);
-            console.log(`${displayIndent}${colors.textDim(`  Skill: ${skillName}`)}`);
-            if (result?.message) {
-              console.log(`${displayIndent}${colors.textDim(`  ${result.message}`)}`);
-            }
+            console.log(`${displayIndent}${colors.textDim('(no result)')}`);
           }
-        } else if (showToolDetails) {
-          console.log('');
-          console.log(`${displayIndent}${colors.success(`${icons.check} Tool Result:`)}`);
-          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'}`)}`);
-        } 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;
-          // Indent the preview
-          const indentedPreview = truncatedPreview.split('\n').map(line => `${displayIndent}  ${line}`).join('\n');
-          console.log(`${indentedPreview}`);
-        } else {
-          console.log(`${displayIndent}${colors.textDim('(no result)')}`);
         }
 
         const toolCallRecord: ToolCall = {
           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 +2424,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 +2572,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 +2618,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 +2653,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 +2702,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 +2914,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 {
+    // Silently ignore update check failures
+  }
+
   await session.start();
 }