@yu_robotics/remote-cli 1.1.21 → 1.1.33

package/dist/client/MessageHandler.js

@@ -1,50 +1,45 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MessageHandler = void 0;
-const executor_1 = require("../executor");
 const hooks_1 = require("../hooks");
 const FileReadDetector_1 = require("../utils/FileReadDetector");
 const child_process_1 = require("child_process");
 /**
- * Message Handler
- * Responsible for handling messages from WebSocket and invoking Claude executor
+ * Thread-aware Message Handler.
+ * Each thread has its own executor process managed by ThreadExecutorPool.
+ * Commands without a threadId are routed to the default thread.
  */
 class MessageHandler {
     wsClient;
-    executor;
+    threadPool;
+    threadManager;
     directoryGuard;
     config;
     isDestroyed = false;
-    isExecuting = false;
     currentOpenId;
     notificationAdapter;
-    constructor(wsClient, executor, directoryGuard, config) {
+    constructor(wsClient, threadPool, threadManager, directoryGuard, config) {
         this.wsClient = wsClient;
-        this.executor = executor;
+        this.threadPool = threadPool;
+        this.threadManager = threadManager;
         this.directoryGuard = directoryGuard;
         this.config = config;
-        // Initialize Feishu notification adapter
         this.notificationAdapter = new hooks_1.FeishuNotificationAdapter(wsClient);
         this.notificationAdapter.register();
     }
     /**
      * Handle message (supports new IncomingMessage format)
-     * @param message Message object
      */
     async handleMessage(message) {
-        // Check if already destroyed
-        if (this.isDestroyed) {
+        if (this.isDestroyed)
             return;
-        }
-        // Validate message structure
         if (!message || !this.isValidMessage(message)) {
-            this.sendResponse(message?.messageId || 'unknown', {
+            this.sendResponse(message?.messageId || 'unknown', undefined, {
                 success: false,
                 error: 'Invalid message format',
             });
             return;
         }
-        // Handle different types of messages
         switch (message.type) {
             case 'status':
                 await this.handleStatusQuery(message.messageId);
@@ -53,53 +48,56 @@ class MessageHandler {
                 await this.handleCommandMessage(message);
                 return;
             case 'heartbeat':
-                // Silently ignore heartbeat responses from server
                 return;
             case 'binding_confirm':
-                // Silently ignore binding confirmation from server
                 return;
             default:
-                this.sendResponse(message.messageId, {
+                this.sendResponse(message.messageId, undefined, {
                     success: false,
                     error: `Unknown message type: ${message.type}`,
                 });
         }
     }
     /**
-     * Handle command message
+     * Handle command message — route to the correct thread executor.
      */
     async handleCommandMessage(message) {
-        const { messageId, content, workingDirectory, openId, isSlashCommand } = message;
-        // Store openId for response routing and notifications
+        const { messageId, content, workingDirectory, openId, isSlashCommand, threadId } = message;
         this.currentOpenId = openId;
         this.notificationAdapter.setCurrentOpenId(openId);
-        // Handle /abort command first, even when busy
+        // Resolve target thread — fall back to default if not specified
+        const thread = threadId
+            ? this.threadManager.getThread(threadId)
+            : this.threadManager.getDefaultThread();
+        if (!thread) {
+            this.sendResponse(messageId, undefined, {
+                success: false,
+                error: `Thread not found: ${threadId}`,
+            });
+            return;
+        }
+        const resolvedThreadId = thread.id;
+        const executor = this.threadPool.getExecutor(resolvedThreadId);
+        // Handle /abort for this specific thread (bypasses busy check)
         if (content?.trim() === '/abort') {
-            await this.handleAbortCommand(messageId);
+            await this.handleAbortCommand(messageId, resolvedThreadId, executor);
             return;
         }
         // Check if executor is waiting for interactive input
-        if ('isWaitingInput' in this.executor && typeof this.executor.isWaitingInput === 'function') {
-            const executor = this.executor;
-            if (executor.isWaitingInput()) {
+        if ('isWaitingInput' in executor && typeof executor.isWaitingInput === 'function') {
+            const ex = executor;
+            if (ex.isWaitingInput()) {
                 const input = content?.trim();
                 if (input) {
-                    const sent = executor.sendInput(input);
-                    if (sent) {
-                        this.sendResponse(messageId, {
-                            success: true,
-                            output: `✅ Sent: "${input}"`,
-                        });
-                    }
-                    else {
-                        this.sendResponse(messageId, {
-                            success: false,
-                            error: '❌ Failed to send input - executor is no longer waiting',
-                        });
-                    }
+                    const sent = ex.sendInput(input);
+                    this.sendResponse(messageId, resolvedThreadId, {
+                        success: sent,
+                        output: sent ? `✅ Sent: "${input}"` : undefined,
+                        error: sent ? undefined : '❌ Failed to send input - executor is no longer waiting',
+                    });
                 }
                 else {
-                    this.sendResponse(messageId, {
+                    this.sendResponse(messageId, resolvedThreadId, {
                         success: false,
                         error: '❌ Please provide a non-empty input',
                     });
@@ -107,19 +105,18 @@ class MessageHandler {
                 return;
             }
         }
-        // Check if there is a task currently executing
-        if (this.isExecuting) {
-            this.sendResponse(messageId, {
+        // Per-thread busy check
+        if (this.threadPool.isThreadBusy(resolvedThreadId)) {
+            this.sendResponse(messageId, resolvedThreadId, {
                 success: false,
-                error: 'Executor is busy, please wait for current task to complete. Send the abort command to cancel the running task.',
+                error: `Thread "${thread.name}" is busy. Send /abort to cancel the running task, or use another thread.`,
             });
             return;
         }
-        // If working directory is provided, validate and set it
+        // Validate and set working directory if provided
         if (workingDirectory) {
-            // Verify directory is in the whitelist
             if (!this.directoryGuard.isSafePath(workingDirectory)) {
-                this.sendResponse(messageId, {
+                this.sendResponse(messageId, resolvedThreadId, {
                     success: false,
                     error: `Directory not in whitelist: ${workingDirectory}\n\nAllowed directories:\n${this.directoryGuard
                         .getAllowedDirectories()
@@ -128,49 +125,44 @@ class MessageHandler {
                 });
                 return;
             }
-            // Set working directory
-            await this.executor.setWorkingDirectory(workingDirectory);
+            await executor.setWorkingDirectory(workingDirectory);
         }
         try {
-            this.isExecuting = true;
-            // Handle built-in commands (except /abort which was handled above)
-            const builtInResult = await this.handleBuiltInCommand(messageId, content);
-            if (builtInResult) {
+            this.threadPool.setThreadBusy(resolvedThreadId, true);
+            // Update thread activity timestamp
+            await this.threadManager.updateThread(resolvedThreadId, { lastActiveAt: Date.now() });
+            const builtInResult = await this.handleBuiltInCommand(messageId, resolvedThreadId, content, executor);
+            if (builtInResult)
                 return;
-            }
-            // Check if this is a passthrough slash command from server
             if (isSlashCommand) {
                 console.log(`[MessageHandler] Executing passthrough slash command: ${content}`);
-                await this.executeSlashCommand(messageId, content);
+                await this.executeSlashCommand(messageId, resolvedThreadId, content, executor);
                 return;
             }
-            // Expand command shortcuts
             const expandedContent = this.expandCommandShortcuts(content);
-            // Detect file-reading intent and inject hint for mobile optimization
             const processedContent = (0, FileReadDetector_1.processFileReadContent)(expandedContent);
-            // Execute Claude command
-            await this.executeCommand(messageId, processedContent);
+            await this.executeCommand(messageId, resolvedThreadId, processedContent, executor);
         }
         catch (error) {
-            this.sendResponse(messageId, {
+            this.threadPool.setThreadError(resolvedThreadId, true);
+            this.sendResponse(messageId, resolvedThreadId, {
                 success: false,
                 error: error instanceof Error ? error.message : 'Unknown error',
             });
         }
         finally {
-            this.isExecuting = false;
+            this.threadPool.setThreadBusy(resolvedThreadId, false);
         }
     }
     /**
-     * Handle abort command
-     * Can be executed even when executor is busy
+     * Handle /abort command for a specific thread executor
      */
-    async handleAbortCommand(messageId) {
-        const wasExecuting = this.isExecuting;
-        const aborted = await this.executor.abort();
+    async handleAbortCommand(messageId, threadId, executor) {
+        const wasExecuting = this.threadPool.isThreadBusy(threadId);
+        const aborted = await executor.abort();
         if (aborted) {
-            this.isExecuting = false;
-            this.sendResponse(messageId, {
+            this.threadPool.setThreadBusy(threadId, false);
+            this.sendResponse(messageId, threadId, {
                 success: true,
                 output: wasExecuting
                     ? '✅ Current command has been aborted'
@@ -178,7 +170,7 @@ class MessageHandler {
             });
         }
         else {
-            this.sendResponse(messageId, {
+            this.sendResponse(messageId, threadId, {
                 success: true,
                 output: 'ℹ️ No command is currently executing',
             });
@@ -188,207 +180,280 @@ class MessageHandler {
      * Handle status query
      */
     async handleStatusQuery(messageId) {
+        const defaultThread = this.threadManager.getDefaultThread();
+        const defaultExecutor = this.threadPool.getExecutor(defaultThread.id);
         this.wsClient.send({
             type: 'status',
             messageId,
             status: {
                 connected: this.wsClient.isConnected(),
                 allowedDirectories: this.directoryGuard.getAllowedDirectories(),
-                currentWorkingDirectory: this.executor.getCurrentWorkingDirectory(),
+                currentWorkingDirectory: defaultExecutor.getCurrentWorkingDirectory(),
+                threads: this.threadPool.getSummaries(),
             },
             timestamp: Date.now(),
         });
     }
-    /**
-     * Validate message structure
-     */
     isValidMessage(message) {
-        if (!message || typeof message !== 'object') {
+        if (!message || typeof message !== 'object')
             return false;
-        }
-        if (message.type !== 'command') {
-            return true; // Non-command messages don't need further validation
-        }
+        if (message.type !== 'command')
+            return true;
         return Boolean(message.messageId && message.content);
     }
     /**
-     * Handle built-in commands
-     * @returns Returns true if built-in command was handled, otherwise false
+     * Handle built-in commands (thread-scoped).
+     * Returns true if handled.
      */
-    async handleBuiltInCommand(messageId, content) {
+    async handleBuiltInCommand(messageId, threadId, content, executor) {
         const trimmed = content.trim();
-        // /status command
         if (trimmed === '/status') {
-            const cwd = this.executor.getCurrentWorkingDirectory();
+            const cwd = executor.getCurrentWorkingDirectory();
             const allowedDirs = this.directoryGuard.getAllowedDirectories();
-            this.sendResponse(messageId, {
+            const threads = this.threadPool.getSummaries();
+            const threadList = threads
+                .map(t => `  • ${t.name}${t.status === 'running' ? ' 🔄' : t.status === 'error' ? ' ❌' : ' ✅'} (${t.status})`)
+                .join('\n');
+            this.sendResponse(messageId, threadId, {
                 success: true,
                 output: `📊 Status:
 - Working Directory: ${cwd}
 - Allowed Directories: ${allowedDirs.join(', ')}
-- Connection: Active`,
+- Connection: Active
+- Threads:\n${threadList}`,
             });
             return true;
         }
-        // /help command
         if (trimmed === '/help') {
-            this.sendResponse(messageId, {
+            this.sendResponse(messageId, threadId, {
                 success: true,
                 output: `📖 Available commands:
 - /help - Show this help message
-- /status - Show current status
-- /abort - Abort the currently executing command
-- /clear - Clear conversation context
+- /status - Show current status and threads
+- /abort - Abort the currently executing command in this thread
+- /clear - Clear conversation context for this thread
 - /compact - Compress conversation history to reduce context size
-- /cd <directory> - Change working directory
+- /cd <directory> - Change working directory for this thread
 - /backend - List available AI backends and switch between them
+- /thread list - List all threads with their status
+- /thread new [name] - Create a new thread
+- /thread delete <name> - Delete a thread (only when idle)
 You can also use natural language commands to control Claude Code CLI.`,
             });
             return true;
         }
-        // /clear command
         if (trimmed === '/clear') {
-            this.executor.resetContext();
-            this.sendResponse(messageId, {
+            executor.resetContext();
+            this.sendResponse(messageId, threadId, {
                 success: true,
                 output: '✅ Conversation context cleared',
             });
             return true;
         }
-        // /compact command - compress conversation history via Claude CLI's built-in /compact
         if (trimmed === '/compact') {
-            if (!('compactWhenFull' in this.executor && typeof this.executor.compactWhenFull === 'function')) {
-                this.sendResponse(messageId, {
+            if (!('compactWhenFull' in executor && typeof executor.compactWhenFull === 'function')) {
+                this.sendResponse(messageId, threadId, {
                     success: false,
                     error: '/compact is not supported in this executor mode',
                 });
                 return true;
             }
-            this.sendStreamChunk(messageId, '🗜️ Compressing conversation history...\n');
-            const persistentExecutor = this.executor;
-            const result = await persistentExecutor.compactWhenFull((chunk) => {
-                this.sendStreamChunk(messageId, chunk);
+            this.sendStreamChunk(messageId, threadId, '🗜️ Compressing conversation history...\n');
+            const result = await executor.compactWhenFull((chunk) => {
+                this.sendStreamChunk(messageId, threadId, chunk);
             });
-            if (!result.success) {
-                this.sendResponse(messageId, {
-                    success: false,
-                    error: result.error || 'Compaction failed',
-                });
-            }
-            else {
-                this.sendResponse(messageId, {
-                    success: true,
-                    output: '✅ Conversation history compressed',
-                });
-            }
+            this.sendResponse(messageId, threadId, result.success
+                ? { success: true, output: '✅ Conversation history compressed' }
+                : { success: false, error: result.error || 'Compaction failed' });
             return true;
         }
-        // /backend command
         if (trimmed === '/backend' || trimmed.startsWith('/backend ')) {
-            await this.handleBackendCommand(messageId, trimmed);
+            await this.handleBackendCommand(messageId, threadId, trimmed);
             return true;
         }
-        // /cd command
         if (trimmed.startsWith('/cd')) {
             const parts = trimmed.split(/\s+/);
             if (parts.length < 2) {
-                this.sendResponse(messageId, {
-                    success: false,
-                    error: 'Usage: /cd <directory>',
-                });
+                this.sendResponse(messageId, threadId, { success: false, error: 'Usage: /cd <directory>' });
                 return true;
             }
             const targetDir = parts.slice(1).join(' ');
             try {
-                await this.executor.setWorkingDirectory(targetDir);
-                const newCwd = this.executor.getCurrentWorkingDirectory();
-                // Save lastWorkingDirectory to config (set() already saves)
-                await this.config.set('lastWorkingDirectory', newCwd);
-                this.sendResponse(messageId, {
+                await executor.setWorkingDirectory(targetDir);
+                const newCwd = executor.getCurrentWorkingDirectory();
+                // Persist the thread's working directory (restored on next startup via ThreadExecutorPool)
+                await this.threadManager.updateThread(threadId, { workingDirectory: newCwd });
+                this.sendResponse(messageId, threadId, {
                     success: true,
                     output: `✅ Changed working directory to: ${newCwd}`,
                 });
             }
             catch (error) {
-                this.sendResponse(messageId, {
+                this.sendResponse(messageId, threadId, {
                     success: false,
-                    error: error instanceof Error
-                        ? error.message
-                        : 'Failed to change directory',
+                    error: error instanceof Error ? error.message : 'Failed to change directory',
                 });
             }
             return true;
         }
+        if (trimmed === '/thread' || trimmed.startsWith('/thread ')) {
+            await this.handleThreadCommand(messageId, threadId, trimmed);
+            return true;
+        }
         return false;
     }
+    /**
+     * Handle /thread subcommands
+     */
+    async handleThreadCommand(messageId, callerThreadId, trimmed) {
+        const parts = trimmed.split(/\s+/);
+        const sub = parts[1]; // list | new | delete
+        if (!sub || sub === 'list') {
+            const summaries = this.threadPool.getSummaries();
+            const lines = summaries.map(t => {
+                const icon = t.status === 'running' ? '🔄' : t.status === 'error' ? '❌' : '✅';
+                const current = t.id === callerThreadId ? ' ← (this thread)' : '';
+                return `${icon} ${t.name}${current}`;
+            });
+            this.sendResponse(messageId, callerThreadId, {
+                success: true,
+                output: `🧵 Threads:\n${lines.join('\n')}\n\nUse /thread new [name] to create a new thread.\nReply to a thread's card to send commands to it.`,
+            });
+            return;
+        }
+        if (sub === 'new') {
+            const name = parts[2];
+            const callerThread = this.threadManager.getThread(callerThreadId) || this.threadManager.getDefaultThread();
+            const callerExecutor = this.threadPool.getExecutor(callerThread.id);
+            const cwd = callerExecutor.getCurrentWorkingDirectory();
+            try {
+                const newThread = await this.threadManager.createThread(name || this.generateThreadName(), cwd);
+                // Use newThread.id so the router maps this card to the new thread,
+                // enabling the user to reply to this card to target the new thread.
+                this.sendResponse(messageId, newThread.id, {
+                    success: true,
+                    output: `✅ Thread "${newThread.name}" created.\nReply to this card to send the first command to the new thread.`,
+                    threads: this.threadPool.getSummaries(),
+                });
+            }
+            catch (error) {
+                this.sendResponse(messageId, callerThreadId, {
+                    success: false,
+                    error: error instanceof Error ? error.message : 'Failed to create thread',
+                });
+            }
+            return;
+        }
+        if (sub === 'delete') {
+            const name = parts[2];
+            if (!name) {
+                this.sendResponse(messageId, callerThreadId, {
+                    success: false,
+                    error: 'Usage: /thread delete <name>',
+                });
+                return;
+            }
+            const target = this.threadManager.getThreadByName(name);
+            if (!target) {
+                this.sendResponse(messageId, callerThreadId, {
+                    success: false,
+                    error: `Thread "${name}" not found.`,
+                });
+                return;
+            }
+            if (this.threadPool.isThreadBusy(target.id)) {
+                this.sendResponse(messageId, callerThreadId, {
+                    success: false,
+                    error: `Cannot delete thread "${name}" while it is running. Send /abort first.`,
+                });
+                return;
+            }
+            try {
+                await this.threadPool.destroyThread(target.id);
+                await this.threadManager.deleteThread(target.id);
+                this.sendResponse(messageId, callerThreadId, {
+                    success: true,
+                    output: `✅ Thread "${name}" deleted.`,
+                    threads: this.threadPool.getSummaries(),
+                });
+            }
+            catch (error) {
+                this.sendResponse(messageId, callerThreadId, {
+                    success: false,
+                    error: error instanceof Error ? error.message : 'Failed to delete thread',
+                });
+            }
+            return;
+        }
+        this.sendResponse(messageId, callerThreadId, {
+            success: false,
+            error: `Unknown /thread subcommand: ${sub}\nUsage: /thread list | /thread new [name] | /thread delete <name>`,
+        });
+    }
+    /**
+     * Generate a unique auto-name for a new thread (e.g. "thread-2")
+     */
+    generateThreadName() {
+        const existing = new Set(this.threadManager.listThreads().map(t => t.name));
+        for (let i = 2; i <= 99; i++) {
+            const name = `thread-${i}`;
+            if (!existing.has(name))
+                return name;
+        }
+        return `thread-${Date.now()}`;
+    }
     /**
      * Expand command shortcuts
      */
     expandCommandShortcuts(content) {
         const trimmed = content.trim();
-        // Only expand when command is the entire content
-        if (trimmed === '/r' || trimmed === '/resume') {
+        if (trimmed === '/r' || trimmed === '/resume')
             return 'Please resume the previous conversation';
-        }
-        if (trimmed === '/c' || trimmed === '/continue') {
+        if (trimmed === '/c' || trimmed === '/continue')
             return 'Please continue from where we left off';
-        }
         return content;
     }
     /**
      * Execute passthrough slash command using local Claude CLI
-     * This allows users to use their custom slash commands
      */
-    async executeSlashCommand(messageId, command) {
+    async executeSlashCommand(messageId, threadId, command, executor) {
         return new Promise((resolve) => {
             const chunks = [];
             const errorChunks = [];
             console.log(`[MessageHandler] Spawning Claude CLI for command: ${command}`);
-            // Spawn Claude CLI with the slash command
-            // Use --print to get output and exit
             const child = (0, child_process_1.spawn)('claude', [command, '--print'], {
-                cwd: this.executor.getCurrentWorkingDirectory(),
+                cwd: executor.getCurrentWorkingDirectory(),
                 stdio: ['ignore', 'pipe', 'pipe'],
-                env: {
-                    ...process.env,
-                    CLAUDECODE: '', // Prevent nested session error
-                },
+                env: { ...process.env, CLAUDECODE: '' },
             });
-            // Handle stdout (stream chunks)
             child.stdout?.on('data', (data) => {
                 const chunk = data.toString();
                 chunks.push(chunk);
-                this.sendStreamChunk(messageId, chunk);
+                this.sendStreamChunk(messageId, threadId, chunk);
             });
-            // Handle stderr
             child.stderr?.on('data', (data) => {
-                const chunk = data.toString();
-                errorChunks.push(chunk);
-                console.error(`[MessageHandler] Claude stderr: ${chunk}`);
+                errorChunks.push(data.toString());
             });
-            // Handle process exit
             child.on('exit', (code) => {
-                console.log(`[MessageHandler] Claude process exited with code: ${code}`);
                 if (code === 0) {
                     const output = chunks.join('');
-                    this.sendResponse(messageId, {
+                    this.sendResponse(messageId, threadId, {
                         success: true,
                         output: output.trim() || '✅ Command executed successfully',
                     });
                 }
                 else {
                     const errorOutput = errorChunks.join('') || chunks.join('');
-                    this.sendResponse(messageId, {
+                    this.sendResponse(messageId, threadId, {
                         success: false,
                         error: errorOutput.trim() || `Command failed with exit code ${code}`,
                     });
                 }
                 resolve();
             });
-            // Handle process error
             child.on('error', (error) => {
-                console.error(`[MessageHandler] Failed to spawn Claude:`, error);
-                this.sendResponse(messageId, {
+                console.error('[MessageHandler] Failed to spawn Claude:', error);
+                this.sendResponse(messageId, threadId, {
                     success: false,
                     error: `Failed to execute command: ${error.message}`,
                 });
@@ -397,80 +462,58 @@ You can also use natural language commands to control Claude Code CLI.`,
         });
     }
     /**
-     * Execute Claude command
+     * Execute AI command on a specific executor
      */
-    async executeCommand(messageId, content) {
+    async executeCommand(messageId, threadId, content, executor) {
         try {
-            const result = await this.executor.execute(content, {
-                onStream: (chunk) => {
-                    this.sendStreamChunk(messageId, chunk);
-                },
-                onToolUse: (toolUse) => {
-                    this.sendToolUse(messageId, toolUse);
-                },
-                onToolResult: (toolResult) => {
-                    this.sendToolResult(messageId, toolResult);
-                },
-                onRedactedThinking: () => {
-                    this.sendRedactedThinking(messageId);
-                },
-                onPlanMode: (planContent) => {
-                    this.sendPlanMode(messageId, planContent);
-                },
+            const result = await executor.execute(content, {
+                onStream: (chunk) => this.sendStreamChunk(messageId, threadId, chunk),
+                onToolUse: (toolUse) => this.sendToolUse(messageId, threadId, toolUse),
+                onToolResult: (toolResult) => this.sendToolResult(messageId, threadId, toolResult),
+                onRedactedThinking: () => this.sendRedactedThinking(messageId, threadId),
+                onPlanMode: (planContent) => this.sendPlanMode(messageId, threadId, planContent),
             });
-            // Only send success status, not the output
-            // Output has already been streamed via onStream callback
             if (!result.success && result.error && result.error.includes('Prompt too long')) {
-                if ('compactWhenFull' in this.executor && typeof this.executor.compactWhenFull === 'function') {
-                    // Context is full - use external compact which stops/restarts the process
-                    this.sendStreamChunk(messageId, '⚠️ Conversation history too long, auto-compressing...\n');
-                    const persistentExecutor = this.executor;
-                    const compactResult = await persistentExecutor.compactWhenFull((chunk) => {
-                        this.sendStreamChunk(messageId, chunk);
+                if ('compactWhenFull' in executor && typeof executor.compactWhenFull === 'function') {
+                    this.sendStreamChunk(messageId, threadId, '⚠️ Conversation history too long, auto-compressing...\n');
+                    const compactResult = await executor.compactWhenFull((chunk) => {
+                        this.sendStreamChunk(messageId, threadId, chunk);
                     });
                     if (!compactResult.success) {
-                        this.sendResponse(messageId, {
+                        this.sendResponse(messageId, threadId, {
                             success: false,
                             error: `❌ Auto-compact failed: ${compactResult.error}\n\nUse /compact to try again, or /clear to start fresh.`,
                         });
                         return;
                     }
-                    this.sendStreamChunk(messageId, '✅ Compressed. Retrying...\n');
-                    const retryResult = await this.executor.execute(content, {
-                        onStream: (chunk) => { this.sendStreamChunk(messageId, chunk); },
-                        onToolUse: (toolUse) => { this.sendToolUse(messageId, toolUse); },
-                        onToolResult: (toolResult) => { this.sendToolResult(messageId, toolResult); },
-                        onRedactedThinking: () => { this.sendRedactedThinking(messageId); },
-                        onPlanMode: (planContent) => { this.sendPlanMode(messageId, planContent); },
-                    });
-                    this.sendResponse(messageId, {
-                        success: retryResult.success,
-                        error: retryResult.error,
+                    this.sendStreamChunk(messageId, threadId, '✅ Compressed. Retrying...\n');
+                    const retryResult = await executor.execute(content, {
+                        onStream: (chunk) => this.sendStreamChunk(messageId, threadId, chunk),
+                        onToolUse: (toolUse) => this.sendToolUse(messageId, threadId, toolUse),
+                        onToolResult: (toolResult) => this.sendToolResult(messageId, threadId, toolResult),
+                        onRedactedThinking: () => this.sendRedactedThinking(messageId, threadId),
+                        onPlanMode: (planContent) => this.sendPlanMode(messageId, threadId, planContent),
                     });
+                    this.sendResponse(messageId, threadId, { success: retryResult.success, error: retryResult.error, threads: this.threadPool.getSummaries() });
                     return;
                 }
-                this.sendResponse(messageId, {
+                this.sendResponse(messageId, threadId, {
                     success: false,
                     error: '❌ Conversation history too long.\n\nUse /compact to compress it, or /clear to start fresh.',
                 });
                 return;
             }
-            this.sendResponse(messageId, {
-                success: result.success,
-                error: result.error,
-            });
+            this.sendResponse(messageId, threadId, { success: result.success, error: result.error, threads: this.threadPool.getSummaries() });
         }
         catch (error) {
-            this.sendResponse(messageId, {
+            this.sendResponse(messageId, threadId, {
                 success: false,
                 error: error instanceof Error ? error.message : 'Execution error',
             });
         }
     }
-    /**
-     * Send streaming output chunk
-     */
-    sendStreamChunk(messageId, chunk) {
+    // ── Outgoing message helpers ──────────────────────────────────────────────
+    sendStreamChunk(messageId, threadId, chunk) {
         try {
             this.wsClient.send({
                 type: 'stream',
@@ -478,18 +521,15 @@ You can also use natural language commands to control Claude Code CLI.`,
                 chunk,
                 streamType: 'text',
                 openId: this.currentOpenId,
+                threadId,
                 timestamp: Date.now(),
             });
         }
         catch (error) {
-            // Ignore send errors, don't affect main flow
             console.error('Failed to send stream chunk:', error);
         }
     }
-    /**
-     * Send tool use event
-     */
-    sendToolUse(messageId, toolUse) {
+    sendToolUse(messageId, threadId, toolUse) {
         try {
             this.wsClient.send({
                 type: 'stream',
@@ -497,6 +537,7 @@ You can also use natural language commands to control Claude Code CLI.`,
                 streamType: 'tool_use',
                 toolUse,
                 openId: this.currentOpenId,
+                threadId,
                 timestamp: Date.now(),
             });
         }
@@ -504,10 +545,7 @@ You can also use natural language commands to control Claude Code CLI.`,
             console.error('Failed to send tool use:', error);
         }
     }
-    /**
-     * Send tool result event
-     */
-    sendToolResult(messageId, toolResult) {
+    sendToolResult(messageId, threadId, toolResult) {
         try {
             this.wsClient.send({
                 type: 'stream',
@@ -515,6 +553,7 @@ You can also use natural language commands to control Claude Code CLI.`,
                 streamType: 'tool_result',
                 toolResult,
                 openId: this.currentOpenId,
+                threadId,
                 timestamp: Date.now(),
             });
         }
@@ -522,17 +561,14 @@ You can also use natural language commands to control Claude Code CLI.`,
             console.error('Failed to send tool result:', error);
         }
     }
-    /**
-     * Send redacted thinking event
-     * This occurs when AI reasoning is filtered by safety systems (Claude 3.7 Sonnet, Gemini)
-     */
-    sendRedactedThinking(messageId) {
+    sendRedactedThinking(messageId, threadId) {
         try {
             this.wsClient.send({
                 type: 'stream',
                 messageId,
                 streamType: 'redacted_thinking',
                 openId: this.currentOpenId,
+                threadId,
                 timestamp: Date.now(),
             });
         }
@@ -540,12 +576,7 @@ You can also use natural language commands to control Claude Code CLI.`,
             console.error('Failed to send redacted thinking:', error);
         }
     }
-    /**
-     * Send plan mode event
-     * Fired when Claude completes its plan between EnterPlanMode and ExitPlanMode tool calls.
-     * Execution is auto-approved; this event is for user visibility only.
-     */
-    sendPlanMode(messageId, planContent) {
+    sendPlanMode(messageId, threadId, planContent) {
         try {
             this.wsClient.send({
                 type: 'stream',
@@ -553,6 +584,7 @@ You can also use natural language commands to control Claude Code CLI.`,
                 streamType: 'plan_mode',
                 planContent,
                 openId: this.currentOpenId,
+                threadId,
                 timestamp: Date.now(),
             });
         }
@@ -560,29 +592,33 @@ You can also use natural language commands to control Claude Code CLI.`,
             console.error('Failed to send plan mode:', error);
         }
     }
-    /**
-     * Send structured content for rich formatting
-     */
-    sendStructuredContent(messageId, structuredContent) {
+    sendStructuredContent(messageId, threadId, structuredContent) {
         try {
             this.wsClient.send({
                 type: 'structured',
                 messageId,
                 structuredContent,
                 openId: this.currentOpenId,
+                threadId,
                 timestamp: Date.now(),
-                cwd: this.executor.getCurrentWorkingDirectory(),
             });
         }
         catch (error) {
             console.error('Failed to send structured content:', error);
         }
     }
-    /**
-     * Send response
-     */
-    sendResponse(messageId, result) {
+    sendResponse(messageId, threadId, result) {
         try {
+            // Resolve CWD from thread executor if possible
+            let cwd;
+            try {
+                if (threadId) {
+                    cwd = this.threadPool.getExecutor(threadId).getCurrentWorkingDirectory();
+                }
+            }
+            catch {
+                // Ignore — thread may have been deleted
+            }
             this.wsClient.send({
                 type: 'response',
                 messageId,
@@ -591,25 +627,22 @@ You can also use natural language commands to control Claude Code CLI.`,
                 error: result.error,
                 sessionAbbr: result.sessionAbbr,
                 openId: this.currentOpenId,
+                threadId,
+                threads: result.threads,
+                cwd,
                 timestamp: Date.now(),
-                cwd: this.executor.getCurrentWorkingDirectory(),
             });
         }
         catch (error) {
             console.error('Failed to send response:', error);
         }
     }
-    /**
-     * Detect whether a command is available on PATH
-     */
+    // ── Backend switching ─────────────────────────────────────────────────────
     checkCommand(cmd, args) {
         return new Promise((resolve) => {
             (0, child_process_1.execFile)(cmd, args, { timeout: 5000 }, (err) => resolve(!err));
         });
     }
-    /**
-     * Detect all installed AI backends
-     */
     async detectBackends() {
         const [claudeInstalled, geminiInstalled] = await Promise.all([
             this.checkCommand('claude', ['--version']),
@@ -620,23 +653,16 @@ You can also use natural language commands to control Claude Code CLI.`,
             { id: 'gemini', label: 'Gemini CLI', installed: geminiInstalled },
         ];
     }
-    /**
-     * Handle /backend command
-     * Usage:
-     *   /backend              — list available backends
-     *   /backend <name|index> — switch to the specified backend
-     */
-    async handleBackendCommand(messageId, trimmed) {
+    async handleBackendCommand(messageId, threadId, trimmed) {
         const parts = trimmed.split(/\s+/);
         const arg = parts[1];
         const currentConfig = this.config.get('executor') ?? { type: 'auto' };
         const currentType = currentConfig.type;
         const backends = await this.detectBackends();
         const installed = backends.filter((b) => b.installed);
-        // List mode
         if (!arg) {
             if (installed.length === 0) {
-                this.sendResponse(messageId, {
+                this.sendResponse(messageId, threadId, {
                     success: false,
                     error: 'No supported AI backends found.\n\nMake sure Claude Code is installed: npm install -g @anthropic-ai/claude-code',
                 });
@@ -648,13 +674,12 @@ You can also use natural language commands to control Claude Code CLI.`,
                 const active = b.id === currentType || isClaudeActive ? ' ★ (active)' : '';
                 return `${i + 1}. ${b.label}${active}`;
             });
-            this.sendResponse(messageId, {
+            this.sendResponse(messageId, threadId, {
                 success: true,
                 output: `🤖 Available AI backends:\n${lines.join('\n')}\n\nSwitch with: /backend <index> or /backend <name>`,
             });
             return;
         }
-        // Switch mode — resolve by index or name
         const index = parseInt(arg, 10);
         let target;
         if (!isNaN(index) && index >= 1 && index <= installed.length) {
@@ -664,33 +689,32 @@ You can also use natural language commands to control Claude Code CLI.`,
             target = installed.find((b) => b.id === arg || b.label.toLowerCase().includes(arg.toLowerCase()));
         }
         if (!target) {
-            this.sendResponse(messageId, {
+            this.sendResponse(messageId, threadId, {
                 success: false,
                 error: `Backend "${arg}" not found. Use /backend to see available options.`,
             });
             return;
         }
-        // Persist to config
         const newConfig = { ...currentConfig, type: target.id };
         await this.config.set('executor', newConfig);
-        // Hot-swap executor without restart
-        const cwd = this.executor.getCurrentWorkingDirectory();
-        if (typeof this.executor.destroy === 'function') {
-            this.executor.destroy();
-        }
-        this.executor = (0, executor_1.createExecutor)(this.directoryGuard, newConfig, cwd);
-        this.sendResponse(messageId, {
+        await this.threadPool.switchBackend(newConfig);
+        this.sendResponse(messageId, threadId, {
             success: true,
-            output: `✅ Backend switched to: ${target.label}`,
+            output: `✅ Backend switched to: ${target.label}\n\nAll threads will use the new backend for future commands.`,
         });
     }
     /**
-     * Destroy handler
+     * Destroy handler and all executors
      */
-    destroy() {
+    async destroy() {
         this.isDestroyed = true;
-        this.isExecuting = false;
         this.notificationAdapter.unregister();
+        try {
+            await this.threadPool.destroyAll();
+        }
+        catch (err) {
+            console.error('Error destroying thread executors:', err);
+        }
     }
 }
 exports.MessageHandler = MessageHandler;