muonroi-cli 1.8.5 → 1.9.0

package/dist/src/orchestrator/council-manager.js

@@ -19,7 +19,7 @@ import { getRoutedModelByTier } from "../router/peak-hour.js";
 import { appendSystemMessage } from "../storage/index.js";
 import { createBuiltinTools } from "../tools/registry.js";
 import { isProviderDisabled } from "../utils/settings.js";
-import { COUNCIL_COLOR_BG, COUNCIL_COLOR_RESET, COUNCIL_ROLE_COLORS, } from "./agent-options.js";
+import { COUNCIL_COLOR_BG, COUNCIL_COLOR_RESET, COUNCIL_ROLE_COLORS } from "./agent-options.js";
 import { extractUserContent, getCompactionSummaryText, isCompactionSummaryMessage } from "./compaction.js";
 /**
  * CouncilManager — extracted council subsystem.
@@ -149,8 +149,8 @@ export class CouncilManager {
     async generate(modelId, system, prompt, maxTokens = 2048) {
         const providerId = detectProviderForModel(modelId);
         const key = await loadKeyForProvider(providerId);
-        const provider = createCouncilProvider(providerId, key);
-        const runtime = resolveModelRuntime(provider, modelId);
+        ensureCouncilProvider(providerId, key);
+        const runtime = resolveModelRuntime(modelId);
         const { text } = await generateText({
             model: runtime.model,
             system,
@@ -170,8 +170,8 @@ export class CouncilManager {
     async research(modelId, topic, conversationContext, signal) {
         const providerId = detectProviderForModel(modelId);
         const key = await loadKeyForProvider(providerId);
-        const provider = createCouncilProvider(providerId, key);
-        const runtime = resolveModelRuntime(provider, modelId);
+        ensureCouncilProvider(providerId, key);
+        const runtime = resolveModelRuntime(modelId);
         // Build tool set with bash, grep, read_file for codebase research
         const researchTools = createBuiltinTools(this.deps.getBash(), this.deps.getMode(), {
             // research phase intentionally has no runTask/runDelegation handlers
@@ -504,11 +504,12 @@ export class CouncilManager {
     static COLOR_RESET = COUNCIL_COLOR_RESET;
 }
 /**
- * Internal: build a provider factory using the shared runtime factory.
+ * Internal: register a provider factory using the shared runtime factory, so a
+ * council sub-call on a provider the session never built can still resolve.
  * Mirrors `createProvider` in orchestrator.ts to keep council sub-calls
  * decoupled from Agent state.
  */
-function createCouncilProvider(providerId, apiKey, baseURL) {
-    return createProviderFactory(providerId, { apiKey, baseURL }).factory;
+function ensureCouncilProvider(providerId, apiKey, baseURL) {
+    createProviderFactory(providerId, { apiKey, baseURL });
 }
 //# sourceMappingURL=council-manager.js.map

package/dist/src/orchestrator/council-request.d.ts

@@ -0,0 +1,49 @@
+/**
+ * src/orchestrator/council-request.ts
+ *
+ * Process-global one-shot channel for an AGENT-initiated council convening.
+ *
+ * The `convene_council` tool (src/tools/registry.ts) sets a pending request when
+ * the model decides THIS request warrants a multi-model debate; the tool-engine
+ * consumes it from the OUTER restart loop after a stream drain (NOT solely via
+ * dynamicStopWhen — a phase-1 SAMR step ends on stepCountIs(1) and never
+ * evaluates the stop hook), runs `runCouncilV2({ convenePath: true })`, splices
+ * the synthesis into the convene tool's tool_result, and restarts streamText so
+ * the model reads the conclusion as the tool's result and continues the turn.
+ *
+ * Modelled on compact-request.ts. Two differences that matter for correctness:
+ *   1. It carries the `toolCallId` of the convene_council call so the tool-engine
+ *      can (a) confirm the pending request actually belongs to THIS drain's
+ *      messages before running council — guarding against a nested sub-session
+ *      whose convene call would otherwise be consumed by the parent loop — and
+ *      (b) locate the exact tool-result to replace with the synthesis.
+ *   2. `peekCouncilConveneToolCallId()` is a NON-consuming read for that guard;
+ *      the flag is only cleared by `consumeCouncilConvene()` (on run) or by the
+ *      turn-teardown `finally` (discard) so a request can never leak into the
+ *      next user turn when the convene call shared a step with a terminal
+ *      `respond_*` tool.
+ *
+ * Single-active-turn assumption (inherited from compact-request.ts): the TUI
+ * streams one turn at a time, so a process-global slot cannot cross-talk between
+ * concurrent user turns.
+ */
+export interface CouncilConveneRequestState {
+    /** Model-supplied justification for convening (the specific tradeoff/decision at stake). */
+    reason: string | null;
+    /** Tool-call id of the convene_council call, so the tool-engine can match + replace its result. */
+    toolCallId: string | null;
+}
+/** Queue a council convening to run before the model's next step. */
+export declare function requestCouncilConvene(reason?: string | null, toolCallId?: string | null): void;
+/** True when a council convening is queued (non-consuming peek). */
+export declare function hasPendingCouncilConvene(): boolean;
+/**
+ * Non-consuming read of the pending request's toolCallId. Used by the tool-engine
+ * to check whether the pending convene belongs to THIS drain's response.messages
+ * before committing to a (possibly expensive, possibly wrong-frame) debate.
+ */
+export declare function peekCouncilConveneToolCallId(): string | null;
+/** Consume the pending request exactly once (returns null when none queued). */
+export declare function consumeCouncilConvene(): CouncilConveneRequestState | null;
+/** Test hook — clear any queued request. */
+export declare function __resetCouncilConveneForTests(): void;

package/dist/src/orchestrator/council-request.js

@@ -0,0 +1,62 @@
+/**
+ * src/orchestrator/council-request.ts
+ *
+ * Process-global one-shot channel for an AGENT-initiated council convening.
+ *
+ * The `convene_council` tool (src/tools/registry.ts) sets a pending request when
+ * the model decides THIS request warrants a multi-model debate; the tool-engine
+ * consumes it from the OUTER restart loop after a stream drain (NOT solely via
+ * dynamicStopWhen — a phase-1 SAMR step ends on stepCountIs(1) and never
+ * evaluates the stop hook), runs `runCouncilV2({ convenePath: true })`, splices
+ * the synthesis into the convene tool's tool_result, and restarts streamText so
+ * the model reads the conclusion as the tool's result and continues the turn.
+ *
+ * Modelled on compact-request.ts. Two differences that matter for correctness:
+ *   1. It carries the `toolCallId` of the convene_council call so the tool-engine
+ *      can (a) confirm the pending request actually belongs to THIS drain's
+ *      messages before running council — guarding against a nested sub-session
+ *      whose convene call would otherwise be consumed by the parent loop — and
+ *      (b) locate the exact tool-result to replace with the synthesis.
+ *   2. `peekCouncilConveneToolCallId()` is a NON-consuming read for that guard;
+ *      the flag is only cleared by `consumeCouncilConvene()` (on run) or by the
+ *      turn-teardown `finally` (discard) so a request can never leak into the
+ *      next user turn when the convene call shared a step with a terminal
+ *      `respond_*` tool.
+ *
+ * Single-active-turn assumption (inherited from compact-request.ts): the TUI
+ * streams one turn at a time, so a process-global slot cannot cross-talk between
+ * concurrent user turns.
+ */
+let pending = null;
+/** Queue a council convening to run before the model's next step. */
+export function requestCouncilConvene(reason, toolCallId) {
+    const trimmedReason = typeof reason === "string" ? reason.trim() : "";
+    const trimmedId = typeof toolCallId === "string" ? toolCallId.trim() : "";
+    pending = {
+        reason: trimmedReason.length > 0 ? trimmedReason : null,
+        toolCallId: trimmedId.length > 0 ? trimmedId : null,
+    };
+}
+/** True when a council convening is queued (non-consuming peek). */
+export function hasPendingCouncilConvene() {
+    return pending !== null;
+}
+/**
+ * Non-consuming read of the pending request's toolCallId. Used by the tool-engine
+ * to check whether the pending convene belongs to THIS drain's response.messages
+ * before committing to a (possibly expensive, possibly wrong-frame) debate.
+ */
+export function peekCouncilConveneToolCallId() {
+    return pending?.toolCallId ?? null;
+}
+/** Consume the pending request exactly once (returns null when none queued). */
+export function consumeCouncilConvene() {
+    const p = pending;
+    pending = null;
+    return p;
+}
+/** Test hook — clear any queued request. */
+export function __resetCouncilConveneForTests() {
+    pending = null;
+}
+//# sourceMappingURL=council-request.js.map

package/dist/src/orchestrator/interactive-pause.d.ts

@@ -0,0 +1,26 @@
+/**
+ * src/orchestrator/interactive-pause.ts
+ *
+ * Process-global "an interactive card is blocking the turn" gate.
+ *
+ * Some tools (`ask_user`) block inside their AI-SDK `execute()` waiting for a
+ * human to answer a card. During that wait NO stream chunks flow, so both the
+ * per-attempt stall watchdog (getProviderStallTimeoutMs, default 2 min) and the
+ * turn-idle watchdog (MUONROI_TURN_IDLE_MS, default 2 min) would fire and abort
+ * a turn that is not stalled at all — the human is just thinking.
+ *
+ * Rather than thread a keepalive timer through every call site, the blocking
+ * handler brackets its wait with {@link beginInteractivePause} /
+ * {@link endInteractivePause}, and both watchdogs consult
+ * {@link isInteractivePaused} before firing — re-arming instead of aborting
+ * while a card is open. Counter (not boolean) so nested/concurrent cards are
+ * safe.
+ */
+/** Enter an interactive pause — call before awaiting a blocking card. */
+export declare function beginInteractivePause(): void;
+/** Leave an interactive pause — call in a `finally` after the card resolves. */
+export declare function endInteractivePause(): void;
+/** True while at least one interactive card is blocking the turn. */
+export declare function isInteractivePaused(): boolean;
+/** Test-only: force the counter back to zero. */
+export declare function __resetInteractivePauseForTests(): void;

package/dist/src/orchestrator/interactive-pause.js

@@ -0,0 +1,36 @@
+/**
+ * src/orchestrator/interactive-pause.ts
+ *
+ * Process-global "an interactive card is blocking the turn" gate.
+ *
+ * Some tools (`ask_user`) block inside their AI-SDK `execute()` waiting for a
+ * human to answer a card. During that wait NO stream chunks flow, so both the
+ * per-attempt stall watchdog (getProviderStallTimeoutMs, default 2 min) and the
+ * turn-idle watchdog (MUONROI_TURN_IDLE_MS, default 2 min) would fire and abort
+ * a turn that is not stalled at all — the human is just thinking.
+ *
+ * Rather than thread a keepalive timer through every call site, the blocking
+ * handler brackets its wait with {@link beginInteractivePause} /
+ * {@link endInteractivePause}, and both watchdogs consult
+ * {@link isInteractivePaused} before firing — re-arming instead of aborting
+ * while a card is open. Counter (not boolean) so nested/concurrent cards are
+ * safe.
+ */
+let pauseDepth = 0;
+/** Enter an interactive pause — call before awaiting a blocking card. */
+export function beginInteractivePause() {
+    pauseDepth += 1;
+}
+/** Leave an interactive pause — call in a `finally` after the card resolves. */
+export function endInteractivePause() {
+    pauseDepth = Math.max(0, pauseDepth - 1);
+}
+/** True while at least one interactive card is blocking the turn. */
+export function isInteractivePaused() {
+    return pauseDepth > 0;
+}
+/** Test-only: force the counter back to zero. */
+export function __resetInteractivePauseForTests() {
+    pauseDepth = 0;
+}
+//# sourceMappingURL=interactive-pause.js.map

package/dist/src/orchestrator/message-processor.d.ts

@@ -7,6 +7,7 @@ import type { SessionInfo, StreamChunk, SubagentStatus } from "../types/index.js
 import { type PermissionMode } from "../utils/permission-mode.js";
 import type { AbortContext } from "./abort.js";
 import type { LegacyProvider, ProcessMessageObserver } from "./agent-options.js";
+import type { AskUserAskInfo } from "./ask-user.js";
 import type { CouncilManager } from "./council-manager.js";
 import type { CrossTurnDedup } from "./cross-turn-dedup.js";
 import type { PendingCallsLog } from "./pending-calls.js";
@@ -115,10 +116,13 @@ export interface MessageProcessorDeps extends TurnRunnerDepsBase {
     askToolLoopContinue?: ToolLoopCapAsk;
     /** Safety override handler — invoked when a tool call is blocked by the safety filter. */
     askSafetyOverride?: (info: SafetyOverrideAskInfo) => Promise<SafetyOverrideVerdict>;
+    /** ask_user handler — invoked when the model calls the `ask_user` tool; resolves the human's answer. */
+    askUser?: (info: AskUserAskInfo) => Promise<string>;
     runCouncilV2(userMessage: string, opts: {
         skipClarification: boolean;
         observer?: ProcessMessageObserver;
         userModelMessage: ModelMessage;
+        convenePath?: boolean;
     }): AsyncGenerator<StreamChunk, void, unknown>;
     processMessage(userMessage: string, observer?: ProcessMessageObserver, images?: Array<{
         path: string;

package/dist/src/orchestrator/message-processor.js

@@ -681,13 +681,31 @@ export class MessageProcessor {
         const turnProviderId = detectProviderForModel(turnModelId);
         let turnProvider;
         if (turnProviderId !== deps.providerId) {
+            const disabled = isProviderDisabled(turnProviderId);
             // Even if the key is reachable, skip disabled providers
-            const turnKey = !isProviderDisabled(turnProviderId)
-                ? await loadKeyForProvider(turnProviderId).catch(() => null)
-                : null;
-            if (turnKey) {
-                const { createProviderFactory } = await import("../providers/runtime.js");
-                turnProvider = createProviderFactory(turnProviderId, { apiKey: turnKey }).factory;
+            const turnKey = !disabled ? await loadKeyForProvider(turnProviderId).catch(() => null) : null;
+            // An OAuth-capable provider may be authenticated by subscription tokens
+            // (no env API key). Detect that so the turn can still run over OAuth.
+            let hasOAuth = false;
+            if (!disabled) {
+                try {
+                    const { getOAuthProviderConfig } = await import("../providers/auth/registry.js");
+                    const cfg = await getOAuthProviderConfig(turnProviderId);
+                    const tokens = cfg ? await cfg.loadTokensWithRefresh().catch(() => null) : null;
+                    hasOAuth = !!tokens?.accessToken;
+                }
+                catch {
+                    hasOAuth = false;
+                }
+            }
+            if (turnKey || hasOAuth) {
+                // OAuth XOR API key: the ASYNC factory injects OAuth (codex baseURL +
+                // Bearer headers) when tokens exist for this provider, otherwise it
+                // uses the env key. Using the sync factory here was the cross-provider
+                // shadowing bug (it shipped a stale sk-proj key to api.openai.com).
+                const { createProviderFactoryAsync } = await import("../providers/runtime.js");
+                const built = await createProviderFactoryAsync(turnProviderId, turnKey ? { apiKey: turnKey } : {});
+                turnProvider = built.factory;
             }
             else {
                 // Router's provider unreachable or disabled — fall back to a non-disabled provider
@@ -905,7 +923,7 @@ export class MessageProcessor {
         const system = applyModelConstraints(applyPilSuffix(`${systemParts.staticPrefix}${playwrightGuidance}${systemParts.dynamicSuffix}`, pilCtx, _hasResponseTools), turnModelId);
         // Tool-turn system: same template as system but with toolTurn-prefix
         const toolTurnSystem = applyModelConstraints(applyPilSuffix(`${toolTurnParts.staticPrefix}${playwrightGuidance}${toolTurnParts.dynamicSuffix}`, pilCtx, _hasResponseTools), turnModelId);
-        const runtime = resolveModelRuntime(provider, turnModelId);
+        const runtime = resolveModelRuntime(turnModelId);
         const modelInfo = runtime.modelInfo;
         // SAMR: Step-Aware Model Routing — downgrade to fast model for tool-execution
         // steps after the initial reasoning step. The premium model decides WHAT to do;
@@ -938,7 +956,7 @@ export class MessageProcessor {
         const stepRouterDecision = decideStepRouting(turnModelId, deps.providerId, stepRouterCfg);
         const stepRouterPhase = stepRouterDecision.phase2ModelId ? "phase1" : "done";
         const phase2Runtime = stepRouterDecision.phase2ModelId
-            ? resolveModelRuntime(provider, stepRouterDecision.phase2ModelId)
+            ? resolveModelRuntime(stepRouterDecision.phase2ModelId)
             : null;
         if (stepRouterDecision.phase2ModelId && _debugOn) {
             _debugSteps.push({

package/dist/src/orchestrator/orchestrator.d.ts

@@ -5,6 +5,7 @@ import type { AgentMode, ChatEntry, SessionInfo, SessionSnapshot, StreamChunk, S
 import { type SandboxMode, type SandboxSettings } from "../utils/settings.js";
 import { type SideQuestionResult } from "../utils/side-question.js";
 import { type AgentOptions, type LegacyProvider, type ProcessMessageObserver } from "./agent-options.js";
+import type { AskUserAskInfo } from "./ask-user.js";
 import type { SafetyOverrideAskInfo, SafetyOverrideVerdict } from "./safety-askcard.js";
 import type { ToolLoopCapAsk } from "./tool-loop-cap.js";
 /** Deterministic fallback title: truncated first user message, or "" when the
@@ -121,6 +122,22 @@ export declare class Agent {
         text: string;
     }[]) | null): void;
     getActiveRunId(): string | null;
+    /**
+     * Point the agent at `model`, re-resolving the provider when the new model
+     * belongs to a different one.
+     *
+     * EVERY path that changes `this.modelId` must go through here. Changing the
+     * id alone leaves `providerId` / `provider` / `baseURL` / `apiKey` describing
+     * the PREVIOUS provider, so the next turn POSTs the new model to the old
+     * provider's endpoint — which rejects it as unknown (session 0c6728ba1a25:
+     * `gpt-5.4` sent to api.x.ai → 404 "The model gpt-5.4 does not exist", a
+     * wiring bug that reads like a bad model name). `setMode` used to do exactly
+     * that; it now calls this too.
+     *
+     * Session persistence is NOT done here — callers own that, because setMode
+     * writes mode+model together.
+     */
+    private _applyModelId;
     setModel(model: string): void;
     getMode(): AgentMode;
     getSandboxMode(): SandboxMode;
@@ -174,6 +191,8 @@ export declare class Agent {
     extendHardCeilingForAutoCompaction(): void;
     private _safetyOverrideHandler;
     setSafetyOverrideHandler(fn: ((block: SafetyOverrideAskInfo) => Promise<SafetyOverrideVerdict>) | null): void;
+    private _askUserHandler;
+    setAskUserHandler(fn: ((info: AskUserAskInfo) => Promise<string>) | null): void;
     respondToToolApproval(approvalId: string, approved: boolean): void;
     clearHistory(): Promise<void>;
     startNewSession(): SessionSnapshot | null;
@@ -237,6 +256,12 @@ export declare class Agent {
         skipClarification?: boolean;
         observer?: ProcessMessageObserver;
         userModelMessage?: ModelMessage;
+        /**
+         * convene_council path — forwarded into runCouncil so the post-debate
+         * decision surface is suppressed and the synthesis is returned to the
+         * calling agent (no CLI-hardcoded post-council branch).
+         */
+        convenePath?: boolean;
     }): AsyncGenerator<StreamChunk, void, unknown>;
     runProductLoopV1(payload: {
         subcommand: "start" | "status" | "resume" | "abort" | "ship" | "review";