@yu_robotics/remote-cli 1.6.8 → 1.6.10

package/dist/client/MessageHandler.js

@@ -5,7 +5,13 @@ const hooks_1 = require("../hooks");
 const FileReadDetector_1 = require("../utils/FileReadDetector");
 const MachineCommands_1 = require("../machines/MachineCommands");
 const child_process_1 = require("child_process");
+const promises_1 = require("fs/promises");
+const os_1 = require("os");
+const path_1 = require("path");
 const config_1 = require("../types/config");
+const uuid_1 = require("uuid");
+const QUEUE_CONFIRMATION_TTL_MS = 5 * 60 * 1000;
+const MAX_THREAD_QUEUE_LENGTH = 10;
 /**
  * Thread-aware Message Handler.
  * Each thread has its own executor process managed by ThreadExecutorPool.
@@ -22,6 +28,10 @@ class MessageHandler {
     notificationAdapter;
     machineCommands;
     pendingReplaces = new Map();
+    threadQueues = new Map();
+    pendingQueueConfirmations = new Map();
+    pausedQueues = new Set();
+    messageOpenIds = new Map();
     constructor(wsClient, threadPool, threadManager, directoryGuard, config) {
         this.wsClient = wsClient;
         this.threadPool = threadPool;
@@ -71,6 +81,7 @@ class MessageHandler {
     async handleCommandMessage(message) {
         const { messageId, content, attachments, workingDirectory, openId, isSlashCommand, threadId } = message;
         this.currentOpenId = openId;
+        this.messageOpenIds.set(message.messageId, openId);
         this.notificationAdapter.setCurrentOpenId(openId);
         // Resolve target thread — fall back to default if not specified
         const thread = threadId
@@ -85,6 +96,23 @@ class MessageHandler {
         }
         const resolvedThreadId = thread.id;
         const executor = this.threadPool.getExecutor(resolvedThreadId);
+        if (content?.trim() === '/queue' || content?.trim().startsWith('/queue ')) {
+            await this.handleQueueCommand(messageId, resolvedThreadId, content.trim());
+            return;
+        }
+        // Backend switching has its own lifecycle handling and must run before the
+        // normal command busy flag is acquired.
+        if (content?.trim() === '/backend' || content?.trim().startsWith('/backend ')) {
+            if (this.threadPool.isThreadBusy(resolvedThreadId)) {
+                this.sendResponse(messageId, resolvedThreadId, {
+                    success: false,
+                    error: `Thread "${thread.name}" is busy. Send /abort to cancel the running task before switching backend.`,
+                });
+                return;
+            }
+            await this.handleBackendCommand(messageId, resolvedThreadId, content.trim());
+            return;
+        }
         // Handle /abort for this specific thread (bypasses busy check)
         if (content?.trim() === '/abort') {
             await this.handleAbortCommand(messageId, resolvedThreadId, executor);
@@ -120,9 +148,35 @@ class MessageHandler {
                 await this.executePendingReplace(messageId, resolvedThreadId, pendingKey, content);
                 return;
             }
+            if (isSlashCommand || content?.trim().startsWith('/')) {
+                this.sendResponse(messageId, resolvedThreadId, {
+                    success: false,
+                    error: `Thread "${thread.name}" is busy. Send /abort to cancel the running task, or use /queue to inspect queued messages.`,
+                });
+            }
+            else {
+                if ((this.threadQueues.get(resolvedThreadId)?.length ?? 0) >= MAX_THREAD_QUEUE_LENGTH) {
+                    this.sendResponse(messageId, resolvedThreadId, {
+                        success: false,
+                        error: `Thread queue is full (${MAX_THREAD_QUEUE_LENGTH} messages). Use /abort to clear it.`,
+                    });
+                    return;
+                }
+                const queueConfirmation = this.createQueueConfirmation(resolvedThreadId, thread.name, content, attachments, openId, messageId, executor);
+                this.sendResponse(messageId, resolvedThreadId, {
+                    success: false,
+                    output: `⏳ Thread "${thread.name}" is busy. Confirm whether to add this message to its queue.`,
+                    queueConfirmation,
+                });
+            }
+            return;
+        }
+        const queueSensitiveCommand = /^\/(?:clear|compact|cd|model|effort)(?:\s|$)/.test(content?.trim() ?? '')
+            || /^\/thread\s+delete(?:\s|$)/.test(content?.trim() ?? '');
+        if (queueSensitiveCommand && this.hasThreadQueueState(resolvedThreadId)) {
             this.sendResponse(messageId, resolvedThreadId, {
                 success: false,
-                error: `Thread "${thread.name}" is busy. Send /abort to cancel the running task, or use another thread.`,
+                error: 'This thread has queued messages. Send /abort to clear the current task and queue before changing its execution context.',
             });
             return;
         }
@@ -160,7 +214,10 @@ class MessageHandler {
             }
             const expandedContent = this.expandCommandShortcuts(content);
             const processedContent = (0, FileReadDetector_1.processFileReadContent)(expandedContent);
-            await this.executeCommand(messageId, resolvedThreadId, processedContent, executor, attachments);
+            const success = await this.executeCommand(messageId, resolvedThreadId, processedContent, executor, attachments);
+            if (!success && this.threadQueues.has(resolvedThreadId)) {
+                this.pausedQueues.add(resolvedThreadId);
+            }
         }
         catch (error) {
             this.threadPool.setThreadError(resolvedThreadId, true);
@@ -171,6 +228,8 @@ class MessageHandler {
         }
         finally {
             this.threadPool.setThreadBusy(resolvedThreadId, false);
+            if (!this.pausedQueues.has(resolvedThreadId))
+                void this.startNextQueuedCommand(resolvedThreadId);
         }
     }
     /**
@@ -178,20 +237,21 @@ class MessageHandler {
      */
     async handleAbortCommand(messageId, threadId, executor) {
         const wasExecuting = this.threadPool.isThreadBusy(threadId);
+        const clearedCount = this.clearThreadQueue(threadId);
         const aborted = await executor.abort();
         if (aborted) {
             this.threadPool.setThreadBusy(threadId, false);
             this.sendResponse(messageId, threadId, {
                 success: true,
-                output: wasExecuting
-                    ? '✅ Current command has been aborted'
-                    : '⚠️ No command was executing, but executor has been reset',
+                output: `${wasExecuting ? '✅ Current command has been aborted' : '⚠️ No command was executing, but executor has been reset'}${clearedCount ? `\n🗑️ Cleared ${clearedCount} queued message${clearedCount === 1 ? '' : 's'}.` : ''}`,
             });
         }
         else {
             this.sendResponse(messageId, threadId, {
                 success: true,
-                output: 'ℹ️ No command is currently executing',
+                output: clearedCount
+                    ? `ℹ️ No command is currently executing\n🗑️ Cleared ${clearedCount} queued message${clearedCount === 1 ? '' : 's'}.`
+                    : 'ℹ️ No command is currently executing',
             });
         }
     }
@@ -231,12 +291,24 @@ class MessageHandler {
             const cwd = executor.getCurrentWorkingDirectory();
             const allowedDirs = this.directoryGuard.getAllowedDirectories();
             const threads = this.threadPool.getSummaries();
+            const thread = this.threadManager.getThread(threadId);
+            const backend = this.threadPool.getBackendKey(threadId);
+            const model = thread?.models?.[backend] ?? (backend === 'claude' ? thread?.model : undefined);
+            const effort = thread?.efforts?.[backend] ?? 'auto';
             const threadList = threads
-                .map(t => `  • ${t.name}${t.status === 'running' ? ' 🔄' : t.status === 'error' ? ' ❌' : ' ✅'} (${t.status})`)
+                .map(t => {
+                const queued = this.threadQueues.get(t.id)?.length ?? 0;
+                const queueSuffix = queued > 0 ? `, queue: ${queued}` : '';
+                return `  • ${t.name}${t.status === 'running' ? ' 🔄' : t.status === 'error' ? ' ❌' : ' ✅'} (${t.status}, backend: ${t.backend ?? 'claude'}${queueSuffix})`;
+            })
                 .join('\n');
             this.sendResponse(messageId, threadId, {
                 success: true,
                 output: `📊 Status:
+- Thread: ${thread?.name ?? threadId}
+- Backend: ${backend}
+- Model: ${model ?? 'backend default'}
+- Reasoning effort: ${effort}
 - Working Directory: ${cwd}
 - Allowed Directories: ${allowedDirs.join(', ')}
 - Connection: Active
@@ -244,19 +316,66 @@ class MessageHandler {
             });
             return true;
         }
+        if (trimmed === '/context') {
+            const thread = this.threadManager.getThread(threadId);
+            const backend = this.threadPool.getBackendKey(threadId);
+            const model = thread?.models?.[backend] ?? (backend === 'claude' ? thread?.model : undefined);
+            const effort = thread?.efforts?.[backend] ?? 'auto';
+            const sessionId = typeof executor.getSessionId === 'function' ? executor.getSessionId() : null;
+            const queued = this.threadQueues.get(threadId)?.length ?? 0;
+            const pending = Array.from(this.pendingQueueConfirmations.values())
+                .filter((confirmation) => confirmation.info.threadId === threadId).length;
+            this.sendResponse(messageId, threadId, {
+                success: true,
+                output: `🧠 Context:
+- Thread: ${thread?.name ?? threadId}
+- Backend: ${backend}
+- Model: ${model ?? 'backend default'}
+- Reasoning effort: ${effort}
+- Working Directory: ${executor.getCurrentWorkingDirectory()}
+- Session: ${sessionId ?? 'not started'}
+- Queue: ${queued} confirmed, ${pending} awaiting confirmation
+- Token usage: exact usage is not exposed by the active remote transport
+
+Use /compact to reduce conversation context or /clear to start a fresh context.`,
+            });
+            return true;
+        }
+        if (trimmed === '/skills') {
+            const backend = this.threadPool.getBackendKey(threadId);
+            if (backend === 'claude' || backend === 'agy') {
+                await this.executeSlashCommand(messageId, threadId, trimmed, executor);
+            }
+            else {
+                const skills = await this.listLocalSkills(executor.getCurrentWorkingDirectory(), backend);
+                this.sendResponse(messageId, threadId, {
+                    success: true,
+                    output: skills.length > 0
+                        ? `🧩 Available skills (local discovery):\n${skills.map((skill) => `- ${skill}`).join('\n')}`
+                        : '🧩 No local skills were discovered for the Codex backend.\n\nExpected locations include .agents/skills and ~/.codex/skills.',
+                });
+            }
+            return true;
+        }
         if (trimmed === '/help') {
             this.sendResponse(messageId, threadId, {
                 success: true,
                 output: `📖 Available commands:
 - /help - Show this help message
-- /status - Show current status and threads
+- /status - Show backend, model, effort, queue, and thread status
+- /context - Show current session context and queue diagnostics
+- /skills - List available skills for the active backend
 - /abort - Abort the currently executing command in this thread
+- /queue [clear|continue|confirm <id>|cancel <id>] - Inspect or manage this thread's command queue
 - /clear - Clear conversation context for this thread
 - /compact - Compress conversation history to reduce context size
 - /cd <directory> - Change working directory for this thread
-- /model [name] - Show available models, or switch the AI model for this thread (persists across sessions)
-- /effort [auto|level] - Show or set reasoning effort for this thread
-- /backend - List available AI backends and switch between them
+- /model [name] - Show models for the active backend, or set this thread's model
+- /effort [auto|low|medium|high] - Show or set effort for Codex/AGY (Claude Code is unsupported)
+- /backend - List backends and show the current thread's effective backend
+- /backend <index> - Switch all threads and clear per-thread backend overrides
+- /backend <index> @ - Switch only the current thread
+- /backend default @ - Clear the current thread override and follow the global backend
 - /thread list - List all threads with their status
 - /thread new [name] - Create a new thread
 - /thread delete <name> - Delete a thread (only when idle)
@@ -340,7 +459,7 @@ You can also use natural language commands to control Claude Code CLI.`,
         }
         if (trimmed === '/effort' || trimmed.startsWith('/effort ')) {
             const executorConfig = this.config.get('executor') ?? { type: 'auto' };
-            const key = (0, config_1.backendKeyOf)(executorConfig.type);
+            const key = this.threadPool.getBackendKey(threadId);
             if (key !== 'codex' && key !== 'agy') {
                 this.sendResponse(messageId, threadId, {
                     success: false,
@@ -432,7 +551,7 @@ You can also use natural language commands to control Claude Code CLI.`,
                 // thread.models[backendKey]. The legacy `model` field is kept in
                 // sync for the Claude backend only.
                 const executorConfig = this.config.get('executor') ?? { type: 'auto' };
-                const key = (0, config_1.backendKeyOf)(executorConfig.type);
+                const key = this.threadPool.getBackendKey(threadId);
                 const current = this.threadManager.getThread(threadId);
                 const models = { ...current?.models, [key]: modelArg };
                 await this.threadManager.updateThread(threadId, key === 'claude' ? { models, model: modelArg } : { models });
@@ -449,6 +568,170 @@ You can also use natural language commands to control Claude Code CLI.`,
         }
         return false;
     }
+    createQueueConfirmation(threadId, threadName, content, attachments, openId, messageId, executor) {
+        this.removeExpiredQueueConfirmations();
+        const id = (0, uuid_1.v4)();
+        const info = {
+            id,
+            threadId,
+            threadName,
+            backend: this.threadPool.getBackendKey(threadId),
+            cwd: executor.getCurrentWorkingDirectory(),
+            preview: content.replace(/\s+/g, ' ').trim().slice(0, 240),
+            pendingCount: this.threadQueues.get(threadId)?.length ?? 0,
+            expiresAt: Date.now() + QUEUE_CONFIRMATION_TTL_MS,
+        };
+        this.pendingQueueConfirmations.set(id, {
+            info,
+            command: { messageId, threadId, content, attachments, openId, enqueuedAt: Date.now() },
+        });
+        setTimeout(() => {
+            const pending = this.pendingQueueConfirmations.get(id);
+            if (pending && pending.info.expiresAt <= Date.now())
+                this.pendingQueueConfirmations.delete(id);
+        }, QUEUE_CONFIRMATION_TTL_MS).unref?.();
+        return info;
+    }
+    removeExpiredQueueConfirmations() {
+        const now = Date.now();
+        for (const [id, pending] of this.pendingQueueConfirmations) {
+            if (pending.info.expiresAt <= now)
+                this.pendingQueueConfirmations.delete(id);
+        }
+    }
+    clearThreadQueue(threadId) {
+        let cleared = this.threadQueues.get(threadId)?.length ?? 0;
+        this.threadQueues.delete(threadId);
+        for (const [id, pending] of this.pendingQueueConfirmations) {
+            if (pending.info.threadId === threadId) {
+                this.pendingQueueConfirmations.delete(id);
+                cleared += 1;
+            }
+        }
+        this.pausedQueues.delete(threadId);
+        return cleared;
+    }
+    clearAllQueues() {
+        const threadIds = new Set([
+            ...this.threadQueues.keys(),
+            ...this.pausedQueues,
+            ...Array.from(this.pendingQueueConfirmations.values()).map((pending) => pending.info.threadId),
+        ]);
+        return Array.from(threadIds).reduce((total, threadId) => total + this.clearThreadQueue(threadId), 0);
+    }
+    async handleQueueCommand(messageId, threadId, trimmed) {
+        this.removeExpiredQueueConfirmations();
+        const parts = trimmed.split(/\s+/);
+        const action = parts[1]?.toLowerCase();
+        const id = parts[2];
+        if (action === 'confirm' && id) {
+            const pending = this.pendingQueueConfirmations.get(id);
+            const currentCwd = this.threadPool.getExecutor(threadId).getCurrentWorkingDirectory();
+            if (!pending || pending.info.threadId !== threadId || pending.info.expiresAt <= Date.now()
+                || pending.info.backend !== this.threadPool.getBackendKey(threadId) || pending.info.cwd !== currentCwd
+                || (pending.command.openId && pending.command.openId !== this.getMessageOpenId(messageId))) {
+                this.pendingQueueConfirmations.delete(id);
+                this.sendResponse(messageId, threadId, { success: false, error: 'Queue confirmation is no longer valid. The message was not queued.' });
+                return;
+            }
+            this.pendingQueueConfirmations.delete(id);
+            const queue = this.threadQueues.get(threadId) ?? [];
+            if (queue.length >= MAX_THREAD_QUEUE_LENGTH) {
+                this.sendResponse(messageId, threadId, { success: false, error: `This thread queue is full (${MAX_THREAD_QUEUE_LENGTH} messages).` });
+                return;
+            }
+            queue.push({ ...pending.command, messageId: parts[3] || pending.command.messageId });
+            this.threadQueues.set(threadId, queue);
+            this.sendResponse(messageId, threadId, {
+                success: true,
+                output: `✅ Added to queue for ${pending.info.threadName}.\nQueue position: ${queue.length}\nPending messages for this thread: ${queue.length}`,
+            });
+            void this.startNextQueuedCommand(threadId);
+            return;
+        }
+        if (action === 'cancel' && id) {
+            const pending = this.pendingQueueConfirmations.get(id);
+            if (pending?.info.threadId === threadId) {
+                this.pendingQueueConfirmations.delete(id);
+                this.sendResponse(messageId, threadId, { success: true, output: '❌ Message was not queued.' });
+            }
+            else {
+                this.sendResponse(messageId, threadId, { success: false, error: 'Queue confirmation is no longer valid.' });
+            }
+            return;
+        }
+        if (action === 'clear') {
+            const cleared = this.clearThreadQueue(threadId);
+            this.sendResponse(messageId, threadId, {
+                success: true,
+                output: cleared ? `🗑️ Cleared ${cleared} queued message${cleared === 1 ? '' : 's'}.` : 'ℹ️ This thread queue is empty.',
+            });
+            return;
+        }
+        if (action === 'continue') {
+            this.pausedQueues.delete(threadId);
+            this.sendResponse(messageId, threadId, { success: true, output: '▶️ Queue resumed.' });
+            void this.startNextQueuedCommand(threadId);
+            return;
+        }
+        const lines = ['📋 Thread queues:'];
+        for (const summary of this.threadPool.getSummaries()) {
+            const queued = this.threadQueues.get(summary.id) ?? [];
+            const pending = Array.from(this.pendingQueueConfirmations.values()).filter((item) => item.info.threadId === summary.id);
+            if (summary.status !== 'running' && queued.length === 0 && pending.length === 0 && !this.pausedQueues.has(summary.id))
+                continue;
+            lines.push(`\n${summary.name} (${summary.backend ?? 'global'}) — ${summary.status}`);
+            lines.push(`  Confirmed: ${queued.length}; awaiting confirmation: ${pending.length}`);
+            queued.forEach((command, index) => lines.push(`  ${index + 1}. ${command.content.replace(/\s+/g, ' ').slice(0, 160)}`));
+            if (this.pausedQueues.has(summary.id))
+                lines.push('  ⏸️ Paused after a failed task. Use /queue continue or /abort.');
+        }
+        if (lines.length === 1)
+            lines.push('No active or pending thread queues.');
+        this.sendResponse(messageId, threadId, { success: true, output: lines.join('\n') });
+    }
+    async startNextQueuedCommand(threadId) {
+        if (this.threadPool.isThreadBusy(threadId) || this.pausedQueues.has(threadId))
+            return;
+        const queue = this.threadQueues.get(threadId);
+        const command = queue?.shift();
+        if (!command) {
+            this.threadQueues.delete(threadId);
+            return;
+        }
+        if (queue?.length === 0)
+            this.threadQueues.delete(threadId);
+        const thread = this.threadManager.getThread(threadId);
+        if (!thread)
+            return;
+        this.currentOpenId = command.openId;
+        this.messageOpenIds.set(command.messageId, command.openId);
+        this.notificationAdapter.setCurrentOpenId(command.openId);
+        this.threadPool.setThreadBusy(threadId, true);
+        try {
+            const executor = this.threadPool.getExecutor(threadId);
+            await this.threadManager.updateThread(threadId, { lastActiveAt: Date.now() });
+            const processedContent = (0, FileReadDetector_1.processFileReadContent)(this.expandCommandShortcuts(command.content));
+            const success = await this.executeCommand(command.messageId, threadId, processedContent, executor, command.attachments);
+            if (!success) {
+                this.pausedQueues.add(threadId);
+            }
+        }
+        catch (error) {
+            this.pausedQueues.add(threadId);
+            this.sendResponse(command.messageId, threadId, { success: false, error: error instanceof Error ? error.message : 'Queued command failed' });
+        }
+        finally {
+            this.threadPool.setThreadBusy(threadId, false);
+            if (!this.pausedQueues.has(threadId))
+                void this.startNextQueuedCommand(threadId);
+        }
+    }
+    hasThreadQueueState(threadId) {
+        if ((this.threadQueues.get(threadId)?.length ?? 0) > 0)
+            return true;
+        return Array.from(this.pendingQueueConfirmations.values()).some((pending) => pending.info.threadId === threadId);
+    }
     /**
      * Bare /model: show the thread's current model on the active backend plus
      * the available models. Listing source per backend (all verified live):
@@ -459,7 +742,7 @@ You can also use natural language commands to control Claude Code CLI.`,
      */
     async handleModelList(messageId, threadId) {
         const executorConfig = this.config.get('executor') ?? { type: 'auto' };
-        const key = (0, config_1.backendKeyOf)(executorConfig.type);
+        const key = this.threadPool.getBackendKey(threadId);
         const thread = this.threadManager.getThread(threadId);
         const current = thread?.models?.[key] ?? (key === 'claude' ? thread?.model : undefined);
         const backendLabel = key === 'claude' ? 'Claude Code' : key === 'agy' ? 'AGY CLI' : 'Codex CLI';
@@ -553,7 +836,8 @@ You can also use natural language commands to control Claude Code CLI.`,
             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}`;
+                const backend = t.backend ? ` [${t.backend}]` : '';
+                return `${icon} ${t.name}${backend}${current}`;
             });
             this.sendResponse(messageId, callerThreadId, {
                 success: true,
@@ -567,7 +851,7 @@ You can also use natural language commands to control Claude Code CLI.`,
             const callerExecutor = this.threadPool.getExecutor(callerThread.id);
             const cwd = callerExecutor.getCurrentWorkingDirectory();
             try {
-                const newThread = await this.threadManager.createThread(name || this.generateThreadName(), cwd);
+                const newThread = await this.threadManager.createThread(name || this.generateThreadName(), cwd, this.threadPool.getBackendKey(callerThread.id));
                 // 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, {
@@ -876,18 +1160,43 @@ You can also use natural language commands to control Claude Code CLI.`,
         '/help', '/model', '/skills', '/usage', '/config', '/changelog',
         '/agents', '/permissions', '/hooks', '/credits',
     ]);
+    async listLocalSkills(cwd, backend) {
+        const roots = backend === 'codex'
+            ? [(0, path_1.join)(cwd, '.agents', 'skills'), (0, path_1.join)((0, os_1.homedir)(), '.codex', 'skills'), (0, path_1.join)((0, os_1.homedir)(), '.codex', 'skills', '.system')]
+            : [(0, path_1.join)(cwd, '.claude', 'skills'), (0, path_1.join)((0, os_1.homedir)(), '.claude', 'skills')];
+        const skills = [];
+        const seen = new Set();
+        for (const root of roots) {
+            let entries;
+            try {
+                entries = await (0, promises_1.readdir)(root, { withFileTypes: true });
+            }
+            catch {
+                continue;
+            }
+            for (const entry of entries) {
+                if (!entry.isDirectory() || seen.has(entry.name))
+                    continue;
+                const skillPath = (0, path_1.join)(root, entry.name, 'SKILL.md');
+                try {
+                    const content = await (0, promises_1.readFile)(skillPath, 'utf8');
+                    const description = content.match(/^description:\s*(.+)$/mi)?.[1]?.trim();
+                    skills.push(description ? `${entry.name} — ${description}` : entry.name);
+                    seen.add(entry.name);
+                }
+                catch {
+                    continue;
+                }
+            }
+        }
+        return skills.sort((left, right) => left.localeCompare(right));
+    }
     /**
-     * Which backend slash commands should be forwarded to, based on config.
+     * Which backend slash commands should be forwarded to for a thread.
      * 'auto'/claude-* always resolve to Claude; legacy 'gemini' means AGY.
      */
-    resolveSlashBackend() {
-        const cfg = this.config.get('executor') ?? { type: 'auto' };
-        const t = cfg.type;
-        if (t === 'agy' || t === 'gemini')
-            return 'agy';
-        if (t === 'codex')
-            return 'codex';
-        return 'claude';
+    resolveSlashBackend(threadId) {
+        return this.threadPool.getBackendKey(threadId);
     }
     /**
      * Execute passthrough slash command on the active backend's CLI.
@@ -901,7 +1210,7 @@ You can also use natural language commands to control Claude Code CLI.`,
      *   implemented through app-server methods instead.
      */
     async executeSlashCommand(messageId, threadId, command, executor) {
-        const backend = this.resolveSlashBackend();
+        const backend = this.resolveSlashBackend(threadId);
         if (backend === 'codex') {
             this.sendResponse(messageId, threadId, {
                 success: false,
@@ -1009,7 +1318,7 @@ You can also use natural language commands to control Claude Code CLI.`,
                             success: false,
                             error: `❌ Auto-compact failed: ${compactResult.error}\n\nUse /compact to try again, or /clear to start fresh.`,
                         });
-                        return;
+                        return false;
                     }
                     this.sendStreamChunk(messageId, threadId, '✅ Compaction done. Retrying your request...\n');
                     const retryResult = await executor.execute(content, {
@@ -1021,28 +1330,30 @@ You can also use natural language commands to control Claude Code CLI.`,
                         attachments,
                     });
                     this.sendResponse(messageId, threadId, { success: retryResult.success, error: retryResult.error, threads: this.threadPool.getSummaries() });
-                    return;
+                    return retryResult.success;
                 }
                 this.sendResponse(messageId, threadId, {
                     success: false,
                     error: '❌ Conversation history too long.\n\nUse /compact to compress it, or /clear to start fresh.',
                 });
-                return;
+                return false;
             }
             this.sendResponse(messageId, threadId, { success: result.success, error: result.error, threads: this.threadPool.getSummaries() });
+            return result.success;
         }
         catch (error) {
             this.sendResponse(messageId, threadId, {
                 success: false,
                 error: error instanceof Error ? error.message : 'Execution error',
             });
+            return false;
         }
     }
     async clearInvalidCodexModel(threadId, executor, error) {
         if (!error || !this.isUnavailableCodexModelError(error))
             return false;
         const executorConfig = this.config.get('executor') ?? { type: 'auto' };
-        if ((0, config_1.backendKeyOf)(executorConfig.type) !== 'codex')
+        if (this.threadPool.getBackendKey(threadId) !== 'codex')
             return false;
         const thread = this.threadManager.getThread(threadId);
         if (!thread?.models?.codex)
@@ -1058,6 +1369,9 @@ You can also use natural language commands to control Claude Code CLI.`,
             || /unknown Codex model/i.test(error);
     }
     // ── Outgoing message helpers ──────────────────────────────────────────────
+    getMessageOpenId(messageId) {
+        return this.messageOpenIds.get(messageId) ?? this.currentOpenId;
+    }
     sendStreamChunk(messageId, threadId, chunk) {
         try {
             this.wsClient.send({
@@ -1065,7 +1379,7 @@ You can also use natural language commands to control Claude Code CLI.`,
                 messageId,
                 chunk,
                 streamType: 'text',
-                openId: this.currentOpenId,
+                openId: this.getMessageOpenId(messageId),
                 threadId,
                 timestamp: Date.now(),
             });
@@ -1081,7 +1395,7 @@ You can also use natural language commands to control Claude Code CLI.`,
                 messageId,
                 streamType: 'tool_use',
                 toolUse,
-                openId: this.currentOpenId,
+                openId: this.getMessageOpenId(messageId),
                 threadId,
                 timestamp: Date.now(),
             });
@@ -1097,7 +1411,7 @@ You can also use natural language commands to control Claude Code CLI.`,
                 messageId,
                 streamType: 'tool_result',
                 toolResult,
-                openId: this.currentOpenId,
+                openId: this.getMessageOpenId(messageId),
                 threadId,
                 timestamp: Date.now(),
             });
@@ -1112,7 +1426,7 @@ You can also use natural language commands to control Claude Code CLI.`,
                 type: 'stream',
                 messageId,
                 streamType: 'redacted_thinking',
-                openId: this.currentOpenId,
+                openId: this.getMessageOpenId(messageId),
                 threadId,
                 timestamp: Date.now(),
             });
@@ -1128,7 +1442,7 @@ You can also use natural language commands to control Claude Code CLI.`,
                 messageId,
                 streamType: 'plan_mode',
                 planContent,
-                openId: this.currentOpenId,
+                openId: this.getMessageOpenId(messageId),
                 threadId,
                 timestamp: Date.now(),
             });
@@ -1143,7 +1457,7 @@ You can also use natural language commands to control Claude Code CLI.`,
                 type: 'structured',
                 messageId,
                 structuredContent,
-                openId: this.currentOpenId,
+                openId: this.getMessageOpenId(messageId),
                 threadId,
                 timestamp: Date.now(),
             });
@@ -1171,12 +1485,14 @@ You can also use natural language commands to control Claude Code CLI.`,
                 output: result.output,
                 error: result.error,
                 sessionAbbr: result.sessionAbbr,
-                openId: this.currentOpenId,
+                openId: this.getMessageOpenId(messageId),
                 threadId,
                 threads: result.threads,
+                queueConfirmation: result.queueConfirmation,
                 cwd,
                 timestamp: Date.now(),
             });
+            this.messageOpenIds.delete(messageId);
         }
         catch (error) {
             console.error('Failed to send response:', error);
@@ -1203,6 +1519,7 @@ You can also use natural language commands to control Claude Code CLI.`,
     async handleBackendCommand(messageId, threadId, trimmed) {
         const parts = trimmed.split(/\s+/);
         const arg = parts[1];
+        const isThreadOverride = parts[2] === '@';
         const currentConfig = this.config.get('executor') ?? { type: 'auto' };
         const currentType = currentConfig.type;
         const backends = await this.detectBackends();
@@ -1224,9 +1541,30 @@ You can also use natural language commands to control Claude Code CLI.`,
                 const active = b.id === currentType || isClaudeActive || isAgyActive ? ' ★ (active)' : '';
                 return `${i + 1}. ${b.label}${active}`;
             });
+            const currentBackend = this.threadPool.getBackendKey(threadId);
+            lines.push(`\nCurrent thread backend: ${currentBackend}${this.threadManager.getThread(threadId)?.backend ? ' (override)' : ' (global)'}`);
             this.sendResponse(messageId, threadId, {
                 success: true,
-                output: `🤖 Available AI backends:\n${lines.join('\n')}\n\nSwitch with: /backend <index> or /backend <name>`,
+                output: `🤖 Available AI backends:\n${lines.join('\n')}\n\nSwitch all threads with: /backend <index>\nSwitch this thread with: /backend <index> @\nReset this thread: /backend default @`,
+                threads: this.threadPool.getSummaries(),
+            });
+            return;
+        }
+        if (arg === 'default' && isThreadOverride) {
+            if (this.threadPool.isThreadBusy(threadId)) {
+                this.sendResponse(messageId, threadId, {
+                    success: false,
+                    error: 'Cannot reset backend while this thread is running. Send /abort first.',
+                });
+                return;
+            }
+            await this.threadPool.destroyThread(threadId, { deleteData: false });
+            await this.threadManager.updateThread(threadId, { backend: undefined });
+            const clearedCount = this.clearThreadQueue(threadId);
+            this.sendResponse(messageId, threadId, {
+                success: true,
+                output: `✅ Thread backend reset to the global backend (${(0, config_1.backendKeyOf)(currentType)}).${clearedCount ? `\n🗑️ Cleared ${clearedCount} queued message${clearedCount === 1 ? '' : 's'}.` : ''}`,
+                threads: this.threadPool.getSummaries(),
             });
             return;
         }
@@ -1246,11 +1584,39 @@ You can also use natural language commands to control Claude Code CLI.`,
             return;
         }
         const newConfig = { ...currentConfig, type: target.id };
+        if (isThreadOverride) {
+            try {
+                await this.threadPool.switchThreadBackend(threadId, (0, config_1.backendKeyOf)(target.id));
+                const clearedCount = this.clearThreadQueue(threadId);
+                this.sendResponse(messageId, threadId, {
+                    success: true,
+                    output: `✅ This thread switched to: ${target.label}${clearedCount ? `\n🗑️ Cleared ${clearedCount} queued message${clearedCount === 1 ? '' : 's'}.` : ''}\n\nUse /backend ${installed.indexOf(target) + 1} to switch all threads, or /backend default @ to follow the global backend again.`,
+                    threads: this.threadPool.getSummaries(),
+                });
+            }
+            catch (error) {
+                this.sendResponse(messageId, threadId, {
+                    success: false,
+                    error: error instanceof Error ? error.message : 'Failed to switch thread backend',
+                });
+            }
+            return;
+        }
+        if (this.threadPool.getSummaries().some((thread) => thread.status === 'running')) {
+            this.sendResponse(messageId, threadId, {
+                success: false,
+                error: 'Cannot switch all backends while a thread is running. Send /abort first.',
+            });
+            return;
+        }
         await this.config.set('executor', newConfig);
         await this.threadPool.switchBackend(newConfig);
+        await this.threadManager.clearBackendOverrides();
+        const clearedCount = this.clearAllQueues();
         this.sendResponse(messageId, threadId, {
             success: true,
-            output: `✅ Backend switched to: ${target.label}\n\nAll threads will use the new backend for future commands. Conversations on the previous backend are preserved — switch back to resume them.`,
+            output: `✅ Backend switched to: ${target.label}${clearedCount ? `\n🗑️ Cleared ${clearedCount} queued message${clearedCount === 1 ? '' : 's'}.` : ''}\n\nAll threads will use the new backend for future commands. Conversations on the previous backend are preserved — switch back to resume them.`,
+            threads: this.threadPool.getSummaries(),
         });
     }
     /**