@code-yeongyu/senpi 2026.7.23 → 2026.7.25-2

package/dist/core/agent-session.js

@@ -16,6 +16,7 @@ import { randomUUID } from "node:crypto";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 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, isRetryableAssistantError, modelsAreEqual, resetApiProviders, streamSimple, } from "@earendil-works/pi-ai/compat";
 import { getAgentDir } from "../config.js";
 import { getThemeByName, theme } from "../modes/interactive/theme/theme.js";
@@ -25,6 +26,7 @@ import { sleep } from "../utils/sleep.js";
 import { formatNoApiKeyFoundMessage, formatNoModelSelectedMessage } from "./auth-guidance.js";
 import { executeBashWithOperations } from "./bash-executor.js";
 import { calculateContextTokens, collectEntriesForBranchSummary, compact, estimateContextTokens, estimateTokens, generateBranchSummary, prepareCompaction, shouldCompact, } from "./compaction/index.js";
+import { CompactionLifecycleCoordinator } from "./compaction/lifecycle.js";
 import { DEFAULT_THINKING_LEVEL } from "./defaults.js";
 import { buildDynamicSystemPrompt } from "./dynamic-prompt/index.js";
 import { exportSessionToHtml } from "./export-html/index.js";
@@ -47,6 +49,7 @@ import { getSupportedThinkingLevels, supportsMax, supportsXhigh } from "./thinki
 import { createLocalBashOperations } from "./tools/bash.js";
 import { createAllToolDefinitions } from "./tools/index.js";
 import { createToolDefinitionFromAgentTool } from "./tools/tool-definition-wrapper.js";
+import { addUsageToTotals, createUsageTotals } from "./usage-totals.js";
 /**
  * Parse a skill block from message text.
  * Returns null if the text doesn't contain a skill block.
@@ -70,6 +73,15 @@ function withoutDeletedHeaders(headers) {
         ? Object.fromEntries(Object.entries(headers).filter((entry) => entry[1] !== null))
         : undefined;
 }
+function isCompactionOwnedPreCompactDiagnostic(message, requestId) {
+    if (message.role !== "custom" || message.customType !== "senpi.hook")
+        return false;
+    const details = message.details;
+    if (!details || typeof details !== "object")
+        return false;
+    const diagnostic = details;
+    return diagnostic.event === "PreCompact" && diagnostic.compactionRequestId === requestId;
+}
 /**
  * Human-readable rejection message paired with a `CompactionRejectionCause`.
  *
@@ -86,6 +98,8 @@ function describeCompactionRejection(cause) {
             return "Compaction rejected: the compaction circuit breaker is open after repeated failures. Wait for the cooldown and retry.";
         case "per-turn-cap":
             return "Compaction rejected: per-turn compaction cap reached for this turn.";
+        case "stale-revision":
+            return "Compaction rejected: the session changed while the summary was being prepared. Retry compaction against the latest context.";
     }
 }
 class CompactionRejectedError extends Error {
@@ -97,6 +111,33 @@ class CompactionRejectedError extends Error {
         this.rejectionCause = rejectionCause;
     }
 }
+class CompactionCancelledError extends Error {
+    constructor() {
+        super("Compaction cancelled");
+        this.name = "CompactionCancelledError";
+    }
+}
+/**
+ * An execution failure annotated with whether this operation still owns its
+ * terminal transition. Callers must not publish a terminal event for an
+ * operation that a newer compaction generation has superseded.
+ */
+class CompactionExecutionError extends Error {
+    constructor(error, ownsTerminalTransition, aborted) {
+        super(error instanceof Error ? error.message : String(error));
+        this.name = "CompactionExecutionError";
+        this.ownsTerminalTransition = ownsTerminalTransition;
+        this.aborted = aborted;
+    }
+}
+function compactionExecutionOwnsTerminalTransition(error) {
+    return !(error instanceof CompactionExecutionError) || error.ownsTerminalTransition;
+}
+function isCompactionExecutionAborted(error) {
+    return ((error instanceof CompactionExecutionError && error.aborted) ||
+        error instanceof CompactionCancelledError ||
+        (error instanceof Error && error.name === "AbortError"));
+}
 class RequiredCompactionError extends Error {
     constructor() {
         super("Context remains above the compaction threshold because compaction did not complete");
@@ -135,18 +176,40 @@ export class AgentSession {
     constructor(config) {
         this._eventListeners = [];
         this._agentEventQueue = Promise.resolve();
+        /**
+         * Exact message objects whose message_end persistence is still queued.
+         * Agent core appends messages to agent.state.messages before emitting
+         * message_end; until that event settles on _agentEventQueue, compaction must
+         * treat these identities as pending persistence, never as stale or droppable.
+         */
+        this._messageEndsAwaitingPersistence = new Set();
         this._isAgentRunActive = false;
+        this._promptStartPending = false;
         /** 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 = [];
         /** 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
+        // core otherwise drains steering immediately before AgentSession can consume
+        // the stale-usage exemption and schedule the continuation itself.
+        this._postCompactionDeferredSteeringMessages = [];
+        this._postCompactionDeferredFollowUpMessages = [];
         // Compaction state
         this._compactionAbortController = undefined;
         this._autoCompactionAbortController = undefined;
+        this._pendingCompactionAdmission = undefined;
+        this._compactionLifecycle = new CompactionLifecycleCoordinator();
         this._sessionWorkBarrier = new SessionWorkBarrier();
         this._overflowRecoveryAttempted = false;
+        // A retry continuation immediately follows an accepted compaction. Its first
+        // response must not retrigger threshold compaction from stale provider usage.
+        this._skipNextPostRetryCompactionCheck = false;
+        this._skipNextPostCompactionAssistantCheck = false;
+        this._scheduledContinuationRecompacted = false;
+        this._assistantsPendingAtCompaction = new WeakSet();
+        this._postCompactionUsageExemptAssistants = new WeakSet();
         this._messageRevision = 0;
         // Branch summarization state
         this._branchSummaryAbortController = undefined;
@@ -159,6 +222,7 @@ export class AgentSession {
         this._retryResolve = undefined;
         this._userAbortPromise = undefined;
         this._suppressQueuedContinuationAfterUserAbort = false;
+        this._extensionEventSignal = undefined;
         // Bash execution state
         this._bashAbortController = undefined;
         this._pendingBashMessages = [];
@@ -176,20 +240,52 @@ export class AgentSession {
         // Track last assistant message for auto-compaction check
         this._lastAssistantMessage = undefined;
         /** Internal handler for agent events - shared by subscribe and reconnect */
-        this._handleAgentEvent = (event) => {
+        this._handleAgentEvent = (event, signal) => {
+            // Agent core drains native steer/follow-up queues immediately after its
+            // final agent_end. This subscriber intentionally processes its own event
+            // queue asynchronously, so a later recovery rejection cannot abort that
+            // drain in time. agent_end itself is still an awaited synchronous boundary
+            // before that drain: transfer every required overflow or threshold
+            // compaction to AgentSession, retaining queues until recovery is accepted.
+            if (event.type === "agent_end") {
+                const lastAssistant = this._findLastAssistantInMessages(event.messages);
+                const requiredAutoCompaction = lastAssistant
+                    ? this._getRequiredAutoCompactionReason(lastAssistant)
+                    : undefined;
+                if (requiredAutoCompaction) {
+                    this.agent.suppressQueuedMessageDrain();
+                }
+            }
             // Create retry promise synchronously before queueing async processing.
             // Agent.emit() calls this handler synchronously, and prompt() calls waitForRetry()
             // as soon as agent.prompt() resolves. If _retryPromise is created only inside
             // _processAgentEvent, slow earlier queued events can delay agent_end processing
             // and waitForRetry() can miss the in-flight retry.
             this._createRetryPromiseForAgentEnd(event);
-            this._agentEventQueue = this._agentEventQueue.then(() => this._processAgentEvent(event), () => this._processAgentEvent(event));
+            // The message object is already in agent.state.messages when message_end
+            // fires; track its exact identity until this event's queued processing
+            // settles so compaction can distinguish pending persistence from stale state.
+            if (event.type === "message_end" && event.message.role === "assistant") {
+                this._emitServerFallbackAborted(event.message);
+            }
+            const pendingMessage = event.type === "message_end" ? event.message : undefined;
+            if (pendingMessage !== undefined) {
+                this._messageEndsAwaitingPersistence.add(pendingMessage);
+            }
+            const processing = this._agentEventQueue.then(() => this._processAgentEvent(event, signal), () => this._processAgentEvent(event, signal));
+            this._agentEventQueue =
+                pendingMessage !== undefined
+                    ? processing.finally(() => {
+                        this._messageEndsAwaitingPersistence.delete(pendingMessage);
+                    })
+                    : processing;
             // Keep queue alive if an event handler fails
             this._agentEventQueue.catch(() => { });
         };
         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) {
@@ -221,8 +317,9 @@ export class AgentSession {
                     persistDefault: false,
                     appendSessionEntry: true,
                     entryReason: reason,
-                    emitModelSelect: reason === "fallback-revert",
-                    invalidateCompaction: false,
+                    emitModelSelect: true,
+                    modelSelectSource: reason,
+                    invalidateCompaction: true,
                     ephemeralThinkingLevel: thinking,
                 });
             },
@@ -268,7 +365,7 @@ export class AgentSession {
             }
             throw error;
         }
-        if (result?.auth.apiKey) {
+        if (result && (result.auth.apiKey || result.auth.headers)) {
             return {
                 apiKey: result.auth.apiKey,
                 headers: withoutDeletedHeaders(result.auth.headers),
@@ -284,26 +381,31 @@ export class AgentSession {
         }
         throw new Error(formatNoApiKeyFoundMessage(model.provider));
     }
-    async _getCompactionRequestAuth(model) {
-        if (this.agent.streamFn === streamSimple) {
+    /**
+     * Resolve optional auth for a summarization stream. Native/custom stream
+     * functions may provide ambient credentials, unlike streamSimple.
+     */
+    async _getSummarizationRequestAuth(model) {
+        if (this.agent.streamFunction === streamSimple) {
             return this._getRequiredRequestAuth(model);
         }
-        const compatibility = this._modelRuntime.getCompatibilityRequestConfig(model);
         try {
             const result = await this._modelRuntime.getAuth(model);
             return result
-                ? {
-                    apiKey: result.auth.apiKey,
-                    headers: withoutDeletedHeaders(result.auth.headers),
-                    extraBody: compatibility.extraBody,
-                    env: result.env,
-                }
-                : { extraBody: compatibility.extraBody };
+                ? { apiKey: result.auth.apiKey, headers: withoutDeletedHeaders(result.auth.headers), env: result.env }
+                : {};
         }
         catch {
-            return { extraBody: compatibility.extraBody };
+            return {};
         }
     }
+    async _getCompactionRequestAuth(model) {
+        const auth = await this._getSummarizationRequestAuth(model);
+        return {
+            ...auth,
+            extraBody: this._modelRuntime.getCompatibilityRequestConfig(model).extraBody,
+        };
+    }
     /**
      * Install tool hooks once on the Agent instance.
      *
@@ -312,6 +414,24 @@ export class AgentSession {
      * registered tool execution to the extension context. Tool call and tool result interception now
      * happens here instead of in wrappers.
      */
+    /**
+     * Surface a provider-level server-fallback abort before retry handling runs so
+     * the UI can explain the switch. Emitted synchronously here because retry work
+     * for the following agent_end starts before queued message_end processing
+     * drains. `chainConfigured` is required because the no-chain refusal path
+     * emits no retry_fallback_exhausted, leaving the UI no other signal.
+     */
+    _emitServerFallbackAborted(message) {
+        const details = message.diagnostics?.find((entry) => entry.type === SERVER_FALLBACK_ABORTED_DIAGNOSTIC)?.details;
+        if (details === undefined)
+            return;
+        this._emit({
+            type: "server_fallback_aborted",
+            from: typeof details.from === "string" ? details.from : message.model,
+            to: typeof details.to === "string" ? details.to : message.model,
+            chainConfigured: this._retryFallback.hasConfiguredChain(),
+        });
+    }
     _installAgentToolHooks() {
         this.agent.beforeToolCall = async ({ toolCall, args }) => {
             return this._emitBeforeToolCallHooks(toolCall, args);
@@ -354,6 +474,7 @@ export class AgentSession {
             content: result.content,
             details: result.details,
             isError,
+            usage: result.usage,
         });
         if (!hookResult) {
             return undefined;
@@ -362,6 +483,7 @@ export class AgentSession {
             content: hookResult.content,
             details: hookResult.details,
             isError: hookResult.isError ?? isError,
+            usage: hookResult.usage,
         };
     }
     _installAgentNextTurnRefresh() {
@@ -370,31 +492,68 @@ export class AgentSession {
                 ? async (_turn, signal) => await this.agent.prepareNextTurn?.(signal)
                 : undefined);
         this.agent.prepareNextTurnWithContext = async (turn, signal) => {
-            let messages = turn.context.messages;
-            if (turn.toolResults.length > 0) {
+            // Enforce compaction only when this prepare precedes an actual provider
+            // admission: a tool continuation or queued steer/follow-up messages. A
+            // completed turn with no continuation keeps pre-PR timing, while the
+            // prior prepare callback and context refresh below still run every turn.
+            const compactBeforeNextAdmission = async () => {
+                if (turn.toolResults.length === 0 && !this.agent.hasQueuedMessages()) {
+                    return false;
+                }
                 await this._agentEventQueue;
-                const compacted = await this._checkCompaction(turn.message, true, "threshold");
-                if (compacted) {
-                    messages = this.agent.state.messages.slice();
+                // A queue can be cleared while waiting for persistence. Re-sample it
+                // immediately before compaction so a completed turn never compacts
+                // merely because it once had a possible continuation.
+                if (turn.toolResults.length === 0 && !this.agent.hasQueuedMessages()) {
+                    return false;
                 }
-                else {
-                    const settings = this.settingsManager.getCompactionSettings();
-                    const contextTokens = estimateContextTokens(filterContextExcludedMessages(this.sessionManager.buildSessionContext().messages)).tokens;
-                    if (settings.enabled && this.model && shouldCompact(contextTokens, this.model.contextWindow, settings)) {
-                        throw new RequiredCompactionError();
+                try {
+                    return await this._enforceCompactionBeforeProvider(turn.message, true, "threshold");
+                }
+                catch (error) {
+                    if (error instanceof RequiredCompactionError && this.agent.hasQueuedMessages()) {
+                        this._requiredCompactionAdmissionError = error;
                     }
+                    throw error;
                 }
-            }
+            };
+            const compactedBeforeCallback = await compactBeforeNextAdmission();
+            const messages = compactedBeforeCallback ? this.agent.state.messages.slice() : turn.context.messages;
             const postCompactionTurn = {
                 ...turn,
                 context: { ...turn.context, messages },
             };
-            const previousSnapshot = await previousPrepareNextTurnWithContext?.(postCompactionTurn, signal);
-            const previousContext = previousSnapshot?.context ?? postCompactionTurn.context;
+            let previousSnapshot = await previousPrepareNextTurnWithContext?.(postCompactionTurn, signal);
+            let previousContext = previousSnapshot?.context ?? postCompactionTurn.context;
+            // The previous callback may await while agent_end extensions enqueue
+            // continuation work. Re-sample after it returns so that work cannot
+            // slip through with the stale provider snapshot it observed on entry.
+            let compactedAfterCallback = false;
+            if (!compactedBeforeCallback) {
+                compactedAfterCallback = await compactBeforeNextAdmission();
+            }
+            if (compactedAfterCallback) {
+                // The callback's first result describes the stale pre-compaction
+                // context. Reapply it once to the compacted context so any host
+                // transformation reaches the provider request. Do not re-sample after
+                // this invocation: one replay is the bounded admission path.
+                const postLateCompactionTurn = {
+                    ...turn,
+                    context: { ...turn.context, messages: this.agent.state.messages.slice() },
+                };
+                const postLateCompactionSnapshot = await previousPrepareNextTurnWithContext?.(postLateCompactionTurn, signal);
+                previousSnapshot = {
+                    ...previousSnapshot,
+                    ...postLateCompactionSnapshot,
+                    context: postLateCompactionSnapshot?.context ?? postLateCompactionTurn.context,
+                };
+                previousContext = previousSnapshot.context ?? postLateCompactionTurn.context;
+            }
             return {
                 ...previousSnapshot,
                 context: {
                     ...previousContext,
+                    messages: previousContext.messages,
                     systemPrompt: this._systemPromptOverride ?? this._baseSystemPrompt,
                     tools: this.agent.state.tools.slice(),
                 },
@@ -421,6 +580,7 @@ export class AgentSession {
     }
     _incrementMessageRevision() {
         this._messageRevision++;
+        this._blockedPostCompactionAssistant = undefined;
     }
     getMessageRevision() {
         return this._messageRevision;
@@ -481,14 +641,46 @@ export class AgentSession {
     }
     async _promptAgent(messages) {
         this._isAgentRunActive = true;
+        this._requiredCompactionAdmissionError = undefined;
         try {
             await this.agent.prompt(messages);
+            // AgentSession's subscriber intentionally queues event work instead of
+            // blocking Agent core. Wait for this run's queued recovery decision
+            // before reporting prompt completion to the caller.
+            await this._agentEventQueue;
+            const requiredCompactionError = this._requiredCompactionAdmissionError;
+            this._requiredCompactionAdmissionError = undefined;
+            if (requiredCompactionError) {
+                throw requiredCompactionError;
+            }
         }
         catch (error) {
+            if (error instanceof Error &&
+                error.message ===
+                    "Agent is already processing a prompt. Use steer() or followUp() to queue messages, or wait for completion.") {
+                const queuedMessages = Array.isArray(messages) ? messages : [messages];
+                for (const message of queuedMessages)
+                    this.agent.steer(message);
+                const userMessage = queuedMessages.find((message) => message.role === "user");
+                if (userMessage?.role === "user") {
+                    this._steeringMessages.push(this._extractUserMessageText(userMessage.content));
+                    this._emitQueueUpdate();
+                }
+                return;
+            }
             await this._emitAgentSettled();
             throw error;
         }
     }
+    /** Extract text content used to track fork-owned queued user messages. */
+    _extractUserMessageText(content) {
+        if (typeof content === "string")
+            return content;
+        return content
+            .filter((part) => part.type === "text")
+            .map((part) => part.text)
+            .join("");
+    }
     _createRetryPromiseForAgentEnd(event) {
         if (event.type !== "agent_end" || this._retryPromise) {
             return;
@@ -505,6 +697,10 @@ export class AgentSession {
         this._retryPromise = new Promise((resolve) => {
             this._retryResolve = resolve;
         });
+        // Agent core normally drains queued input immediately after agent_end.
+        // Retry owns that continuation until its final provider-admission check has
+        // either started it or reported a terminal rejection.
+        this.agent.suppressQueuedMessageDrain();
     }
     _findLastAssistantInMessages(messages) {
         for (let i = messages.length - 1; i >= 0; i--) {
@@ -515,6 +711,91 @@ export class AgentSession {
         }
         return undefined;
     }
+    /**
+     * Synchronously mirror the auto-compaction decision that _checkCompaction()
+     * will make after agent_end. Agent core drains queues before that async work
+     * runs, so only this preflight can transfer required admissions safely.
+     */
+    _getRequiredAutoCompactionReason(message) {
+        const reason = this._getAutoCompactionReason(message);
+        // Retry and post-compaction exemptions only cover stale usage estimates.
+        // A provider-confirmed overflow must always retain queue ownership and run
+        // fail-closed recovery.
+        if (reason === "overflow" &&
+            message.stopReason === "stop" &&
+            this._hasPendingPostCompactionUsageExemption(message)) {
+            // A successful post-compaction response can carry stale provider usage.
+            // Retain its queues while the asynchronous check consumes the exemption.
+            return "threshold";
+        }
+        if (reason === "overflow")
+            return reason;
+        // Keep queued continuations under AgentSession ownership while the
+        // asynchronous check consumes this post-compaction usage exemption.
+        if (this._hasPendingPostCompactionUsageExemption(message))
+            return "threshold";
+        if (reason === "threshold" &&
+            (this._skipNextPostRetryCompactionCheck || this._postCompactionUsageExemptAssistants.has(message))) {
+            return undefined;
+        }
+        return reason;
+    }
+    _getAutoCompactionReason(message) {
+        const settings = this.settingsManager.getCompactionSettings();
+        if (!settings.enabled || message.stopReason === "aborted") {
+            return undefined;
+        }
+        const model = this.model;
+        if (!model || this._isAssistantFromBeforeLatestCompaction(message)) {
+            return undefined;
+        }
+        const sameModel = isSameOverflowSource(message, model, this._modelRuntime.getCompatibilityRequestConfig(model).upstreamModelId);
+        const contextUsage = this.getContextUsage();
+        const currentContextNeedsCompaction = contextUsage !== undefined &&
+            contextUsage.tokens !== null &&
+            shouldCompact(contextUsage.tokens, contextUsage.contextWindow, settings);
+        if (isContextOverflow(message, model.contextWindow) && (sameModel || currentContextNeedsCompaction)) {
+            return "overflow";
+        }
+        let contextTokens;
+        const directContextTokens = message.usage ? calculateContextTokens(message.usage) : 0;
+        if (message.stopReason !== "error" && directContextTokens !== 0) {
+            contextTokens = directContextTokens;
+        }
+        else {
+            const messages = filterContextExcludedMessages(this.agent.state.messages);
+            const estimate = estimateContextTokens(messages);
+            if (estimate.lastUsageIndex === null) {
+                return undefined;
+            }
+            const compactionEntry = getLatestCompactionEntry(this.sessionManager.getBranch());
+            const usageMessage = messages[estimate.lastUsageIndex];
+            if (compactionEntry &&
+                usageMessage?.role === "assistant" &&
+                this._isAssistantFromBeforeLatestCompaction(usageMessage)) {
+                return undefined;
+            }
+            contextTokens = estimate.tokens;
+        }
+        return shouldCompact(contextTokens, model.contextWindow, settings) ? "threshold" : undefined;
+    }
+    _hasPendingPostCompactionUsageExemption(message) {
+        return (this._skipNextPostCompactionAssistantCheck &&
+            !this._assistantsPendingAtCompaction.has(message) &&
+            !this._overflowRecoveryAttempted);
+    }
+    _isPostCompactionUsageExempt(message) {
+        return (this._postCompactionUsageExemptAssistants.has(message) || this._hasPendingPostCompactionUsageExemption(message));
+    }
+    _consumePostCompactionUsageExemption(message) {
+        if (this._postCompactionUsageExemptAssistants.has(message))
+            return true;
+        if (!this._isPostCompactionUsageExempt(message))
+            return false;
+        this._skipNextPostCompactionAssistantCheck = false;
+        this._postCompactionUsageExemptAssistants.add(message);
+        return true;
+    }
     _agentEndAllowsQueuedContinuation(messages) {
         let lastAssistantIndex = -1;
         for (let index = messages.length - 1; index >= 0; index--) {
@@ -533,6 +814,9 @@ export class AgentSession {
         if (lastAssistant.stopReason === "aborted" || lastAssistant.stopReason === "error") {
             return false;
         }
+        if (this._getRequiredAutoCompactionReason(lastAssistant)) {
+            return false;
+        }
         for (let index = lastAssistantIndex + 1; index < messages.length; index++) {
             const message = messages[index];
             if (message?.role === "toolResult" &&
@@ -572,13 +856,13 @@ export class AgentSession {
         }
         return providerDelayMs <= this.settingsManager.getProviderRetrySettings().maxRetryDelayMs;
     }
-    async _processAgentEvent(event) {
+    async _processAgentEvent(event, signal) {
         // When a user message starts, check if it's from either queue and remove it BEFORE emitting
         // This ensures the UI sees the updated queue state
         if (event.type === "message_start" && event.message.role === "user") {
             this._overflowRecoveryAttempted = false;
             this._retryFallback.resetTurn();
-            const messageText = this._getUserMessageText(event.message);
+            const messageText = contentText(event.message.content, "");
             if (messageText) {
                 // Check steering queue first
                 const steeringIndex = this._steeringMessages.indexOf(messageText);
@@ -596,8 +880,15 @@ export class AgentSession {
                 }
             }
         }
-        // Emit to extensions first
-        await this._emitExtensionEvent(event);
+        // Emit to extensions first. Agent event persistence is intentionally
+        // asynchronous, so retain the source run signal while dispatching.
+        this._extensionEventSignal = signal;
+        try {
+            await this._emitExtensionEvent(event);
+        }
+        finally {
+            this._extensionEventSignal = undefined;
+        }
         // Notify all listeners
         this._emit(event.type === "agent_end" ? { ...event, willRetry: this._willRetryAfterAgentEnd(event.messages) } : event);
         // Handle session persistence
@@ -643,8 +934,10 @@ export class AgentSession {
                 }
             }
         }
-        // Check auto-retry and auto-compaction after agent completes
+        // Check auto-retry and auto-compaction after agent completes.
         let launchedContinuation = false;
+        let retryContinuationBlocked = false;
+        let allowsPostCompactionUsageExemptContinuation = false;
         const userAbortSuppressedQueuedContinuation = event.type === "agent_end" && this._suppressQueuedContinuationAfterUserAbort;
         if (userAbortSuppressedQueuedContinuation) {
             this._suppressQueuedContinuationAfterUserAbort = false;
@@ -655,23 +948,62 @@ export class AgentSession {
         if (event.type === "agent_end" && this._lastAssistantMessage) {
             const msg = this._lastAssistantMessage;
             this._lastAssistantMessage = undefined;
+            this._skipNextPostRetryCompactionCheck = false;
+            const requiredAutoCompaction = this._getRequiredAutoCompactionReason(msg);
             // Retry transient failures normally and eligible hard errors only through a fallback.
             const retryableError = this._isRetryableError(msg);
-            let didRetry = false;
-            if (retryableError) {
-                didRetry = await this._handleRetryableError(msg);
+            const hardErrorFallbackEligible = this._isHardErrorFallbackEligible(msg);
+            const retryCanAdmitProvider = this.settingsManager.getRetrySettings().enabled && (retryableError || hardErrorFallbackEligible);
+            let compactedBeforeRetry = false;
+            if (retryCanAdmitProvider &&
+                requiredAutoCompaction &&
+                !(requiredAutoCompaction === "threshold" && this._hasPendingPostCompactionUsageExemption(msg))) {
+                this._retireFailedRetryAssistant(msg);
+                compactedBeforeRetry = await this._runPrePromptCompaction(msg, true, "threshold", true);
+                retryContinuationBlocked = !compactedBeforeRetry;
             }
-            else if (this._isHardErrorFallbackEligible(msg)) {
-                didRetry = await this._handleRetryableError(msg, { hardErrorFallback: true });
+            let retryOutcome = "not-handled";
+            if (!retryContinuationBlocked) {
+                if (retryableError) {
+                    retryOutcome = await this._handleRetryableError(msg);
+                }
+                else if (hardErrorFallbackEligible) {
+                    retryOutcome = await this._handleRetryableError(msg, { hardErrorFallback: true });
+                }
             }
-            if (didRetry)
-                return; // Retry was initiated, don't proceed to compaction
+            if (retryOutcome === "continued")
+                return;
             this._resolveRetry();
-            launchedContinuation = await this._checkCompaction(msg);
+            retryContinuationBlocked ||= retryOutcome === "blocked";
+            if (!retryContinuationBlocked) {
+                if (compactedBeforeRetry && this.agent.hasQueuedMessages()) {
+                    this._scheduleContinuationAfterCurrentEvent();
+                    launchedContinuation = true;
+                }
+                else {
+                    launchedContinuation = await this._checkCompaction(msg);
+                    allowsPostCompactionUsageExemptContinuation = this._postCompactionUsageExemptAssistants.has(msg);
+                    if (allowsPostCompactionUsageExemptContinuation) {
+                        this._flushPostCompactionDeferredMessages();
+                    }
+                    // _runAutoCompaction() returns false both when recovery was rejected and
+                    // when an accepted compaction had no queue to continue. Re-sample after
+                    // it settles so only the still-required (rejected) case fails admission.
+                    if (requiredAutoCompaction &&
+                        !launchedContinuation &&
+                        this.agent.hasQueuedMessages() &&
+                        this._getRequiredAutoCompactionReason(msg) !== undefined) {
+                        this._requiredCompactionAdmissionError = new RequiredCompactionError();
+                    }
+                }
+            }
         }
         if (event.type === "agent_end") {
             this._flushPendingBashMessages();
-            if (!launchedContinuation && allowsQueuedContinuation && this.agent.hasQueuedMessages()) {
+            if (!launchedContinuation &&
+                !retryContinuationBlocked &&
+                (allowsQueuedContinuation || allowsPostCompactionUsageExemptContinuation) &&
+                this.agent.hasQueuedMessages()) {
                 this._scheduleContinuationAfterCurrentEvent();
                 launchedContinuation = true;
             }
@@ -688,16 +1020,6 @@ export class AgentSession {
             this._retryPromise = undefined;
         }
     }
-    /** Extract text content from a message */
-    _getUserMessageText(message) {
-        if (message.role !== "user")
-            return "";
-        const content = message.content;
-        if (typeof content === "string")
-            return content;
-        const textBlocks = content.filter((c) => c.type === "text");
-        return textBlocks.map((c) => c.text).join("");
-    }
     /** Find the last assistant message in agent state (including aborted ones) */
     _findLastAssistantMessage() {
         const messages = this.agent.state.messages;
@@ -709,9 +1031,47 @@ export class AgentSession {
         }
         return undefined;
     }
+    /**
+     * Retry failures stay in append-only history but must not be retained in the
+     * active context branch. Otherwise split-turn compaction keeps the failed
+     * assistant response verbatim and cannot make progress before a retry.
+     */
+    _retireFailedRetryAssistant(message) {
+        const position = this.sessionManager.getMessageEntryPosition(message);
+        if (!position || this.sessionManager.getLeafId() !== position.entryId)
+            return;
+        const entry = this.sessionManager.getEntry(position.entryId);
+        if (entry?.type !== "message")
+            return;
+        if (entry.parentId === null) {
+            this.sessionManager.resetLeaf();
+        }
+        else {
+            this.sessionManager.branch(entry.parentId);
+        }
+        const messageIndex = this.agent.state.messages.lastIndexOf(message);
+        if (messageIndex !== -1) {
+            this.agent.state.messages = this.agent.state.messages.slice(0, messageIndex);
+        }
+        this._incrementMessageRevision();
+    }
     _isAssistantFromBeforeLatestCompaction(assistantMessage) {
         const compactionEntry = getLatestCompactionEntry(this.sessionManager.getBranch());
-        return compactionEntry !== null && assistantMessage.timestamp <= new Date(compactionEntry.timestamp).getTime();
+        if (compactionEntry === null)
+            return false;
+        // An agent message_end can still be awaiting persistence while compaction
+        // commits. It is necessarily a post-boundary message, even when a provider
+        // supplied an older payload timestamp.
+        if (this._messageEndsAwaitingPersistence.has(assistantMessage))
+            return false;
+        const messagePosition = this.sessionManager.getMessageEntryPosition(assistantMessage);
+        const compactionOrder = this.sessionManager.getEntryOrder(compactionEntry.id);
+        if (messagePosition !== undefined && compactionOrder !== undefined) {
+            return messagePosition.order <= compactionOrder;
+        }
+        // Reloaded/reconstructed messages have no runtime identity. Retain the
+        // historical timestamp heuristic only for that compatibility path.
+        return assistantMessage.timestamp <= new Date(compactionEntry.timestamp).getTime();
     }
     _replaceMessageInPlace(target, replacement) {
         // Agent-core stores the finalized message object in its state before emitting message_end.
@@ -1006,17 +1366,28 @@ export class AgentSession {
                 validToolNames.push(name);
             }
         }
+        const activeToolNamesChanged = validToolNames.length !== this.agent.state.tools.length ||
+            validToolNames.some((name, index) => name !== this.agent.state.tools[index]?.name);
         this.agent.state.tools = tools;
         // Rebuild base system prompt with new tool set
         this._baseSystemPrompt = this._rebuildSystemPrompt(validToolNames);
         this.agent.state.systemPrompt = this._systemPromptOverride ?? this._baseSystemPrompt;
+        if (activeToolNamesChanged) {
+            this.abortCompaction();
+            this._incrementMessageRevision();
+        }
     }
     /** Whether compaction or branch summarization is currently running */
     get isCompacting() {
-        return (this._autoCompactionAbortController !== undefined ||
+        return (this._pendingCompactionAdmission !== undefined ||
+            this._compactionLifecycle.state.status === "running" ||
+            this._autoCompactionAbortController !== undefined ||
             this._compactionAbortController !== undefined ||
             this._branchSummaryAbortController !== undefined);
     }
+    get compactionState() {
+        return this._compactionLifecycle.state;
+    }
     /** All messages including custom types like BashExecutionMessage */
     get messages() {
         return this.agent.state.messages;
@@ -1162,28 +1533,52 @@ export class AgentSession {
             await userAbortPromise;
             throwIfCancelled();
         }
-        const shouldWaitForSessionWork = options?.source !== "extension";
+        const ownsPromptStart = !this.isStreaming && !this._promptStartPending && options?.streamingBehavior === undefined;
+        if (ownsPromptStart)
+            this._promptStartPending = true;
+        // Extension bindings deliberately fire-and-forget sendUserMessage(), so an
+        // extension callback cannot deadlock on this wait. The resulting provider
+        // turn must still serialize behind compaction and other session work just
+        // like an interactive prompt does.
+        const shouldWaitForSessionWork = true;
+        const pendingCompactionAdmissionAtExtensionAdmission = options?.source === "extension" ? this._pendingCompactionAdmission : undefined;
+        const compactionGenerationAtExtensionAdmission = options?.source === "extension" &&
+            this._sessionWorkBarrier.hasActiveWork &&
+            this._compactionLifecycle.state.status !== "idle"
+            ? this._compactionLifecycle.state.generation
+            : undefined;
         // A steer/followUp submission during an active run can be queued immediately.
         // Waiting on the session-work barrier here would trap the message inside this
         // call for the rest of the run whenever a queued continuation (e.g. an active
         // goal chain) holds the barrier, making typed input invisible until the run
         // ends or the user aborts.
-        const canQueueWhileStreaming = this.isStreaming && !this.isCompacting && options?.streamingBehavior !== undefined;
+        const canQueueWhileStreaming = (this.isStreaming || this._promptStartPending) &&
+            !this.isCompacting &&
+            options?.streamingBehavior !== undefined;
         if (shouldWaitForSessionWork &&
             !canQueueWhileStreaming &&
             (!this.isStreaming || this.isCompacting || this._sessionWorkBarrier.hasActiveWork)) {
             await this._waitForSettledSessionWork();
             throwIfCancelled();
+            options?.onSessionWorkReady?.();
         }
         // Turn boundary: restore the primary model if the fallback cooldown expired.
         if (!this.isStreaming) {
-            await this._maybeRestoreFallbackPrimary();
+            try {
+                await this._maybeRestoreFallbackPrimary();
+            }
+            catch (error) {
+                if (ownsPromptStart)
+                    this._promptStartPending = false;
+                throw error;
+            }
         }
         const expandPromptTemplates = options?.expandPromptTemplates ?? true;
         const preflightResult = options?.preflightResult;
         const promptDisposition = options?.promptDisposition;
         let messages;
         let titlePrompt;
+        let consumedNextTurnMessages;
         try {
             // Handle extension commands first (execute immediately, even during streaming)
             // Extension commands manage their own LLM interaction via pi.sendMessage()
@@ -1238,6 +1633,23 @@ export class AgentSession {
                 preflightResult?.(true);
                 return;
             }
+            // Input accepted while a run was active remains queued even if that run
+            // ends while extension input handling or template expansion is pending.
+            // Starting a fresh prompt here would let it overtake the held continuation.
+            if (canQueueWhileStreaming && !this.isStreaming) {
+                if (options?.thinkingLevel !== undefined) {
+                    throw new Error("Cannot set thinkingLevel on a queued prompt; set it after the current turn completes.");
+                }
+                if (options?.streamingBehavior === "followUp") {
+                    await this._queueFollowUp(expandedText, currentImages);
+                }
+                else {
+                    await this._queueSteer(expandedText, currentImages);
+                }
+                promptDisposition?.("queued");
+                preflightResult?.(true);
+                return;
+            }
             // The queue-while-streaming bypass above skipped the settled-work wait. If
             // the run ended while input was being expanded, serialize with remaining
             // session work before sending a fresh prompt, and re-queue if a scheduled
@@ -1262,6 +1674,25 @@ export class AgentSession {
                     return;
                 }
             }
+            // A background extension prompt that arrived during a manual compaction
+            // must never overtake a rejected or aborted compaction. Keep its normal
+            // queue ownership instead of attempting another provider admission.
+            if ((pendingCompactionAdmissionAtExtensionAdmission !== undefined &&
+                pendingCompactionAdmissionAtExtensionAdmission.outcome !== "completed") ||
+                (compactionGenerationAtExtensionAdmission !== undefined &&
+                    this._compactionLifecycle.state.generation === compactionGenerationAtExtensionAdmission &&
+                    (this._compactionLifecycle.state.status === "failed" ||
+                        this._compactionLifecycle.state.status === "aborted"))) {
+                if (options?.streamingBehavior === "followUp") {
+                    await this._queueFollowUp(expandedText, currentImages);
+                }
+                else {
+                    await this._queueSteer(expandedText, currentImages);
+                }
+                promptDisposition?.("queued");
+                preflightResult?.(true);
+                return;
+            }
             // Flush any pending bash messages before the new prompt
             this._flushPendingBashMessages();
             // Validate model
@@ -1279,19 +1710,8 @@ export class AgentSession {
                 }
                 throw new Error(formatNoApiKeyFoundMessage(this.model.provider));
             }
-            // Check if we need to compact before sending (catches aborted responses).
             // The user's new prompt is sent below, so do not call agent.continue() here.
-            const lastAssistant = this._findLastAssistantMessage();
-            if (lastAssistant) {
-                const compacted = await this._checkCompaction(lastAssistant, false, "pre_prompt");
-                if (!compacted && !this._isAssistantFromBeforeLatestCompaction(lastAssistant)) {
-                    const settings = this.settingsManager.getCompactionSettings();
-                    const contextTokens = estimateContextTokens(filterContextExcludedMessages(this.sessionManager.buildSessionContext().messages)).tokens;
-                    if (settings.enabled && this.model && shouldCompact(contextTokens, this.model.contextWindow, settings)) {
-                        throw new RequiredCompactionError();
-                    }
-                }
-            }
+            await this._enforceCompactionBeforeProvider(this._findLastAssistantMessage(), false, "pre_prompt");
             // Build messages array (custom message if any, then user message)
             messages = [];
             // Add user message
@@ -1304,11 +1724,14 @@ export class AgentSession {
                 content: userContent,
                 timestamp: Date.now(),
             });
-            // Inject any pending "nextTurn" messages as context alongside the user message
-            for (const msg of this._pendingNextTurnMessages) {
+            // Consume next-turn messages transactionally: a final admission rejection
+            // restores them in their original order rather than dropping or duplicating
+            // one-shot extension state.
+            consumedNextTurnMessages = this._pendingNextTurnMessages;
+            this._pendingNextTurnMessages = [];
+            for (const msg of consumedNextTurnMessages) {
                 messages.push(msg);
             }
-            this._pendingNextTurnMessages = [];
             // Emit before_agent_start extension event
             const result = await this._extensionRunner.emitBeforeAgentStart(expandedText, currentImages, this._baseSystemPrompt, this._baseSystemPromptOptions);
             // Add all custom messages from extensions
@@ -1335,11 +1758,22 @@ export class AgentSession {
                 this._systemPromptOverride = undefined;
                 this.agent.state.systemPrompt = this._baseSystemPrompt;
             }
+            // The preflight above only sees persisted session context. These prompt,
+            // 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);
         }
         catch (error) {
+            if (consumedNextTurnMessages && consumedNextTurnMessages.length > 0) {
+                this._pendingNextTurnMessages = [...consumedNextTurnMessages, ...this._pendingNextTurnMessages];
+            }
             preflightResult?.(false);
             throw error;
         }
+        finally {
+            if (ownsPromptStart)
+                this._promptStartPending = false;
+        }
         if (!messages) {
             return;
         }
@@ -1352,7 +1786,14 @@ export class AgentSession {
         await this._promptAgent(messages);
         await this.waitForRetry();
         await this.waitForIdle();
-        if (shouldWaitForSessionWork) {
+        if (options?.onSessionWorkReady) {
+            // This prompt owns a session-work token acquired after waiting for a
+            // prior operation, so waiting for the global barrier here would await
+            // itself. _promptAgent() already drained its event queue; any newly
+            // scheduled continuation retains its own barrier ownership.
+            await this.agent.waitForIdle();
+        }
+        else if (shouldWaitForSessionWork) {
             await this._waitForSettledSessionWork();
         }
         else {
@@ -1479,7 +1920,7 @@ export class AgentSession {
                 sessionId: this.sessionId,
                 baseOptions: this._buildSessionTitleBaseOptions(),
                 signal: abortController.signal,
-                streamFn: this.agent.streamFn,
+                streamFn: this.agent.streamFunction,
             });
             if (abortController.signal.aborted) {
                 return;
@@ -1532,11 +1973,12 @@ export class AgentSession {
         if (images) {
             content.push(...images);
         }
-        this.agent.steer({
-            role: "user",
-            content,
-            timestamp: Date.now(),
-        });
+        const message = { role: "user", content, timestamp: Date.now() };
+        if (this._promptStartPending && this._skipNextPostCompactionAssistantCheck) {
+            this._postCompactionDeferredSteeringMessages.push(message);
+            return;
+        }
+        this.agent.steer(message);
     }
     /**
      * Internal: Queue a follow-up message (already expanded, no extension command check).
@@ -1548,11 +1990,22 @@ export class AgentSession {
         if (images) {
             content.push(...images);
         }
-        this.agent.followUp({
-            role: "user",
-            content,
-            timestamp: Date.now(),
-        });
+        const message = { role: "user", content, timestamp: Date.now() };
+        if (this._promptStartPending && this._skipNextPostCompactionAssistantCheck) {
+            this._postCompactionDeferredFollowUpMessages.push(message);
+            return;
+        }
+        this.agent.followUp(message);
+    }
+    _flushPostCompactionDeferredMessages() {
+        for (const message of this._postCompactionDeferredSteeringMessages) {
+            this.agent.steer(message);
+        }
+        this._postCompactionDeferredSteeringMessages = [];
+        for (const message of this._postCompactionDeferredFollowUpMessages) {
+            this.agent.followUp(message);
+        }
+        this._postCompactionDeferredFollowUpMessages = [];
     }
     /**
      * Throw an error if the text is an extension command.
@@ -1587,26 +2040,56 @@ export class AgentSession {
             details: message.details,
             timestamp: Date.now(),
         };
-        if (options?.deliverAs === "nextTurn") {
-            this._pendingNextTurnMessages.push(appMessage);
-        }
-        else if (this.isStreaming) {
-            if (options?.deliverAs === "followUp") {
-                this.agent.followUp(appMessage);
+        const waitForExistingSessionWork = options?.triggerTurn === true &&
+            options.deliverAs !== "nextTurn" &&
+            !this.isStreaming &&
+            this._sessionWorkBarrier.hasActiveWork;
+        const pendingCompactionAdmission = this._pendingCompactionAdmission;
+        const activeCompactionGeneration = this._compactionLifecycle.state.status === "running" ? this._compactionLifecycle.state.generation : undefined;
+        let finishSessionWork;
+        try {
+            if (waitForExistingSessionWork) {
+                await this._waitForSettledSessionWork();
+                finishSessionWork = this._sessionWorkBarrier.begin();
+            }
+            if (options?.deliverAs === "nextTurn") {
+                this._pendingNextTurnMessages.push(appMessage);
+            }
+            else if (this.isStreaming) {
+                if (options?.deliverAs === "followUp") {
+                    this.agent.followUp(appMessage);
+                }
+                else {
+                    this.agent.steer(appMessage);
+                }
+            }
+            else if (options?.triggerTurn === true &&
+                ((pendingCompactionAdmission !== undefined && pendingCompactionAdmission.outcome !== "completed") ||
+                    (activeCompactionGeneration !== undefined &&
+                        this._compactionLifecycle.state.generation === activeCompactionGeneration &&
+                        this._compactionLifecycle.state.status !== "completed"))) {
+                if (options?.deliverAs === "followUp") {
+                    this.agent.followUp(appMessage);
+                }
+                else {
+                    this.agent.steer(appMessage);
+                }
+            }
+            else if (options?.triggerTurn) {
+                await this._enforceCompactionBeforeProvider(this._findLastAssistantMessage(), false, "pre_prompt");
+                await this._enforceFinalProviderAdmission([appMessage]);
+                await this._promptAgent(appMessage);
             }
             else {
-                this.agent.steer(appMessage);
+                this.agent.state.messages.push(appMessage);
+                this.sessionManager.appendCustomMessageEntry(message.customType, message.content, message.display, message.details);
+                this._incrementMessageRevision();
+                this._emit({ type: "message_start", message: appMessage });
+                this._emit({ type: "message_end", message: appMessage });
             }
         }
-        else if (options?.triggerTurn) {
-            await this._promptAgent(appMessage);
-        }
-        else {
-            this.agent.state.messages.push(appMessage);
-            this.sessionManager.appendCustomMessageEntry(message.customType, message.content, message.display, message.details);
-            this._incrementMessageRevision();
-            this._emit({ type: "message_start", message: appMessage });
-            this._emit({ type: "message_end", message: appMessage });
+        finally {
+            finishSessionWork?.();
         }
     }
     /**
@@ -1617,6 +2100,14 @@ export class AgentSession {
      * @param options.deliverAs Delivery mode when streaming: "steer" or "followUp"
      */
     async sendUserMessage(content, options) {
+        const bindingPromptReadiness = this._extensionBindingPromptReadiness;
+        let resolveBindingPromptReadiness;
+        if (bindingPromptReadiness) {
+            const readiness = new Promise((resolve) => {
+                resolveBindingPromptReadiness = resolve;
+            });
+            bindingPromptReadiness.add(readiness);
+        }
         // Normalize content to text string + optional images
         let text;
         let images;
@@ -1638,14 +2129,31 @@ export class AgentSession {
             if (images.length === 0)
                 images = undefined;
         }
-        // Use prompt() with expandPromptTemplates: false to skip command handling and template expansion
-        await this.prompt(text, {
-            expandPromptTemplates: false,
-            streamingBehavior: options?.deliverAs,
-            images,
-            source: "extension",
-            sessionTitlePrompt: false,
-        });
+        // An extension binding invokes this method fire-and-forget. When it
+        // arrives during session work, retain a barrier token after the prior work
+        // settles so callers observing session idle cannot race its provider turn.
+        const waitForExistingSessionWork = this._sessionWorkBarrier.hasActiveWork;
+        let finishSessionWork;
+        try {
+            // Use prompt() with expandPromptTemplates: false to skip command handling and template expansion
+            await this.prompt(text, {
+                expandPromptTemplates: false,
+                streamingBehavior: options?.deliverAs,
+                images,
+                source: "extension",
+                promptDisposition: () => resolveBindingPromptReadiness?.(),
+                onSessionWorkReady: waitForExistingSessionWork
+                    ? () => {
+                        finishSessionWork ??= this._sessionWorkBarrier.begin();
+                    }
+                    : undefined,
+                sessionTitlePrompt: false,
+            });
+        }
+        finally {
+            resolveBindingPromptReadiness?.();
+            finishSessionWork?.();
+        }
     }
     /**
      * Clear all queued messages and return them.
@@ -1655,8 +2163,13 @@ export class AgentSession {
     clearQueue() {
         const steering = [...this._steeringMessages];
         const followUp = [...this._followUpMessages];
+        // 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._postCompactionDeferredSteeringMessages = [];
+        this._postCompactionDeferredFollowUpMessages = [];
         this.agent.clearAllQueues();
         this._emitQueueUpdate();
         return { steering, followUp };
@@ -1680,30 +2193,8 @@ export class AgentSession {
      * Abort current operation and wait for agent to become idle.
      */
     async abort() {
-        this.abortRetry();
         this.abortCompaction();
-        this.abortBranchSummary();
-        if (this._userAbortPromise) {
-            this.agent.abort();
-            await this._userAbortPromise;
-            return;
-        }
-        if (this.isStreaming) {
-            this._suppressQueuedContinuationAfterUserAbort = true;
-        }
-        const abortPromise = (async () => {
-            this.agent.abort();
-            await this.waitForIdle();
-        })();
-        this._userAbortPromise = abortPromise;
-        try {
-            await abortPromise;
-        }
-        finally {
-            if (this._userAbortPromise === abortPromise) {
-                this._userAbortPromise = undefined;
-            }
-        }
+        await this._abortActiveAgentAndRetry();
     }
     async waitForIdle() {
         if (this.isIdle) {
@@ -1779,6 +2270,7 @@ export class AgentSession {
             persistDefault: updateGlobalDefaults,
             appendSessionEntry: true,
             emitModelSelect: true,
+            modelSelectSource: "set",
             invalidateCompaction: true,
         });
     }
@@ -1817,7 +2309,7 @@ export class AgentSession {
         }
         if (!opts.emitModelSelect)
             return undefined;
-        return await this._emitModelSelect(model, previousModel, "set");
+        return await this._emitModelSelect(model, previousModel, opts.modelSelectSource);
     }
     _applyEphemeralThinkingLevel(level) {
         const previousLevel = this.agent.state.thinkingLevel;
@@ -2009,29 +2501,133 @@ export class AgentSession {
     // =========================================================================
     // Compaction
     // =========================================================================
+    _claimCompactionController(controller, owner) {
+        const supersedesCurrentOperation = (this._compactionAbortController !== undefined && this._compactionAbortController !== controller) ||
+            (this._autoCompactionAbortController !== undefined && this._autoCompactionAbortController !== controller);
+        if (supersedesCurrentOperation) {
+            // Supersession has no public terminal event: the stale operation no
+            // longer owns the route. Finishing its lifecycle state here prevents a
+            // missing late feedback end from keeping isCompacting true.
+            this._compactionLifecycle.abort(this._messageRevision);
+        }
+        if (this._compactionAbortController && this._compactionAbortController !== controller) {
+            this._compactionAbortController.abort();
+            this._compactionAbortController = undefined;
+        }
+        if (this._autoCompactionAbortController && this._autoCompactionAbortController !== controller) {
+            this._autoCompactionAbortController.abort();
+            this._autoCompactionAbortController = undefined;
+        }
+        if (owner === "auto") {
+            this._autoCompactionAbortController = controller;
+        }
+        else {
+            this._compactionAbortController = controller;
+        }
+    }
+    _ownsCompactionController(controller, owner) {
+        return (!controller.signal.aborted &&
+            (owner === "auto"
+                ? this._autoCompactionAbortController === controller
+                : this._compactionAbortController === controller));
+    }
+    _releaseCompactionController(signal) {
+        if (this._compactionAbortController?.signal === signal) {
+            this._compactionAbortController = undefined;
+        }
+        if (this._autoCompactionAbortController?.signal === signal) {
+            this._autoCompactionAbortController = undefined;
+        }
+    }
+    _claimPendingCompactionAdmission() {
+        const priorAdmission = this._pendingCompactionAdmission;
+        if (priorAdmission) {
+            priorAdmission.controller.abort();
+            priorAdmission.outcome = "aborted";
+            priorAdmission.finishSessionWork();
+        }
+        const controller = new AbortController();
+        const admission = {
+            controller,
+            finishSessionWork: this._sessionWorkBarrier.begin(),
+        };
+        this._pendingCompactionAdmission = admission;
+        this._claimCompactionController(controller, "compaction");
+        return admission;
+    }
+    _releasePendingCompactionAdmission(admission, outcome) {
+        admission.outcome = outcome;
+        if (this._pendingCompactionAdmission !== admission)
+            return;
+        this._pendingCompactionAdmission = undefined;
+        admission.finishSessionWork();
+    }
+    async _abortActiveAgentAndRetry() {
+        this.abortRetry();
+        this.abortBranchSummary();
+        if (this._userAbortPromise) {
+            this.agent.abort();
+            await this._userAbortPromise;
+            return;
+        }
+        if (this.isStreaming) {
+            this._suppressQueuedContinuationAfterUserAbort = true;
+        }
+        const abortPromise = (async () => {
+            this.agent.abort();
+            await this.waitForIdle();
+        })();
+        this._userAbortPromise = abortPromise;
+        try {
+            await abortPromise;
+        }
+        finally {
+            if (this._userAbortPromise === abortPromise) {
+                this._userAbortPromise = undefined;
+            }
+        }
+    }
     /**
      * Manually compact the session context.
      * Aborts current agent operation first.
      * @param customInstructions Optional instructions for the compaction summary
      */
     async compact(customInstructions) {
-        this._disconnectFromAgent();
-        await this.abort();
-        this._compactionAbortController = new AbortController();
-        this._emit({ type: "compaction_start", reason: "manual" });
+        const admission = this._claimPendingCompactionAdmission();
+        const controller = admission.controller;
+        let outcome = "failed";
+        let disconnected = false;
         try {
-            const execution = await this._executeCompaction({ reason: "manual", customInstructions, willRetry: false });
+            // Keep the session subscriber attached until the aborted run emits
+            // agent_end. That event clears the active-run and retry state that
+            // waitForIdle() depends on.
+            await this._abortActiveAgentAndRetry();
+            this._disconnectFromAgent();
+            disconnected = true;
+            this._emit({ type: "compaction_start", reason: "manual" });
+            const execution = await this._executeCompaction({
+                controller,
+                owner: "compaction",
+                reason: "manual",
+                customInstructions,
+                willRetry: false,
+            });
             if (!execution.accepted) {
                 throw new CompactionRejectedError(execution.rejectionCause);
             }
+            outcome = "completed";
             return execution.result;
         }
         catch (error) {
+            outcome = isCompactionExecutionAborted(error) ? "aborted" : "failed";
             if (error instanceof CompactionRejectedError) {
                 throw new Error(error.message);
             }
+            if (!compactionExecutionOwnsTerminalTransition(error)) {
+                throw error;
+            }
             const message = error instanceof Error ? error.message : String(error);
-            const aborted = message === "Compaction cancelled" || (error instanceof Error && error.name === "AbortError");
+            const aborted = isCompactionExecutionAborted(error);
             this._emit({
                 type: "compaction_end",
                 reason: "manual",
@@ -2043,21 +2639,34 @@ export class AgentSession {
             throw error;
         }
         finally {
-            this._compactionAbortController = undefined;
-            this._reconnectToAgent();
+            if (this._compactionAbortController === controller && this._compactionLifecycle.state.status !== "running") {
+                this._compactionAbortController = undefined;
+            }
+            this._releasePendingCompactionAdmission(admission, outcome);
+            if (disconnected && !this.isCompacting)
+                this._reconnectToAgent();
         }
     }
     async applyCompaction(precomputed, options) {
+        if (options.signal !== undefined && options.signal !== this._compactionAbortController?.signal) {
+            return { applied: false, reason: "stale" };
+        }
         if (options.expectedRevision !== undefined && options.expectedRevision !== this._messageRevision) {
             return { applied: false, reason: "stale" };
         }
         const ownsController = this._compactionAbortController === undefined;
         if (ownsController) {
-            this._compactionAbortController = new AbortController();
+            this._claimCompactionController(new AbortController(), "compaction");
             this._emit({ type: "compaction_start", reason: options.reason });
         }
+        const controller = this._compactionAbortController;
+        if (!controller)
+            return { applied: false, reason: "rejected" };
+        this._claimCompactionController(controller, "compaction");
         try {
             const execution = await this._executeCompaction({
+                controller,
+                owner: "compaction",
                 reason: options.reason,
                 willRetry: false,
                 precomputed,
@@ -2068,8 +2677,11 @@ export class AgentSession {
             return { applied: true, reason: "ok" };
         }
         catch (error) {
+            if (!compactionExecutionOwnsTerminalTransition(error)) {
+                return { applied: false, reason: "rejected" };
+            }
             const message = error instanceof Error ? error.message : String(error);
-            const aborted = message === "Compaction cancelled" || (error instanceof Error && error.name === "AbortError");
+            const aborted = isCompactionExecutionAborted(error);
             this._emit({
                 type: "compaction_end",
                 reason: options.reason,
@@ -2081,18 +2693,27 @@ export class AgentSession {
             return { applied: false, reason: "rejected" };
         }
         finally {
-            this._compactionAbortController = undefined;
+            if (this._compactionAbortController === controller && this._compactionLifecycle.state.status !== "running") {
+                this._compactionAbortController = undefined;
+            }
         }
     }
     _beginExtensionCompactionFeedback(reason) {
-        if (!this._compactionAbortController) {
-            this._compactionAbortController = new AbortController();
-            this._emit({ type: "compaction_start", reason });
-        }
-        return this._compactionAbortController.signal;
+        const controller = new AbortController();
+        this._claimCompactionController(controller, "compaction");
+        const model = this.model;
+        this._compactionLifecycle.begin({
+            operationId: randomUUID(),
+            stage: "feedback",
+            reason,
+            model: model ? { provider: model.provider, id: model.id } : undefined,
+            startedRevision: this._messageRevision,
+        }, controller);
+        this._emit({ type: "compaction_start", reason });
+        return controller.signal;
     }
     _updateExtensionCompactionFeedback(options) {
-        if (!this._compactionAbortController && !this._autoCompactionAbortController)
+        if (!options.signal || !this._compactionLifecycle.hasCurrentSignal(options.signal))
             return;
         this._emit({
             type: "compaction_progress",
@@ -2102,10 +2723,24 @@ export class AgentSession {
         });
     }
     _endExtensionCompactionFeedback(options) {
-        const controller = this._compactionAbortController;
-        if (!controller)
+        if (!options.signal)
+            return;
+        if (!this._compactionLifecycle.hasCurrentSignal(options.signal)) {
+            this._releaseCompactionController(options.signal);
             return;
-        const aborted = options.aborted ?? controller.signal.aborted;
+        }
+        const operation = this._compactionLifecycle.state;
+        if (operation.status !== "running" || operation.stage !== "feedback")
+            return;
+        const aborted = options.aborted ?? options.signal.aborted;
+        this._compactionLifecycle.finish({
+            operationId: operation.operationId,
+            status: aborted ? "aborted" : "failed",
+            endedRevision: this._messageRevision,
+            ...(aborted
+                ? { errorMessage: "Compaction cancelled" }
+                : { errorMessage: options.errorMessage ?? "Compaction did not apply" }),
+        });
         this._emit({
             type: "compaction_end",
             reason: options.reason,
@@ -2114,26 +2749,41 @@ export class AgentSession {
             willRetry: false,
             errorMessage: aborted ? undefined : options.errorMessage,
         });
-        this._compactionAbortController = undefined;
+        this._releaseCompactionController(options.signal);
     }
     async _executeCompaction(request) {
+        const model = this.model;
+        if (!model)
+            throw new Error(formatNoModelSelectedMessage());
+        const thinkingLevel = this.thinkingLevel;
+        const controller = request.controller;
+        // Async auth and provider preparation may yield to a newer route. A stale
+        // controller must never promote itself into a lifecycle generation.
+        if (!this._ownsCompactionController(controller, request.owner)) {
+            throw new CompactionExecutionError(new CompactionCancelledError(), false, true);
+        }
+        const requestId = randomUUID();
+        const operationId = this._compactionLifecycle.begin({
+            operationId: requestId,
+            stage: "execution",
+            reason: request.reason,
+            model: { provider: model.provider, id: model.id },
+            startedRevision: this._messageRevision,
+        }, controller);
         const finishCompactionWork = this._sessionWorkBarrier.begin();
         const agentMessagesAtStart = request.agentMessagesAtStart ?? this.agent.state.messages.slice();
+        const compactionOwnedDiagnosticMessages = new Set();
+        const signal = controller.signal;
         try {
-            if (!this.model) {
-                throw new Error(formatNoModelSelectedMessage());
+            if (signal.aborted) {
+                throw new CompactionCancelledError();
             }
-            const requestId = randomUUID();
             const pathEntries = this.sessionManager.getBranch();
             const settings = this.settingsManager.getCompactionSettings();
-            const signal = this._compactionAbortController?.signal ?? this._autoCompactionAbortController?.signal;
-            if (!signal) {
-                throw new Error("Compaction abort controller unavailable");
-            }
             let compactionResult = request.precomputed;
             let fromExtension = request.precomputed !== undefined;
             if (!compactionResult) {
-                const preparation = prepareCompaction(pathEntries, settings);
+                const preparation = prepareCompaction(pathEntries, settings, request.reason === "overflow", request.allowSummaryOnly);
                 if (!preparation) {
                     const lastEntry = pathEntries[pathEntries.length - 1];
                     if (lastEntry?.type === "compaction") {
@@ -2142,6 +2792,7 @@ export class AgentSession {
                     throw new Error("Nothing to compact (session too small)");
                 }
                 if (this._extensionRunner.hasHandlers("session_before_compact")) {
+                    const messagesBeforeExtension = new Set(this.agent.state.messages);
                     const extensionResult = (await this._extensionRunner.emit({
                         type: "session_before_compact",
                         reason: request.reason,
@@ -2152,8 +2803,17 @@ export class AgentSession {
                         customInstructions: request.customInstructions,
                         signal,
                     }));
+                    for (const message of this.agent.state.messages) {
+                        if (!messagesBeforeExtension.has(message) &&
+                            isCompactionOwnedPreCompactDiagnostic(message, requestId)) {
+                            compactionOwnedDiagnosticMessages.add(message);
+                        }
+                    }
+                    if (!this._compactionLifecycle.isCurrent(operationId, controller)) {
+                        throw new CompactionCancelledError();
+                    }
                     if (extensionResult?.cancel) {
-                        return await this._rejectCompaction(request, requestId, extensionResult.rejectionCause ?? "cancelled-by-extension", true, extensionResult.reason);
+                        return await this._rejectCompaction(request, requestId, operationId, extensionResult.rejectionCause ?? "cancelled-by-extension", true, extensionResult.reason);
                     }
                     if (extensionResult?.compaction) {
                         compactionResult = extensionResult.compaction;
@@ -2161,17 +2821,38 @@ export class AgentSession {
                     }
                 }
                 if (!compactionResult) {
-                    const { apiKey, headers, extraBody, env } = await this._getCompactionRequestAuth(this.model);
-                    compactionResult = await compact(preparation, this.model, apiKey, headers, request.customInstructions, signal, extraBody, this.thinkingLevel, this.agent.streamFn, env, this.agent.transformContext);
+                    const { apiKey, headers, extraBody, env } = await this._getCompactionRequestAuth(model);
+                    compactionResult = await compact(preparation, model, apiKey, headers, request.customInstructions, signal, extraBody, thinkingLevel, this.agent.streamFunction, env, this.agent.transformContext, this.settingsManager.getRetrySettings(), this._summarizationRetryCallbacks({ source: "compaction", reason: request.reason }));
                 }
             }
             if (signal.aborted) {
-                throw new Error("Compaction cancelled");
+                throw new CompactionCancelledError();
+            }
+            if (!this._compactionLifecycle.isCurrent(operationId, controller)) {
+                throw new CompactionCancelledError();
             }
-            if (this._wouldCompactionOverflow(pathEntries, compactionResult, fromExtension)) {
-                return await this._rejectCompaction(request, requestId, "would-overflow", false);
+            const lifecycleState = this._compactionLifecycle.state;
+            const currentMessagesAtCheck = this.agent.state.messages;
+            const startPrefixIntact = agentMessagesAtStart.every((message, index) => currentMessagesAtCheck[index] === message);
+            // Appends after the start snapshot are fresh only while they are exact
+            // message_end identities still awaiting persistence. Any revision change,
+            // other append, replacement, or reorder still makes this compaction stale.
+            const onlyPendingPersistenceAppends = startPrefixIntact &&
+                currentMessagesAtCheck
+                    .slice(agentMessagesAtStart.length)
+                    .every((message) => this._messageEndsAwaitingPersistence.has(message) ||
+                    compactionOwnedDiagnosticMessages.has(message));
+            const sourceChanged = lifecycleState.status !== "running" ||
+                lifecycleState.operationId !== operationId ||
+                lifecycleState.startedRevision + compactionOwnedDiagnosticMessages.size !== this._messageRevision ||
+                !onlyPendingPersistenceAppends;
+            if (sourceChanged) {
+                return await this._rejectCompaction(request, requestId, operationId, "stale-revision", false);
             }
-            const compactionEntryId = this.sessionManager.appendCompaction(compactionResult.summary, compactionResult.firstKeptEntryId, compactionResult.tokensBefore, compactionResult.details, fromExtension);
+            if (this._wouldCompactionOverflow(pathEntries, compactionResult, fromExtension, model)) {
+                return await this._rejectCompaction(request, requestId, operationId, "would-overflow", false);
+            }
+            const compactionEntryId = this.sessionManager.appendCompaction(compactionResult.summary, compactionResult.firstKeptEntryId, compactionResult.tokensBefore, compactionResult.details, fromExtension, compactionResult.usage);
             const savedEntry = this.sessionManager.getEntry(compactionEntryId);
             if (savedEntry?.type !== "compaction") {
                 throw new Error("Compaction entry was not saved");
@@ -2182,18 +2863,33 @@ export class AgentSession {
             const messagesAppendedDuringCompaction = hasUnchangedPrefix
                 ? currentAgentMessages.slice(agentMessagesAtStart.length)
                 : [];
-            this.agent.state.messages = [...sessionContext.messages, ...messagesAppendedDuringCompaction];
+            // Preserve an identity-deduped, agent-ordered union of the append-during-
+            // compaction suffix and exact messages still awaiting persistence. Their
+            // queued message_end owns exactly-once persistence, so they are kept in
+            // agent state only and never persisted here.
+            const preservedIdentities = new Set(messagesAppendedDuringCompaction);
+            for (const message of currentAgentMessages) {
+                if (this._messageEndsAwaitingPersistence.has(message)) {
+                    preservedIdentities.add(message);
+                }
+            }
+            const preservedPendingMessages = currentAgentMessages.filter((message) => preservedIdentities.delete(message));
+            this._skipNextPostCompactionAssistantCheck = true;
+            for (const message of preservedPendingMessages) {
+                if (message.role === "assistant") {
+                    this._assistantsPendingAtCompaction.add(message);
+                }
+            }
+            this.agent.state.messages = [...sessionContext.messages, ...preservedPendingMessages];
             compactionResult.estimatedTokensAfter = estimateMessagesTokens(sessionContext.messages);
             this._incrementMessageRevision();
-            await this._extensionRunner.emit({
-                type: "session_compact",
-                reason: request.reason,
-                requestId,
-                accepted: true,
-                compactionEntry: savedEntry,
-                fromExtension,
-                willRetry: request.willRetry,
-            });
+            if (!this._compactionLifecycle.finish({
+                operationId,
+                status: "completed",
+                endedRevision: this._messageRevision,
+            })) {
+                throw new CompactionCancelledError();
+            }
             this._emit({
                 type: "compaction_end",
                 reason: request.reason,
@@ -2203,15 +2899,41 @@ export class AgentSession {
                 requestId,
                 accepted: true,
             });
+            await this._extensionRunner.emit({
+                type: "session_compact",
+                reason: request.reason,
+                requestId,
+                accepted: true,
+                compactionEntry: savedEntry,
+                fromExtension,
+                willRetry: request.willRetry,
+            });
             return { accepted: true, requestId, result: compactionResult, compactionEntry: savedEntry, fromExtension };
         }
+        catch (error) {
+            if (error instanceof CompactionExecutionError) {
+                throw error;
+            }
+            const lifecycleState = this._compactionLifecycle.state;
+            const ownsTerminalTransition = lifecycleState.status !== "idle" && lifecycleState.operationId === operationId;
+            const aborted = signal.aborted || isCompactionExecutionAborted(error);
+            if (ownsTerminalTransition && lifecycleState.status === "running") {
+                this._compactionLifecycle.finish({
+                    operationId,
+                    status: aborted ? "aborted" : "failed",
+                    endedRevision: this._messageRevision,
+                    errorMessage: error instanceof Error ? error.message : String(error),
+                });
+            }
+            throw new CompactionExecutionError(error, ownsTerminalTransition, aborted);
+        }
         finally {
             finishCompactionWork();
         }
     }
-    _wouldCompactionOverflow(pathEntries, compactionResult, fromExtension) {
+    _wouldCompactionOverflow(pathEntries, compactionResult, fromExtension, model) {
         const currentLeaf = pathEntries[pathEntries.length - 1];
-        if (!currentLeaf || !this.model)
+        if (!currentLeaf)
             return false;
         const simulatedCompactionEntry = {
             type: "compaction",
@@ -2227,9 +2949,28 @@ export class AgentSession {
         const simulatedMessages = buildSessionContext([...pathEntries, simulatedCompactionEntry], simulatedCompactionEntry.id).messages;
         const contextTokens = estimateMessagesTokens(filterContextExcludedMessages(simulatedMessages));
         const settings = this.settingsManager.getCompactionSettings();
-        return contextTokens > this.model.contextWindow - settings.reserveTokens;
+        return contextTokens > model.contextWindow - settings.reserveTokens;
+    }
+    /**
+     * Replaces agent state with the canonical session context while keeping exact
+     * message objects whose message_end persistence is still queued. Identities
+     * already present in the session context are kept from the context only, so
+     * nothing is duplicated; the queued message_end still owns exactly-once
+     * persistence for the rest.
+     */
+    _restoreAgentMessagesFromSession() {
+        const sessionMessages = this.sessionManager.buildSessionContext().messages;
+        const seen = new Set(sessionMessages);
+        const pendingMessages = [];
+        for (const message of this.agent.state.messages) {
+            if (seen.has(message) || !this._messageEndsAwaitingPersistence.has(message))
+                continue;
+            seen.add(message);
+            pendingMessages.push(message);
+        }
+        this.agent.state.messages = [...sessionMessages, ...pendingMessages];
     }
-    async _rejectCompaction(request, requestId, rejectionCause, aborted, extensionReason) {
+    async _rejectCompaction(request, requestId, operationId, rejectionCause, aborted, extensionReason) {
         // Per plan Section 1: rejection must never be silent. The compaction_end event
         // carries a non-empty human-readable errorMessage (unless the user aborted, where
         // the aborted branch already renders "Compaction cancelled"). session_compact is
@@ -2241,6 +2982,15 @@ export class AgentSession {
             ? `Compaction rejected: ${trimmedExtensionReason}`
             : describeCompactionRejection(rejectionCause);
         const errorMessage = aborted && !trimmedExtensionReason ? undefined : detailedMessage;
+        if (!this._compactionLifecycle.finish({
+            operationId,
+            status: "failed",
+            endedRevision: this._messageRevision,
+            rejectionCause,
+            ...(trimmedExtensionReason !== undefined ? { errorMessage: trimmedExtensionReason } : {}),
+        })) {
+            throw new CompactionCancelledError();
+        }
         this._emit({
             type: "compaction_end",
             reason: request.reason,
@@ -2267,8 +3017,19 @@ export class AgentSession {
      * Cancel in-progress compaction (manual or auto).
      */
     abortCompaction() {
+        const feedbackOperation = this._compactionLifecycle.abort(this._messageRevision);
         this._compactionAbortController?.abort();
         this._autoCompactionAbortController?.abort();
+        if (feedbackOperation?.stage === "feedback") {
+            this._compactionAbortController = undefined;
+            this._emit({
+                type: "compaction_end",
+                reason: feedbackOperation.reason,
+                result: undefined,
+                aborted: true,
+                willRetry: false,
+            });
+        }
     }
     /**
      * Cancel in-progress branch summarization.
@@ -2287,7 +3048,80 @@ export class AgentSession {
      * @param assistantMessage The assistant message to check
      * @param skipAbortedCheck If false, include aborted messages (for pre-prompt check). Default: true
      */
-    async _checkCompaction(assistantMessage, skipAbortedCheck = true, inlineReason) {
+    async _enforceCompactionBeforeProvider(assistantMessage, skipAbortedCheck, inlineReason, retryAfterCompaction = false) {
+        const blockedAdmission = this._blockedPostCompactionAssistant;
+        if (blockedAdmission !== undefined &&
+            blockedAdmission.assistant === assistantMessage &&
+            blockedAdmission.revision === this._messageRevision) {
+            throw new RequiredCompactionError();
+        }
+        const settings = this.settingsManager.getCompactionSettings();
+        const model = this.model;
+        const contextTokens = estimateContextTokens(filterContextExcludedMessages(this.sessionManager.buildSessionContext().messages)).tokens;
+        const compacted = assistantMessage
+            ? await this._checkCompaction(assistantMessage, skipAbortedCheck, inlineReason, retryAfterCompaction)
+            : false;
+        if (compacted || (assistantMessage && this._postCompactionUsageExemptAssistants.has(assistantMessage))) {
+            return compacted;
+        }
+        if (!settings.enabled || !model || !shouldCompact(contextTokens, model.contextWindow, settings)) {
+            return false;
+        }
+        const latestCompaction = getLatestCompactionEntry(this.sessionManager.getBranch());
+        const assistantBeforeLatestCompaction = assistantMessage !== undefined && this._isAssistantFromBeforeLatestCompaction(assistantMessage);
+        const hasPostCompactionCustomState = latestCompaction !== null &&
+            this.agent.state.messages.some((message) => message.role === "custom" && message.timestamp >= new Date(latestCompaction.timestamp).getTime());
+        if (assistantBeforeLatestCompaction && !hasPostCompactionCustomState) {
+            return false;
+        }
+        if (assistantBeforeLatestCompaction && assistantMessage) {
+            const compacted = await this._runPrePromptCompaction(assistantMessage, skipAbortedCheck, inlineReason);
+            if (compacted)
+                return true;
+        }
+        throw new RequiredCompactionError();
+    }
+    /**
+     * The normal pre-prompt check only estimates persisted session context. This
+     * final gate also includes turn-local messages which the provider will see:
+     * the current prompt, next-turn custom messages, and before_agent_start
+     * additions. Compaction rewrites only session context, so callers retain and
+     * reapply their already-assembled one-shot additions after it succeeds.
+     */
+    async _enforceFinalProviderAdmission(messages) {
+        // Normal user-only prompts keep the established provider-overflow recovery
+        // path. This final gate closes the separate gap introduced by turn-local
+        // custom additions, which the normal pre-prompt check cannot observe.
+        if (!messages.some((message) => message.role === "custom"))
+            return;
+        const model = this.model;
+        if (!model)
+            return;
+        const settings = this.settingsManager.getCompactionSettings();
+        const isOversized = () => {
+            const providerMessages = filterContextExcludedMessages([...this.agent.state.messages, ...messages]);
+            const estimate = estimateContextTokens(providerMessages);
+            const usageMessage = estimate.lastUsageIndex === null ? undefined : providerMessages[estimate.lastUsageIndex];
+            // Kept assistant usage can describe the pre-compaction request. Once a
+            // compaction boundary exists, fall back to byte-derived message estimates
+            // until a provider response refreshes that usage.
+            const contextTokens = usageMessage?.role === "assistant" && this._isAssistantFromBeforeLatestCompaction(usageMessage)
+                ? estimateMessagesTokens(providerMessages)
+                : estimate.tokens;
+            return contextTokens > model.contextWindow - settings.reserveTokens;
+        };
+        if (!settings.enabled || !isOversized())
+            return;
+        const lastAssistantMessage = this._findLastAssistantMessage();
+        if (!lastAssistantMessage) {
+            throw new RequiredCompactionError();
+        }
+        const compacted = await this._runPrePromptCompaction(lastAssistantMessage, false, "pre_prompt");
+        if (!compacted || isOversized()) {
+            throw new RequiredCompactionError();
+        }
+    }
+    async _checkCompaction(assistantMessage, skipAbortedCheck = true, inlineReason, retryAfterCompaction = false) {
         const settings = this.settingsManager.getCompactionSettings();
         if (!settings.enabled)
             return false;
@@ -2315,10 +3149,26 @@ export class AgentSession {
         const currentContextNeedsCompaction = contextUsage !== undefined &&
             contextUsage.tokens !== null &&
             shouldCompact(contextUsage.tokens, contextUsage.contextWindow, settings);
-        if (isContextOverflow(assistantMessage, contextWindow) && (sameModel || currentContextNeedsCompaction)) {
-            const willRetry = assistantMessage.stopReason !== "stop";
+        const isOverflow = isContextOverflow(assistantMessage, contextWindow) && (sameModel || currentContextNeedsCompaction);
+        if (isOverflow &&
+            assistantMessage.stopReason === "stop" &&
+            this._consumePostCompactionUsageExemption(assistantMessage)) {
+            return false;
+        }
+        if (isOverflow) {
+            this._flushPostCompactionDeferredMessages();
+            const willRetry = retryAfterCompaction || assistantMessage.stopReason !== "stop";
             if (!willRetry) {
-                return await this._runAutoCompaction("overflow", false);
+                const compacted = await this._runAutoCompaction("overflow", false);
+                if (!compacted &&
+                    this._compactionLifecycle.state.status === "failed" &&
+                    getLatestCompactionEntry(this.sessionManager.getBranch()) !== null) {
+                    this._blockedPostCompactionAssistant = {
+                        assistant: assistantMessage,
+                        revision: this._messageRevision,
+                    };
+                }
+                return compacted;
             }
             if (this._overflowRecoveryAttempted) {
                 const errorMessage = "Context overflow recovery failed after one compact-and-retry attempt. Try reducing context or switching to a larger-context model.";
@@ -2339,17 +3189,29 @@ export class AgentSession {
             // Remove the error message from agent state (it IS saved to session for history,
             // but we don't want it in context for the retry)
             const messages = this.agent.state.messages;
+            let removedOverflowAssistant = false;
             if (messages.length > 0 && messages[messages.length - 1].role === "assistant") {
                 this.agent.state.messages = messages.slice(0, -1);
+                removedOverflowAssistant = true;
                 this._incrementMessageRevision();
             }
-            if (inlineReason) {
-                return await this._runPrePromptCompaction(assistantMessage, skipAbortedCheck, "overflow", willRetry);
+            const compacted = inlineReason
+                ? await this._runPrePromptCompaction(assistantMessage, skipAbortedCheck, "overflow", willRetry)
+                : await this._runAutoCompaction("overflow", willRetry);
+            if (!compacted && removedOverflowAssistant) {
+                this._restoreAgentMessagesFromSession();
+                this._incrementMessageRevision();
             }
-            else {
-                return await this._runAutoCompaction("overflow", willRetry);
+            if (!compacted && inlineReason) {
+                throw new RequiredCompactionError();
             }
+            return compacted;
         }
+        // The first ordinary response can carry provider usage calculated before
+        // compaction. Consume that exemption only after proving this is not an
+        // overflow, then retain the decision for later admission re-sampling.
+        if (this._consumePostCompactionUsageExemption(assistantMessage))
+            return false;
         // Case 2: Threshold - context is getting large
         // For error messages or all-zero usage messages, estimate from the last valid response.
         // This ensures sessions that hit persistent API errors (e.g. 529) or malformed zero-usage
@@ -2375,7 +3237,7 @@ export class AgentSession {
                 const usageMsg = messages[estimate.lastUsageIndex];
                 if (compactionEntry &&
                     usageMsg.role === "assistant" &&
-                    usageMsg.timestamp <= new Date(compactionEntry.timestamp).getTime()) {
+                    this._isAssistantFromBeforeLatestCompaction(usageMsg)) {
                     return false;
                 }
                 contextTokens = estimate.tokens;
@@ -2383,35 +3245,53 @@ export class AgentSession {
         }
         if (shouldCompact(contextTokens, contextWindow, settings)) {
             if (inlineReason) {
-                return await this._runPrePromptCompaction(assistantMessage, skipAbortedCheck, inlineReason);
+                return await this._runPrePromptCompaction(assistantMessage, skipAbortedCheck, inlineReason, retryAfterCompaction);
             }
             else {
-                return await this._runAutoCompaction("threshold", false);
+                const compacted = await this._runAutoCompaction("threshold", false);
+                if (!compacted &&
+                    this._compactionLifecycle.state.status === "failed" &&
+                    getLatestCompactionEntry(this.sessionManager.getBranch()) !== null) {
+                    this._blockedPostCompactionAssistant = {
+                        assistant: assistantMessage,
+                        revision: this._messageRevision,
+                    };
+                }
+                return compacted;
             }
         }
         return false;
     }
-    async _runPrePromptCompaction(lastAssistantMessage, skipAbortedCheck, reason = "pre_prompt", willRetry = false) {
+    async _runPrePromptCompaction(lastAssistantMessage, skipAbortedCheck, reason = "pre_prompt", willRetry = false, allowSummaryOnly = false) {
+        const controller = new AbortController();
+        this._claimCompactionController(controller, "compaction");
         this._emit({ type: "compaction_start", reason });
-        this._compactionAbortController = new AbortController();
         try {
             const execution = await this._executeCompaction({
+                controller,
+                owner: "compaction",
                 reason,
                 willRetry,
                 lastAssistantMessage,
                 skipAbortedCheck,
+                allowSummaryOnly,
             });
-            if (!execution.accepted && isContextOverflow(lastAssistantMessage, this.model?.contextWindow ?? 0)) {
+            if (!execution.accepted &&
+                lastAssistantMessage &&
+                isContextOverflow(lastAssistantMessage, this.model?.contextWindow ?? 0)) {
                 this._overflowRecoveryAttempted = false;
             }
             return execution.accepted;
         }
         catch (error) {
-            if (isContextOverflow(lastAssistantMessage, this.model?.contextWindow ?? 0)) {
+            if (!compactionExecutionOwnsTerminalTransition(error)) {
+                return false;
+            }
+            if (lastAssistantMessage && isContextOverflow(lastAssistantMessage, this.model?.contextWindow ?? 0)) {
                 this._overflowRecoveryAttempted = false;
             }
             const errorMessage = error instanceof Error ? error.message : "compaction failed";
-            const aborted = errorMessage === "Compaction cancelled" || (error instanceof Error && error.name === "AbortError");
+            const aborted = isCompactionExecutionAborted(error);
             this._emit({
                 type: "compaction_end",
                 reason,
@@ -2423,12 +3303,44 @@ export class AgentSession {
             return false;
         }
         finally {
-            this._compactionAbortController = undefined;
+            if (this._compactionAbortController === controller && this._compactionLifecycle.state.status !== "running") {
+                this._compactionAbortController = undefined;
+            }
         }
     }
+    async _revalidateScheduledContinuationAdmission() {
+        const model = this.model;
+        const settings = this.settingsManager.getCompactionSettings();
+        if (!model || !settings.enabled)
+            return;
+        const canonicalMessages = filterContextExcludedMessages(this.sessionManager.buildSessionContext().messages);
+        const estimate = estimateContextTokens(canonicalMessages);
+        const usageMessage = estimate.lastUsageIndex === null ? undefined : canonicalMessages[estimate.lastUsageIndex];
+        const contextTokens = usageMessage?.role === "assistant" && this._isAssistantFromBeforeLatestCompaction(usageMessage)
+            ? estimateMessagesTokens(canonicalMessages)
+            : estimate.tokens;
+        if (!shouldCompact(contextTokens, model.contextWindow, settings))
+            return;
+        const compacted = await this._runPrePromptCompaction(this._findLastAssistantMessage(), true, "pre_prompt");
+        if (!compacted)
+            throw new RequiredCompactionError();
+        this._scheduledContinuationRecompacted = true;
+    }
     async _continueAgentAfterCurrentRun() {
         await this.agent.waitForIdle();
-        await this.agent.continue();
+        await this._revalidateScheduledContinuationAdmission();
+        const useQueuedContinuation = this._scheduledContinuationRecompacted;
+        try {
+            if (useQueuedContinuation) {
+                await this.agent.continueWithQueuedMessages();
+            }
+            else {
+                await this.agent.continue();
+            }
+        }
+        finally {
+            this._scheduledContinuationRecompacted = false;
+        }
     }
     _scheduleContinuationAfterCurrentEvent() {
         // Tool hooks wait for queued message persistence, so continue() cannot run inside this event promise.
@@ -2458,49 +3370,53 @@ export class AgentSession {
     async _runAutoCompaction(reason, willRetry) {
         const finishCompactionWork = this._sessionWorkBarrier.begin();
         const agentMessagesAtStart = this.agent.state.messages.slice();
-        this._emit({ type: "compaction_start", reason });
         const autoCompactionController = new AbortController();
-        this._autoCompactionAbortController = autoCompactionController;
+        this._claimCompactionController(autoCompactionController, "auto");
+        const endBeforeExecution = () => {
+            this._emit({ type: "compaction_start", reason });
+            if (reason === "overflow")
+                this._overflowRecoveryAttempted = false;
+            this._emit({
+                type: "compaction_end",
+                reason,
+                result: undefined,
+                aborted: false,
+                willRetry: false,
+            });
+            return false;
+        };
         try {
             if (!this.model) {
-                if (reason === "overflow")
-                    this._overflowRecoveryAttempted = false;
-                this._emit({
-                    type: "compaction_end",
-                    reason,
-                    result: undefined,
-                    aborted: false,
-                    willRetry: false,
-                });
-                return false;
+                return endBeforeExecution();
             }
-            const authResult = await this._modelRuntime.getAuth(this.model);
-            if (this.agent.streamFn === streamSimple && !authResult?.auth.apiKey) {
-                if (reason === "overflow")
-                    this._overflowRecoveryAttempted = false;
-                this._emit({
-                    type: "compaction_end",
-                    reason,
-                    result: undefined,
-                    aborted: false,
-                    willRetry: false,
-                });
-                return false;
+            try {
+                // Resolve once before admission so a pending auth refresh remains a
+                // cancellable boundary. _executeCompaction resolves the policy-specific
+                // auth after extension compaction hooks have had a chance to provide a
+                // summary without credentials.
+                await this._modelRuntime.getAuth(this.model);
             }
-            const preparation = prepareCompaction(this.sessionManager.getBranch(), this.settingsManager.getCompactionSettings());
-            if (!preparation) {
-                if (reason === "overflow")
-                    this._overflowRecoveryAttempted = false;
-                this._emit({
-                    type: "compaction_end",
-                    reason,
-                    result: undefined,
-                    aborted: false,
-                    willRetry: false,
-                });
+            catch {
+                if (!this._ownsCompactionController(autoCompactionController, "auto"))
+                    return false;
+                return endBeforeExecution();
+            }
+            if (!this._ownsCompactionController(autoCompactionController, "auto"))
                 return false;
+            const preparation = prepareCompaction(this.sessionManager.getBranch(), this.settingsManager.getCompactionSettings(), reason === "overflow");
+            if (!preparation) {
+                return endBeforeExecution();
             }
-            const execution = await this._executeCompaction({ reason, willRetry, agentMessagesAtStart });
+            if (!this._ownsCompactionController(autoCompactionController, "auto"))
+                return false;
+            this._emit({ type: "compaction_start", reason });
+            const execution = await this._executeCompaction({
+                controller: autoCompactionController,
+                owner: "auto",
+                reason,
+                willRetry,
+                agentMessagesAtStart,
+            });
             if (!execution.accepted) {
                 if (reason === "overflow")
                     this._overflowRecoveryAttempted = false;
@@ -2530,10 +3446,13 @@ export class AgentSession {
             return false;
         }
         catch (error) {
+            if (!compactionExecutionOwnsTerminalTransition(error)) {
+                return false;
+            }
             if (reason === "overflow")
                 this._overflowRecoveryAttempted = false;
             const errorMessage = error instanceof Error ? error.message : "compaction failed";
-            const aborted = errorMessage === "Compaction cancelled" || (error instanceof Error && error.name === "AbortError");
+            const aborted = isCompactionExecutionAborted(error);
             this._emit({
                 type: "compaction_end",
                 reason,
@@ -2566,27 +3485,39 @@ export class AgentSession {
         return this.settingsManager.getCompactionEnabled();
     }
     async bindExtensions(bindings) {
-        if (bindings.uiContext !== undefined) {
-            this._extensionUIContext = bindings.uiContext;
-        }
-        if (bindings.mode !== undefined) {
-            this._extensionMode = bindings.mode;
-        }
-        if (bindings.commandContextActions !== undefined) {
-            this._extensionCommandContextActions = bindings.commandContextActions;
-        }
-        if (bindings.abortHandler !== undefined) {
-            this._extensionAbortHandler = bindings.abortHandler;
-        }
-        if (bindings.shutdownHandler !== undefined) {
-            this._extensionShutdownHandler = bindings.shutdownHandler;
+        const finishBindingWork = this._sessionWorkBarrier.begin();
+        const bindingPromptReadiness = new Set();
+        this._extensionBindingPromptReadiness = bindingPromptReadiness;
+        try {
+            if (bindings.uiContext !== undefined) {
+                this._extensionUIContext = bindings.uiContext;
+            }
+            if (bindings.mode !== undefined) {
+                this._extensionMode = bindings.mode;
+            }
+            if (bindings.commandContextActions !== undefined) {
+                this._extensionCommandContextActions = bindings.commandContextActions;
+            }
+            if (bindings.abortHandler !== undefined) {
+                this._extensionAbortHandler = bindings.abortHandler;
+            }
+            if (bindings.shutdownHandler !== undefined) {
+                this._extensionShutdownHandler = bindings.shutdownHandler;
+            }
+            if (bindings.onError !== undefined) {
+                this._extensionErrorListener = bindings.onError;
+            }
+            this._applyExtensionBindings(this._extensionRunner);
+            await this._extensionRunner.emit(this._sessionStartEvent);
+            await this.extendResourcesFromExtensions(this._sessionStartEvent.reason === "reload" ? "reload" : "startup");
         }
-        if (bindings.onError !== undefined) {
-            this._extensionErrorListener = bindings.onError;
+        finally {
+            if (this._extensionBindingPromptReadiness === bindingPromptReadiness) {
+                this._extensionBindingPromptReadiness = undefined;
+            }
+            finishBindingWork();
         }
-        this._applyExtensionBindings(this._extensionRunner);
-        await this._extensionRunner.emit(this._sessionStartEvent);
-        await this.extendResourcesFromExtensions(this._sessionStartEvent.reason === "reload" ? "reload" : "startup");
+        await Promise.all(bindingPromptReadiness);
     }
     async extendResourcesFromExtensions(reason) {
         if (!this._extensionRunner.hasHandlers("resources_discover")) {
@@ -2729,7 +3660,7 @@ export class AgentSession {
             getServiceTier: () => this.serviceTier,
             isIdle: () => this.isIdle,
             isProjectTrusted: () => this.settingsManager.isProjectTrusted(),
-            getSignal: () => this.agent.signal,
+            getSignal: () => this._extensionEventSignal ?? this.agent.signal,
             abort: () => {
                 if (this._extensionAbortHandler) {
                     this._extensionAbortHandler();
@@ -2788,27 +3719,39 @@ export class AgentSession {
                 },
             },
             compact: (options) => {
+                const admission = this._claimPendingCompactionAdmission();
+                const controller = admission.controller;
                 void (async () => {
-                    this._disconnectFromAgent();
-                    await this.abort();
-                    this._compactionAbortController = new AbortController();
-                    this._emit({ type: "compaction_start", reason: "extension" });
+                    let outcome = "failed";
+                    let disconnected = false;
                     try {
+                        await this._abortActiveAgentAndRetry();
+                        this._disconnectFromAgent();
+                        disconnected = true;
+                        this._emit({ type: "compaction_start", reason: "extension" });
                         const execution = await this._executeCompaction({
+                            controller,
+                            owner: "compaction",
                             reason: "extension",
                             customInstructions: options?.customInstructions,
                             willRetry: false,
                         });
                         if (execution.accepted) {
+                            outcome = "completed";
                             options?.onComplete?.(execution.result);
                         }
                         else {
+                            outcome = "failed";
                             options?.onError?.(new CompactionRejectedError(execution.rejectionCause));
                         }
                     }
                     catch (error) {
+                        outcome = isCompactionExecutionAborted(error) ? "aborted" : "failed";
+                        if (!compactionExecutionOwnsTerminalTransition(error)) {
+                            return;
+                        }
                         const message = error instanceof Error ? error.message : String(error);
-                        const aborted = message === "Compaction cancelled" || (error instanceof Error && error.name === "AbortError");
+                        const aborted = isCompactionExecutionAborted(error);
                         this._emit({
                             type: "compaction_end",
                             reason: "extension",
@@ -2821,8 +3764,13 @@ export class AgentSession {
                         options?.onError?.(err);
                     }
                     finally {
-                        this._compactionAbortController = undefined;
-                        this._reconnectToAgent();
+                        if (this._compactionAbortController === controller &&
+                            this._compactionLifecycle.state.status !== "running") {
+                            this._compactionAbortController = undefined;
+                        }
+                        this._releasePendingCompactionAdmission(admission, outcome);
+                        if (disconnected && !this.isCompacting)
+                            this._reconnectToAgent();
                     }
                 })();
             },
@@ -3056,15 +4004,43 @@ export class AgentSession {
         }
         return Math.ceil(value);
     }
+    /**
+     * Retry policy + callbacks shared by compaction and branch-summary summarization calls.
+     * Uses the same `settings.retry` budget/backoff as agent-turn retries so a single transient
+     * stream drop no longer fails the whole operation. `source` carries the context
+     * the TUI needs to render the retry and recreate the underlying indicator.
+     */
+    _summarizationRetryCallbacks(source) {
+        return {
+            onRetryScheduled: (attempt, maxAttempts, delayMs, errorMessage) => {
+                this._emit({
+                    type: "summarization_retry_scheduled",
+                    attempt,
+                    maxAttempts,
+                    delayMs,
+                    errorMessage,
+                });
+            },
+            onRetryAttemptStart: () => {
+                this._emit({
+                    type: "summarization_retry_attempt_start",
+                    ...source,
+                });
+            },
+            onRetryFinished: () => {
+                this._emit({ type: "summarization_retry_finished" });
+            },
+        };
+    }
     /**
      * Handle retryable errors with exponential backoff.
-     * @returns true if retry was initiated, false if max retries exceeded or disabled
+     * @returns whether retry continuation started, was blocked by compaction, or was not handled
      */
     async _handleRetryableError(message, options = {}) {
         const settings = this.settingsManager.getRetrySettings();
         if (!settings.enabled) {
             this._resolveRetry();
-            return false;
+            return "not-handled";
         }
         // Retry promise is created synchronously in _handleAgentEvent for agent_end.
         // Keep a defensive fallback here in case a future refactor bypasses that path.
@@ -3082,7 +4058,7 @@ export class AgentSession {
             switchedFallback = await this._retryFallback.tryFallback("hard-error", { errorMessage });
             if (!switchedFallback) {
                 this._resolveRetry();
-                return false;
+                return "not-handled";
             }
             // The fallback starts fresh; the failed model's transient attempts do not carry over.
             this._retryAttempt = 1;
@@ -3092,7 +4068,7 @@ export class AgentSession {
             // same-model retries or the transient over-budget fallback escape hatch.
             if (this._retryAttempt + 1 > settings.maxRetries) {
                 this._resolveRetry();
-                return false;
+                return "not-handled";
             }
             switchedFallback = await this._retryFallback.tryFallback("refusal", {});
             if (!switchedFallback) {
@@ -3101,7 +4077,7 @@ export class AgentSession {
                     this._emit({ type: "retry_fallback_exhausted", chainKey: exhaustedChainKey, lastError: errorMessage });
                 }
                 this._resolveRetry();
-                return false;
+                return "not-handled";
             }
             this._retryAttempt++;
         }
@@ -3133,7 +4109,7 @@ export class AgentSession {
                     });
                     this._retryAttempt = 0;
                     this._resolveRetry();
-                    return false;
+                    return "not-handled";
                 }
             }
         }
@@ -3148,7 +4124,7 @@ export class AgentSession {
             });
             this._retryAttempt = 0;
             this._resolveRetry();
-            return false;
+            return "not-handled";
         }
         if (!switchedFallback) {
             switchedFallback = await this._retryFallback.tryFallback("transient", {
@@ -3189,19 +4165,52 @@ export class AgentSession {
                 finalError: "Retry cancelled",
             });
             this._resolveRetry();
-            return false;
+            return "not-handled";
         }
         this._retryAbortController = undefined;
         // Turn boundary: a suppression that expired during the backoff sleep lets
         // the retry continue on the restored primary instead of the fallback model.
         await this._maybeRestoreFallbackPrimary();
-        // Retry via continue() - use setTimeout to break out of event handler chain
+        // Model fallback (or reversion) can select a smaller context window after
+        // the prior retry checks. Revalidate canonical session context immediately
+        // before the continuation so a rejected compaction never admits that model.
+        const model = this.model;
+        const compactionSettings = this.settingsManager.getCompactionSettings();
+        const contextTokens = estimateContextTokens(filterContextExcludedMessages(this.sessionManager.buildSessionContext().messages)).tokens;
+        if (compactionSettings.enabled &&
+            model &&
+            shouldCompact(contextTokens, model.contextWindow, compactionSettings)) {
+            if (!(await this._runPrePromptCompaction(message, true, "threshold", true, true))) {
+                const attempt = this._retryAttempt;
+                this._retryAttempt = 0;
+                this._emit({
+                    type: "auto_retry_end",
+                    success: false,
+                    attempt,
+                    finalError: new RequiredCompactionError().message,
+                });
+                this._resolveRetry();
+                return "blocked";
+            }
+            this._skipNextPostRetryCompactionCheck = true;
+        }
+        // Retry via the shared continuation path after the event handler chain settles.
+        // Agent core would otherwise drain these queues before the continuation
+        // revalidates its provider admission. The scheduled continuation owns them
+        // until it either starts or reports a terminal admission failure.
+        this.agent.suppressQueuedMessageDrain();
         setTimeout(() => {
-            this.agent.continue().catch(() => {
-                // Retry failed - will be caught by next agent_end
+            void this._continueAgentAfterCurrentRun().catch(async (error) => {
+                const message = error instanceof Error ? error.message : String(error);
+                this._emit({
+                    type: "continuation_error",
+                    errorMessage: `Failed to continue queued messages: ${message}`,
+                });
+                await this._emitAgentSettled();
+                this._resolveRetry();
             });
         }, 0);
-        return true;
+        return "continued";
     }
     /**
      * Cancel in-progress retry.
@@ -3245,6 +4254,7 @@ export class AgentSession {
      * @param command The bash command to execute
      * @param onChunk Optional streaming callback for output
      * @param options.excludeFromContext If true, command output won't be sent to LLM (!! prefix)
+     * @param options.id Optional identifier included in bash execution update events
      * @param options.operations Custom BashOperations for remote execution
      */
     async executeBash(command, onChunk, options) {
@@ -3255,7 +4265,10 @@ export class AgentSession {
         const resolvedCommand = prefix ? `${prefix}\n${command}` : command;
         try {
             const result = await executeBashWithOperations(resolvedCommand, this.sessionManager.getCwd(), options?.operations ?? createLocalBashOperations({ shellPath }), {
-                onChunk,
+                onChunk: (delta) => {
+                    onChunk?.(delta);
+                    this._emit({ type: "bash_execution_update", id: options?.id, delta });
+                },
                 signal: this._bashAbortController.signal,
             });
             this.recordBashResult(command, result, options);
@@ -3413,6 +4426,7 @@ export class AgentSession {
             // Run default summarizer if needed
             let summaryText;
             let summaryDetails;
+            let summaryUsage;
             if (options.summarize && entriesToSummarize.length > 0 && !extensionSummary) {
                 const model = this.model;
                 const { apiKey, headers, extraBody, env } = await this._getCompactionRequestAuth(model);
@@ -3427,7 +4441,9 @@ export class AgentSession {
                     customInstructions,
                     replaceInstructions,
                     reserveTokens: branchSummarySettings.reserveTokens,
-                    streamFn: this.agent.streamFn,
+                    streamFn: this.agent.streamFunction,
+                    retry: this.settingsManager.getRetrySettings(),
+                    callbacks: this._summarizationRetryCallbacks({ source: "branchSummary" }),
                 });
                 if (result.aborted) {
                     return { cancelled: true, aborted: true };
@@ -3436,6 +4452,7 @@ export class AgentSession {
                     throw new Error(result.error);
                 }
                 summaryText = result.summary;
+                summaryUsage = result.usage;
                 summaryDetails = {
                     readFiles: result.readFiles || [],
                     modifiedFiles: result.modifiedFiles || [],
@@ -3444,6 +4461,7 @@ export class AgentSession {
             else if (extensionSummary) {
                 summaryText = extensionSummary.summary;
                 summaryDetails = extensionSummary.details;
+                summaryUsage = extensionSummary.usage;
             }
             // Determine the new leaf position based on target type
             let newLeafId;
@@ -3451,18 +4469,12 @@ export class AgentSession {
             if (targetEntry.type === "message" && targetEntry.message.role === "user") {
                 // User message: leaf = parent (null if root), text goes to editor
                 newLeafId = targetEntry.parentId;
-                editorText = this._extractUserMessageText(targetEntry.message.content);
+                editorText = contentText(targetEntry.message.content, "");
             }
             else if (targetEntry.type === "custom_message") {
                 // Custom message: leaf = parent (null if root), text goes to editor
                 newLeafId = targetEntry.parentId;
-                editorText =
-                    typeof targetEntry.content === "string"
-                        ? targetEntry.content
-                        : targetEntry.content
-                            .filter((c) => c.type === "text")
-                            .map((c) => c.text)
-                            .join("");
+                editorText = contentText(targetEntry.content, "");
             }
             else {
                 // Non-user message: leaf = selected node
@@ -3473,7 +4485,7 @@ export class AgentSession {
             let summaryEntry;
             if (summaryText) {
                 // Create summary at target position (can be null for root)
-                const summaryId = this.sessionManager.branchWithSummary(newLeafId, summaryText, summaryDetails, fromExtension);
+                const summaryId = this.sessionManager.branchWithSummary(newLeafId, summaryText, summaryDetails, fromExtension, summaryUsage);
                 summaryEntry = this.sessionManager.getEntry(summaryId);
                 // Attach label to the summary entry
                 if (label) {
@@ -3492,9 +4504,8 @@ export class AgentSession {
             if (label && !summaryText) {
                 this.sessionManager.appendLabelChange(targetId, label);
             }
-            // Update agent state
-            const sessionContext = this.sessionManager.buildSessionContext();
-            this.agent.state.messages = sessionContext.messages;
+            // Update agent state (preserving exact messages still awaiting persistence)
+            this._restoreAgentMessagesFromSession();
             this._incrementMessageRevision();
             // Emit session_tree event
             await this._extensionRunner.emit({
@@ -3522,24 +4533,13 @@ export class AgentSession {
                 continue;
             if (entry.message.role !== "user")
                 continue;
-            const text = this._extractUserMessageText(entry.message.content);
+            const text = contentText(entry.message.content, "");
             if (text) {
                 result.push({ entryId: entry.id, text });
             }
         }
         return result;
     }
-    _extractUserMessageText(content) {
-        if (typeof content === "string")
-            return content;
-        if (Array.isArray(content)) {
-            return content
-                .filter((c) => c.type === "text")
-                .map((c) => c.text)
-                .join("");
-        }
-        return "";
-    }
     /**
      * Get session statistics. Aggregates over ALL session entries (including
      * history that was compacted away), so token/cost totals reflect what was
@@ -3551,12 +4551,11 @@ export class AgentSession {
         let toolResults = 0;
         let totalMessages = 0;
         let toolCalls = 0;
-        let totalInput = 0;
-        let totalOutput = 0;
-        let totalCacheRead = 0;
-        let totalCacheWrite = 0;
-        let totalCost = 0;
+        const usageTotals = createUsageTotals();
         for (const entry of this.sessionManager.getEntries()) {
+            if ((entry.type === "branch_summary" || entry.type === "compaction") && entry.usage) {
+                addUsageToTotals(usageTotals, entry.usage);
+            }
             if (entry.type !== "message")
                 continue;
             totalMessages++;
@@ -3566,6 +4565,9 @@ export class AgentSession {
             }
             else if (message.role === "toolResult") {
                 toolResults++;
+                if (message.usage) {
+                    addUsageToTotals(usageTotals, message.usage);
+                }
             }
             else if (message.role === "assistant") {
                 assistantMessages++;
@@ -3573,12 +4575,7 @@ export class AgentSession {
                 if (Array.isArray(assistantMsg.content)) {
                     toolCalls += assistantMsg.content.filter((c) => c.type === "toolCall").length;
                 }
-                const usage = assistantMsg.usage;
-                totalInput += usage.input;
-                totalOutput += usage.output;
-                totalCacheRead += usage.cacheRead;
-                totalCacheWrite += usage.cacheWrite;
-                totalCost += usage.cost.total;
+                addUsageToTotals(usageTotals, assistantMsg.usage);
             }
         }
         return {
@@ -3590,13 +4587,13 @@ export class AgentSession {
             toolResults,
             totalMessages,
             tokens: {
-                input: totalInput,
-                output: totalOutput,
-                cacheRead: totalCacheRead,
-                cacheWrite: totalCacheWrite,
-                total: totalInput + totalOutput + totalCacheRead + totalCacheWrite,
+                input: usageTotals.input,
+                output: usageTotals.output,
+                cacheRead: usageTotals.cacheRead,
+                cacheWrite: usageTotals.cacheWrite,
+                total: usageTotals.input + usageTotals.output + usageTotals.cacheRead + usageTotals.cacheWrite,
             },
-            cost: totalCost,
+            cost: usageTotals.cost,
             contextUsage: this.getContextUsage(),
         };
     }