@dreb/coding-agent 2.45.4 → 2.47.0

package/dist/modes/interactive/interactive-mode.js

@@ -14,17 +14,19 @@ import { parseSkillBlock } from "../../core/agent-session.js";
 import { BuddyManager, checkOllama } from "../../core/buddy/buddy-manager.js";
 import { Rarity, Stat } from "../../core/buddy/buddy-types.js";
 import { BuddyController } from "../../core/buddy/index.js";
+import { formatDispatchArbitrationRecord } from "../../core/dispatch-arbiter.js";
 import { acquireDreamLock, buildDreamPrompt, cleanupDreamTmpDirs, parseDreamCommand, performDreamBackup, pruneOldBackups, resolveDreamContext, validateArchivePath, validateMemoryLinks, } from "../../core/dream.js";
 import { FooterDataProvider } from "../../core/footer-data-provider.js";
 import { KeybindingsManager } from "../../core/keybindings.js";
 import { createCompactionSummaryMessage } from "../../core/messages.js";
 import { findExactModelReferenceMatch, resolveModelScope } from "../../core/model-resolver.js";
+import { loadAndValidateModelRoutingGuide } from "../../core/model-routing-guide.js";
 import { DefaultPackageManager } from "../../core/package-manager.js";
 import { SessionManager } from "../../core/session-manager.js";
 import { BUILTIN_SLASH_COMMANDS } from "../../core/slash-commands.js";
 import { restoreStderr, takeOverStderr } from "../../core/stderr-guard.js";
 import { TabTitleGenerator } from "../../core/tab-title.js";
-import { resolveThinkingDisplay } from "../../core/thinking.js";
+import { resolveThinkingDisplay, validateThinkingLevelForModel } from "../../core/thinking.js";
 import { resolveToCwd } from "../../core/tools/path-utils.js";
 import { abortBackgroundAgents, discoverAgentTypes, getRunningBackgroundAgents } from "../../core/tools/subagent.js";
 import { copyToClipboard } from "../../utils/clipboard.js";
@@ -33,6 +35,7 @@ import { parseGitUrl } from "../../utils/git.js";
 import { extractCopyableText, extractThinkingText, getMessagePreview, getMessageRoleLabel, toSingleLinePreview, } from "../../utils/message-text.js";
 import { ensureTool } from "../../utils/tools-manager.js";
 import { ArminComponent } from "./components/armin.js";
+import { AskUserComponent } from "./components/ask-user.js";
 import { AssistantMessageComponent } from "./components/assistant-message.js";
 import { BashExecutionComponent } from "./components/bash-execution.js";
 import { BorderedLoader } from "./components/bordered-loader.js";
@@ -134,6 +137,8 @@ export class InteractiveMode {
     extensionSelector = undefined;
     extensionInput = undefined;
     extensionEditor = undefined;
+    extensionAsk = undefined;
+    extensionDialogQueue = Promise.resolve();
     extensionTerminalInputUnsubscribers = new Set();
     // Extension widgets (components rendered above/below the editor)
     extensionWidgetsAbove = new Map();
@@ -1182,6 +1187,9 @@ export class InteractiveMode {
         if (this.extensionEditor) {
             this.hideExtensionEditor();
         }
+        if (this.extensionAsk) {
+            this.hideExtensionAsk();
+        }
         this.ui.hideOverlay();
         this.clearExtensionTerminalInputListeners();
         this.setExtensionFooter(undefined);
@@ -1404,9 +1412,22 @@ export class InteractiveMode {
      */
     createExtensionUIContext() {
         return {
-            select: (title, options, opts) => this.showExtensionSelector(title, options, opts),
-            confirm: (title, message, opts) => this.showExtensionConfirm(title, message, opts),
-            input: (title, placeholder, opts) => this.showExtensionInput(title, placeholder, opts),
+            select: (title, options, opts) => this.enqueueExtensionDialog(() => this.showExtensionSelector(title, options, opts), {
+                signal: opts?.signal,
+                abortedValue: undefined,
+            }),
+            confirm: (title, message, opts) => this.enqueueExtensionDialog(() => this.showExtensionConfirm(title, message, opts), {
+                signal: opts?.signal,
+                abortedValue: false,
+            }),
+            input: (title, placeholder, opts) => this.enqueueExtensionDialog(() => this.showExtensionInput(title, placeholder, opts), {
+                signal: opts?.signal,
+                abortedValue: undefined,
+            }),
+            ask: (request, opts) => this.enqueueExtensionDialog(() => this.showExtensionAsk(request, opts), {
+                signal: opts?.signal,
+                abortedValue: undefined,
+            }),
             notify: (message, type) => this.showExtensionNotify(message, type),
             onTerminalInput: (handler) => this.addExtensionTerminalInputListener(handler),
             setStatus: (key, text) => this.setExtensionStatus(key, text),
@@ -1415,11 +1436,11 @@ export class InteractiveMode {
             setFooter: (factory) => this.setExtensionFooter(factory),
             setHeader: (factory) => this.setExtensionHeader(factory),
             setTitle: (title) => this.ui.terminal.setTitle(title),
-            custom: (factory, options) => this.showExtensionCustom(factory, options),
+            custom: (factory, options) => this.enqueueExtensionDialog(() => this.showExtensionCustom(factory, options)),
             pasteToEditor: (text) => this.editor.handleInput(`\x1b[200~${text}\x1b[201~`),
             setEditorText: (text) => this.editor.setText(text),
             getEditorText: () => this.editor.getExpandedText?.() ?? this.editor.getText(),
-            editor: (title, prefill) => this.showExtensionEditor(title, prefill),
+            editor: (title, prefill) => this.enqueueExtensionDialog(() => this.showExtensionEditor(title, prefill)),
             setEditorComponent: (factory) => this.setCustomEditorComponent(factory),
             get theme() {
                 return theme;
@@ -1445,6 +1466,32 @@ export class InteractiveMode {
             setToolsExpanded: (expanded) => this.setToolsExpanded(expanded),
         };
     }
+    /** Serialize every blocking extension dialog that can take over keyboard focus. */
+    enqueueExtensionDialog(open, opts) {
+        if (!opts?.signal) {
+            const result = this.extensionDialogQueue.then(open, open);
+            this.extensionDialogQueue = result.then(() => undefined, () => undefined);
+            return result;
+        }
+        const { signal, abortedValue } = opts;
+        if (signal.aborted)
+            return Promise.resolve(abortedValue);
+        // Settle the caller as soon as a queued dialog aborts, even if an earlier
+        // unbounded dialog still owns the UI. Its queue slot remains as a no-op so
+        // later dialogs keep their FIFO order.
+        let onQueuedAbort;
+        const aborted = new Promise((resolve) => {
+            onQueuedAbort = () => resolve(abortedValue);
+            signal.addEventListener("abort", onQueuedAbort, { once: true });
+        });
+        const run = () => {
+            signal.removeEventListener("abort", onQueuedAbort);
+            return signal.aborted ? Promise.resolve(abortedValue) : open();
+        };
+        const queued = this.extensionDialogQueue.then(run, run);
+        this.extensionDialogQueue = queued.then(() => undefined, () => undefined);
+        return Promise.race([queued, aborted]).finally(() => signal.removeEventListener("abort", onQueuedAbort));
+    }
     /**
      * Show a selector for extensions.
      */
@@ -1526,6 +1573,48 @@ export class InteractiveMode {
         this.extensionInput = undefined;
         this.restoreEditorComponent();
     }
+    /**
+     * Show a rich ask_user question for extensions/built-in tools.
+     */
+    showExtensionAsk(request, opts) {
+        return new Promise((resolve) => {
+            if (opts?.signal?.aborted) {
+                resolve(undefined);
+                return;
+            }
+            const onAbort = () => {
+                this.hideExtensionAsk();
+                resolve(undefined);
+            };
+            opts?.signal?.addEventListener("abort", onAbort, { once: true });
+            this.extensionAsk = new AskUserComponent(request, (result) => {
+                opts?.signal?.removeEventListener("abort", onAbort);
+                this.hideExtensionAsk();
+                resolve(result);
+            }, () => {
+                opts?.signal?.removeEventListener("abort", onAbort);
+                this.hideExtensionAsk();
+                // The question-level escape action means stop the whole turn, not
+                // continue without an answer. Mirror the default editor's Escape
+                // behavior, including background-agent and queued-message cleanup.
+                this.cancelBackgroundAgents();
+                this.restoreQueuedMessagesToEditor({ abort: true });
+                resolve(undefined);
+            }, { tui: this.ui, timeout: opts?.timeout });
+            this.editorContainer.clear();
+            this.editorContainer.addChild(this.extensionAsk);
+            this.ui.setFocus(this.extensionAsk);
+            this.ui.requestRender();
+        });
+    }
+    /**
+     * Hide the ask_user question.
+     */
+    hideExtensionAsk() {
+        this.extensionAsk?.dispose();
+        this.extensionAsk = undefined;
+        this.restoreEditorComponent();
+    }
     /**
      * Show a multi-line editor for extensions (with Ctrl+G support).
      */
@@ -2295,6 +2384,15 @@ export class InteractiveMode {
                 this.showWarning(`Response truncated, retrying with larger token budget (${event.attempt}/${event.maxAttempts})…`);
                 break;
             }
+            case "subagent_arbitration": {
+                const message = formatDispatchArbitrationRecord(event);
+                if (event.status === "failure")
+                    this.showWarning(message);
+                else
+                    this.showStatus(message);
+                this.updateBackgroundAgentStatus();
+                break;
+            }
             case "background_agent_start":
             case "background_agent_end": {
                 this.updateBackgroundAgentStatus();
@@ -3098,6 +3196,67 @@ export class InteractiveMode {
         this.ui.setFocus(focus);
         this.ui.requestRender();
     }
+    async handleSubagentArbiterSettingsChange(settings) {
+        if (this.settingsManager.hasGlobalSettingsLoadError()) {
+            this.showError("Cannot write Dispatch Arbiter settings: the global settings file failed to load. Fix or remove the corrupt settings.json first.");
+            return false;
+        }
+        if (settings.enabled) {
+            if (!settings.model) {
+                this.showError("Choose an exact Dispatch Arbiter model before enabling it.");
+                return false;
+            }
+            const slash = settings.model.indexOf("/");
+            const arbiterModel = slash > 0
+                ? this.session.modelRegistry.find(settings.model.slice(0, slash), settings.model.slice(slash + 1))
+                : undefined;
+            if (!arbiterModel) {
+                this.showError(`Dispatch Arbiter model "${settings.model}" is not available.`);
+                return false;
+            }
+            const thinking = settings.thinking ?? "off";
+            const thinkingValidation = validateThinkingLevelForModel(arbiterModel, thinking);
+            if (!thinkingValidation.ok) {
+                this.showError(thinkingValidation.error);
+                return false;
+            }
+            try {
+                loadAndValidateModelRoutingGuide(settings.guidePath, process.cwd(), this.session.scopedModels.map(({ model }) => `${model.provider}/${model.id}`));
+            }
+            catch (error) {
+                this.showError(`Dispatch Arbiter is not ready: ${error instanceof Error ? error.message : String(error)}`);
+                return false;
+            }
+        }
+        this.settingsManager.drainErrors();
+        try {
+            this.settingsManager.setGlobalSubagentArbiterSettings(settings);
+            await this.settingsManager.flush();
+        }
+        catch (error) {
+            try {
+                this.settingsManager.reload();
+            }
+            catch { }
+            this.showError(`Failed to persist Dispatch Arbiter settings: ${error instanceof Error ? error.message : String(error)}`);
+            return false;
+        }
+        const writeErrors = this.settingsManager.drainErrors();
+        if (writeErrors.length > 0) {
+            try {
+                this.settingsManager.reload();
+            }
+            catch { }
+            this.showError(`Failed to persist Dispatch Arbiter settings: ${writeErrors
+                .map((entry) => `${entry.scope}: ${entry.error.message}`)
+                .join("; ")}`);
+            return false;
+        }
+        this.showStatus(settings.enabled
+            ? `Dispatch Arbiter enabled (${settings.model}, thinking ${settings.thinking ?? "off"}).`
+            : "Dispatch Arbiter disabled.");
+        return true;
+    }
     showSettingsSelector() {
         this.showSelector((done) => {
             // Discover agent types for agent models section
@@ -3137,6 +3296,7 @@ export class InteractiveMode {
                 agentModels: this.settingsManager.getAgentModels(),
                 agentNames: agentNames,
                 availableModelIds,
+                subagentArbiter: this.settingsManager.getGlobalSubagentArbiterSettings() ?? {},
             }, {
                 onAutoCompactChange: (enabled) => {
                     this.session.setAutoCompactionEnabled(enabled);
@@ -3251,6 +3411,7 @@ export class InteractiveMode {
                         this.editor.setAutocompleteMaxVisible(maxVisible);
                     }
                 },
+                onSubagentArbiterChange: (settings) => this.handleSubagentArbiterSettingsChange(settings),
                 onAgentModelsChange: (agentName, models) => {
                     const shadowedByProject = this.settingsManager.hasProjectAgentModelOverride(agentName);
                     if (models.length > 0) {