@yu_robotics/remote-cli 1.6.170 → 1.6.176

package/dist/client/MessageHandler.js

@@ -12,9 +12,11 @@ const fs_1 = __importDefault(require("fs"));
 const os_1 = __importDefault(require("os"));
 const path_1 = __importDefault(require("path"));
 const DelegationSettings_1 = require("../thread/DelegationSettings");
+const GoalCommand_1 = require("./GoalCommand");
 const hooks_1 = require("../hooks");
 const FileReadDetector_1 = require("../utils/FileReadDetector");
 const LocalImageDetector_1 = require("../utils/LocalImageDetector");
+const ImageDelivery_1 = require("../utils/ImageDelivery");
 const WorkingDirectory_1 = require("../utils/WorkingDirectory");
 const MachineCommands_1 = require("../machines/MachineCommands");
 const child_process_1 = require("child_process");
@@ -167,6 +169,7 @@ class MessageHandler {
     });
     activeThreadOperations = new Map();
     abortOperations = new Map();
+    pendingGoalActivations = new Map();
     automaticUpdateInProgress = false;
     approvalCardsSupported = false;
     streamingContextSupported = false;
@@ -176,6 +179,7 @@ class MessageHandler {
     activityProgressSupported = false;
     workerContextResetSupported = false;
     settingsCardsSupported = false;
+    modelSpeedSettingsSupported = false;
     directoryCardsSupported = false;
     directoryBrowser;
     delegationCardsSupported = false;
@@ -186,6 +190,8 @@ class MessageHandler {
     delegation;
     delegationBridges = new Map();
     fileInbox;
+    imageDeliveries = new Map();
+    imageConnectionEpoch = 0;
     constructor(wsClient, threadPool, threadManager, directoryGuard, config) {
         this.wsClient = wsClient;
         this.threadPool = threadPool;
@@ -193,8 +199,11 @@ class MessageHandler {
         this.directoryGuard = directoryGuard;
         this.config = config;
         this.wsClient.onClose?.(() => {
+            this.imageConnectionEpoch++;
             this.routerVersion = undefined;
             this.fileInbox?.disconnect();
+            for (const delivery of this.imageDeliveries.values())
+                delivery.invalidatePending();
         });
         this.delegation = new DelegationManager_1.DelegationManager(directoryGuard);
         this.settingsCatalogReader = new SettingsCatalog_1.SettingsCatalogReader(directoryGuard);
@@ -216,7 +225,7 @@ class MessageHandler {
                 if (!thread)
                     throw new Error('This thread no longer exists.');
                 const config = this.executorConfiguration();
-                return this.settingsCatalogReader.read(config, thread, this.threadPool.getBackendKey(id), target, kind);
+                return this.settingsCatalogReader.read(config, thread, this.threadPool.getBackendKey(id), target, kind, this.modelSpeedSettingsSupported);
             },
             busy: (id, except, queue = true) => this.settingsBusy(id, except, queue),
             threads: () => this.threadManager.listThreads().map(thread => thread.id),
@@ -234,6 +243,7 @@ class MessageHandler {
             preference: (id, target, kind, value) => this.applyPreference(id, target, kind, value),
             delegation: (id, enabled) => this.applyDelegationSetting(id, enabled),
             delegationSupported: id => Boolean(this.threadPool.getExecutor(id).configureDelegation),
+            speedSettingsSupported: () => this.modelSpeedSettingsSupported,
         });
         this.directoryBrowser = new DirectoryBrowser_1.DirectoryBrowser({
             guard: this.directoryGuard,
@@ -344,6 +354,7 @@ class MessageHandler {
                 this.delegationProgressSupported = data.capabilities?.delegationProgress === true;
                 this.workerContextResetSupported = this.delegationProgressSupported && data.capabilities?.workerContextReset === true;
                 this.settingsCardsSupported = data.capabilities?.settingsCards === true;
+                this.modelSpeedSettingsSupported = this.settingsCardsSupported && data.capabilities?.modelSpeedSettings === true;
                 this.directoryCardsSupported = this.settingsCardsSupported && data.capabilities?.directoryCards === true;
                 this.delegationCardsSupported = this.settingsCardsSupported && data.capabilities?.delegationCards === true;
                 this.delegationProgressTextSupported = this.delegationProgressSupported
@@ -525,6 +536,53 @@ class MessageHandler {
         }
         const executor = this.threadPool.getExecutor(resolvedThreadId);
         this.sendStreamContext(messageId, resolvedThreadId, executor);
+        const goalCommand = (0, GoalCommand_1.parseGoalCommand)(settingsCommand);
+        let goalRequest;
+        if (goalCommand) {
+            if (goalCommand.kind === 'invalid' || goalCommand.kind === 'help') {
+                this.sendResponse(messageId, resolvedThreadId, goalCommand.kind === 'invalid'
+                    ? { success: false, error: goalCommand.error } : { success: true, output: GoalCommand_1.GOAL_USAGE });
+                return;
+            }
+            if (this.threadPool.getBackendKey(resolvedThreadId) !== 'codex'
+                || !executor.getGoal || !executor.executeGoal || !executor.pauseGoal || !executor.clearGoal) {
+                this.sendResponse(messageId, resolvedThreadId, { success: false,
+                    error: '/goal requires the Codex app-server backend and an executor version with native goal support.' });
+                return;
+            }
+            if (attachments?.length || message.fileIds?.length) {
+                this.sendResponse(messageId, resolvedThreadId, { success: false,
+                    error: 'Send attachments in a normal message before starting a goal. No goal was changed.' });
+                return;
+            }
+            if (goalCommand.kind !== 'run') {
+                try {
+                    const pending = this.pendingGoalActivations.get(resolvedThreadId);
+                    if (pending && goalCommand.kind !== 'show')
+                        pending.cancelled = true;
+                    const result = goalCommand.kind === 'show' ? { success: true, output: (0, GoalCommand_1.formatGoal)(await executor.getGoal()) }
+                        : goalCommand.kind === 'pause' ? await executor.pauseGoal() : await executor.clearGoal();
+                    this.sendResponse(messageId, resolvedThreadId, { ...result, threads: this.threadPool.getSummaries() });
+                }
+                catch (error) {
+                    this.sendResponse(messageId, resolvedThreadId, { success: false,
+                        error: `Goal control failed: ${error instanceof Error ? error.message : String(error)}` });
+                }
+                return;
+            }
+            if ((0, DelegationSettings_1.isDelegationEnabled)(thread) || this.delegation.hasActiveTasks(resolvedThreadId)) {
+                this.sendResponse(messageId, resolvedThreadId, { success: false,
+                    error: 'Native goals require managed delegation to be off. Wait for workers to finish and send /delegation off in this thread, then retry /goal.' });
+                return;
+            }
+            if (this.threadPool.isThreadBusy(resolvedThreadId) || executor.isBusy?.()
+                || this.hasThreadQueueState(resolvedThreadId) || this.abortOperations.has(resolvedThreadId)) {
+                this.sendResponse(messageId, resolvedThreadId, { success: false,
+                    error: 'Start or resume a goal only when this thread and its queue are idle. Use /goal pause or /abort to stop current goal work.' });
+                return;
+            }
+            goalRequest = goalCommand.request;
+        }
         // Handle /abort for this specific thread (bypasses busy check)
         if (content?.trim() === '/abort') {
             await this.handleAbortCommand(messageId, resolvedThreadId, executor);
@@ -594,7 +652,7 @@ class MessageHandler {
             return;
         }
         const inputExecutor = this.delegation.waitingExecutor(resolvedThreadId) ?? executor;
-        if ('isWaitingInput' in inputExecutor && typeof inputExecutor.isWaitingInput === 'function') {
+        if (!goalRequest && 'isWaitingInput' in inputExecutor && typeof inputExecutor.isWaitingInput === 'function') {
             const ex = inputExecutor;
             if (ex.isWaitingInput()) {
                 const input = content?.trim();
@@ -682,6 +740,9 @@ class MessageHandler {
             });
             return;
         }
+        const goalActivation = goalRequest ? { cancelled: false } : undefined;
+        if (goalActivation)
+            this.pendingGoalActivations.set(resolvedThreadId, goalActivation);
         const operationToken = this.beginThreadOperation(resolvedThreadId);
         try {
             this.trackTask(messageId, resolvedThreadId, content || '');
@@ -716,6 +777,10 @@ class MessageHandler {
                 await this.executePendingReplace(messageId, resolvedThreadId, pendingKey, content);
                 return;
             }
+            if (goalRequest) {
+                await this.executeCommand(messageId, resolvedThreadId, content, executor, undefined, false, goalRequest, goalActivation);
+                return;
+            }
             const builtInResult = await this.handleBuiltInCommand(messageId, resolvedThreadId, content, executor);
             if (builtInResult)
                 return;
@@ -736,6 +801,9 @@ class MessageHandler {
             });
         }
         finally {
+            if (goalActivation && this.pendingGoalActivations.get(resolvedThreadId) === goalActivation) {
+                this.pendingGoalActivations.delete(resolvedThreadId);
+            }
             if (this.finishThreadOperation(resolvedThreadId, operationToken) && !this.pausedQueues.has(resolvedThreadId)) {
                 void this.startNextQueuedCommand(resolvedThreadId);
             }
@@ -746,9 +814,20 @@ class MessageHandler {
      */
     async handleAbortCommand(messageId, threadId, executor) {
         this.fileInbox?.cancelThread(threadId);
+        this.imageDeliveries.get(threadId)?.cancel();
+        const pendingGoal = this.pendingGoalActivations.get(threadId);
+        if (pendingGoal)
+            pendingGoal.cancelled = true;
         const existingAbort = this.abortOperations.get(threadId);
         if (existingAbort) {
             await existingAbort;
+            if (executor.isGoalRunning?.()) {
+                this.sendResponse(messageId, threadId, {
+                    success: false,
+                    error: 'Native goal stop could not be confirmed. This thread remains busy; retry /goal pause or /abort.',
+                });
+                return;
+            }
             this.sendResponse(messageId, threadId, {
                 success: true,
                 output: 'ℹ️ The abort operation has already completed.',
@@ -763,6 +842,9 @@ class MessageHandler {
             if ((0, DelegationSettings_1.isDelegationEnabled)(this.threadManager.getThread(threadId)))
                 await this.delegation.cancelThread(threadId);
             aborted = await executor.abort();
+            if (!aborted && executor.isGoalRunning?.()) {
+                throw new Error('Native goal stop could not be confirmed. This thread remains busy; retry /goal pause or /abort.');
+            }
             if (activeOperation)
                 await activeOperation.done;
         })();
@@ -1051,6 +1133,7 @@ Use /compact to reduce conversation context or /clear to start a fresh context.`
 - /cd <directory> - Change working directory for this thread
 - /model [name] - Open model settings, or set the active backend model with a text argument
 - /effort [auto|level] - Open effort settings, or set a native supported level with a text argument
+- /goal [objective|pause|resume|clear] - Manage a native Codex goal; optional --budget <tokens> on start or resume
 - /sandbox [on|off|read-only|default|allow <directory>|remove <directory>|network on|off] - Configure this thread's sandbox (Codex, Claude Code)
 - /delegation [on|off|reset [backend]] - Delegate tasks between installed agent backends; reset saved worker context when needed
 - /backend - Open backend settings (Current thread by default; Confirm applies)
@@ -2010,12 +2093,13 @@ 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) {
+    async executeCommand(messageId, threadId, content, executor, attachments, fromQueue = false, goalRequest, goalActivation) {
         this.sendStreamContext(messageId, threadId, executor);
         let delegationScope;
         let delegationBridge;
         let executionMetadata;
         let requestFinished = false;
+        let imageDelivery;
         let executionActive = false;
         let lastProgramState;
         const activity = new ActivityProgress_1.ActivityProgress(snapshot => {
@@ -2040,6 +2124,9 @@ You can also use natural language commands to control Claude Code CLI.`,
                 lastProgramState = text;
         };
         const complete = async (success, error) => {
+            await imageDelivery?.finish();
+            if (this.imageDeliveries.get(threadId) === imageDelivery)
+                this.imageDeliveries.delete(threadId);
             requestFinished = true;
             activity.dispose();
             delegationBridge?.activate(undefined);
@@ -2079,6 +2166,9 @@ You can also use natural language commands to control Claude Code CLI.`,
             }
             const openId = this.getMessageOpenId(messageId);
             const thread = this.threadManager.getThread(threadId);
+            if (goalRequest && thread && (0, DelegationSettings_1.isDelegationEnabled)(thread)) {
+                throw new Error('Turn managed delegation off before starting a native goal.');
+            }
             if (thread && (0, DelegationSettings_1.isDelegationEnabled)(thread) && 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.');
@@ -2133,37 +2223,41 @@ You can also use natural language commands to control Claude Code CLI.`,
                     return;
                 this.notificationAdapter.sendTaskNotification({ ...notification, threadId }, openId);
             };
-            const emittedLocalImages = new Set();
-            const pendingLocalImageEmissions = new Set();
+            const imageCwd = thread?.workingDirectory ?? executor.getCurrentWorkingDirectory();
+            const imageGeneration = thread?.delegationWorkspaceGeneration ?? 0;
+            const imageBackend = this.threadPool.getBackendKey(threadId);
+            let imagePhase = 0;
+            const imageEligible = () => {
+                const phase = imagePhase;
+                return () => phase === imagePhase && (!delegationScope
+                    || (!delegationScope.isClosed() && !delegationScope.hasPendingResults()));
+            };
+            imageDelivery = new ImageDelivery_1.ImageDelivery({
+                readFile: filePath => (0, LocalImageDetector_1.readLocalImagePath)(filePath, imageCwd, this.directoryGuard),
+                publish: image => {
+                    if (!this.sendImage(messageId, threadId, image))
+                        throw new Error('Image send failed');
+                },
+                notice: text => this.sendStreamChunk(messageId, threadId, text),
+                isCurrent: () => {
+                    const current = this.threadManager.getThread(threadId);
+                    return !requestFinished && !this.isDestroyed && !this.abortOperations.has(threadId)
+                        && this.wsClient.isConnected() && this.imageDeliveries.get(threadId) === imageDelivery
+                        && this.wsClient.canSendTaskOutput?.(messageId) !== false
+                        && !!current && current.workingDirectory === imageCwd
+                        && (current.delegationWorkspaceGeneration ?? 0) === imageGeneration
+                        && this.threadPool.getBackendKey(threadId) === imageBackend;
+                },
+            });
+            this.imageDeliveries.get(threadId)?.cancel();
+            this.imageDeliveries.set(threadId, imageDelivery);
             const delegationControlTools = new Set();
             const toolImageStates = new Map();
             const webToolNames = new Set(['websearch', 'webfetch', 'web_search', 'web_fetch', 'search_web', 'read_url_content', 'fetch']);
-            let streamedOutput = '';
-            const emitLocalImages = async (text) => {
-                try {
-                    const thread = this.threadManager.getThread(threadId);
-                    if (typeof text !== 'string' || !text || !thread?.workingDirectory)
-                        return;
-                    const images = await (0, LocalImageDetector_1.readLocalImages)(text, thread.workingDirectory, (candidate, cwd) => (this.directoryGuard.isSafePath(candidate, cwd)));
-                    for (const image of images) {
-                        if (emittedLocalImages.has(image.path))
-                            continue;
-                        emittedLocalImages.add(image.path);
-                        this.sendImage(messageId, threadId, {
-                            type: 'image',
-                            data: image.data,
-                            mimeType: image.mimeType,
-                        });
-                    }
-                }
-                catch {
-                    // Image forwarding is optional; never reject a task or log native content on failure.
-                    console.warn('Failed to forward local images; continuing task output.');
-                }
-            };
+            let streamedAny = false;
+            let imageTextDropped = false;
             const queueLocalImages = (text) => {
-                const pending = emitLocalImages(text).finally(() => pendingLocalImageEmissions.delete(pending));
-                pendingLocalImageEmissions.add(pending);
+                imageDelivery?.offerText(text, imageEligible());
             };
             const executeOptions = {
                 onActivity: this.activityProgressSupported ? (snapshot) => activity.offer(snapshot) : undefined,
@@ -2174,8 +2268,11 @@ You can also use natural language commands to control Claude Code CLI.`,
                 onApprovalResolved: (requestId, status) => this.resolveApprovalCard(requestId, status),
                 onTaskNotification,
                 onStream: (chunk) => {
-                    streamedOutput += chunk;
-                    this.sendStreamChunk(messageId, threadId, chunk);
+                    streamedAny = true;
+                    if (this.sendStreamChunk(messageId, threadId, chunk))
+                        imageDelivery?.offerStream(chunk, imageEligible());
+                    else
+                        imageTextDropped = true;
                 },
                 onToolUse: (toolUse) => {
                     if (delegationScope && /remote_cli_(list_backends|delegate|result|cancel|integrate)$/.test(toolUse.name)) {
@@ -2213,7 +2310,8 @@ You can also use natural language commands to control Claude Code CLI.`,
                 },
                 onRedactedThinking: () => this.sendRedactedThinking(messageId, threadId),
                 onPlanMode: (planContent) => this.sendPlanMode(messageId, threadId, planContent),
-                onImage: (image) => this.sendImage(messageId, threadId, image),
+                onImage: (image) => imageDelivery?.offerImage(image, imageEligible()),
+                onImageFile: (filePath) => imageDelivery?.offerFile(filePath, imageEligible()),
                 attachments,
             };
             const assertCoordinatorActive = () => {
@@ -2225,6 +2323,11 @@ You can also use natural language commands to control Claude Code CLI.`,
             let mayRetry = true;
             const executeOnce = async (prompt, options, flushImages = true) => {
                 assertCoordinatorActive();
+                imagePhase++;
+                streamedAny = false;
+                imageTextDropped = false;
+                imageDelivery?.resetStream();
+                const imageEpoch = this.imageConnectionEpoch;
                 const scope = delegationScope;
                 let active = true;
                 let finished = false;
@@ -2280,6 +2383,10 @@ You can also use natural language commands to control Claude Code CLI.`,
                         options.onImage?.(image);
                     else
                         suppressed = true; },
+                    onImageFile: filePath => { if (canPublish())
+                        options.onImageFile?.(filePath);
+                    else
+                        suppressed = true; },
                     onRedactedThinking: () => { if (canPublish())
                         options.onRedactedThinking?.(); },
                     onToolUse: tool => { if (active && !scope?.isClosed())
@@ -2292,7 +2399,19 @@ You can also use natural language commands to control Claude Code CLI.`,
                 executionMetadata = launchMetadata;
                 let capturedMetadata = false;
                 try {
-                    const result = await executor.execute(prompt, guardedOptions);
+                    if (goalRequest && (goalActivation?.cancelled || this.isDestroyed || this.abortOperations.has(threadId))) {
+                        throw new Error('Native goal activation was cancelled before it started.');
+                    }
+                    // No await between releasing preparation ownership and the adapter's
+                    // synchronous installation of native goal ownership.
+                    if (goalActivation && this.pendingGoalActivations.get(threadId) === goalActivation) {
+                        this.pendingGoalActivations.delete(threadId);
+                    }
+                    const result = goalRequest
+                        ? await executor.executeGoal(goalRequest, guardedOptions)
+                        : await executor.execute(prompt, guardedOptions);
+                    if (goalRequest && !streamedAny && result.output)
+                        guardedOptions.onStream?.(result.output);
                     executionMetadata = (0, ExecutionMetadata_1.mergeReportedExecutionMetadata)(launchMetadata, (0, ExecutionMetadata_1.captureExecutionMetadata)(executor, backend));
                     capturedMetadata = true;
                     active = false;
@@ -2303,9 +2422,11 @@ You can also use natural language commands to control Claude Code CLI.`,
                     scope?.finishExecution(result.success);
                     finished = true;
                     if (flushImages) {
-                        await Promise.all(pendingLocalImageEmissions);
-                        const visibleResult = scope && (suppressed || scope.hasPendingResults()) ? '' : result.output ?? '';
-                        await emitLocalImages(`${streamedOutput}\n${visibleResult}`);
+                        imageDelivery?.flushStream();
+                        const visibleResult = imageTextDropped || this.imageConnectionEpoch !== imageEpoch
+                            || (scope && (suppressed || scope.hasPendingResults())) ? '' : result.output ?? '';
+                        queueLocalImages(visibleResult);
+                        await imageDelivery?.drain();
                     }
                     assertCoordinatorActive();
                     return result;
@@ -2319,7 +2440,8 @@ You can also use natural language commands to control Claude Code CLI.`,
                     delegationBridge?.activate(undefined);
                     if (!finished)
                         scope?.finishExecution(false);
-                    mayRetry = !scope || scope.getLaunchRevision() === launchRevision;
+                    // Goal activation mutates durable native state; never replay it as a model retry.
+                    mayRetry = !goalRequest && (!scope || scope.getLaunchRevision() === launchRevision);
                 }
             };
             let prompt = content;
@@ -2514,7 +2636,7 @@ You can also use natural language commands to control Claude Code CLI.`,
     }
     sendStreamChunk(messageId, threadId, chunk) {
         try {
-            this.wsClient.send({
+            return this.wsClient.send({
                 type: 'stream',
                 messageId,
                 chunk,
@@ -2522,10 +2644,11 @@ You can also use natural language commands to control Claude Code CLI.`,
                 openId: this.getMessageOpenId(messageId),
                 threadId,
                 timestamp: Date.now(),
-            });
+            }) !== false;
         }
         catch (error) {
             console.error('Failed to send stream chunk:', error);
+            return false;
         }
     }
     sendToolUse(messageId, threadId, toolUse) {
@@ -2624,7 +2747,7 @@ You can also use natural language commands to control Claude Code CLI.`,
     }
     sendImage(messageId, threadId, image) {
         try {
-            this.wsClient.send({
+            return this.wsClient.send({
                 type: 'stream',
                 messageId,
                 streamType: 'image',
@@ -2632,10 +2755,11 @@ You can also use natural language commands to control Claude Code CLI.`,
                 openId: this.getMessageOpenId(messageId),
                 threadId,
                 timestamp: Date.now(),
-            });
+            }) !== false;
         }
-        catch (error) {
-            console.error('Failed to send generated image:', error);
+        catch {
+            console.warn('Failed to send generated image.');
+            return false;
         }
     }
     sendStructuredContent(messageId, threadId, structuredContent) {
@@ -2718,7 +2842,7 @@ You can also use natural language commands to control Claude Code CLI.`,
             return undefined;
         const projection = (entry) => ({ id: entry.id, backend: entry.backend,
             cwd: entry.workingDirectory, generation: entry.delegationWorkspaceGeneration, model: entry.model,
-            models: entry.models, efforts: entry.efforts, delegation: entry.delegation, delegationBackends: entry.delegationBackends });
+            models: entry.models, efforts: entry.efforts, speeds: entry.speeds, delegation: entry.delegation, delegationBackends: entry.delegationBackends });
         const all = this.threadManager.listThreads().map(projection).sort((a, b) => a.id.localeCompare(b.id));
         const configuredModels = { ...thread.models };
         if (configuredModels.claude === undefined && thread.model)
@@ -2786,6 +2910,11 @@ You can also use natural language commands to control Claude Code CLI.`,
         const config = this.executorConfiguration();
         const coordinator = this.threadPool.getBackendKey(threadId);
         const apply = async (executor) => {
+            if (kind === 'speed') {
+                if (!this.modelSpeedSettingsSupported || !executor.setSpeed)
+                    return { success: false, error: 'Native speed settings are unavailable.' };
+                return executor.setSpeed(value);
+            }
             if (kind === 'effort') {
                 if (!executor.setEffort)
                     return { success: false, error: 'This backend does not expose effort controls.' };
@@ -2822,7 +2951,7 @@ You can also use natural language commands to control Claude Code CLI.`,
                 await this.threadManager.updateThread(threadId, { models: Object.keys(models).length ? models : undefined,
                     ...(backend === 'claude' ? { model: value } : {}) });
             }
-            else {
+            else if (kind === 'effort') {
                 const efforts = { ...current.efforts };
                 if (value === undefined)
                     delete efforts[backend];
@@ -2830,6 +2959,14 @@ You can also use natural language commands to control Claude Code CLI.`,
                     efforts[backend] = value;
                 await this.threadManager.updateThread(threadId, { efforts: Object.keys(efforts).length ? efforts : undefined });
             }
+            else {
+                const speeds = { ...current.speeds };
+                // Null records an explicit return to native configuration, so resumed
+                // worker lanes also clear any previously sticky tier. Unset old threads
+                // retain their original RPC shapes without additional settings reads.
+                speeds[backend] = value ?? null;
+                await this.threadManager.updateThread(threadId, { speeds: Object.keys(speeds).length ? speeds : undefined });
+            }
             return result;
         }
         finally {
@@ -2997,6 +3134,9 @@ You can also use natural language commands to control Claude Code CLI.`,
         this.directoryBrowser.destroy();
         this.settingsService.destroy();
         this.isDestroyed = true;
+        for (const delivery of this.imageDeliveries.values())
+            delivery.cancel();
+        this.imageDeliveries.clear();
         await this.fileInbox?.destroy();
         this.notificationAdapter.unregister();
         try {