@yu_robotics/remote-cli 1.6.75 → 1.6.85

package/README.md

@@ -26,6 +26,11 @@ The client is normally installed and run directly on the developer's machine rat
 
 ## Installation
 
+Sending local image files requires a Router with image forwarding support and
+the bot application's `im:resource` permission. Router 1.6.85 and newer render
+local and URL-based Markdown image references as captions; the uploaded image
+is rendered separately using its Feishu image key. Code examples are preserved.
+
 ```bash
 npm install -g @yu_robotics/remote-cli
 ```
@@ -91,7 +96,7 @@ Linux users upgrading from version 1.6.23 or earlier should run `remote-cli serv
 | Command | Description |
 |---------|-------------|
 | `/help` | Show help information |
-| `/status` | Show backend, model, effort, queue, and thread status |
+| `/status` | Show backend, model, effort, delegation, queue, and thread status |
 | `/context` | Show current session context and queue diagnostics |
 | `/skills` | List available skills for the active backend |
 | `/abort` | Abort executing task in current thread |
@@ -104,6 +109,7 @@ Linux users upgrading from version 1.6.23 or earlier should run `remote-cli serv
 | `/effort [auto|level]` | Show or set Codex/AGY/OpenCode/Kimi/ZCode/Pi reasoning effort |
 | `/sandbox [on/off/read-only/default]` | Configure the current Codex or Claude Code thread sandbox, directory grants, and networking |
 | `/backend` | List backends and show the current thread's effective backend |
+| `/delegation [on|off]` | Inspect or enable delegation between installed agent backends in this thread |
 | `/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 |
@@ -113,6 +119,31 @@ Linux users upgrading from version 1.6.23 or earlier should run `remote-cli serv
 
 ### Threads & Machines
 
+Use `/delegation on` in an existing thread to let its selected backend assign
+bounded tasks to other installed, authenticated backends. Claude Code, Codex,
+Pi, AGY, OpenCode, Kimi Code, and ZCode can coordinate or work, including sessions of
+the same backend. Workers return results to the original conversation and use
+its working directory; they do not create extra thread buttons. `/delegation`
+shows discovery and restrictions; `/delegation off` disables the feature. The
+setting is off by default and persists per thread. Start with one trial thread;
+never-enabled threads skip managed tools, prompt changes, and delegation
+configuration. Turning it off cleans only backends used for delegation, including
+when resumed after a CLI restart or a backend switch, while preserving their
+conversations.
+
+`/status` shows `Delegation: on/off (current thread)` for the thread receiving
+the command. Reading this setting does not initialize delegation or start workers.
+
+Child progress, approvals, and questions use the existing reply flow. `/abort`
+stops managed children as well as the parent. Sandboxed coordinators can delegate
+only to the same backend; enforced read-only workers require Claude Code or Codex. There is one
+active child per parent and at most three per CLI process, with overlapping
+workspaces serialized and bounded time/output. Workspace reservations apply to
+delegation-enabled work; opted-out threads keep ordinary workspace access, so
+use separate workspaces for independent writers. See
+[Cross-backend Delegation](../../README.md#cross-backend-delegation) for limits,
+recovery, context transfer, and permission behavior.
+
 | Command | Description |
 |---------|-------------|
 | `/thread list/new/delete` | Manage session threads |

package/dist/client/MessageHandler.d.ts

@@ -38,6 +38,8 @@ export declare class MessageHandler {
     private automaticUpdateInProgress;
     private approvalCardsSupported;
     private readonly pendingApprovalCards;
+    private readonly delegation;
+    private readonly delegationBridges;
     constructor(wsClient: WebSocketClient, threadPool: ThreadExecutorPool, threadManager: ThreadManager, directoryGuard: DirectoryGuard, config: ConfigManager);
     /**
      * Handle message (supports new IncomingMessage format)

package/dist/client/MessageHandler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MessageHandler.d.ts","sourceRoot":"","sources":["../../src/client/MessageHandler.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAC5D,OAAO,EAAE,eAAe,EAAwI,MAAM,UAAU,CAAC;AACjL,OAAO,EAAE,kBAAkB,EAAE,MAAM,8BAA8B,CAAC;AAClE,OAAO,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAKxD,OAAO,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAkGxD;;GAEG;AACH,MAAM,WAAW,OAAO;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;;GAIG;AACH,qBAAa,cAAc;IACzB,OAAO,CAAC,QAAQ,CAAkB;IAClC,OAAO,CAAC,UAAU,CAAqB;IACvC,OAAO,CAAC,aAAa,CAAgB;IACrC,OAAO,CAAC,cAAc,CAAiB;IACvC,OAAO,CAAC,MAAM,CAAgB;IAC9B,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,aAAa,CAAC,CAAS;IAC/B,OAAO,CAAC,mBAAmB,CAA4B;IACvD,OAAO,CAAC,eAAe,CAAkB;IACzC,OAAO,CAAC,eAAe,CAA0C;IACjE,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAsC;IACnE,OAAO,CAAC,QAAQ,CAAC,yBAAyB,CAA+C;IACzF,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAqB;IAClD,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAyC;IACxE,OAAO,CAAC,QAAQ,CAAC,sBAAsB,CAA4C;IACnF,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAoC;IACpE,OAAO,CAAC,yBAAyB,CAAS;IAC1C,OAAO,CAAC,sBAAsB,CAAS;IACvC,OAAO,CAAC,QAAQ,CAAC,oBAAoB,CAA+E;gBAGlH,QAAQ,EAAE,eAAe,EACzB,UAAU,EAAE,kBAAkB,EAC9B,aAAa,EAAE,aAAa,EAC5B,cAAc,EAAE,cAAc,EAC9B,MAAM,EAAE,aAAa;IAgBvB;;OAEG;IACG,aAAa,CAAC,OAAO,EAAE,OAAO,GAAG,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC;IAgDtE,uBAAuB,IAAI,OAAO;IAoBlC,kBAAkB,IAAI,IAAI;IAI1B;;OAEG;YACW,oBAAoB;IAgOlC;;OAEG;YACW,kBAAkB;IAsDhC;;OAEG;YACW,iBAAiB;IAiB/B,OAAO,CAAC,cAAc;IAOtB;;;OAGG;YACW,oBAAoB;IA4VlC,OAAO,CAAC,uBAAuB;IAgC/B,OAAO,CAAC,+BAA+B;IAOvC,OAAO,CAAC,gBAAgB;IAaxB,OAAO,CAAC,cAAc;YASR,kBAAkB;YA0ElB,sBAAsB;IAkDpC,OAAO,CAAC,sBAAsB;IAU9B,OAAO,CAAC,oBAAoB;IAS5B,OAAO,CAAC,qBAAqB;IAS7B,OAAO,CAAC,mBAAmB;IAK3B;;;;;;;;;OASG;YACW,eAAe;IA+C7B;;;OAGG;IACH,OAAO,CAAC,iBAAiB;IAkCzB;;OAEG;YACW,mBAAmB;IAoGjC;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAS1B;;;OAGG;YACW,oBAAoB;IA6MlC;;OAEG;YACW,qBAAqB;IAiBnC;;OAEG;IACH,OAAO,CAAC,UAAU;IAuBlB;;OAEG;IACH,OAAO,CAAC,sBAAsB;IAO9B;;;;;;OAMG;IACH,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,wBAAwB,CAG7C;YAEW,eAAe;IAgC7B;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAI3B;;;;;;;;;;;;;OAaG;YACW,mBAAmB;IAyDjC;;;OAGG;IACH,OAAO,CAAC,uBAAuB;IA2D/B;;OAEG;YACW,cAAc;YAkHd,sBAAsB;IAoBpC,OAAO,CAAC,4BAA4B;IAOpC,OAAO,CAAC,gBAAgB;IAIxB,OAAO,CAAC,SAAS;IASjB,OAAO,CAAC,eAAe;IAWvB,OAAO,CAAC,mBAAmB;IAI3B,OAAO,CAAC,oBAAoB;IAQ5B,OAAO,CAAC,mBAAmB;IAQ3B,OAAO,CAAC,sBAAsB;IAmB9B,OAAO,CAAC,eAAe;IAgBvB,OAAO,CAAC,WAAW;IAgBnB,OAAO,CAAC,cAAc;IAgBtB,OAAO,CAAC,oBAAoB;IAe5B,OAAO,CAAC,YAAY;IAgBpB,OAAO,CAAC,SAAS;IAgBjB,OAAO,CAAC,qBAAqB;IAmB7B,OAAO,CAAC,YAAY;IA6CpB,OAAO,CAAC,YAAY;YAMN,cAAc;YAqBd,oBAAoB;IAkHlC;;OAEG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;CAU/B"}
+{"version":3,"file":"MessageHandler.d.ts","sourceRoot":"","sources":["../../src/client/MessageHandler.ts"],"names":[],"mappings":"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"}

package/dist/client/MessageHandler.js

@@ -7,11 +7,15 @@ const LocalImageDetector_1 = require("../utils/LocalImageDetector");
 const MachineCommands_1 = require("../machines/MachineCommands");
 const child_process_1 = require("child_process");
 const promises_1 = require("fs/promises");
+const fs_1 = require("fs");
 const os_1 = require("os");
 const path_1 = require("path");
 const config_1 = require("../types/config");
 const uuid_1 = require("uuid");
 const ZCodeCommand_1 = require("../executor/zcode/ZCodeCommand");
+const DelegationManager_1 = require("../delegation/DelegationManager");
+const DelegationBridge_1 = require("../delegation/DelegationBridge");
+const contract_1 = require("../delegation/contract");
 const EFFORT_BACKENDS = new Set(['codex', 'agy', 'opencode', 'kimi', 'zcode', 'pi']);
 const NATIVE_MODEL_LIST_BACKENDS = new Set(['codex', 'opencode', 'kimi', 'zcode', 'pi']);
 const SLASH_SESSION_BACKENDS = new Set(['opencode', 'kimi', 'zcode', 'pi']);
@@ -89,12 +93,15 @@ class MessageHandler {
     automaticUpdateInProgress = false;
     approvalCardsSupported = false;
     pendingApprovalCards = new Map();
+    delegation;
+    delegationBridges = new Map();
     constructor(wsClient, threadPool, threadManager, directoryGuard, config) {
         this.wsClient = wsClient;
         this.threadPool = threadPool;
         this.threadManager = threadManager;
         this.directoryGuard = directoryGuard;
         this.config = config;
+        this.delegation = new DelegationManager_1.DelegationManager(directoryGuard);
         this.notificationAdapter = new hooks_1.FeishuNotificationAdapter(wsClient);
         this.notificationAdapter.setThreadNameResolver((threadId) => this.threadManager.getThread(threadId)?.name);
         this.notificationAdapter.register();
@@ -242,9 +249,10 @@ class MessageHandler {
             await this.handleBackendCommand(messageId, resolvedThreadId, content.trim());
             return;
         }
-        // Check if executor is waiting for interactive input
-        if ('isWaitingInput' in executor && typeof executor.isWaitingInput === 'function') {
-            const ex = executor;
+        // Child input belongs to the child executor, even though the parent owns the thread.
+        const inputExecutor = this.delegation.waitingExecutor(resolvedThreadId) ?? executor;
+        if ('isWaitingInput' in inputExecutor && typeof inputExecutor.isWaitingInput === 'function') {
+            const ex = inputExecutor;
             if (ex.isWaitingInput()) {
                 const input = content?.trim();
                 if (input) {
@@ -308,6 +316,7 @@ class MessageHandler {
             return;
         }
         const queueSensitiveCommand = /^\/(?:clear|new|compact|cd|model|effort|sandbox)(?:\s|$)/.test(content?.trim() ?? '')
+            || /^\/delegation\s+(?:on|off)(?:\s|$)/.test(content?.trim() ?? '')
             || /^\/thread\s+delete(?:\s|$)/.test(content?.trim() ?? '');
         if (queueSensitiveCommand && this.hasThreadQueueState(resolvedThreadId)) {
             this.sendResponse(messageId, resolvedThreadId, {
@@ -384,6 +393,8 @@ class MessageHandler {
         const activeOperation = this.activeThreadOperations.get(threadId);
         let aborted = false;
         const operation = (async () => {
+            if (this.threadManager.getThread(threadId)?.delegation)
+                await this.delegation.cancelThread(threadId);
             aborted = await executor.abort();
             if (activeOperation)
                 await activeOperation.done;
@@ -453,6 +464,51 @@ class MessageHandler {
      */
     async handleBuiltInCommand(messageId, threadId, content, executor) {
         const trimmed = content.trim();
+        if (trimmed === '/delegation' || trimmed.startsWith('/delegation ')) {
+            const argument = trimmed.slice('/delegation'.length).trim();
+            if (argument && argument !== 'on' && argument !== 'off') {
+                this.sendResponse(messageId, threadId, { success: false, error: 'Usage: /delegation [on|off]' });
+                return true;
+            }
+            if (argument === 'on' && !executor.configureDelegation) {
+                this.sendResponse(messageId, threadId, { success: false, error: 'This executor does not support delegation tool registration.' });
+                return true;
+            }
+            if (argument) {
+                if (argument === 'off') {
+                    const thread = this.threadManager.getThread(threadId);
+                    const backend = this.threadPool.getBackendKey(threadId);
+                    if (thread.delegationBackends?.includes(backend) || (thread.delegation && !thread.delegationBackends)) {
+                        await executor.configureDelegation?.(undefined);
+                        // Preserve cleanup ownership across process recreation and backend switches.
+                        if (!thread.delegationBackends)
+                            await this.threadManager.updateThread(threadId, { delegationBackends: [backend] });
+                    }
+                    await this.delegationBridges.get(threadId)?.close();
+                    this.delegationBridges.delete(threadId);
+                }
+                await this.threadManager.updateThread(threadId, { delegation: argument === 'on' });
+            }
+            const config = this.config.get('executor') ?? { type: 'auto' };
+            const backends = await this.delegation.registry.list(config);
+            this.sendResponse(messageId, threadId, { success: true, output: [
+                    `Delegation: ${this.threadManager.getThread(threadId)?.delegation ? 'on' : 'off'}`,
+                    `Coordinator: ${executor.configureDelegation ? backendDisplayName(this.threadPool.getBackendKey(threadId)) : 'unsupported for this backend'}`,
+                    ...(this.threadPool.getBackendKey(threadId) === 'zcode'
+                        ? ['ZCode delegation temporarily replaces user-configured MCP servers. Native tools and plugins remain available; /delegation off restores the normal MCP configuration.'] : []),
+                    ...backends.map(item => `${item.backend}: ${item.installed ? item.version : item.reason}`),
+                    'Authentication and quota are checked when a task runs. Sandboxed coordinators can delegate only to the same backend. Enforced read-only workers are available only for Claude Code and Codex.',
+                    'Usage: /delegation on|off. Applies to this thread; workers use independent sessions.',
+                ].join('\n') });
+            return true;
+        }
+        if (trimmed.startsWith('/')) {
+            const thread = this.threadManager.getThread(threadId);
+            if (!thread?.delegation && thread?.delegationBackends?.includes(this.threadPool.getBackendKey(threadId))) {
+                // Native slash commands can resume a session before the next ordinary turn.
+                await executor.configureDelegation?.(undefined);
+            }
+        }
         if (trimmed === '/sandbox' || trimmed.startsWith('/sandbox ')) {
             if (!('getSandboxStatus' in executor) || !('configureSandbox' in executor)) {
                 this.sendResponse(messageId, threadId, { success: false, error: '/sandbox is currently supported by the Codex and Claude Code backends.' });
@@ -497,6 +553,7 @@ class MessageHandler {
                 output: `📊 Status:
 - Thread: ${thread?.name ?? threadId}
 - Backend: ${backend}
+- Delegation: ${thread?.delegation ? 'on' : 'off'} (current thread)
 - Model: ${model ?? 'backend default'}
 - Reasoning effort: ${effort}
 - Working Directory: ${cwd}
@@ -567,6 +624,7 @@ Use /compact to reduce conversation context or /clear to start a fresh context.`
 - /model [name] - Show models for the active backend, or set this thread's model
 - /effort [auto|level] - Show or set effort for Codex/AGY/OpenCode/Kimi/ZCode/Pi (Claude Code is unsupported)
 - /sandbox [on|off|read-only|default|allow <directory>|remove <directory>|network on|off] - Configure this thread's sandbox (Codex, Claude Code)
+- /delegation [on|off] - Delegate tasks between installed agent backends in this thread
 - /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
@@ -1143,6 +1201,12 @@ You can also use natural language commands to control Claude Code CLI.`,
                 return;
             }
             try {
+                if (target.delegation || target.delegationBackends?.length) {
+                    await this.delegation.cancelThread(target.id);
+                    await this.delegationBridges.get(target.id)?.close();
+                    this.delegationBridges.delete(target.id);
+                    await this.delegation.store.deleteThread(target.id);
+                }
                 await this.threadPool.destroyThread(target.id);
                 await this.threadManager.deleteThread(target.id);
                 this.sendResponse(messageId, callerThreadId, {
@@ -1407,7 +1471,7 @@ You can also use natural language commands to control Claude Code CLI.`,
      * its own --print invocation").
      */
     static AGY_PASSTHROUGH_COMMANDS = new Set([
-        '/help', '/model', '/skills', '/usage', '/config', '/changelog',
+        '/help', '/model', '/skills', '/usage', '/quota', '/config', '/changelog',
         '/agents', '/permissions', '/hooks', '/credits',
     ]);
     async listLocalSkills(cwd, backend) {
@@ -1482,7 +1546,7 @@ You can also use natural language commands to control Claude Code CLI.`,
         if (backend === 'codex') {
             this.sendResponse(messageId, threadId, {
                 success: false,
-                error: `❌ "${command}" is not exposed as a Codex backend command.\n\nBuilt-in commands (/clear, /compact, /model, /effort, /cd, /thread, /backend, /abort, /status, /help) work on the supported backends.`,
+                error: `❌ "${command}" is not exposed as a Codex backend command.\n\nBuilt-in commands (/clear, /compact, /model, /effort, /cd, /thread, /backend, /delegation, /abort, /status, /help) work on the supported backends.`,
             });
             return;
         }
@@ -1561,7 +1625,12 @@ You can also use natural language commands to control Claude Code CLI.`,
      * Execute AI command on a specific executor
      */
     async executeCommand(messageId, threadId, content, executor, attachments, fromQueue = false) {
-        const complete = (success, error) => {
+        let delegationScope;
+        let delegationBridge;
+        const complete = async (success, error) => {
+            delegationBridge?.activate(undefined);
+            if (delegationScope)
+                await delegationScope.close();
             const responseError = fromQueue && !success
                 ? this.pauseQueueAfterFailure(threadId, error || 'Queued command failed') : error;
             this.sendResponse(messageId, threadId, { success, error: responseError, threads: this.threadPool.getSummaries() });
@@ -1571,6 +1640,47 @@ You can also use natural language commands to control Claude Code CLI.`,
         };
         try {
             const openId = this.getMessageOpenId(messageId);
+            const thread = this.threadManager.getThread(threadId);
+            if (thread?.delegation && executor.configureDelegation) {
+                if (this.delegation.blocksWorkspace(executor.getCurrentWorkingDirectory(), threadId)) {
+                    throw new Error('A delegated worker holds this workspace. Wait for it to finish; if worker cleanup failed, stop the worker and restart the CLI.');
+                }
+                const backend = this.threadPool.getBackendKey(threadId);
+                if (!thread.delegationBackends?.includes(backend)) {
+                    await this.threadManager.updateThread(threadId, { delegationBackends: [...(thread.delegationBackends ?? []), backend] });
+                }
+                delegationScope = this.delegation.begin({ thread, messageId,
+                    backend: this.threadPool.getBackendKey(threadId),
+                    config: this.config.get('executor') ?? { type: 'auto' },
+                    cwd: executor.getCurrentWorkingDirectory(),
+                    onToolUse: tool => this.sendToolUse(messageId, threadId, tool),
+                    onToolResult: result => this.sendToolResult(messageId, threadId, result),
+                    onNotice: text => this.sendStreamChunk(messageId, threadId, text),
+                    onApproval: (request, child) => this.forwardApproval(request, child, messageId, threadId, true),
+                    onApprovalResolved: (id, status) => this.resolveApprovalCard(id, status),
+                    isWorkspaceBusy: cwd => this.threadManager.listThreads().some(other => {
+                        if (other.id === threadId || !this.threadPool.isThreadBusy(other.id))
+                            return false;
+                        try {
+                            return (0, DelegationManager_1.workspacesOverlap)((0, fs_1.realpathSync)(this.threadPool.getExecutor(other.id).getCurrentWorkingDirectory()), cwd);
+                        }
+                        catch {
+                            return true;
+                        }
+                    }), });
+                delegationBridge = this.delegationBridges.get(threadId) ?? new DelegationBridge_1.DelegationBridge();
+                this.delegationBridges.set(threadId, delegationBridge);
+                const connection = await delegationBridge.start();
+                delegationBridge.activate(delegationScope.invoke);
+                await executor.configureDelegation(connection);
+                if (delegationScope.isClosed() || this.isDestroyed || this.abortOperations.has(threadId)) {
+                    throw new Error('Delegation was cancelled before the coordinator started');
+                }
+                content = `${contract_1.DELEGATION_INSTRUCTIONS}\n\nUser request:\n${content}`;
+            }
+            else if (thread?.delegationBackends?.includes(this.threadPool.getBackendKey(threadId)) && executor.configureDelegation) {
+                await executor.configureDelegation(undefined);
+            }
             const onTaskNotification = (notification) => {
                 if (this.isDestroyed || !this.threadManager.getThread(threadId))
                     return;
@@ -1578,6 +1688,7 @@ You can also use natural language commands to control Claude Code CLI.`,
             };
             const emittedLocalImages = new Set();
             const pendingLocalImageEmissions = new Set();
+            const delegationControlTools = new Set();
             let streamedOutput = '';
             const emitLocalImages = async (text) => {
                 const thread = this.threadManager.getThread(threadId);
@@ -1607,8 +1718,16 @@ You can also use natural language commands to control Claude Code CLI.`,
                     streamedOutput += chunk;
                     this.sendStreamChunk(messageId, threadId, chunk);
                 },
-                onToolUse: (toolUse) => this.sendToolUse(messageId, threadId, toolUse),
+                onToolUse: (toolUse) => {
+                    if (delegationScope && /remote_cli_(list_backends|delegate|result|cancel)$/.test(toolUse.name)) {
+                        delegationControlTools.add(toolUse.id);
+                        return;
+                    }
+                    this.sendToolUse(messageId, threadId, toolUse);
+                },
                 onToolResult: (toolResult) => {
+                    if (delegationControlTools.delete(toolResult.tool_use_id))
+                        return;
                     this.sendToolResult(messageId, threadId, toolResult);
                     queueLocalImages(toolResult.content);
                 },
@@ -1634,22 +1753,8 @@ You can also use natural language commands to control Claude Code CLI.`,
                         return complete(false, `❌ Auto-compact failed: ${compactResult.error}\n\nUse /compact to try again, or /clear to start fresh.`);
                     }
                     this.sendStreamChunk(messageId, threadId, '✅ Compaction done. Retrying your request...\n');
-                    const retryResult = await executor.execute(content, {
-                        onTaskNotification,
-                        onStream: (chunk) => {
-                            streamedOutput += chunk;
-                            this.sendStreamChunk(messageId, threadId, chunk);
-                        },
-                        onToolUse: (toolUse) => this.sendToolUse(messageId, threadId, toolUse),
-                        onToolResult: (toolResult) => {
-                            this.sendToolResult(messageId, threadId, toolResult);
-                            queueLocalImages(toolResult.content);
-                        },
-                        onRedactedThinking: () => this.sendRedactedThinking(messageId, threadId),
-                        onPlanMode: (planContent) => this.sendPlanMode(messageId, threadId, planContent),
-                        onImage: (image) => this.sendImage(messageId, threadId, image),
-                        attachments,
-                    });
+                    const { onApprovalRequest, onApprovalResolved, ...ordinaryRetryOptions } = executeOptions;
+                    const retryResult = await executor.execute(content, delegationScope ? executeOptions : ordinaryRetryOptions);
                     await Promise.all(pendingLocalImageEmissions);
                     await emitLocalImages(`${streamedOutput}\n${retryResult.output ?? ''}`);
                     return complete(retryResult.success, retryResult.error);
@@ -1694,14 +1799,14 @@ You can also use natural language commands to control Claude Code CLI.`,
             backend: this.threadPool.getBackendKey(threadId),
             cwd: this.threadPool.getExecutor(threadId).getCurrentWorkingDirectory(), preview: content });
     }
-    forwardApproval(approval, executor, taskMessageId, threadId) {
+    forwardApproval(approval, executor, taskMessageId, threadId, delegated = false) {
         const openId = this.getMessageOpenId(taskMessageId);
         if (!openId)
             return false;
         const request = { type: 'approval_request', messageId: approval.requestId,
             taskMessageId, openId, threadId, threadName: this.threadManager.getThread(threadId)?.name ?? threadId,
             cwd: executor.getCurrentWorkingDirectory(), approval, timestamp: Date.now() };
-        this.pendingApprovalCards.set(approval.requestId, { request, executor });
+        this.pendingApprovalCards.set(approval.requestId, { request, executor, delegated });
         if (this.approvalCardsSupported)
             this.sendApprovalMessage(request);
         return this.approvalCardsSupported;
@@ -1738,7 +1843,9 @@ You can also use natural language commands to control Claude Code CLI.`,
         }
         let accepted = false;
         try {
-            accepted = pending.executor.respondToApproval?.(message.messageId, message.action) === true;
+            if (!pending.delegated || message.action !== 'remember' || pending.request.approval.canRemember) {
+                accepted = pending.executor.respondToApproval?.(message.messageId, message.action) === true;
+            }
         }
         catch { /* Report failure without approving another request. */ }
         if (accepted) {
@@ -2025,6 +2132,9 @@ You can also use natural language commands to control Claude Code CLI.`,
         this.isDestroyed = true;
         this.notificationAdapter.unregister();
         try {
+            await this.delegation.destroy();
+            await Promise.all([...this.delegationBridges.values()].map(bridge => bridge.close()));
+            this.delegationBridges.clear();
             await this.threadPool.destroyAll({ deleteData: false });
             this.pendingApprovalCards.clear();
         }