@xagent-ai/cli 1.3.0 → 1.3.1

package/src/session.ts

@@ -18,10 +18,8 @@ import {
   ChatMessage,
   ToolCall,
   AuthType,
-  AuthConfig,
-  AgentConfig,
-  ToolCallItem,
 } 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';
@@ -29,13 +27,13 @@ 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,
@@ -45,7 +43,6 @@ import {
   renderMarkdown,
   renderDiff,
   renderLines,
-  TERMINAL_BG,
 } from './theme.js';
 import { getCancellationManager, CancellationManager } from './cancellation.js';
 import {
@@ -53,8 +50,9 @@ import {
   ContextCompressor,
   CompressionResult,
 } from './context-compressor.js';
-import { Logger, LogLevel, getLogger } from './logger.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;
@@ -86,6 +84,18 @@ 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({
@@ -173,6 +183,76 @@ export class InteractiveSession {
     this.executionMode = mode;
   }
 
+  /**
+   * 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;
+
+    // Initialize SDK mode for other modules using centralized output util
+    const { initOutputMode } = require('./output-util.js');
+    initOutputMode(true, adapter);
+
+    // Initialize SmartApprovalEngine in SDK mode
+    this.initSmartApprovalSdkMode(adapter).catch(() => {
+      // Silently ignore errors - not critical
+    });
+
+    // 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);
+  }
+
+  /**
+   * Initialize tool registry in SDK mode.
+   */
+  private async initToolRegistrySdkMode(adapter: SdkOutputAdapter): Promise<void> {
+    const toolRegistry = getToolRegistry();
+    await toolRegistry.setSdkMode(true, adapter);
+  }
+
+  /**
+   * Get SDK mode status.
+   */
+  getIsSdkMode(): boolean {
+    return this.isSdkMode;
+  }
+
+  /**
+   * 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)
    */
@@ -228,6 +308,18 @@ export class InteractiveSession {
 
     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 {
@@ -238,14 +330,16 @@ export class InteractiveSession {
           
           if (state.lastSkillUpdate && state.lastSkillUpdate > lastUpdateTime) {
             lastUpdateTime = state.lastSkillUpdate;
-            
+
             // Update system prompt with new skills
             await this.updateSystemPrompt();
-            
-            console.log(colors.textMuted('  🔄 Skills updated from CLI'));
+
+            if (!this.isSdkMode) {
+              console.log(colors.textMuted('  🔄 Skills updated from CLI'));
+            }
           }
         }
-      } catch (error) {
+      } catch {
         // Silent fail - watcher is optional
       }
     }, 2000);
@@ -265,45 +359,56 @@ export class InteractiveSession {
     // 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'));
+    const _separator = icons.separator.repeat(60);
 
-    // Show initialization message if skills were initialized
-    if (initializedCount > 0) {
-      console.log(colors.textMuted(`  ✨ Initialized ${initializedCount} built-in skills`));
+    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('');
     }
-    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;
+    let _escCleanup: (() => void) | undefined;
     if (process.stdin.isTTY) {
-      escCleanup = setupEscKeyHandler(() => {
+      _escCleanup = setupEscKeyHandler(() => {
         if ((this as any)._isOperationInProgress) {
           // An operation is running, let it be cancelled
           this.cancellationManager.cancel();
@@ -490,31 +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 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}`)}`);
+          }
         }
       }
 
@@ -530,7 +653,11 @@ export class InteractiveSession {
 
       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}`));
@@ -596,7 +723,7 @@ export class InteractiveSession {
       } else {
         return null;
       }
-    } catch (error: any) {
+    } catch {
       return null;
     }
   }
@@ -641,10 +768,14 @@ export class InteractiveSession {
     // 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 /model 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('');
+      }
     }
 
     this.configManager.setAuthConfig(authConfig);
@@ -665,21 +796,82 @@ export class InteractiveSession {
     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 {
@@ -714,10 +906,12 @@ export class InteractiveSession {
     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}`)}`);
-    console.log('');
+    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();
   }
@@ -726,6 +920,21 @@ export class InteractiveSession {
     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');
@@ -748,6 +957,12 @@ 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();
@@ -779,12 +994,54 @@ 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) {
@@ -804,6 +1061,327 @@ export class InteractiveSession {
     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}`);
+    }
+  }
+
+  /**
+   * 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> {
     const [agentType, ...taskParts] = input.slice(1).split(' ');
     const task = taskParts.join(' ');
@@ -829,8 +1407,8 @@ export class InteractiveSession {
     await this.processUserMessage(task, agent);
   }
 
-  public async processUserMessage(message: string, agent?: AgentConfig): Promise<void> {
-    const inputs = parseInput(message);
+  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');
@@ -908,6 +1486,12 @@ export class InteractiveSession {
     const thinkingConfig = this.configManager.getThinkingConfig();
     const displayMode = thinkingConfig.displayMode || 'compact';
 
+    // 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
     );
@@ -923,7 +1507,7 @@ 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 =
@@ -936,6 +1520,7 @@ export class InteractiveSession {
         console.log(`${indent}${colors.textDim(truncatedContent.replace(/^/gm, indent))}`);
         console.log(`${indent}${colors.textDim(`[${reasoningContent.length} chars total]`)}`);
         break;
+      }
 
       case 'indicator':
         // Show indicator only
@@ -966,7 +1551,7 @@ export class InteractiveSession {
     }
 
     const indent = this.getIndent();
-    const currentTokens = this.contextCompressor.estimateContextTokens(this.conversation);
+    const _currentTokens = this.contextCompressor.estimateContextTokens(this.conversation);
     const currentMessages = this.conversation.length;
     const { needsCompression, reason, tokenCount } = this.contextCompressor.needsCompression(
       this.conversation,
@@ -983,10 +1568,14 @@ export class InteractiveSession {
     const threshold = thresholdMatch ? parseInt(thresholdMatch[1], 10) : 0;
     const contextWindow = contextWindowMatch ? parseInt(contextWindowMatch[1], 10) : 0;
 
-    console.log('');
-    console.log(
-      `${indent}${colors.success(`${icons.sparkles} Compressing context (${currentMessages} msgs, ${tokenCount.toLocaleString()} > ${threshold.toLocaleString()}/${contextWindow.toLocaleString()} tokens, ${Math.round((tokenCount / contextWindow) * 100)}% of context window)...`)}`
-    );
+    if (this.isSdkMode && this.sdkOutputAdapter) {
+      this.sdkOutputAdapter.outputContextCompressionTriggered(reason);
+    } else {
+      console.log('');
+      console.log(
+        `${indent}${colors.success(`${icons.sparkles} Compressing context (${currentMessages} msgs, ${tokenCount.toLocaleString()} > ${threshold.toLocaleString()}/${contextWindow.toLocaleString()} tokens, ${Math.round((tokenCount / contextWindow) * 100)}% of context window)...`)}`
+      );
+    }
 
     const toolRegistry = getToolRegistry();
     const baseSystemPrompt = this.currentAgent?.systemPrompt || 'You are a helpful AI assistant.';
@@ -1003,9 +1592,20 @@ export class InteractiveSession {
     if (result.wasCompressed) {
       this.conversation = result.compressedMessages;
       const reductionPercent = Math.round((1 - result.compressedSize / result.originalSize) * 100);
-      console.log(
-        `${indent}${colors.success(`${icons.success} Compressed ${result.originalMessageCount} → ${result.compressedMessageCount} messages (${reductionPercent}% smaller)`)}`
-      );
+
+      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}"
@@ -1034,27 +1634,36 @@ export class InteractiveSession {
           summaryContent = summaryContent.substring(0, maxPreviewLength) + '\n...';
         }
 
-        console.log('');
-        console.log(
-          `${indent}${theme.predefinedStyles.title(`${icons.sparkles} Conversation Summary`)}`
-        );
-        const separator = icons.separator.repeat(
-          Math.min(60, process.stdout.columns || 80) - indent.length * 2
-        );
-        console.log(`${indent}${colors.border(separator)}`);
-        const renderedSummary = renderMarkdown(
-          summaryContent,
-          (process.stdout.columns || 80) - indent.length * 4
-        );
-        console.log(
-          `${indent}${theme.predefinedStyles.dim(renderedSummary).replace(/^/gm, indent)}`
-        );
-        if (isTruncated) {
+        if (this.isSdkMode && this.sdkOutputAdapter) {
+          this.sdkOutputAdapter.outputContextCompressionSummary(
+            'Conversation compressed successfully',
+            summaryContent,
+            isTruncated,
+            summaryMessage.content.length
+          );
+        } else {
+          console.log('');
           console.log(
-            `${indent}${colors.textMuted(`(... ${summaryMessage.content.length - maxPreviewLength} more chars hidden)`)}`
+            `${indent}${theme.predefinedStyles.title(`${icons.sparkles} Conversation Summary`)}`
           );
+          const separator = icons.separator.repeat(
+            Math.min(60, process.stdout.columns || 80) - indent.length * 2
+          );
+          console.log(`${indent}${colors.border(separator)}`);
+          const renderedSummary = renderMarkdown(
+            summaryContent,
+            (process.stdout.columns || 80) - indent.length * 4
+          );
+          console.log(
+            `${indent}${theme.predefinedStyles.dim(renderedSummary).replace(/^/gm, indent)}`
+          );
+          if (isTruncated) {
+            console.log(
+              `${indent}${colors.textMuted(`(... ${summaryMessage.content.length - maxPreviewLength} more chars hidden)`)}`
+            );
+          }
+          console.log(`${indent}${colors.border(separator)}`);
         }
-        console.log(`${indent}${colors.border(separator)}`);
       }
 
       // Sync compressed conversation history to slashCommandHandler
@@ -1135,7 +1744,7 @@ 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!;
 
 
@@ -1195,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();
@@ -1257,30 +1874,20 @@ 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',
@@ -1313,15 +1920,28 @@ export class InteractiveSession {
         );
       }
 
+      // 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') {
         // Notify backend to cancel the task
         if (this.remoteAIClient && this.currentTaskId) {
@@ -1423,7 +2043,7 @@ export class InteractiveSession {
         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 interactive prompt
         this.rl.close();
@@ -1491,7 +2111,7 @@ export class InteractiveSession {
       let parsedParams: any;
       try {
         parsedParams = typeof params === 'string' ? JSON.parse(params) : params;
-      } catch (e) {
+      } catch {
         parsedParams = params;
       }
 
@@ -1500,13 +2120,19 @@ 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}`)}`);
+        }
       }
     }
 
@@ -1532,7 +2158,7 @@ export class InteractiveSession {
     }
 
     // Process results in the original tool_calls order (critical for Anthropic format APIs)
-    let hasError = false;
+    let _hasError = false;
     for (let i = 0; i < preparedToolCalls.length; i++) {
       const toolCall = preparedToolCalls[i];
       const { name: tool, params } = toolCall;
@@ -1555,10 +2181,16 @@ export class InteractiveSession {
           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}`)}`);
+        }
 
         // Add detailed error info including tool name and params for AI understanding and correction
         this.conversation.push({
@@ -1572,200 +2204,208 @@ export class InteractiveSession {
           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}`)}`);
+          // 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 (result?.cancelled) {
+          } 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.warning(`${icons.cross} ${subagentType}: Cancelled`)}`
+              `${displayIndent}${colors.success(`${icons.check} Deleted: ${result.filePath}`)}`
             );
-            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 (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) {
+            if (result?.success !== false) {
               console.log(
-                `${displayIndent}${colors.textDim(`  ${result?.message || result?.error}`)}`
+                `${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 = {
@@ -2188,7 +2828,7 @@ async function initializeSkillsOnDemand(): Promise<number> {
 }
 
 // Synchronous version (kept for backwards compatibility)
-function copyDirectoryRecursive(src: string, dest: string): void {
+function _copyDirectoryRecursive(src: string, dest: string): void {
   if (!fs.existsSync(dest)) {
     fs.mkdirSync(dest, { recursive: true });
   }
@@ -2199,7 +2839,7 @@ function copyDirectoryRecursive(src: string, dest: string): void {
     const destPath = path.join(dest, entry.name);
 
     if (entry.isDirectory()) {
-      copyDirectoryRecursive(srcPath, destPath);
+      _copyDirectoryRecursive(srcPath, destPath);
     } else if (entry.isFile()) {
       fs.copyFileSync(srcPath, destPath);
     }
@@ -2279,7 +2919,7 @@ export async function startInteractiveSession(): Promise<void> {
   try {
     const { checkUpdatesOnStartup } = await import('./update.js');
     await checkUpdatesOnStartup();
-  } catch (error) {
+  } catch {
     // Silently ignore update check failures
   }