@code-yeongyu/senpi 2026.8.1 → 2026.8.3-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";
@@ -203,6 +207,7 @@ export class AgentSession {
         /** Recovery-only order across both native queue modes and TUI compaction ownership. */
         this._queuedInputOrder = [];
         this._nextQueuedInputOrder = 0;
+        this._supersededCompactionLogAttemptIds = new Set();
         /** 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
@@ -233,6 +238,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 +250,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();
@@ -306,7 +314,6 @@ export class AgentSession {
         this.agent = config.agent;
         this.sessionManager = config.sessionManager;
         this.settingsManager = config.settingsManager;
-        this.agent.abortServerSideFallback = this.settingsManager.getAbortServerSideFallback();
         const noModelFallback = config.resourceLoader.getExtensions().runtime.flagValues.get("no-model-fallback") === true ||
             process.env.SENPI_NO_FALLBACK === "1";
         if (noModelFallback) {
@@ -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,15 +632,77 @@ export class AgentSession {
     }
     /** Mirror stuck-prone lifecycle transitions into logs/session.log (content-free). */
     _logSessionEvent(event) {
+        if (event.type === "compaction_start") {
+            const previousAttempt = this._activeCompactionLogAttempt;
+            if (previousAttempt) {
+                const tokensAfter = this._estimateCompactionLogTokens("persisted");
+                this._sessionLogger.info("compaction_decision", {
+                    attemptId: previousAttempt.id,
+                    reason: previousAttempt.reason,
+                    mode: previousAttempt.reason === "manual" ? "manual" : "auto",
+                    action: "compact",
+                    disposition: "superseded",
+                    accepted: false,
+                    skipped: true,
+                    aborted: true,
+                    willRetry: false,
+                    tokensBefore: previousAttempt.tokensBefore,
+                    tokensAfter,
+                });
+                this._supersededCompactionLogAttemptIds.add(previousAttempt.id);
+            }
+            const attempt = {
+                id: event.requestId ?? randomUUID(),
+                reason: event.reason,
+                tokensBefore: this._estimateCompactionLogTokens("persisted"),
+            };
+            this._activeCompactionLogAttempt = attempt;
+            this._sessionLogger.info("compaction_start", {
+                attemptId: attempt.id,
+                reason: event.reason,
+                mode: event.reason === "manual" ? "manual" : "auto",
+                action: "compact",
+                tokensBefore: attempt.tokensBefore,
+            });
+            return;
+        }
         if (event.type === "compaction_end") {
+            if (event.requestId && this._supersededCompactionLogAttemptIds.delete(event.requestId))
+                return;
+            const activeAttempt = this._activeCompactionLogAttempt;
+            const attempt = event.requestId !== undefined && activeAttempt?.id === event.requestId ? activeAttempt : undefined;
+            const accepted = event.accepted ?? event.result !== undefined;
+            const rejected = event.rejectionCause !== undefined;
+            const skipped = !accepted && (attempt === undefined || (!rejected && !event.aborted && !event.errorMessage));
+            const disposition = accepted
+                ? "committed"
+                : attempt === undefined
+                    ? "skipped"
+                    : rejected
+                        ? "rejected"
+                        : event.aborted
+                            ? "aborted"
+                            : event.errorMessage
+                                ? "failed"
+                                : "skipped";
+            const tokensAfter = this._estimateCompactionLogTokens(accepted ? "active" : "persisted");
             this._sessionLogger.info("compaction_decision", {
+                attemptId: attempt?.id ?? event.requestId,
                 reason: event.reason,
-                accepted: event.accepted ?? event.result !== undefined,
+                mode: event.reason === "manual" ? "manual" : "auto",
+                action: accepted || attempt ? "compact" : "none",
+                disposition,
+                accepted,
+                skipped,
                 aborted: event.aborted,
                 willRetry: event.willRetry,
                 rejectionCause: event.rejectionCause,
                 error: event.errorMessage,
+                tokensBefore: attempt?.tokensBefore ?? tokensAfter,
+                tokensAfter,
             });
+            if (attempt)
+                this._activeCompactionLogAttempt = undefined;
             return;
         }
         if (event.type === "message_end" && event.message.role === "assistant") {
@@ -642,6 +717,15 @@ export class AgentSession {
             this._sessionLogger.warn("provider_error", { kind, error: message.errorMessage });
         }
     }
+    _estimateCompactionLogTokens(source) {
+        try {
+            const messages = source === "active" ? this.agent.state.messages : this.sessionManager.buildSessionContext().messages;
+            return estimateMessagesTokens(filterContextExcludedMessages(messages));
+        }
+        catch {
+            return undefined;
+        }
+    }
     _emitQueueUpdate() {
         this._emit({
             type: "queue_update",
@@ -656,6 +740,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);
     }
@@ -716,6 +804,8 @@ export class AgentSession {
     async _promptAgent(messages) {
         this._isAgentRunActive = true;
         this._requiredCompactionAdmissionError = undefined;
+        this.agent.abortServerSideFallback =
+            this.settingsManager.getAbortServerSideFallback() && this._retryFallback.hasConfiguredChain();
         try {
             await this.agent.prompt(messages);
             // AgentSession's subscriber intentionally queues event work instead of
@@ -1018,6 +1108,7 @@ export class AgentSession {
                         attempt: this._retryAttempt,
                     });
                     this._retryAttempt = 0;
+                    this._resetHintTierState();
                 }
             }
         }
@@ -1107,6 +1198,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 +1480,7 @@ export class AgentSession {
      */
     dispose() {
         try {
+            this._probeBackScheduler.cancel("dispose");
             this.abortRetry();
             this.abortCompaction();
             this.abortBranchSummary();
@@ -2253,8 +2416,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 +2687,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();
@@ -2537,6 +2716,8 @@ export class AgentSession {
         }
         const thinkingLevel = this._getThinkingLevelForModelSwitch(opts.ephemeralThinkingLevel);
         this.agent.state.model = model;
+        this.agent.abortServerSideFallback =
+            this.settingsManager.getAbortServerSideFallback() && this._retryFallback.hasConfiguredChain();
         if (opts.appendSessionEntry) {
             this.sessionManager.appendModelChange(model.provider, model.id, opts.entryReason, previousModel?.provider, previousModel?.id);
         }
@@ -2594,6 +2775,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;
@@ -2855,6 +3037,7 @@ export class AgentSession {
     async compact(customInstructions) {
         const admission = this._claimPendingCompactionAdmission();
         const controller = admission.controller;
+        const requestId = randomUUID();
         let outcome = "failed";
         let disconnected = false;
         try {
@@ -2864,11 +3047,12 @@ export class AgentSession {
             await this._abortActiveAgentAndRetry("system");
             this._disconnectFromAgent();
             disconnected = true;
-            this._emit({ type: "compaction_start", reason: "manual" });
+            this._emit({ type: "compaction_start", reason: "manual", requestId });
             const execution = await this._executeCompaction({
                 controller,
                 owner: "compaction",
                 reason: "manual",
+                requestId,
                 customInstructions,
                 willRetry: false,
             });
@@ -2894,6 +3078,7 @@ export class AgentSession {
                 result: undefined,
                 aborted,
                 willRetry: false,
+                requestId,
                 errorMessage: aborted ? undefined : `Compaction failed: ${message}`,
             });
             throw error;
@@ -2905,6 +3090,8 @@ export class AgentSession {
             this._releasePendingCompactionAdmission(admission, outcome);
             if (disconnected && !this.isCompacting)
                 this._reconnectToAgent();
+            if (outcome === "completed")
+                this._resumeQueuedMessagesAfterCompaction();
         }
     }
     async applyCompaction(precomputed, options) {
@@ -2915,9 +3102,13 @@ export class AgentSession {
             return { applied: false, reason: "stale" };
         }
         const ownsController = this._compactionAbortController === undefined;
+        const lifecycleState = this._compactionLifecycle.state;
+        const requestId = !ownsController && lifecycleState.status === "running" && lifecycleState.stage === "feedback"
+            ? lifecycleState.operationId
+            : randomUUID();
         if (ownsController) {
             this._claimCompactionController(new AbortController(), "compaction");
-            this._emit({ type: "compaction_start", reason: options.reason });
+            this._emit({ type: "compaction_start", reason: options.reason, requestId });
         }
         const controller = this._compactionAbortController;
         if (!controller)
@@ -2928,12 +3119,14 @@ export class AgentSession {
                 controller,
                 owner: "compaction",
                 reason: options.reason,
+                requestId,
                 willRetry: false,
                 precomputed,
             });
             if (!execution.accepted) {
                 return { applied: false, reason: "rejected" };
             }
+            this._resumeQueuedMessagesAfterCompaction();
             return { applied: true, reason: "ok" };
         }
         catch (error) {
@@ -2948,6 +3141,7 @@ export class AgentSession {
                 result: undefined,
                 aborted,
                 willRetry: false,
+                requestId,
                 errorMessage: aborted ? undefined : `Compaction failed: ${message}`,
             });
             return { applied: false, reason: "rejected" };
@@ -2962,14 +3156,15 @@ export class AgentSession {
         const controller = new AbortController();
         this._claimCompactionController(controller, "compaction");
         const model = this.model;
+        const requestId = randomUUID();
         this._compactionLifecycle.begin({
-            operationId: randomUUID(),
+            operationId: requestId,
             stage: "feedback",
             reason,
             model: model ? { provider: model.provider, id: model.id } : undefined,
             startedRevision: this._messageRevision,
         }, controller);
-        this._emit({ type: "compaction_start", reason });
+        this._emit({ type: "compaction_start", reason, requestId });
         return controller.signal;
     }
     _updateExtensionCompactionFeedback(options) {
@@ -3007,7 +3202,8 @@ export class AgentSession {
             result: undefined,
             aborted,
             willRetry: false,
-            errorMessage: aborted ? undefined : options.errorMessage,
+            requestId: operation.operationId,
+            errorMessage: aborted ? undefined : (options.errorMessage ?? "Compaction did not apply"),
         });
         this._releaseCompactionController(options.signal);
     }
@@ -3022,7 +3218,7 @@ export class AgentSession {
         if (!this._ownsCompactionController(controller, request.owner)) {
             throw new CompactionExecutionError(new CompactionCancelledError(), false, true);
         }
-        const requestId = randomUUID();
+        const requestId = request.requestId ?? randomUUID();
         const operationId = this._compactionLifecycle.begin({
             operationId: requestId,
             stage: "execution",
@@ -3277,6 +3473,10 @@ export class AgentSession {
      * Cancel in-progress compaction (manual or auto).
      */
     abortCompaction() {
+        const lifecycleState = this._compactionLifecycle.state;
+        const activeFeedbackRequestId = lifecycleState.status === "running" && lifecycleState.stage === "feedback"
+            ? lifecycleState.operationId
+            : undefined;
         const feedbackOperation = this._compactionLifecycle.abort(this._messageRevision);
         this._compactionAbortController?.abort();
         this._autoCompactionAbortController?.abort();
@@ -3288,6 +3488,7 @@ export class AgentSession {
                 result: undefined,
                 aborted: true,
                 willRetry: false,
+                requestId: activeFeedbackRequestId,
             });
         }
     }
@@ -3532,13 +3733,15 @@ export class AgentSession {
     }
     async _runPrePromptCompaction(lastAssistantMessage, skipAbortedCheck, reason = "pre_prompt", willRetry = false, allowSummaryOnly = false) {
         const controller = new AbortController();
+        const requestId = randomUUID();
         this._claimCompactionController(controller, "compaction");
-        this._emit({ type: "compaction_start", reason });
+        this._emit({ type: "compaction_start", reason, requestId });
         try {
             const execution = await this._executeCompaction({
                 controller,
                 owner: "compaction",
                 reason,
+                requestId,
                 willRetry,
                 lastAssistantMessage,
                 skipAbortedCheck,
@@ -3566,6 +3769,7 @@ export class AgentSession {
                 result: undefined,
                 aborted,
                 willRetry: false,
+                requestId,
                 errorMessage: aborted ? undefined : `Pre-prompt compaction failed: ${errorMessage}`,
             });
             return false;
@@ -3633,6 +3837,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;
@@ -3666,9 +3882,10 @@ export class AgentSession {
         const finishCompactionWork = this._sessionWorkBarrier.begin();
         const agentMessagesAtStart = this.agent.state.messages.slice();
         const autoCompactionController = new AbortController();
+        const requestId = randomUUID();
         this._claimCompactionController(autoCompactionController, "auto");
         const endBeforeExecution = () => {
-            this._emit({ type: "compaction_start", reason });
+            this._emit({ type: "compaction_start", reason, requestId });
             if (reason === "overflow" && this._autoCompactionAbortController === autoCompactionController) {
                 this._overflowRecoveryAttempted = false;
             }
@@ -3685,6 +3902,7 @@ export class AgentSession {
                 result: undefined,
                 aborted: autoCompactionController.signal.aborted,
                 willRetry: false,
+                requestId,
             });
             return false;
         };
@@ -3712,11 +3930,12 @@ export class AgentSession {
             }
             if (!this._ownsCompactionController(autoCompactionController, "auto"))
                 return false;
-            this._emit({ type: "compaction_start", reason });
+            this._emit({ type: "compaction_start", reason, requestId });
             const execution = await this._executeCompaction({
                 controller: autoCompactionController,
                 owner: "auto",
                 reason,
+                requestId,
                 willRetry,
                 agentMessagesAtStart,
             });
@@ -3762,6 +3981,7 @@ export class AgentSession {
                 result: undefined,
                 aborted,
                 willRetry: false,
+                requestId,
                 errorMessage: aborted
                     ? undefined
                     : reason === "overflow"
@@ -3976,7 +4196,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: () => {
@@ -4041,23 +4263,27 @@ export class AgentSession {
             compact: (options) => {
                 const admission = this._claimPendingCompactionAdmission();
                 const controller = admission.controller;
+                const requestId = randomUUID();
                 void (async () => {
                     let outcome = "failed";
+                    let compactionCompleted = false;
                     let disconnected = false;
                     try {
                         await this._abortActiveAgentAndRetry("system");
                         this._disconnectFromAgent();
                         disconnected = true;
-                        this._emit({ type: "compaction_start", reason: "extension" });
+                        this._emit({ type: "compaction_start", reason: "extension", requestId });
                         const execution = await this._executeCompaction({
                             controller,
                             owner: "compaction",
                             reason: "extension",
+                            requestId,
                             customInstructions: options?.customInstructions,
                             willRetry: false,
                         });
                         if (execution.accepted) {
                             outcome = "completed";
+                            compactionCompleted = true;
                             options?.onComplete?.(execution.result);
                         }
                         else {
@@ -4078,6 +4304,7 @@ export class AgentSession {
                             result: undefined,
                             aborted,
                             willRetry: false,
+                            requestId,
                             errorMessage: aborted ? undefined : `Compaction failed: ${message}`,
                         });
                         const err = error instanceof Error ? error : new Error(String(error));
@@ -4091,6 +4318,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 +4583,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 +4655,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 +4683,7 @@ export class AgentSession {
                     });
                 }
                 this._retryAttempt = 0;
+                this._resetHintTierState();
                 this._resolveRetry();
                 return "not-handled";
             }
@@ -4489,6 +4702,7 @@ export class AgentSession {
                     });
                 }
                 this._retryAttempt = 0;
+                this._resetHintTierState();
                 this._resolveRetry();
                 return "not-handled";
             }
@@ -4508,8 +4722,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 +4899,7 @@ export class AgentSession {
                         finalError: message.errorMessage,
                     });
                     this._retryAttempt = 0;
+                    this._resetHintTierState();
                     this._resolveRetry();
                     return "not-handled";
                 }
@@ -4544,7 +4910,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 +4933,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 +4943,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 +4972,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 +5001,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 +5070,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 +5082,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 +5124,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 +5179,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) {