@yu_robotics/remote-cli 1.6.151 → 1.6.154

package/README.md

@@ -20,6 +20,8 @@ Router 1.6.117 and newer explicitly label standalone background-task notificatio
 
 ## Public Activity
 
+From CLI 1.6.153, Codex shell calls no longer lose their label when native command actions are absent or unknown. Native reads, searches, and directory listings remain preferred. Other calls use fixed operation labels such as `Run npm command` or `Run Git command` for simple allowlisted programs, and `Run shell command` for compound or unrecognized commands. These are deterministic operation labels, not model-authored purpose summaries: installed Codex 0.160.0 command items have no per-call description field. Arguments, full paths, output, and execution-wide reasoning are never copied into these fallback labels. Late native action metadata can enrich a pending row before its first result; repeated results retain one row. Existing description fields, heading limits, and card-node counts are unchanged; upgrade the CLI, with no new Router capability required.
+
 Router 1.6.145 combines each foreground tool call and its matching result into one collapsed row, retaining input, output, and diff previews. Independent calls, workers, and approvals remain separate. This uses the existing CLI protocol; the client does not need a new capability. See [Code Change Previews](../../README.md#code-change-previews).
 
 Router 1.6.146 gives Bash and other foreground tools one compact heading with a gray success dot, pending hourglass, or gray failure cross, plus the tool name and an optional public description or file basename. Full tool IDs and explicit status labels remain inside the expanded details. Raw commands are not fallback headings; the existing CLI protocol is unchanged.
@@ -171,10 +173,10 @@ Linux users upgrading from version 1.6.23 or earlier should run `remote-cli serv
 | `/new` | Alias for `/clear`; start a fresh conversation in this thread |
 | `/compact` | Compress history to save tokens |
 | `/cd <dir>` | Change directory; a different directory starts fresh conversations for this thread |
-| `/model [name]` | List models for the active backend or set this thread's model |
-| `/effort [auto|level]` | Show or set Codex/AGY/OpenCode/Kimi/ZCode/Pi reasoning effort |
+| `/model [name]` | Open native model settings, or set the active backend model with a text argument |
+| `/effort [auto|level]` | Open native effort settings, or set/clear the active backend effort with a text argument |
 | `/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 |
+| `/backend` | Open backend settings; Current thread is the default and Confirm applies the selection |
 | `/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 |
@@ -183,6 +185,10 @@ Linux users upgrading from version 1.6.23 or earlier should run `remote-cli serv
 | `/unbind` | Unbind all devices |
 | `/device` | List and switch between bound devices |
 
+CLI and Router 1.6.152 add standalone settings cards. `/backend` lists all eight stable backend choices, disables missing installations and applies only after Confirm; Current thread is the default and All threads on this device is opt-in. `/model` and `/effort` submit native options immediately, and show applied state only after a saved-setting acknowledgement. Their target-backend selector configures future worker launches without switching the coordinator. Busy work, expired cards and changed settings require refresh; older peers and parameterized text commands retain their existing behavior. See [Model and Reasoning Effort](../../README.md#model-and-reasoning-effort).
+
+From 1.6.154, numbered sections separate backend selection, scope and Confirm, or target backend, model/effort choices and secondary actions. Selected drafts and known preferences carry explicit checks; changing the target still never switches the coordinator. AGY model catalogs accept tab-delimited and formatted multi-space native rows, with exact IDs and explicit failures for empty, unusable or oversized responses. No inference or additional protocol capability is needed.
+
 ### Threads & Machines
 
 From CLI 1.6.121, new and existing threads without a saved preference enable
@@ -294,8 +300,19 @@ fail admission; reconcile those rules before delegating.
 From CLI 1.6.151, checkpoint index queries are combined and identical trees are
 audited once within a capture. Both working-file passes and source HEAD/index
 checks remain; no state is cached across tasks and Git deadlines are unchanged.
-CLI tests run real Git fixture suites in one isolated process alongside at most
-two lightweight test threads, avoiding CPU-count-driven Git subprocess contention.
+From CLI 1.6.153, real Git fixture suites use at most two isolated processes
+(one on hosts with fewer than four available CPUs), alongside one to four
+lightweight test threads. Pristine test repositories are copied into independently
+owned directories instead of rebuilt for every case. Publish still runs the full
+suite; ordinary test deadlines and production Git safety checks are unchanged.
+From 1.6.154, filesystem checks run in batches of at most eight and drain before
+failure; checkout readers still hash every byte with independent buffers up to
+1 MiB each. Test-only clocks remove mocked startup/stop and transfer-deadline
+waits after readiness gates; real Git streams, partial packs, cleanup assertions,
+129 MiB files and 10,001-file stress coverage remain. ZIP fixtures use faster
+CRC generation without changing archive bytes. Hosts with at least eight
+available CPUs use at most four isolated Git processes plus at most four
+lightweight threads; lower-core pool limits and ordinary deadlines are unchanged.
 
 From CLI 1.6.140, managed Git preparation, repository-lock waits, and artifact
 collection are awaited separately from native startup/stop deadlines. Slots and

package/dist/client/MessageHandler.d.ts

@@ -42,6 +42,10 @@ export declare class MessageHandler {
     private delegationProgressTextSupported;
     private activityProgressSupported;
     private workerContextResetSupported;
+    private settingsCardsSupported;
+    private readonly settingsAdmission;
+    private readonly settingsCatalogReader;
+    private readonly settingsService;
     private readonly pendingApprovalCards;
     private readonly delegation;
     private readonly delegationBridges;
@@ -58,6 +62,7 @@ export declare class MessageHandler {
      * Handle command message — route to the correct thread executor.
      */
     private handleCommandMessage;
+    private handleAdmittedCommandMessage;
     /**
      * Handle /abort command for a specific thread executor
      */
@@ -85,8 +90,8 @@ export declare class MessageHandler {
     private hasThreadQueueState;
     /**
      * Bare /model: show the thread's current model on the active backend plus
-     * the available models. Listing source per backend (all verified live):
-     * - claude: `claude --print /model` prints current + available aliases
+     * the available models, using each adapter's structured catalog:
+     * - claude: native control initialization exposes model aliases and capabilities
      * - agy: `agy models` prints "slug<TAB>Display Name" lines
      * - codex: app-server `model/list` returns the authenticated catalog
      * - opencode/kimi ACP: session config options expose enabled models
@@ -94,11 +99,6 @@ export declare class MessageHandler {
      * - pi: RPC `get_available_models` returns the configured Pi catalog
      */
     private handleModelList;
-    /**
-     * Run a short-lived CLI listing command with a 10s timeout.
-     * Returns null on failure/timeout — callers degrade gracefully.
-     */
-    private runListingCommand;
     /**
      * Handle /thread subcommands
      */
@@ -182,6 +182,13 @@ export declare class MessageHandler {
     private sendImage;
     private sendStructuredContent;
     private sendResponse;
+    private executorConfiguration;
+    private settingsState;
+    private settingsBusy;
+    private settingsFallback;
+    /** Shared native/persistent mutation for cards and parameterized text commands. */
+    private applyPreference;
+    private applyBackendSetting;
     private checkCommand;
     private detectBackends;
     private handleBackendCommand;

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

@@ -1 +1 @@
-{"version":3,"file":"MessageHandler.d.ts","sourceRoot":"","sources":["../../src/client/MessageHandler.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"MessageHandler.d.ts","sourceRoot":"","sources":["../../src/client/MessageHandler.ts"],"names":[],"mappings":"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"}

package/dist/client/MessageHandler.js

@@ -32,8 +32,10 @@ const BackendCommand_1 = require("../utils/BackendCommand");
 const ClaudeStderrFilter_1 = require("../executor/claude/ClaudeStderrFilter");
 const ExecutionMetadata_1 = require("../executor/ExecutionMetadata");
 const ActivityProgress_1 = require("../utils/ActivityProgress");
-const EFFORT_BACKENDS = new Set(['codex', 'agy', 'opencode', 'kimi', 'zcode', 'pi', 'dsh']);
-const NATIVE_MODEL_LIST_BACKENDS = new Set(['codex', 'opencode', 'kimi', 'zcode', 'pi', 'dsh']);
+const SettingsAdmission_1 = require("../settings/SettingsAdmission");
+const SettingsCatalog_1 = require("../settings/SettingsCatalog");
+const SettingsService_1 = require("../settings/SettingsService");
+const EFFORT_BACKENDS = new Set(['claude', 'codex', 'agy', 'opencode', 'kimi', 'zcode', 'pi', 'dsh']);
 const SLASH_SESSION_BACKENDS = new Set(['opencode', 'kimi', 'zcode', 'pi']);
 const NATIVE_SKILLS_BACKENDS = new Set(['claude', 'agy', 'opencode', 'kimi', 'zcode', 'pi']);
 function backendDisplayName(key) {
@@ -114,6 +116,10 @@ class MessageHandler {
     delegationProgressTextSupported = false;
     activityProgressSupported = false;
     workerContextResetSupported = false;
+    settingsCardsSupported = false;
+    settingsAdmission = new SettingsAdmission_1.SettingsAdmission();
+    settingsCatalogReader;
+    settingsService;
     pendingApprovalCards = new Map();
     delegation;
     delegationBridges = new Map();
@@ -126,6 +132,33 @@ class MessageHandler {
         this.config = config;
         this.wsClient.onClose?.(() => this.fileInbox?.disconnect());
         this.delegation = new DelegationManager_1.DelegationManager(directoryGuard);
+        this.settingsCatalogReader = new SettingsCatalog_1.SettingsCatalogReader(directoryGuard);
+        this.settingsService = new SettingsService_1.SettingsService({
+            state: id => this.settingsState(id),
+            backends: async () => (await this.detectBackends()).map(entry => ({ ...entry, value: (0, config_1.backendKeyOf)(entry.id) })),
+            catalog: async (id, target, kind) => {
+                const thread = this.threadManager.getThread(id);
+                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);
+            },
+            busy: (id, except, queue = true) => this.settingsBusy(id, except, queue),
+            threads: () => this.threadManager.listThreads().map(thread => thread.id),
+            exclusive: async (target, body) => {
+                try {
+                    return await this.settingsAdmission.mutation(target, body);
+                }
+                finally {
+                    for (const id of target === '*' ? this.threadManager.listThreads().map(thread => thread.id) : [target]) {
+                        void this.startNextQueuedCommand(id);
+                    }
+                }
+            },
+            backend: (id, target, scope, follow) => this.applyBackendSetting(id, target, scope, follow),
+            preference: (id, target, kind, value) => this.applyPreference(id, target, kind, value),
+        });
+        this.wsClient.onClose?.(() => this.settingsService.invalidate());
         this.notificationAdapter = new hooks_1.FeishuNotificationAdapter(wsClient);
         this.notificationAdapter.setThreadNameResolver((threadId) => this.threadManager.getThread(threadId)?.name);
         this.notificationAdapter.register();
@@ -162,6 +195,12 @@ class MessageHandler {
             case 'command':
                 await this.handleCommandMessage(message, this.fileInbox?.mark());
                 return;
+            case 'settings_action':
+                if (this.settingsCardsSupported) {
+                    const result = await this.settingsService.action(message);
+                    this.wsClient.send(result);
+                }
+                return;
             case 'file_pending':
                 if (this.fileInbox)
                     await this.fileInbox.accept(message);
@@ -202,6 +241,7 @@ class MessageHandler {
                 this.activityProgressSupported = data.capabilities?.activityProgress === true;
                 this.delegationProgressSupported = data.capabilities?.delegationProgress === true;
                 this.workerContextResetSupported = this.delegationProgressSupported && data.capabilities?.workerContextReset === true;
+                this.settingsCardsSupported = data.capabilities?.settingsCards === true;
                 this.delegationProgressTextSupported = this.delegationProgressSupported
                     && data.capabilities?.delegationProgressText === true;
                 for (const pending of this.pendingApprovalCards.values()) {
@@ -252,6 +292,34 @@ class MessageHandler {
      * Handle command message — route to the correct thread executor.
      */
     async handleCommandMessage(message, fileOrder) {
+        const threadId = message.threadId ?? this.threadManager.getDefaultThread().id;
+        const content = message.content?.trim() ?? '';
+        const body = () => this.handleAdmittedCommandMessage(message, fileOrder);
+        this.messageOpenIds.set(message.messageId, message.openId);
+        try {
+            // Abort and addressed human replies must remain available during native work.
+            if (content === '/abort' || /^(?:yes|no)(?:\s|$)/.test(content) || content.startsWith('/input '))
+                return await body();
+            if (/^\/(?:backend|model|effort)\s+\S/.test(content)) {
+                const global = /^\/backend\s/.test(content) && !/\s@$/.test(content);
+                await this.settingsAdmission.mutation(global ? '*' : threadId, async () => {
+                    this.settingsService.invalidate(global ? undefined : threadId);
+                    await body();
+                });
+            }
+            else {
+                await this.settingsAdmission.command(threadId, message.messageId, async () => {
+                    if (/^\/(?:clear|new|cd|sandbox)(?:\s|$)/.test(content) || /^\/thread\s+delete(?:\s|$)/.test(content))
+                        this.settingsService.invalidate(threadId);
+                    await body();
+                });
+            }
+        }
+        catch (error) {
+            this.sendResponse(message.messageId, threadId, { success: false, error: error instanceof Error ? error.message : 'Command admission failed.' });
+        }
+    }
+    async handleAdmittedCommandMessage(message, fileOrder) {
         const { messageId, content, attachments, workingDirectory, openId, isSlashCommand, threadId } = message;
         this.currentOpenId = openId;
         this.messageOpenIds.set(message.messageId, openId);
@@ -275,6 +343,17 @@ class MessageHandler {
             });
             return;
         }
+        if (this.settingsCardsSupported && openId && /^\/(?:backend|model|effort)$/.test(content?.trim() ?? '')) {
+            const kind = content.trim().slice(1);
+            try {
+                const menu = await this.settingsService.open(kind, resolvedThreadId, openId, undefined, messageId);
+                this.sendResponse(messageId, resolvedThreadId, { success: true, output: this.settingsFallback(menu), settingsMenu: menu });
+            }
+            catch {
+                this.sendResponse(messageId, resolvedThreadId, { success: false, error: 'The settings menu could not be opened. Retry or use the parameterized text command.' });
+            }
+            return;
+        }
         const executor = this.threadPool.getExecutor(resolvedThreadId);
         this.sendStreamContext(messageId, resolvedThreadId, executor);
         // Handle /abort for this specific thread (bypasses busy check)
@@ -810,11 +889,11 @@ Use /compact to reduce conversation context or /clear to start a fresh context.`
 - /clear, /new - Start a fresh conversation in this thread
 - /compact - Compress conversation history to reduce context size
 - /cd <directory> - Change working directory for this thread
-- /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/DSH (Claude Code is unsupported)
+- /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
 - /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 - List backends and show the current thread's effective backend
+- /backend - Open backend settings (Current thread by default; Confirm applies)
 - /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
@@ -943,9 +1022,9 @@ You can also use natural language commands to control Claude Code CLI.`,
                 if ('listModels' in executor && typeof executor.listModels === 'function') {
                     try {
                         const models = await executor.listModels();
-                        const activeModel = models.find((entry) => entry.id === configuredModel)
-                            ?? models.find((entry) => entry.isDefault)
-                            ?? models[0];
+                        const activeModel = models.find((entry) => entry.isCurrent)
+                            ?? models.find((entry) => entry.id === configuredModel)
+                            ?? models.find((entry) => entry.isDefault);
                         if (activeModel) {
                             lines.push(`Model: ${activeModel.id}`);
                             lines.push(`Model default: ${activeModel.defaultReasoningEffort ?? 'unavailable'}`);
@@ -969,18 +1048,7 @@ You can also use natural language commands to control Claude Code CLI.`,
                 return true;
             }
             const effortArg = parts.slice(1).join(' ').toLowerCase();
-            const result = await executor.setEffort(effortArg);
-            if (result.success) {
-                const current = this.threadManager.getThread(threadId);
-                const efforts = { ...current?.efforts };
-                if (effortArg === 'auto')
-                    delete efforts[key];
-                else
-                    efforts[key] = effortArg;
-                await this.threadManager.updateThread(threadId, {
-                    efforts: Object.keys(efforts).length > 0 ? efforts : undefined,
-                });
-            }
+            const result = await this.applyPreference(threadId, key, 'effort', effortArg === 'auto' ? undefined : effortArg);
             this.sendResponse(messageId, threadId, result.success
                 ? { success: true, output: result.output || `Reasoning effort set to ${effortArg}.` }
                 : { success: false, error: result.error || 'Failed to set reasoning effort' });
@@ -1000,20 +1068,7 @@ You can also use natural language commands to control Claude Code CLI.`,
                 });
                 return true;
             }
-            const result = await executor.setModel(modelArg, (chunk) => {
-                this.sendStreamChunk(messageId, threadId, chunk);
-            });
-            if (result.success) {
-                // Persist per-backend: model names are backend-specific (Claude's
-                // "opus" is rejected by agy), so selections live under
-                // 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 = 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 });
-            }
+            const result = await this.applyPreference(threadId, this.threadPool.getBackendKey(threadId), 'model', modelArg, chunk => this.sendStreamChunk(messageId, threadId, chunk));
             this.sendResponse(messageId, threadId, result.success
                 ? { success: true, output: result.output || `✅ Model set to ${modelArg}` }
                 : { success: false, error: result.error || 'Failed to set model' });
@@ -1162,6 +1217,8 @@ You can also use natural language commands to control Claude Code CLI.`,
         this.sendResponse(messageId, threadId, { success: true, output: lines.join('\n') });
     }
     async startNextQueuedCommand(threadId) {
+        if (this.settingsAdmission.isBlocked(threadId))
+            return;
         if (this.threadPool.isThreadBusy(threadId) || this.pausedQueues.has(threadId) || this.abortOperations.has(threadId))
             return;
         const queue = this.threadQueues.get(threadId);
@@ -1248,8 +1305,8 @@ You can also use natural language commands to control Claude Code CLI.`,
     }
     /**
      * Bare /model: show the thread's current model on the active backend plus
-     * the available models. Listing source per backend (all verified live):
-     * - claude: `claude --print /model` prints current + available aliases
+     * the available models, using each adapter's structured catalog:
+     * - claude: native control initialization exposes model aliases and capabilities
      * - agy: `agy models` prints "slug<TAB>Display Name" lines
      * - codex: app-server `model/list` returns the authenticated catalog
      * - opencode/kimi ACP: session config options expose enabled models
@@ -1257,7 +1314,6 @@ You can also use natural language commands to control Claude Code CLI.`,
      * - pi: RPC `get_available_models` returns the configured Pi catalog
      */
     async handleModelList(messageId, threadId) {
-        const executorConfig = this.config.get('executor') ?? { type: 'auto' };
         const key = this.threadPool.getBackendKey(threadId);
         const thread = this.threadManager.getThread(threadId);
         const current = thread?.models?.[key] ?? (key === 'claude' ? thread?.model : undefined);
@@ -1266,7 +1322,7 @@ You can also use natural language commands to control Claude Code CLI.`,
             `🎯 Backend: ${backendLabel}`,
             `Current model: ${current ?? 'backend default'}`,
         ];
-        if (NATIVE_MODEL_LIST_BACKENDS.has(key)) {
+        {
             const executor = this.threadPool.getExecutor(threadId);
             if ('listModels' in executor && typeof executor.listModels === 'function') {
                 try {
@@ -1290,57 +1346,9 @@ You can also use natural language commands to control Claude Code CLI.`,
                 lines.push('', `Model listing is unavailable in this ${backendLabel} transport.`);
             }
         }
-        else {
-            const bin = (0, BackendCommand_1.getBackendCommand)(key === 'agy' ? 'agy' : 'claude', executorConfig);
-            const args = key === 'agy' ? ['models'] : ['/model', '--print'];
-            const listing = await this.runListingCommand(bin, args);
-            if (listing) {
-                lines.push('', 'Available models:', listing.trim());
-            }
-            else {
-                lines.push('', '⚠️ Could not fetch the model list from the backend CLI.');
-            }
-        }
         lines.push('', 'Set with: /model <name>');
         this.sendResponse(messageId, threadId, { success: true, output: lines.join('\n') });
     }
-    /**
-     * Run a short-lived CLI listing command with a 10s timeout.
-     * Returns null on failure/timeout — callers degrade gracefully.
-     */
-    runListingCommand(bin, args) {
-        return new Promise((resolve) => {
-            let settled = false;
-            let timer;
-            const finish = (value) => {
-                if (settled)
-                    return;
-                settled = true;
-                if (timer)
-                    clearTimeout(timer);
-                resolve(value);
-            };
-            let child;
-            try {
-                child = (0, child_process_1.spawn)(bin, args, {
-                    stdio: ['ignore', 'pipe', 'pipe'],
-                    env: { ...process.env, CLAUDECODE: '' },
-                });
-            }
-            catch {
-                finish(null);
-                return;
-            }
-            timer = setTimeout(() => {
-                child.kill();
-                finish(null);
-            }, 10000);
-            const chunks = [];
-            child.stdout?.on('data', (d) => chunks.push(d.toString()));
-            child.on('exit', (code) => finish(code === 0 ? chunks.join('') : null));
-            child.on('error', () => finish(null));
-        });
-    }
     /**
      * Handle /thread subcommands
      */
@@ -2515,6 +2523,7 @@ You can also use natural language commands to control Claude Code CLI.`,
                 threads: result.threads,
                 queueConfirmation: result.queueConfirmation,
                 ...(result.executionMetadata ? { executionMetadata: result.executionMetadata } : {}),
+                ...(this.settingsCardsSupported && result.settingsMenu ? { settingsMenu: result.settingsMenu } : {}),
                 cwd,
                 timestamp: Date.now(),
             });
@@ -2525,6 +2534,127 @@ You can also use natural language commands to control Claude Code CLI.`,
         }
     }
     // ── Backend switching ─────────────────────────────────────────────────────
+    executorConfiguration() {
+        return this.config.get('executor') ?? { type: 'auto' };
+    }
+    settingsState(threadId) {
+        const thread = this.threadManager.getThread(threadId);
+        if (!thread)
+            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 });
+        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)
+            configuredModels.claude = thread.model;
+        return { threadId, threadName: thread.name, coordinatorBackend: this.threadPool.getBackendKey(threadId),
+            followsGlobal: !thread.backend, configuredModels, configuredEfforts: { ...thread.efforts },
+            revision: (0, crypto_1.createHash)('sha256').update(JSON.stringify({ thread: projection(thread), all, config: this.executorConfiguration() })).digest('hex') };
+    }
+    settingsBusy(threadId, exceptRequest, includeQueue = true) {
+        return this.isDestroyed || this.automaticUpdateInProgress || this.threadPool.isThreadBusy(threadId)
+            || this.delegation.hasActiveTasks(threadId) || this.abortOperations.has(threadId)
+            || this.settingsAdmission.hasCommand(threadId, exceptRequest) || (includeQueue && this.hasThreadQueueState(threadId));
+    }
+    settingsFallback(menu) {
+        const lines = [`${menu.kind === 'backend' ? 'Backend' : menu.kind === 'model' ? 'Model' : 'Reasoning effort'} settings`,
+            `Thread: ${menu.threadName}`, `Target backend: ${menu.targetBackend}`,
+            `Configured: ${menu.configuredValue ?? 'default'}`, `Effective: ${menu.effectiveValue ?? 'not reported'} (${menu.effectiveSource})`];
+        if (menu.unavailableReason)
+            lines.push(menu.unavailableReason);
+        for (const choice of menu.choices)
+            lines.push(`${choice.label}${choice.disabled ? ' (unavailable)' : ''}`);
+        if (menu.kind === 'backend')
+            lines.push('Card scope defaults to Current thread. Confirm to apply. Text commands: /backend <index> @ (current), /backend <index> (all).');
+        else
+            lines.push(`Use the card buttons, or /${menu.kind} <value> for the active backend.`);
+        return lines.join('\n');
+    }
+    /** Shared native/persistent mutation for cards and parameterized text commands. */
+    async applyPreference(threadId, backend, kind, value, onStream) {
+        const thread = this.threadManager.getThread(threadId);
+        if (!thread)
+            return { success: false, error: 'This thread no longer exists.' };
+        if (value !== undefined && (!value || value.length > 512 || /[\x00-\x1f\x7f]/.test(value)))
+            return { success: false, error: 'Invalid settings value.' };
+        const config = this.executorConfiguration();
+        const coordinator = this.threadPool.getBackendKey(threadId);
+        const apply = async (executor) => {
+            if (kind === 'effort') {
+                if (!executor.setEffort)
+                    return { success: false, error: 'This backend does not expose effort controls.' };
+                return executor.setEffort(value ?? 'auto');
+            }
+            if (value === undefined) {
+                const fallback = (0, SettingsCatalog_1.configuredBackendModel)(config, backend);
+                if (fallback && executor.setModel)
+                    return executor.setModel(fallback, onStream);
+                if (!executor.clearModel)
+                    return { success: false, error: 'This backend cannot safely clear its model override.' };
+                await executor.clearModel();
+                return { success: true, output: 'Model override cleared.' };
+            }
+            if (!executor.setModel)
+                return { success: false, error: 'This backend does not expose model controls.' };
+            return executor.setModel(value, onStream);
+        };
+        try {
+            const result = backend === coordinator ? await apply(this.threadPool.getExecutor(threadId))
+                : await this.settingsCatalogReader.withExecutor(config, thread, coordinator, backend, apply, value === undefined && kind === 'model');
+            if (!result.success)
+                return result;
+            // Persistence uses the latest thread object so unrelated backend choices survive.
+            const current = this.threadManager.getThread(threadId);
+            if (!current)
+                throw new Error('The thread was deleted during the settings operation.');
+            if (kind === 'model') {
+                const models = { ...current.models };
+                if (value === undefined)
+                    delete models[backend];
+                else
+                    models[backend] = value;
+                await this.threadManager.updateThread(threadId, { models: Object.keys(models).length ? models : undefined,
+                    ...(backend === 'claude' ? { model: value } : {}) });
+            }
+            else {
+                const efforts = { ...current.efforts };
+                if (value === undefined)
+                    delete efforts[backend];
+                else
+                    efforts[backend] = value;
+                await this.threadManager.updateThread(threadId, { efforts: Object.keys(efforts).length ? efforts : undefined });
+            }
+            return result;
+        }
+        finally {
+            this.settingsService.invalidate(threadId);
+        }
+    }
+    async applyBackendSetting(threadId, backend, scope, followGlobal = false) {
+        try {
+            if (followGlobal) {
+                await this.threadPool.destroyThread(threadId, { deleteData: false });
+                await this.threadManager.updateThread(threadId, { backend: undefined });
+                return { success: true, output: 'This thread now follows the global backend.', clearedCount: this.clearThreadQueue(threadId) };
+            }
+            if (scope === 'thread') {
+                await this.threadPool.switchThreadBackend(threadId, backend);
+                return { success: true, output: `Thread backend set to ${backend}.`, clearedCount: this.clearThreadQueue(threadId) };
+            }
+            if (this.threadPool.getSummaries().some(thread => thread.status === 'running') || this.delegation.hasActiveTasks(threadId)) {
+                return { success: false, error: 'Cannot switch all backends while a thread is running. Send /abort first.', clearedCount: 0 };
+            }
+            const config = { ...this.executorConfiguration(), type: backend === 'claude' ? 'auto' : backend };
+            await this.config.set('executor', config);
+            await this.threadPool.switchBackend(config);
+            await this.threadManager.clearBackendOverrides();
+            return { success: true, output: `All threads will use ${backend} for future commands.`, clearedCount: this.clearAllQueues() };
+        }
+        finally {
+            this.settingsService.invalidate(scope === 'all' ? undefined : threadId);
+        }
+    }
     checkCommand(cmd, args) {
         return new Promise((resolve) => {
             try {
@@ -2596,9 +2726,7 @@ You can also use natural language commands to control Claude Code CLI.`,
                 });
                 return;
             }
-            await this.threadPool.destroyThread(threadId, { deleteData: false });
-            await this.threadManager.updateThread(threadId, { backend: undefined });
-            const clearedCount = this.clearThreadQueue(threadId);
+            const { clearedCount } = await this.applyBackendSetting(threadId, (0, config_1.backendKeyOf)(currentType), 'thread', true);
             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'}.` : ''}`,
@@ -2621,11 +2749,9 @@ 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);
+                const { clearedCount } = await this.applyBackendSetting(threadId, (0, config_1.backendKeyOf)(target.id), 'thread');
                 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.`,
@@ -2647,10 +2773,12 @@ You can also use natural language commands to control Claude Code CLI.`,
             });
             return;
         }
-        await this.config.set('executor', newConfig);
-        await this.threadPool.switchBackend(newConfig);
-        await this.threadManager.clearBackendOverrides();
-        const clearedCount = this.clearAllQueues();
+        const applied = await this.applyBackendSetting(threadId, (0, config_1.backendKeyOf)(target.id), 'all');
+        if (!applied.success) {
+            this.sendResponse(messageId, threadId, applied);
+            return;
+        }
+        const { clearedCount } = applied;
         this.sendResponse(messageId, threadId, {
             success: true,
             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.`,
@@ -2661,6 +2789,7 @@ You can also use natural language commands to control Claude Code CLI.`,
      * Destroy handler and all executors
      */
     async destroy() {
+        this.settingsService.destroy();
         this.isDestroyed = true;
         await this.fileInbox?.destroy();
         this.notificationAdapter.unregister();