@code-yeongyu/senpi 2026.8.1 → 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";
@@ -233,6 +237,9 @@ 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;
@@ -242,7 +249,7 @@ export class AgentSession {
         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();
@@ -323,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, {
@@ -349,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;
@@ -619,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,
@@ -656,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);
     }
@@ -1018,6 +1039,7 @@ export class AgentSession {
                         attempt: this._retryAttempt,
                     });
                     this._retryAttempt = 0;
+                    this._resetHintTierState();
                 }
             }
         }
@@ -1107,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;
@@ -1318,6 +1411,7 @@ export class AgentSession {
      */
     dispose() {
         try {
+            this._probeBackScheduler.cancel("dispose");
             this.abortRetry();
             this.abortCompaction();
             this.abortBranchSummary();
@@ -2253,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 {
@@ -2509,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();
@@ -2594,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;
@@ -2905,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) {
@@ -2934,6 +3047,7 @@ export class AgentSession {
             if (!execution.accepted) {
                 return { applied: false, reason: "rejected" };
             }
+            this._resumeQueuedMessagesAfterCompaction();
             return { applied: true, reason: "ok" };
         }
         catch (error) {
@@ -3633,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;
@@ -3976,7 +4102,9 @@ export class AgentSession {
         }, {
             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: () => {
@@ -4043,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");
@@ -4058,6 +4187,7 @@ export class AgentSession {
                         });
                         if (execution.accepted) {
                             outcome = "completed";
+                            compactionCompleted = true;
                             options?.onComplete?.(execution.result);
                         }
                         else {
@@ -4091,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();
                     }
                 })();
             },
@@ -4352,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))
@@ -4445,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
@@ -4471,6 +4586,7 @@ export class AgentSession {
                     });
                 }
                 this._retryAttempt = 0;
+                this._resetHintTierState();
                 this._resolveRetry();
                 return "not-handled";
             }
@@ -4489,6 +4605,7 @@ export class AgentSession {
                     });
                 }
                 this._retryAttempt = 0;
+                this._resetHintTierState();
                 this._resolveRetry();
                 return "not-handled";
             }
@@ -4508,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),
@@ -4534,6 +4802,7 @@ export class AgentSession {
                         finalError: message.errorMessage,
                     });
                     this._retryAttempt = 0;
+                    this._resetHintTierState();
                     this._resolveRetry();
                     return "not-handled";
                 }
@@ -4544,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
@@ -4566,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";
             }
@@ -4575,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({
@@ -4599,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({
@@ -4627,6 +4904,7 @@ export class AgentSession {
             if (!preRetryCompaction && !this._isCompactionOnCooldown()) {
                 const attempt = this._retryAttempt;
                 this._retryAttempt = 0;
+                this._resetHintTierState();
                 this._emit({
                     type: "auto_retry_end",
                     success: false,
@@ -4695,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();
@@ -4706,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);
         }
     }
     /**
@@ -4748,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() {
@@ -4801,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) {