@code-yeongyu/senpi 2026.7.31 → 2026.8.3

package/dist/core/agent-session.js

@@ -18,6 +18,7 @@ import { basename, dirname } from "node:path";
 import { prepareAgentToolCall } from "@earendil-works/pi-agent-core";
 import { contentText, SERVER_FALLBACK_ABORTED_DIAGNOSTIC } from "@earendil-works/pi-ai";
 import { cleanupSessionResources, isClassifierRefusal, isContextOverflow, isProviderStreamStallError, isProviderTimeoutError, isRetryableAssistantError, modelsAreEqual, resetApiProviders, streamSimple, } from "@earendil-works/pi-ai/compat";
+import { extract429RetryAfterMs, parseRetryAfterMsMarker } from "@earendil-works/pi-ai/utils/retry-hint";
 import { getAgentDir } from "../config.js";
 import { getThemeByName, theme } from "../modes/interactive/theme/theme.js";
 import { stripFrontmatter } from "../utils/frontmatter.js";
@@ -41,9 +42,12 @@ import { getModelNarrowingPatterns, resolveModelScope } from "./model-resolver.j
 import { PROMPT_CACHE_SAFE_WAIT_ENV, resolvePromptCacheSafeWaitSeconds } from "./prompt-cache-budget.js";
 import { expandPromptTemplate } from "./prompt-templates.js";
 import { isBillingErrorMessage } from "./retry-fallback/billing.js";
+import { formatSelector } from "./retry-fallback/chains.js";
 import { RetryFallbackController } from "./retry-fallback/controller.js";
 import { SelectorCooldowns } from "./retry-fallback/cooldown.js";
+import { classifyRateLimitedWait, nextInTurnDelayMs, probeBackSchedule, } from "./retry-fallback/hint-policy.js";
 import { createFallbackLogger } from "./retry-fallback/log.js";
+import { ProbeBackScheduler } from "./retry-fallback/probe-scheduler.js";
 import { validateFallbackChains } from "./retry-fallback/validate.js";
 import { createSessionLogger } from "./session-log.js";
 import { buildSessionContext, CURRENT_SESSION_VERSION, getLatestCompactionEntry, } from "./session-manager.js";
@@ -195,10 +199,14 @@ export class AgentSession {
         this._isAgentRunActive = false;
         this._toolExecutionDepth = 0;
         this._promptStartPending = false;
+        this._nextInputId = 0;
         /** Tracks pending steering messages for UI display. Removed when delivered. */
         this._steeringMessages = [];
         /** Tracks pending follow-up messages for UI display. Removed when delivered. */
         this._followUpMessages = [];
+        /** Recovery-only order across both native queue modes and TUI compaction ownership. */
+        this._queuedInputOrder = [];
+        this._nextQueuedInputOrder = 0;
         /** Messages queued to be included with the next user prompt as context ("asides"). */
         this._pendingNextTurnMessages = [];
         // Queues held while the first post-compaction response is classified. Agent
@@ -229,16 +237,19 @@ export class AgentSession {
         this._retryAbortController = undefined;
         this._retryAttempt = 0;
         this._consecutiveProviderStreamStalls = 0;
+        this._probePhase = "idle";
+        this._hintDeadlineMs = undefined;
+        this._cumulativeHintedWaitMs = 0;
         this._retryPromise = undefined;
         this._retryResolve = undefined;
         this._userAbortPromise = undefined;
         this._agentAbortSource = undefined;
         this._suppressQueuedContinuationAfterUserAbort = false;
-        /** Set when clearQueue() drains non-empty queues, so abort() can detect the gap even after queues are cleared. */
+        /** Set when clearQueue({ abortWillFollow: true }) drains queues immediately before abort(). */
         this._hadClearedQueuedMessages = false;
         this._extensionEventSignal = undefined;
         // Bash execution state
-        this._bashAbortController = undefined;
+        this._bashAbortControllers = new Set();
         this._pendingBashMessages = [];
         this._turnIndex = 0;
         this._baseToolDefinitions = new Map();
@@ -252,7 +263,8 @@ export class AgentSession {
         // Base system prompt (without extension appends) - used to apply fresh appends each turn
         this._baseSystemPrompt = "";
         this._currentServiceTier = undefined;
-        this._lastHighReasoningWarningKey = undefined;
+        this._sessionFastMode = false;
+        this._shownHighReasoningWarningKeys = new Set();
         // Track last assistant message for auto-compaction check
         this._lastAssistantMessage = undefined;
         /** Internal handler for agent events - shared by subscribe and reconnect */
@@ -318,16 +330,19 @@ export class AgentSession {
         }
         this._modelRuntime = modelRuntime;
         this._modelRegistry = config.modelRegistry ?? new ModelRegistry(modelRuntime);
-        const fallbackLogger = createFallbackLogger(config.agentDir ?? getAgentDir());
-        this._sessionLogger = createSessionLogger(config.agentDir ?? getAgentDir());
+        this._agentDir = config.agentDir ?? getAgentDir();
+        const fallbackLogger = createFallbackLogger(this._agentDir);
+        this._sessionLogger = createSessionLogger(this._agentDir);
         this._fallbackValidationWarnings = validateFallbackChains(this.settingsManager.getRawFallbackChains(), this._modelRegistry);
         for (const warning of this._fallbackValidationWarnings) {
             fallbackLogger.warn("validation_warning", { warning });
         }
+        this._selectorCooldowns = new SelectorCooldowns(config.fallbackNow ?? (() => Date.now()));
+        this._fallbackNow = config.fallbackNow ?? (() => Date.now());
         this._retryFallback = new RetryFallbackController({
             getSettings: () => this.settingsManager.getRetryFallbackSettings(),
             registry: this._modelRegistry,
-            cooldowns: new SelectorCooldowns(config.fallbackNow ?? (() => Date.now())),
+            cooldowns: this._selectorCooldowns,
             logger: fallbackLogger,
             switchModel: async (model, thinking, reason) => {
                 await this._switchActiveModel(model, {
@@ -344,6 +359,9 @@ export class AgentSession {
             getCurrentSelector: () => (this.model ? { model: this.model, thinkingLevel: this.thinkingLevel } : undefined),
             isAuthAvailable: (provider) => this._modelRuntime.hasConfiguredAuth(provider),
         });
+        this._probeBackScheduler = new ProbeBackScheduler({
+            now: this._fallbackNow,
+        });
         this._extensionRunnerRef = config.extensionRunnerRef;
         this._initialActiveToolNames = config.initialActiveToolNames;
         this._allowedToolNames = config.allowedToolNames ? new Set(config.allowedToolNames) : undefined;
@@ -614,6 +632,10 @@ export class AgentSession {
     }
     /** Mirror stuck-prone lifecycle transitions into logs/session.log (content-free). */
     _logSessionEvent(event) {
+        if (event.type === "compaction_start") {
+            this._sessionLogger.info("compaction_start", { reason: event.reason });
+            return;
+        }
         if (event.type === "compaction_end") {
             this._sessionLogger.info("compaction_decision", {
                 reason: event.reason,
@@ -651,6 +673,10 @@ export class AgentSession {
     getMessageRevision() {
         return this._messageRevision;
     }
+    /** Resolved agent state directory for this session. */
+    get agentDir() {
+        return this._agentDir;
+    }
     async _waitForSettledSessionWork() {
         await this._sessionWorkBarrier.waitForSettled(() => this._agentEventQueue);
     }
@@ -733,7 +759,9 @@ export class AgentSession {
                     this.agent.steer(message);
                 const userMessage = queuedMessages.find((message) => message.role === "user");
                 if (userMessage?.role === "user") {
-                    this._steeringMessages.push(this._extractUserMessageText(userMessage.content));
+                    const text = this._extractUserMessageText(userMessage.content);
+                    this._steeringMessages.push(text);
+                    this._recordQueuedInput(text, "steer");
                     this._emitQueueUpdate();
                 }
                 return;
@@ -941,6 +969,7 @@ export class AgentSession {
                 const steeringIndex = this._steeringMessages.indexOf(messageText);
                 if (steeringIndex !== -1) {
                     this._steeringMessages.splice(steeringIndex, 1);
+                    this._removeQueuedInput(messageText, "steer");
                     this._emitQueueUpdate();
                 }
                 else {
@@ -948,6 +977,7 @@ export class AgentSession {
                     const followUpIndex = this._followUpMessages.indexOf(messageText);
                     if (followUpIndex !== -1) {
                         this._followUpMessages.splice(followUpIndex, 1);
+                        this._removeQueuedInput(messageText, "followUp");
                         this._emitQueueUpdate();
                     }
                 }
@@ -1009,6 +1039,7 @@ export class AgentSession {
                         attempt: this._retryAttempt,
                     });
                     this._retryAttempt = 0;
+                    this._resetHintTierState();
                 }
             }
         }
@@ -1098,6 +1129,77 @@ export class AgentSession {
             this._retryPromise = undefined;
         }
     }
+    _resetHintTierState() {
+        this._probePhase = "idle";
+        this._hintDeadlineMs = undefined;
+        this._cumulativeHintedWaitMs = 0;
+    }
+    /**
+     * Arm the probe-back scheduler for a tier-2 demoted selector. The scheduler
+     * will fire at most two probes (half-hint, then deadline) and clear the
+     * selector cooldown on success so maybeRestorePrimary reverts at the next
+     * turn boundary.
+     */
+    _armProbeBackForDemotedSelector(selector, hintMs) {
+        if (!selector)
+            return;
+        // Guard: skip when the demoted selector is the ACTIVE model.
+        const currentModel = this.model;
+        if (currentModel && formatSelector(currentModel) === selector)
+            return;
+        // Guard: skip when auth is unavailable at arm time.
+        const parts = selector.split("/");
+        if (parts.length < 2)
+            return;
+        const provider = parts[0];
+        if (!this._modelRuntime.hasConfiguredAuth(provider))
+            return;
+        const now = this._fallbackNow();
+        const schedule = probeBackSchedule(hintMs, now);
+        const modelId = parts.slice(1).join("/");
+        const demotedModel = this._modelRuntime.getModel(provider, modelId);
+        if (!demotedModel)
+            return;
+        this._probeBackScheduler.arm({
+            selector,
+            firstAtMs: schedule.firstAtMs,
+            deadlineMs: schedule.deadlineMs,
+            authAvailable: () => this._modelRuntime.hasConfiguredAuth(provider),
+            runProbe: async (signal) => {
+                try {
+                    const result = await this._modelRuntime.completeSimple(demotedModel, {
+                        systemPrompt: "Reply with OK.",
+                        messages: [{ role: "user", content: [{ type: "text", text: "OK" }], timestamp: now }],
+                    }, { maxTokens: 1, signal });
+                    return result.stopReason !== "error" && result.stopReason !== "aborted";
+                }
+                catch {
+                    return false;
+                }
+            },
+            onCleared: (sel) => {
+                this._selectorCooldowns.clear(sel);
+            },
+            emit: (event) => {
+                if (event.type === "retry_probe_scheduled") {
+                    this._emit({
+                        type: "retry_probe_scheduled",
+                        selector: event.selector,
+                        atMs: event.atMs,
+                        probeIndex: event.probeIndex,
+                    });
+                }
+                else {
+                    this._emit({
+                        type: "retry_probe_result",
+                        selector: event.selector,
+                        ok: event.ok,
+                        errorMessage: event.errorMessage,
+                    });
+                }
+            },
+        });
+    }
     /** Find the last assistant message in agent state (including aborted ones) */
     _findLastAssistantMessage() {
         const messages = this.agent.state.messages;
@@ -1309,6 +1411,7 @@ export class AgentSession {
      */
     dispose() {
         try {
+            this._probeBackScheduler.cancel("dispose");
             this.abortRetry();
             this.abortCompaction();
             this.abortBranchSummary();
@@ -1342,6 +1445,22 @@ export class AgentSession {
     get serviceTier() {
         return this._currentServiceTier;
     }
+    /**
+     * True when the active model is served at the priority ("fast") tier: either the model
+     * itself is configured for it (an `openai` `-fast` catalog variant, a scoped
+     * `provider/id:priority`) or an extension turned fast mode on for this session.
+     *
+     * Display-only: it never feeds request composition, so an extension toggling fast mode
+     * for one provider cannot leak `service_tier` into another provider's payload.
+     * `serviceTier` stays the single request-side source.
+     */
+    isFastModeActive() {
+        return this._sessionFastMode || this._currentServiceTier === "priority";
+    }
+    /** Session-scoped fast-mode indicator; never persisted, reset on session start. */
+    setSessionFastMode(enabled) {
+        this._sessionFastMode = enabled;
+    }
     /**
      * Explicit scoped/favorite tiers win; otherwise fall back to the model's
      * configured serviceTier from models.json/extension compatibility config.
@@ -1683,6 +1802,12 @@ export class AgentSession {
         let messages;
         let titlePrompt;
         let consumedNextTurnMessages;
+        let inputId;
+        const emitInputDisposition = async (disposition) => {
+            if (inputId === undefined)
+                return;
+            await this._extensionRunner.emit({ type: "input_disposition", inputId, disposition });
+        };
         try {
             // Handle extension commands first (execute immediately, even during streaming)
             // Extension commands manage their own LLM interaction via pi.sendMessage()
@@ -1700,9 +1825,11 @@ export class AgentSession {
             let currentText = text;
             let currentImages = options?.images;
             if (this._extensionRunner.hasHandlers("input")) {
-                const inputResult = await this._extensionRunner.emitInput(currentText, currentImages, options?.source ?? "interactive", this.isStreaming ? options?.streamingBehavior : undefined);
+                inputId = `${this.sessionManager.getSessionId()}:${++this._nextInputId}`;
+                const inputResult = await this._extensionRunner.emitInput(currentText, currentImages, options?.source ?? "interactive", this.isStreaming ? options?.streamingBehavior : undefined, inputId);
                 throwIfCancelled();
                 if (inputResult.action === "handled") {
+                    await emitInputDisposition("handled");
                     promptDisposition?.("handled");
                     preflightResult?.(true);
                     return;
@@ -1733,6 +1860,7 @@ export class AgentSession {
                 else {
                     await this._queueSteer(expandedText, currentImages);
                 }
+                await emitInputDisposition("queued");
                 promptDisposition?.("queued");
                 preflightResult?.(true);
                 return;
@@ -1750,6 +1878,7 @@ export class AgentSession {
                 else {
                     await this._queueSteer(expandedText, currentImages);
                 }
+                await emitInputDisposition("queued");
                 promptDisposition?.("queued");
                 preflightResult?.(true);
                 return;
@@ -1773,6 +1902,7 @@ export class AgentSession {
                     else {
                         await this._queueSteer(expandedText, currentImages);
                     }
+                    await emitInputDisposition("queued");
                     promptDisposition?.("queued");
                     preflightResult?.(true);
                     return;
@@ -1793,6 +1923,7 @@ export class AgentSession {
                 else {
                     await this._queueSteer(expandedText, currentImages);
                 }
+                await emitInputDisposition("queued");
                 promptDisposition?.("queued");
                 preflightResult?.(true);
                 return;
@@ -1866,8 +1997,11 @@ export class AgentSession {
             // next-turn, and before_agent_start additions are also provider-visible,
             // so make one final admission decision against the complete request.
             await this._enforceFinalProviderAdmission(messages);
+            throwIfCancelled();
+            await emitInputDisposition("started");
         }
         catch (error) {
+            await emitInputDisposition("rejected");
             if (consumedNextTurnMessages && consumedNextTurnMessages.length > 0) {
                 this._pendingNextTurnMessages = [...consumedNextTurnMessages, ...this._pendingNextTurnMessages];
             }
@@ -1881,7 +2015,6 @@ export class AgentSession {
         if (!messages) {
             return;
         }
-        throwIfCancelled();
         promptDisposition?.("started");
         preflightResult?.(true);
         if (options?.thinkingLevel !== undefined) {
@@ -2001,7 +2134,7 @@ export class AgentSession {
      * @param images Optional image attachments to include with the message
      * @throws Error if text is an extension command
      */
-    async steer(text, images) {
+    async steer(text, images, recovery) {
         // Check for extension commands (cannot be queued)
         if (text.startsWith("/")) {
             this._throwIfExtensionCommand(text);
@@ -2009,7 +2142,7 @@ export class AgentSession {
         // Expand skill commands and prompt templates
         let expandedText = this._expandSkillCommand(text);
         expandedText = expandPromptTemplate(expandedText, [...this.promptTemplates]);
-        await this._queueSteer(expandedText, images);
+        await this._queueSteer(expandedText, images, recovery?.enqueueOrder);
     }
     /**
      * Queue a follow-up message to be processed after the agent finishes.
@@ -2018,7 +2151,7 @@ export class AgentSession {
      * @param images Optional image attachments to include with the message
      * @throws Error if text is an extension command
      */
-    async followUp(text, images) {
+    async followUp(text, images, recovery) {
         // Check for extension commands (cannot be queued)
         if (text.startsWith("/")) {
             this._throwIfExtensionCommand(text);
@@ -2026,7 +2159,7 @@ export class AgentSession {
         // Expand skill commands and prompt templates
         let expandedText = this._expandSkillCommand(text);
         expandedText = expandPromptTemplate(expandedText, [...this.promptTemplates]);
-        await this._queueFollowUp(expandedText, images);
+        await this._queueFollowUp(expandedText, images, recovery?.enqueueOrder);
     }
     _startSessionTitleGeneration(firstPrompt) {
         if (!this._autoTitleSessions || this.sessionManager.getSessionName() || shouldSkipSessionTitle(firstPrompt)) {
@@ -2100,8 +2233,9 @@ export class AgentSession {
     /**
      * Internal: Queue a steering message (already expanded, no extension command check).
      */
-    async _queueSteer(text, images) {
+    async _queueSteer(text, images, enqueueOrder) {
         this._steeringMessages.push(text);
+        this._recordQueuedInput(text, "steer", enqueueOrder);
         this._sessionLogger.debug("queue_enqueue", { mode: "steer", count: this._steeringMessages.length });
         this._emitQueueUpdate();
         const content = [{ type: "text", text }];
@@ -2118,8 +2252,9 @@ export class AgentSession {
     /**
      * Internal: Queue a follow-up message (already expanded, no extension command check).
      */
-    async _queueFollowUp(text, images) {
+    async _queueFollowUp(text, images, enqueueOrder) {
         this._followUpMessages.push(text);
+        this._recordQueuedInput(text, "followUp", enqueueOrder);
         this._sessionLogger.debug("queue_enqueue", { mode: "followUp", count: this._followUpMessages.length });
         this._emitQueueUpdate();
         const content = [{ type: "text", text }];
@@ -2212,8 +2347,23 @@ export class AgentSession {
                 }
             }
             else if (options?.triggerTurn) {
-                await this._enforceCompactionBeforeProvider(this._findLastAssistantMessage(), false, "pre_prompt");
-                await this._enforceFinalProviderAdmission([appMessage]);
+                try {
+                    await this._enforceCompactionBeforeProvider(this._findLastAssistantMessage(), false, "pre_prompt");
+                    await this._enforceFinalProviderAdmission([appMessage]);
+                }
+                catch (error) {
+                    // Mirror sendUserMessage's retention contract: an admission
+                    // rejection must retain the message for later delivery instead
+                    // of silently dropping it (the fire-and-forget extension action
+                    // swallows this rejection).
+                    if (options.deliverAs === "followUp") {
+                        this.agent.followUp(appMessage);
+                    }
+                    else {
+                        this.agent.steer(appMessage);
+                    }
+                    throw error;
+                }
                 await this._promptAgent(appMessage);
             }
             else {
@@ -2311,26 +2461,46 @@ export class AgentSession {
             finishSessionWork?.();
         }
     }
+    /** Reserve a global order for input temporarily owned outside the native queues. */
+    reserveQueuedInputOrder() {
+        this._nextQueuedInputOrder += 1;
+        return this._nextQueuedInputOrder;
+    }
+    _recordQueuedInput(text, mode, enqueueOrder) {
+        const order = enqueueOrder ?? this.reserveQueuedInputOrder();
+        this._nextQueuedInputOrder = Math.max(this._nextQueuedInputOrder, order);
+        this._queuedInputOrder.push({ text, mode, enqueueOrder: order });
+    }
+    _removeQueuedInput(text, mode) {
+        const index = this._queuedInputOrder.findIndex((message) => message.mode === mode && message.text === text);
+        if (index !== -1)
+            this._queuedInputOrder.splice(index, 1);
+    }
     /**
-     * Clear all queued messages and return them.
-     * Useful for restoring to editor when user aborts.
-     * @returns Object with steering and followUp arrays
+     * Clear all queued messages and return them. The non-enumerable `ordered`
+     * view preserves legacy object equality and native queue semantics.
+     * @param options.abortWillFollow Mark a non-empty drain so an immediately following abort can emit session_abort.
      */
-    clearQueue() {
+    clearQueue(options = { abortWillFollow: false }) {
         const steering = [...this._steeringMessages];
         const followUp = [...this._followUpMessages];
-        if (steering.length > 0 || followUp.length > 0)
+        const ordered = [...this._queuedInputOrder].sort((a, b) => a.enqueueOrder - b.enqueueOrder);
+        if (options.abortWillFollow && (steering.length > 0 || followUp.length > 0)) {
             this._hadClearedQueuedMessages = true;
+        }
         // Clear every queue synchronously. Deferred post-compaction messages are
         // already represented in visible bookkeeping, so they must not be returned
         // a second time or later resurrected into Agent's native queues.
         this._steeringMessages = [];
         this._followUpMessages = [];
+        this._queuedInputOrder = [];
         this._postCompactionDeferredSteeringMessages = [];
         this._postCompactionDeferredFollowUpMessages = [];
         this.agent.clearAllQueues();
         this._emitQueueUpdate();
-        return { steering, followUp };
+        const cleared = { steering, followUp };
+        Object.defineProperty(cleared, "ordered", { value: ordered, enumerable: false });
+        return cleared;
     }
     /** Number of pending messages (includes both steering and follow-up) */
     get pendingMessageCount() {
@@ -2448,6 +2618,7 @@ export class AgentSession {
         // A manual model change abandons any active fallback window; if a fallback
         // retry sleep is still pending, cancel it so no surprise continuation fires.
         const hadActiveFallback = this._retryFallback.activeState !== undefined;
+        this._probeBackScheduler.cancel("manual-model-change");
         this._retryFallback.clearForManualModelChange(model);
         if (hadActiveFallback && this._retryAbortController) {
             this.abortRetry();
@@ -2487,9 +2658,6 @@ export class AgentSession {
         if (opts.ephemeralThinkingLevel !== undefined) {
             this._applyEphemeralThinkingLevel(thinkingLevel);
         }
-        else if (opts.persistDefault) {
-            this.setThinkingLevel(thinkingLevel);
-        }
         else {
             this.setSessionThinkingLevel(thinkingLevel);
         }
@@ -2536,6 +2704,7 @@ export class AgentSession {
         if (invalidatesCompaction) {
             this._invalidateCompactionForModelSelection();
         }
+        this._probeBackScheduler.cancel("manual-model-change");
         this._retryFallback.clearForManualModelChange(next.model);
         const thinkingLevel = this._getThinkingLevelForModelSwitch(next.thinkingLevel);
         this.agent.state.model = next.model;
@@ -2543,10 +2712,10 @@ export class AgentSession {
         this.settingsManager.setDefaultModelAndProvider(next.model.provider, next.model.id);
         this._currentServiceTier = this._resolveServiceTier(next.model, next.serviceTier);
         // Apply thinking level.
-        // - Explicit favorite model thinking level overrides current session level
-        // - Undefined favorite model thinking level inherits the current session preference
-        // setThinkingLevel clamps to model capabilities.
-        this.setThinkingLevel(thinkingLevel);
+        // - Explicit favorite model thinking level overrides the effective session level
+        // - Undefined favorite model thinking level restores the remembered user preference
+        // setSessionThinkingLevel clamps without replacing that preference.
+        this.setSessionThinkingLevel(thinkingLevel);
         const systemPromptChange = await this._emitModelSelect(next.model, currentModel, "cycle");
         const cycleResult = { model: next.model, thinkingLevel: this.thinkingLevel, isScoped: true };
         if (systemPromptChange) {
@@ -2599,15 +2768,12 @@ export class AgentSession {
     _emitHighReasoningWarningIfNeeded() {
         const model = this.model;
         const level = this.thinkingLevel;
-        if (!model || !shouldWarnHighReasoning(model, level)) {
-            this._lastHighReasoningWarningKey = undefined;
+        if (!model || !shouldWarnHighReasoning(model, level))
             return;
-        }
-        const key = `${model.provider}/${model.id}:${level}`;
-        if (this._lastHighReasoningWarningKey === key) {
+        const key = `${model.provider}/${model.id}`;
+        if (this._shownHighReasoningWarningKeys.has(key))
             return;
-        }
-        this._lastHighReasoningWarningKey = key;
+        this._shownHighReasoningWarningKeys.add(key);
         this._emit({
             type: "high_reasoning_warning",
             modelId: model.id,
@@ -2660,10 +2826,7 @@ export class AgentSession {
         if (explicitLevel !== undefined) {
             return explicitLevel;
         }
-        if (!this.supportsThinking()) {
-            return this.settingsManager.getDefaultThinkingLevel() ?? DEFAULT_THINKING_LEVEL;
-        }
-        return this.thinkingLevel;
+        return this.settingsManager.getDefaultThinkingLevel() ?? this.thinkingLevel ?? DEFAULT_THINKING_LEVEL;
     }
     _clampThinkingLevel(level, availableLevels) {
         const available = new Set(availableLevels);
@@ -2853,6 +3016,8 @@ export class AgentSession {
             this._releasePendingCompactionAdmission(admission, outcome);
             if (disconnected && !this.isCompacting)
                 this._reconnectToAgent();
+            if (outcome === "completed")
+                this._resumeQueuedMessagesAfterCompaction();
         }
     }
     async applyCompaction(precomputed, options) {
@@ -2882,6 +3047,7 @@ export class AgentSession {
             if (!execution.accepted) {
                 return { applied: false, reason: "rejected" };
             }
+            this._resumeQueuedMessagesAfterCompaction();
             return { applied: true, reason: "ok" };
         }
         catch (error) {
@@ -3287,6 +3453,8 @@ export class AgentSession {
             if (compacted)
                 return true;
         }
+        if (this._isCompactionOnCooldown())
+            return false;
         throw new RequiredCompactionError();
     }
     /**
@@ -3325,6 +3493,8 @@ export class AgentSession {
             throw new RequiredCompactionError();
         }
         const compacted = await this._runPrePromptCompaction(lastAssistantMessage, false, "pre_prompt");
+        if (!compacted && !isOversized() && this._isCompactionOnCooldown())
+            return;
         if (!compacted || isOversized()) {
             throw new RequiredCompactionError();
         }
@@ -3470,6 +3640,10 @@ export class AgentSession {
         }
         return false;
     }
+    _isCompactionOnCooldown() {
+        const state = this._compactionLifecycle.state;
+        return state.status === "failed" && state.rejectionCause === "circuit-breaker";
+    }
     async _runPrePromptCompaction(lastAssistantMessage, skipAbortedCheck, reason = "pre_prompt", willRetry = false, allowSummaryOnly = false) {
         const controller = new AbortController();
         this._claimCompactionController(controller, "compaction");
@@ -3530,8 +3704,11 @@ export class AgentSession {
         if (!shouldCompact(contextTokens, model.contextWindow, settings))
             return;
         const compacted = await this._runPrePromptCompaction(this._findLastAssistantMessage(), true, "pre_prompt");
-        if (!compacted)
+        if (!compacted) {
+            if (this._isCompactionOnCooldown())
+                return;
             throw new RequiredCompactionError();
+        }
         this._scheduledContinuationRecompacted = true;
     }
     async _continueAgentAfterCurrentRun(options = {}) {
@@ -3570,6 +3747,18 @@ export class AgentSession {
             this._scheduledContinuationRecompacted = false;
         }
     }
+    /**
+     * Mirror _runAutoCompaction's post-success recovery for non-auto compaction
+     * owners (manual, extension action, extension apply): a custom triggerTurn
+     * message sent while the compaction was running is parked in the agent-level
+     * queues without starting a turn, so a settled compaction must deliver it or
+     * hidden continuations (e.g. goal) wedge until manual user input.
+     */
+    _resumeQueuedMessagesAfterCompaction() {
+        if (this.pendingMessageCount > 0 || this.agent.hasQueuedMessages()) {
+            this._scheduleContinuationAfterCurrentEvent();
+        }
+    }
     _scheduleContinuationAfterCurrentEvent(options = {}, retryContinuation = false) {
         // Tool hooks wait for queued message persistence, so continue() cannot run inside this event promise.
         const currentEventQueue = this._agentEventQueue;
@@ -3909,10 +4098,13 @@ export class AgentSession {
                 return true;
             },
             setSessionThinkingLevel: (level) => this.setSessionThinkingLevel(level),
+            setSessionFastMode: (enabled) => this.setSessionFastMode(enabled),
         }, {
             getModel: () => this.model,
             getServiceTier: () => this.serviceTier,
+            getScopedModels: () => this._scopedModels,
             isIdle: () => this.isIdle,
+            getAgentDir: () => this._agentDir,
             isProjectTrusted: () => this.settingsManager.isProjectTrusted(),
             getSignal: () => this._extensionEventSignal ?? this.agent.signal,
             abort: () => {
@@ -3979,6 +4171,7 @@ export class AgentSession {
                 const controller = admission.controller;
                 void (async () => {
                     let outcome = "failed";
+                    let compactionCompleted = false;
                     let disconnected = false;
                     try {
                         await this._abortActiveAgentAndRetry("system");
@@ -3994,6 +4187,7 @@ export class AgentSession {
                         });
                         if (execution.accepted) {
                             outcome = "completed";
+                            compactionCompleted = true;
                             options?.onComplete?.(execution.result);
                         }
                         else {
@@ -4027,6 +4221,10 @@ export class AgentSession {
                         this._releasePendingCompactionAdmission(admission, outcome);
                         if (disconnected && !this.isCompacting)
                             this._reconnectToAgent();
+                        // A throwing onComplete consumer overwrites outcome in the catch
+                        // block, so recovery keys off whether compaction itself succeeded.
+                        if (compactionCompleted)
+                            this._resumeQueuedMessagesAfterCompaction();
                     }
                 })();
             },
@@ -4288,32 +4486,11 @@ export class AgentSession {
             this._retryFallback.canTryFallback());
     }
     _getProviderRetryDelayMs(errorMessage) {
-        const retryAfterMsMatch = errorMessage.match(/\bretry[-_ ]?after[-_ ]?ms\s*[:=]\s*(\d+(?:\.\d+)?)/i);
-        if (retryAfterMsMatch) {
-            const delayMs = Math.ceil(Number(retryAfterMsMatch[1]));
-            return Number.isFinite(delayMs) && delayMs > 0 ? delayMs : undefined;
-        }
-        const retryAfterSecondsMatch = errorMessage.match(/\bretry[-_ ]?after\s*[:=]\s*(\d+(?:\.\d+)?)/i);
-        if (retryAfterSecondsMatch) {
-            const delayMs = Math.ceil(Number(retryAfterSecondsMatch[1]) * 1000);
-            return Number.isFinite(delayMs) && delayMs > 0 ? delayMs : undefined;
-        }
-        const retryInMatch = errorMessage.match(/\b(?:retry|try again|wait)\s+(?:after|in)\s*(\d+(?:\.\d+)?)\s*(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m)\b/i);
-        if (!retryInMatch) {
-            return undefined;
-        }
-        const value = Number(retryInMatch[1]);
-        if (!Number.isFinite(value) || value <= 0) {
-            return undefined;
-        }
-        const unit = retryInMatch[2].toLowerCase();
-        if (unit === "m" || unit.startsWith("min")) {
-            return Math.ceil(value * 60_000);
-        }
-        if (unit.startsWith("s")) {
-            return Math.ceil(value * 1000);
-        }
-        return Math.ceil(value);
+        const markerMs = parseRetryAfterMsMarker(errorMessage);
+        if (markerMs !== undefined)
+            return markerMs;
+        const hintMs = extract429RetryAfterMs({ bodyText: errorMessage });
+        return hintMs;
     }
     _getProviderTimeoutRetryOptions(message) {
         if (!isProviderTimeoutError(message))
@@ -4381,6 +4558,8 @@ export class AgentSession {
         const isRefusal = isClassifierRefusal(message);
         const hardErrorFallback = options.hardErrorFallback === true;
         let switchedFallback = false;
+        let is429TierRouted = false;
+        let hintTierDelayMs;
         if (hardErrorFallback) {
             // A non-retryable provider failure must never replay on the same model.
             // Billing-class failures never recover on this account, so the fallback
@@ -4398,6 +4577,16 @@ export class AgentSession {
             // Refusals are only retried through a new chain candidate. They never use
             // same-model retries or the transient over-budget fallback escape hatch.
             if (this._retryAttempt + 1 > settings.maxRetries) {
+                if (this._retryAttempt > 0) {
+                    this._emit({
+                        type: "auto_retry_end",
+                        success: false,
+                        attempt: this._retryAttempt,
+                        finalError: message.errorMessage,
+                    });
+                }
+                this._retryAttempt = 0;
+                this._resetHintTierState();
                 this._resolveRetry();
                 return "not-handled";
             }
@@ -4407,6 +4596,16 @@ export class AgentSession {
                 if (exhaustedChainKey) {
                     this._emit({ type: "retry_fallback_exhausted", chainKey: exhaustedChainKey, lastError: errorMessage });
                 }
+                if (this._retryAttempt > 0) {
+                    this._emit({
+                        type: "auto_retry_end",
+                        success: false,
+                        attempt: this._retryAttempt,
+                        finalError: message.errorMessage,
+                    });
+                }
+                this._retryAttempt = 0;
+                this._resetHintTierState();
                 this._resolveRetry();
                 return "not-handled";
             }
@@ -4426,8 +4625,159 @@ export class AgentSession {
             const stallError = isProviderStreamStallError(message);
             const escalateAfterRepeatedStall = stallError && this._consecutiveProviderStreamStalls > 0;
             this._consecutiveProviderStreamStalls = stallError ? this._consecutiveProviderStreamStalls + 1 : 0;
-            this._retryAttempt++;
-            if (this._retryAttempt > settings.maxRetries || escalateAfterRepeatedStall) {
+            // 429-class detection: retryable AND message carries rate-limit markers.
+            const is429Class = !stallError &&
+                /rate.?limit|(?:^429(?=\s+\{)|(?:\bHTTP\/1\.[01]\s+|\bHTTP\s+|\bstatus(?:\s+code)?\s+|\berror\s+|\bcode\s+)429\b)|too many requests|resource.?exhausted/i.test(errorMessage);
+            if (is429Class) {
+                const hintMs = this._getProviderRetryDelayMs(errorMessage);
+                const hintSettings = this.settingsManager.getHintPolicySettings();
+                const tier = classifyRateLimitedWait(hintMs, hintSettings);
+                is429TierRouted = true;
+                if (tier === "no-hint-fast-fallback") {
+                    // Skip same-model retries entirely; fall back immediately.
+                    switchedFallback = await this._retryFallback.tryFallback("transient", { errorMessage });
+                    if (switchedFallback) {
+                        this._retryAttempt = 1;
+                    }
+                    else {
+                        const exhaustedChainKey = this._retryFallback.exhaustedChainKey;
+                        if (exhaustedChainKey) {
+                            this._emit({
+                                type: "retry_fallback_exhausted",
+                                chainKey: exhaustedChainKey,
+                                lastError: errorMessage,
+                            });
+                        }
+                        this._emit({
+                            type: "auto_retry_end",
+                            success: false,
+                            attempt: 0,
+                            finalError: message.errorMessage,
+                        });
+                        this._retryAttempt = 0;
+                        this._resetHintTierState();
+                        this._resolveRetry();
+                        return "not-handled";
+                    }
+                }
+                else if (tier === "tier1-in-turn") {
+                    this._retryAttempt++;
+                    if (this._retryAttempt > settings.maxRetries) {
+                        // Budget exhausted within tier1; fall back.
+                        switchedFallback = await this._retryFallback.tryFallback("transient", {
+                            errorMessage,
+                            retryAfterMs: this._getProviderRetryDelayMs(errorMessage),
+                        });
+                        if (switchedFallback) {
+                            this._retryAttempt = 1;
+                        }
+                        else {
+                            const exhaustedChainKey = this._retryFallback.exhaustedChainKey;
+                            if (exhaustedChainKey) {
+                                this._emit({
+                                    type: "retry_fallback_exhausted",
+                                    chainKey: exhaustedChainKey,
+                                    lastError: errorMessage,
+                                });
+                            }
+                            this._emit({
+                                type: "auto_retry_end",
+                                success: false,
+                                attempt: this._retryAttempt - 1,
+                                finalError: message.errorMessage,
+                            });
+                            this._retryAttempt = 0;
+                            this._resetHintTierState();
+                            this._resolveRetry();
+                            return "not-handled";
+                        }
+                    }
+                    else {
+                        const inTurnResult = nextInTurnDelayMs({
+                            probePhase: this._probePhase,
+                            hintDeadlineMs: this._hintDeadlineMs,
+                            attempt: this._retryAttempt,
+                            cumulativeHintedWaitMs: this._cumulativeHintedWaitMs,
+                        }, hintMs, settings.baseDelayMs, hintSettings.hintedWaitCapMs, Date.now());
+                        this._probePhase = inTurnResult.probePhase;
+                        this._hintDeadlineMs = inTurnResult.hintDeadlineMs;
+                        this._cumulativeHintedWaitMs = inTurnResult.cumulativeHintedWaitMs;
+                        if (inTurnResult.demoteToProbeBack) {
+                            // Cumulative hinted wait exceeded cap; demote to tier2 fallback path.
+                            const remainingHintMs = Math.max(0, (this._hintDeadlineMs ?? Date.now()) - Date.now());
+                            switchedFallback = await this._retryFallback.tryFallback("transient", {
+                                errorMessage,
+                                retryAfterMs: remainingHintMs,
+                            });
+                            if (switchedFallback) {
+                                this._retryAttempt = 1;
+                            }
+                            else {
+                                const exhaustedChainKey = this._retryFallback.exhaustedChainKey;
+                                if (exhaustedChainKey) {
+                                    this._emit({
+                                        type: "retry_fallback_exhausted",
+                                        chainKey: exhaustedChainKey,
+                                        lastError: errorMessage,
+                                    });
+                                }
+                                this._emit({
+                                    type: "auto_retry_end",
+                                    success: false,
+                                    attempt: this._retryAttempt - 1,
+                                    finalError: message.errorMessage,
+                                });
+                                this._retryAttempt = 0;
+                                this._resetHintTierState();
+                                this._resolveRetry();
+                                return "not-handled";
+                            }
+                        }
+                        else {
+                            hintTierDelayMs = inTurnResult.delayMs;
+                        }
+                    }
+                }
+                else {
+                    // tier2-fallback-probe-back or tier3-fallback-only: immediate fallback.
+                    const remainingHintMs = hintMs ?? 0;
+                    switchedFallback = await this._retryFallback.tryFallback("transient", {
+                        errorMessage,
+                        retryAfterMs: remainingHintMs,
+                    });
+                    if (switchedFallback) {
+                        this._retryAttempt = 1;
+                        if (tier === "tier2-fallback-probe-back") {
+                            const selector = this._retryFallback.activeState?.originalSelector ?? "";
+                            this._armProbeBackForDemotedSelector(selector, remainingHintMs);
+                        }
+                    }
+                    else {
+                        const exhaustedChainKey = this._retryFallback.exhaustedChainKey;
+                        if (exhaustedChainKey) {
+                            this._emit({
+                                type: "retry_fallback_exhausted",
+                                chainKey: exhaustedChainKey,
+                                lastError: errorMessage,
+                            });
+                        }
+                        this._emit({
+                            type: "auto_retry_end",
+                            success: false,
+                            attempt: 0,
+                            finalError: message.errorMessage,
+                        });
+                        this._retryAttempt = 0;
+                        this._resetHintTierState();
+                        this._resolveRetry();
+                        return "not-handled";
+                    }
+                }
+            }
+            if (!is429TierRouted) {
+                this._retryAttempt++;
+            }
+            if (!is429TierRouted && (this._retryAttempt > settings.maxRetries || escalateAfterRepeatedStall)) {
                 switchedFallback = await this._retryFallback.tryFallback("transient", {
                     errorMessage,
                     retryAfterMs: this._getProviderRetryDelayMs(errorMessage),
@@ -4452,6 +4802,7 @@ export class AgentSession {
                         finalError: message.errorMessage,
                     });
                     this._retryAttempt = 0;
+                    this._resetHintTierState();
                     this._resolveRetry();
                     return "not-handled";
                 }
@@ -4462,7 +4813,8 @@ export class AgentSession {
         }
         const providerDelayMs = isRefusal || hardErrorFallback ? undefined : this._getProviderRetryDelayMs(errorMessage);
         const maxRetryDelayMs = this.settingsManager.getProviderRetrySettings().maxRetryDelayMs;
-        if (providerDelayMs !== undefined && providerDelayMs > maxRetryDelayMs) {
+        // For 429-class failures the tier routing replaces the over-budget gate.
+        if (!is429TierRouted && providerDelayMs !== undefined && providerDelayMs > maxRetryDelayMs) {
             // A wait this long means the model is unavailable rather than busy, so the
             // configured chain beats failing the turn. The switch is gated: the over-budget
             // branch above may have already switched on this same error, and hopping again
@@ -4484,6 +4836,7 @@ export class AgentSession {
                     finalError: `Provider requested retry delay ${providerDelayMs}ms, exceeding configured maximum ${maxRetryDelayMs}ms`,
                 });
                 this._retryAttempt = 0;
+                this._resetHintTierState();
                 this._resolveRetry();
                 return "not-handled";
             }
@@ -4493,7 +4846,12 @@ export class AgentSession {
         // reach this point with a fallback already applied (hard-error, refusal) set
         // switchedFallback first and force providerDelayMs undefined, so no branch may
         // be reordered to fall through here expecting an implicit switch.
-        const delayMs = switchedFallback ? 0 : (providerDelayMs ?? settings.baseDelayMs * 2 ** (this._retryAttempt - 1));
+        const nonTierProviderDelayMs = providerDelayMs === 0 ? undefined : providerDelayMs;
+        const delayMs = switchedFallback
+            ? 0
+            : is429TierRouted
+                ? (hintTierDelayMs ?? providerDelayMs ?? settings.baseDelayMs * 2 ** (this._retryAttempt - 1))
+                : (nonTierProviderDelayMs ?? settings.baseDelayMs * 2 ** (this._retryAttempt - 1));
         // Prepare before auto_retry_start so an immediate Esc can cancel the retry sleep.
         this._retryAbortController = new AbortController();
         this._emit({
@@ -4517,6 +4875,7 @@ export class AgentSession {
             // Aborted during sleep - emit end event so UI can clean up
             const attempt = this._retryAttempt;
             this._retryAttempt = 0;
+            this._resetHintTierState();
             this._retryAbortController = undefined;
             await this._emitAgentSettled();
             this._emit({
@@ -4541,9 +4900,11 @@ export class AgentSession {
         if (compactionSettings.enabled &&
             model &&
             shouldCompact(contextTokens, model.contextWindow, compactionSettings)) {
-            if (!(await this._runPrePromptCompaction(message, true, "threshold", true, true))) {
+            const preRetryCompaction = await this._runPrePromptCompaction(message, true, "threshold", true, true);
+            if (!preRetryCompaction && !this._isCompactionOnCooldown()) {
                 const attempt = this._retryAttempt;
                 this._retryAttempt = 0;
+                this._resetHintTierState();
                 this._emit({
                     type: "auto_retry_end",
                     success: false,
@@ -4612,7 +4973,8 @@ export class AgentSession {
      * @param options.operations Custom BashOperations for remote execution
      */
     async executeBash(command, onChunk, options) {
-        this._bashAbortController = new AbortController();
+        const abortController = new AbortController();
+        this._bashAbortControllers.add(abortController);
         // Apply command prefix if configured (e.g., "shopt -s expand_aliases" for alias support)
         const prefix = this.settingsManager.getShellCommandPrefix();
         const shellPath = this.settingsManager.getShellPath();
@@ -4623,13 +4985,13 @@ export class AgentSession {
                     onChunk?.(delta);
                     this._emit({ type: "bash_execution_update", id: options?.id, delta });
                 },
-                signal: this._bashAbortController.signal,
+                signal: abortController.signal,
             });
             this.recordBashResult(command, result, options);
             return result;
         }
         finally {
-            this._bashAbortController = undefined;
+            this._bashAbortControllers.delete(abortController);
         }
     }
     /**
@@ -4665,11 +5027,13 @@ export class AgentSession {
      * Cancel running bash command.
      */
     abortBash() {
-        this._bashAbortController?.abort();
+        for (const abortController of [...this._bashAbortControllers]) {
+            abortController.abort();
+        }
     }
     /** Whether a bash command is currently running */
     get isBashRunning() {
-        return this._bashAbortController !== undefined;
+        return this._bashAbortControllers.size > 0;
     }
     /** Whether there are pending bash messages waiting to be flushed */
     get hasPendingBashMessages() {
@@ -4718,6 +5082,9 @@ export class AgentSession {
      * @returns Result with editorText (if user message) and cancelled status
      */
     async navigateTree(targetId, options = {}) {
+        if (this.isStreaming) {
+            throw new Error("Wait for the current response to finish before navigating the session tree.");
+        }
         const oldLeafId = this.sessionManager.getLeafId();
         // No-op if already at target
         if (targetId === oldLeafId) {