@dreb/coding-agent 2.45.4 → 2.47.0

package/dist/core/agent-session.js

@@ -22,11 +22,13 @@ import { sleep } from "../utils/sleep.js";
 import { executeBash as executeBashCommand, executeBashWithOperations } from "./bash-executor.js";
 import { calculateContextTokens, collectEntriesForBranchSummary, compact, estimateContextTokens, generateBranchSummary, prepareCompaction, shouldCompact, } from "./compaction/index.js";
 import { DEFAULT_THINKING_LEVEL } from "./defaults.js";
+import { DispatchArbiter } from "./dispatch-arbiter.js";
 import { exportSessionToHtml } from "./export-html/index.js";
 import { createToolHtmlRenderer } from "./export-html/tool-renderer.js";
 import { ExtensionRunner, wrapRegisteredTools, } from "./extensions/index.js";
 import { checkScriptContent, extractScriptPaths, isForbiddenCommand } from "./forbidden-commands.js";
-import { getGitRepoState } from "./git-repo-state.js";
+import { getGitRepoState, getGitStatusMetadata } from "./git-repo-state.js";
+import { findGitRoot } from "./git-root.js";
 import { log } from "./logger.js";
 import { computeNestedContextBlock } from "./nested-context.js";
 import { PerformanceTracker } from "./performance-tracker.js";
@@ -153,6 +155,8 @@ export class AgentSession {
     _ownsPerformanceTracker;
     // Git repo state captured once at session start
     _gitRepoState;
+    // Fully headless pre-spawn router. It owns only bounded parent activity context.
+    _dispatchArbiter;
     constructor(config) {
         this.agent = config.agent;
         this.sessionManager = config.sessionManager;
@@ -181,6 +185,29 @@ export class AgentSession {
         this._uiType = config.uiType;
         // Capture git repo state once at session start (before building runtime/system prompt)
         this._gitRepoState = getGitRepoState(this._cwd) ?? undefined;
+        this._dispatchArbiter = new DispatchArbiter({
+            getSettings: () => this.settingsManager.getGlobalSubagentArbiterSettings(),
+            getCandidateModels: () => this._scopedModels,
+            getModelRegistry: () => this._modelRegistry,
+            getMessages: () => this.agent.state.messages,
+            getParentModel: () => this.model,
+            getSessionTitle: () => this.sessionName,
+            getRepoMetadata: (cwd) => {
+                const gitRoot = findGitRoot(cwd);
+                const isSessionCwd = resolve(cwd) === resolve(this._cwd);
+                const currentStatus = gitRoot
+                    ? (getGitStatusMetadata(cwd) ?? (isSessionCwd ? this._gitRepoState : undefined))
+                    : undefined;
+                return {
+                    repo: gitRoot ? basename(gitRoot) : undefined,
+                    cwd,
+                    branch: currentStatus?.branch,
+                    dirtyCount: currentStatus?.dirtyCount,
+                };
+            },
+            getExtraSecretPatterns: () => this._compileExtraSecretPatterns(),
+            complete: config.dispatchArbiterComplete,
+        });
         // Always subscribe to agent events for internal handling
         // (session persistence, extensions, auto-compaction, retry logic)
         this._unsubscribeAgent = this.agent.subscribe(this._handleAgentEvent);
@@ -199,6 +226,21 @@ export class AgentSession {
     getPerformanceTracker() {
         return this.performanceTracker;
     }
+    _compileExtraSecretPatterns() {
+        return this.settingsManager.getSecretOutputPatterns()?.flatMap((pattern) => {
+            if (!pattern.pattern || typeof pattern.pattern !== "string" || pattern.pattern.trim() === "") {
+                console.warn(`[secret-scrubber] Skipping empty or invalid pattern in secretOutputPatterns: "${pattern.name}"`);
+                return [];
+            }
+            try {
+                return [{ name: pattern.name, pattern: new RegExp(pattern.pattern, "g") }];
+            }
+            catch (error) {
+                console.warn(`[secret-scrubber] Skipping invalid regex in secretOutputPatterns "${pattern.name}": ${pattern.pattern} — ${error instanceof Error ? error.message : String(error)}`);
+                return [];
+            }
+        });
+    }
     /**
      * Install tool hooks once on the Agent instance.
      *
@@ -285,20 +327,7 @@ export class AgentSession {
         this.agent.setAfterToolCall(async ({ toolCall, args, result, isError }) => {
             // Scrub secrets from tool output — runs before extensions, cannot be bypassed
             let scrubbedContent = result.content;
-            const extraSecretPatterns = this.settingsManager?.getSecretOutputPatterns();
-            const compiledExtras = extraSecretPatterns?.flatMap((p) => {
-                if (!p.pattern || typeof p.pattern !== "string" || p.pattern.trim() === "") {
-                    console.warn(`[secret-scrubber] Skipping empty or invalid pattern in secretOutputPatterns: "${p.name}"`);
-                    return [];
-                }
-                try {
-                    return [{ name: p.name, pattern: new RegExp(p.pattern, "g") }];
-                }
-                catch (err) {
-                    console.warn(`[secret-scrubber] Skipping invalid regex in secretOutputPatterns "${p.name}": ${p.pattern} — ${err instanceof Error ? err.message : String(err)}`);
-                    return [];
-                }
-            });
+            const compiledExtras = this._compileExtraSecretPatterns();
             let totalRedactions = 0;
             scrubbedContent = scrubbedContent.map((item) => {
                 if (item.type === "text" && item.text) {
@@ -513,6 +542,15 @@ export class AgentSession {
      */
     _handleBackgroundComplete(agentId, result, cancelled) {
         const parts = [];
+        if (result.model || result.thinking) {
+            const metadata = [
+                result.model ? `model: ${result.model}` : undefined,
+                result.thinking ? `thinking: ${result.thinking}` : undefined,
+            ]
+                .filter((value) => value !== undefined)
+                .join(", ");
+            parts.push(`Execution metadata: ${metadata}`);
+        }
         if (cancelled) {
             parts.push("This agent was cancelled by the user.");
         }
@@ -585,6 +623,9 @@ export class AgentSession {
                 agentId,
                 agentType: result.agent,
                 success: result.exitCode === 0,
+                model: result.model,
+                thinking: result.thinking,
+                steps: result.steps,
                 sessionFile: result.sessionFile,
             });
         }
@@ -738,6 +779,17 @@ export class AgentSession {
         await this._emitExtensionEvent(event);
         // Notify all listeners
         this._emit(event);
+        // Keep a small, mode-independent rolling context for the headless arbiter.
+        if (event.type === "message_end") {
+            this._dispatchArbiter.onMessageEnd(event.message);
+        }
+        else if (event.type === "tool_execution_end") {
+            this._dispatchArbiter.onToolEnd({
+                toolName: event.toolName,
+                isError: event.isError,
+                result: event.result,
+            });
+        }
         // Handle session persistence
         if (event.type === "message_end") {
             // Check if this is a custom message from extensions
@@ -831,7 +883,12 @@ export class AgentSession {
     }
     /** Emit extension events based on agent events */
     async _emitExtensionEvent(event) {
-        if (!this._extensionRunner)
+        // The runner is created unconditionally (so built-in tools like ask_user
+        // always have a UI context). When no extensions are loaded there are no
+        // handlers to invoke — return synchronously to avoid inserting an extra
+        // await tick per event, which would otherwise delay the final agent_end
+        // emission past when prompt() resolves.
+        if (!this._extensionRunner || !this._extensionRunner.hasExtensions)
             return;
         if (event.type === "agent_start") {
             this._turnIndex = 0;
@@ -1587,6 +1644,7 @@ export class AgentSession {
         this._disconnectFromAgent();
         await this.abort();
         this.agent.reset();
+        this._dispatchArbiter.clearContext();
         this.sessionManager.newSession({ parentSession: options?.parentSession });
         this.agent.sessionId = this.sessionManager.getSessionId();
         this._steeringMessages = [];
@@ -2390,9 +2448,15 @@ export class AgentSession {
         const wrappedExtensionTools = this._extensionRunner
             ? wrapRegisteredTools(allCustomTools, this._extensionRunner)
             : [];
+        // Give base tools a per-execution extension context so built-ins like
+        // ask_user can reach ctx.ui. createContext() snapshots hasUI at call time,
+        // so print/RPC-without-host modes degrade to the no-op UI (hasUI === false).
+        const baseToolCtxFactory = this._extensionRunner
+            ? () => this._extensionRunner.createContext()
+            : undefined;
         const toolRegistry = new Map(Array.from(this._baseToolDefinitions.values()).map((definition) => [
             definition.name,
-            wrapToolDefinition(definition),
+            wrapToolDefinition(definition, baseToolCtxFactory),
         ]));
         for (const tool of wrappedExtensionTools) {
             toolRegistry.set(tool.name, tool);
@@ -2467,6 +2531,12 @@ export class AgentSession {
                     parentSessionFile: () => this.sessionFile,
                     modelRegistry: this._modelRegistry,
                     getAgentModelsForAgent: (name) => this.settingsManager?.getAgentModelsForAgent(name),
+                    defaultThinkingLevel: () => this.settingsManager.getDefaultThinkingLevel() ?? DEFAULT_THINKING_LEVEL,
+                    arbitrate: (request, signal) => this._dispatchArbiter.arbitrate(request, signal),
+                    onArbitration: (event) => {
+                        this.sessionManager.appendCustomEntry("subagent_arbitration", event);
+                        this._emit(event);
+                    },
                     onBackgroundStart: (agentId, agentType, taskSummary, sessionDir) => {
                         this._emit({ type: "background_agent_start", agentId, agentType, taskSummary, sessionDir });
                     },
@@ -2485,12 +2555,11 @@ export class AgentSession {
                 extensionsResult.runtime.flagValues.set(name, value);
             }
         }
-        const hasExtensions = extensionsResult.extensions.length > 0;
-        const hasCustomTools = this._customTools.length > 0;
-        this._extensionRunner =
-            hasExtensions || hasCustomTools
-                ? new ExtensionRunner(extensionsResult.extensions, extensionsResult.runtime, this._cwd, this.sessionManager, this._modelRegistry)
-                : undefined;
+        // The runner also owns the cross-surface UI context used by built-in
+        // tools such as ask_user. Create it even when no third-party extensions
+        // are loaded; otherwise ordinary TUI/Dashboard sessions give base tools
+        // no ctx.ui and ask_user can never open its dialog.
+        this._extensionRunner = new ExtensionRunner(extensionsResult.extensions, extensionsResult.runtime, this._cwd, this.sessionManager, this._modelRegistry);
         if (this._extensionRunnerRef) {
             this._extensionRunnerRef.current = this._extensionRunner;
         }
@@ -2513,6 +2582,7 @@ export class AgentSession {
                 "subagent",
                 "wait",
                 "search",
+                "ask_user",
                 "skill",
                 "tasks_update",
                 "suggest_next",
@@ -2783,6 +2853,7 @@ export class AgentSession {
         this._steeringMessages = [];
         this._followUpMessages = [];
         this._pendingNextTurnMessages = [];
+        this._dispatchArbiter.clearContext();
         // Set new session
         this.sessionManager.setSessionFile(sessionPath);
         this.agent.sessionId = this.sessionManager.getSessionId();