@code-yeongyu/senpi 2026.9.5 → 2026.9.7-2

package/dist/core/agent-session.js

@@ -35,6 +35,7 @@ import { executeBashWithOperations } from "./bash-executor.js";
 import { envValue } from "./brand.js";
 import { calculateContextTokens, collectEntriesForBranchSummary, compact, estimateContextTokens, estimateTokens, generateBranchSummary, prepareCompaction, resolveThresholdContextTokens, shouldCompact, } from "./compaction/index.js";
 import { CompactionLifecycleCoordinator } from "./compaction/lifecycle.js";
+import { isTurnStuckOnContextOverflow } from "./compaction/stuck-overflow.js";
 import { isWarmSummaryAnchorValid } from "./compaction/warm-anchor.js";
 import { DEFAULT_THINKING_LEVEL } from "./defaults.js";
 import { buildDynamicSystemPrompt } from "./dynamic-prompt/index.js";
@@ -42,7 +43,7 @@ import { areExperimentalFeaturesEnabled } from "./experimental.js";
 import { exportSessionToHtml } from "./export-html/index.js";
 import { createToolHtmlRenderer } from "./export-html/tool-renderer.js";
 import { ModelUsabilityBudgetError, projectModelUsabilityBudget, } from "./extensions/builtin/compaction/model-usability-budget.js";
-import { resolveReserveTokens } from "./extensions/builtin/compaction/policy.js";
+import { resolveEffectiveReserveTokens, resolveReserveTokens, shouldTriggerCompaction, } from "./extensions/builtin/compaction/policy.js";
 import { WAKE_SOURCE_STATE_EVENT } from "./extensions/builtin/monitor-state-event.js";
 import { CODEX_RESPONSES_API } from "./extensions/builtin/service-tier.js";
 import { deriveExtensionRegistrationId } from "./extensions/builtin/tool-search/engine/marker.js";
@@ -208,6 +209,8 @@ function removeSkillInvocationTokens(text, tokens) {
     let result = "";
     for (const token of tokens) {
         result += text.slice(cursor, token.start);
+        if (token.position === "inline")
+            result += `[skill: ${token.name}]`;
         cursor = token.end;
         if (token.position === "inline" &&
             (result.endsWith(" ") || result.endsWith("\t")) &&
@@ -755,6 +758,25 @@ export class AgentSession {
             return { model };
         }
     }
+    /**
+     * Resolve the model used for compaction summarization. When the user sets a
+     * `compaction.model` override ("provider/model"), that model is used for the
+     * summarization call instead of the session model — this is what lets an
+     * SDK-owned lane (claude-sdk-oauth) compact on a cheaper/different model.
+     * Any resolution failure (unset, malformed, unknown model) falls back to the
+     * session model so compaction never silently breaks.
+     */
+    _resolveCompactionModel(sessionModel) {
+        const override = this._getCompactionSettings().model;
+        if (!override)
+            return sessionModel;
+        const slash = override.indexOf("/");
+        if (slash <= 0 || slash === override.length - 1)
+            return sessionModel;
+        const provider = override.slice(0, slash);
+        const modelId = override.slice(slash + 1);
+        return this._modelRuntime.getModel(provider, modelId) ?? sessionModel;
+    }
     async _getCompactionRequestAuth(model) {
         const auth = await this._getSummarizationRequestAuth(model);
         return {
@@ -1115,6 +1137,31 @@ export class AgentSession {
     }
     _incrementMessageRevision() {
         this._messageRevision++;
+        // A revision bump alone is not evidence that the rejected context changed:
+        // releasing here let a synthetic bump retry the unchanged oversized context
+        // (#7921 case 6). Release only once the context actually shrank.
+        this._releaseBlockedPostCompactionAdmissionIfReduced();
+    }
+    /** Byte-derived size of the context an admission decision would carry. */
+    _blockedAdmissionContentTokens() {
+        return estimateMessagesTokens(filterContextExcludedMessages(this.agent.state.messages));
+    }
+    /** A compaction that genuinely reduced the context clears the blocked state. */
+    _releaseBlockedPostCompactionAdmissionIfReduced() {
+        const blocked = this._blockedPostCompactionAssistant;
+        if (blocked === undefined)
+            return;
+        if (this._blockedAdmissionContentTokens() < blocked.contentTokens) {
+            this._blockedPostCompactionAssistant = undefined;
+        }
+    }
+    /**
+     * Unconditional release for manual `/compact`, the user's explicit remedy. An
+     * ordinary user prompt is deliberately not a release: it only adds context, so
+     * it cannot make the rejected context admissible, and the pre-prompt gate
+     * already owns its own fail-closed rejection for that route.
+     */
+    _releaseBlockedPostCompactionAdmission() {
         this._blockedPostCompactionAssistant = undefined;
     }
     getMessageRevision() {
@@ -1163,7 +1210,7 @@ export class AgentSession {
             systemPrompt: this.agent.state.systemPrompt,
             tools: this.agent.state.tools,
             liveContextTokens: this._getDownswitchLiveContextTokens(model),
-            compaction: this.settingsManager.getCompactionSettings(),
+            compaction: this._getCompactionSettings(),
         });
         return projection.usable ? undefined : projection;
     }
@@ -1353,13 +1400,22 @@ export class AgentSession {
         const messages = filterContextExcludedMessages(this.agent.state.messages);
         return resolveThresholdContextTokens(directContextTokens, estimateMessagesTokens(messages));
     }
+    /**
+     * `compaction.enabled=false` disables proactive (threshold) compaction only.
+     * A provider-confirmed overflow is an error the session cannot progress past
+     * by any other route, so overflow recovery stays armed regardless (#1422).
+     */
     _getAutoCompactionReason(message) {
-        const settings = this.settingsManager.getCompactionSettings();
-        if (!settings.enabled || message.stopReason === "aborted") {
+        const settings = this._getCompactionSettings();
+        if (message.stopReason === "aborted") {
             return undefined;
         }
         const model = this.model;
-        if (!model || this._isAssistantFromBeforeLatestCompaction(message)) {
+        // Narrowed to the stale usage number itself: pre-boundary provenance does
+        // not exempt a context whose own content already exceeds the policy.
+        if (!model)
+            return undefined;
+        if (this._isAssistantFromBeforeLatestCompaction(message) && !this._exceedsPolicyByContentEstimate()) {
             return undefined;
         }
         const sameModel = isSameOverflowSource(message, model, this._modelRuntime.getCompatibilityRequestConfig(model).upstreamModelId);
@@ -1367,11 +1423,15 @@ export class AgentSession {
         const currentContextNeedsCompaction = contextUsage !== undefined &&
             contextUsage.tokens !== null &&
             shouldCompact(contextUsage.tokens, contextUsage.contextWindow, settings);
-        if (isContextOverflow(message, model.contextWindow) && (sameModel || currentContextNeedsCompaction)) {
-            return "overflow";
+        const isOverflow = (isContextOverflow(message, model.contextWindow) && (sameModel || currentContextNeedsCompaction)) ||
+            this._isCursorPayloadOverflow(message);
+        if (isOverflow) {
+            if (settings.enabled || isTurnStuckOnContextOverflow(message, model.contextWindow))
+                return "overflow";
+            return undefined;
         }
-        if (this._isCursorPayloadOverflow(message)) {
-            return "overflow";
+        if (!settings.enabled) {
+            return undefined;
         }
         let contextTokens;
         const directContextTokens = message.usage ? calculateContextTokens(message.usage) : 0;
@@ -1391,13 +1451,31 @@ export class AgentSession {
                 if (compactionEntry &&
                     usageMessage?.role === "assistant" &&
                     this._isAssistantFromBeforeLatestCompaction(usageMessage)) {
-                    return undefined;
+                    // Drop only the stale usage number; the messages themselves still count.
+                    const contentTokens = estimateMessagesTokens(messages);
+                    return shouldCompact(contentTokens, model.contextWindow, settings) ? "threshold" : undefined;
                 }
             }
             contextTokens = estimate.tokens;
         }
         return shouldCompact(contextTokens, model.contextWindow, settings) ? "threshold" : undefined;
     }
+    /**
+     * Content measured by bytes, ignoring every provider usage number. The
+     * stale-usage exemptions below only claim that a usage figure measured before
+     * the accepted compaction boundary is not evidence of current pressure; they
+     * must not exempt the messages themselves, because fresh post-boundary content
+     * (a large tool result, late steering) is measurable without any usage report
+     * (#7921 case 5).
+     */
+    _exceedsPolicyByContentEstimate() {
+        const model = this.model;
+        if (!model)
+            return false;
+        const settings = this._getCompactionSettings();
+        const contextTokens = estimateMessagesTokens(filterContextExcludedMessages(this.agent.state.messages));
+        return shouldCompact(contextTokens, model.contextWindow, settings);
+    }
     _hasPendingPostCompactionUsageExemption(message) {
         return (this._skipNextPostCompactionAssistantCheck &&
             !this._assistantsPendingAtCompaction.has(message) &&
@@ -3621,7 +3699,7 @@ export class AgentSession {
             systemPrompt: this.agent.state.systemPrompt,
             tools: this.agent.state.tools,
             liveContextTokens,
-            compaction: this.settingsManager.getCompactionSettings(),
+            compaction: this._getCompactionSettings(),
             includeSpeculationLead: options?.includeSpeculationLead,
             admission: options?.admission,
         });
@@ -3632,7 +3710,7 @@ export class AgentSession {
         const currentModel = this.model;
         if (!currentModel)
             return 0;
-        const compaction = this.settingsManager.getCompactionSettings();
+        const compaction = this._getCompactionSettings();
         const currentBudget = projectModelUsabilityBudget({
             model: currentModel,
             systemPrompt: this.agent.state.systemPrompt,
@@ -3711,17 +3789,18 @@ export class AgentSession {
         const thinking = this._getThinkingForModelSwitch(model, opts.ephemeralThinkingLevel);
         const liveContextTokens = this._getDownswitchLiveContextTokens(model);
         this.agent.state.model = model;
-        this.agent.abortServerSideFallback =
-            this.settingsManager.getAbortServerSideFallback() && this._retryFallback.hasConfiguredChain();
-        if (opts.appendSessionEntry) {
-            this.sessionManager.appendModelChange(model.provider, model.id, opts.entryReason, previousModel?.provider, previousModel?.id);
-        }
-        if (opts.persistDefault) {
-            this.settingsManager.setDefaultModelAndProvider(model.provider, model.id);
+        if (!(model.id === "gpt-6-astra" && (model.provider === "openai" || model.provider === "openai-codex"))) {
+            this.agent.state.reasoningBaseline = undefined;
         }
         const scopedMatch = this._scopedModels.find((sm) => modelsAreEqual(sm.model, model));
         const previousTier = this._currentServiceTier;
         const previousFastMode = this.isFastModeActive();
+        const previousThinkingLevel = this.agent.state.thinkingLevel;
+        const previousThinkingSelection = this.agent.state.thinkingSelection;
+        const previousReasoningBaseline = this.agent.state.reasoningBaseline;
+        const previousAbortServerSideFallback = this.agent.abortServerSideFallback;
+        this.agent.abortServerSideFallback =
+            this.settingsManager.getAbortServerSideFallback() && this._retryFallback.hasConfiguredChain();
         this._currentServiceTier = this._resolveServiceTier(model, scopedMatch?.serviceTier);
         if (opts.ephemeralThinkingLevel !== undefined) {
             this._applyEphemeralThinkingLevel(thinking.level);
@@ -3730,21 +3809,25 @@ export class AgentSession {
             this._setThinkingLevel(thinking.level, false, thinking.selection);
         }
         this._emitHighReasoningWarningIfNeeded();
-        // Post-switch: the level reported here is the one actually in force (clamped, or restored
-        // from this model's memory), not the level requested for the previous model.
-        this._emit({
-            type: "model_changed",
-            model,
-            thinkingLevel: this.thinkingLevel,
-            source: opts.modelSelectSource,
-        });
-        this._emitServiceTierChangeIfNeeded(previousTier, previousFastMode);
-        if (!opts.emitModelSelect)
-            return undefined;
         const previousSystemPrompt = this.agent.state.systemPrompt;
         try {
-            const systemPromptChange = await this._emitModelSelect(model, previousModel, opts.modelSelectSource);
+            const systemPromptChange = opts.emitModelSelect
+                ? await this._emitModelSelect(model, previousModel, opts.modelSelectSource)
+                : undefined;
             this.assertModelUsable(model, liveContextTokens);
+            if (opts.appendSessionEntry) {
+                this.sessionManager.appendModelChange(model.provider, model.id, opts.entryReason, previousModel?.provider, previousModel?.id);
+            }
+            if (opts.persistDefault)
+                this.settingsManager.setDefaultModelAndProvider(model.provider, model.id);
+            // Emit only after all admission hooks have accepted the candidate.
+            this._emit({
+                type: "model_changed",
+                model,
+                thinkingLevel: this.thinkingLevel,
+                source: opts.modelSelectSource,
+            });
+            this._emitServiceTierChangeIfNeeded(previousTier, previousFastMode);
             return systemPromptChange;
         }
         catch (error) {
@@ -3753,6 +3836,11 @@ export class AgentSession {
             else
                 delete this.agent.state.model;
             this.agent.state.systemPrompt = previousSystemPrompt;
+            this.agent.state.thinkingLevel = previousThinkingLevel;
+            this.agent.state.thinkingSelection = previousThinkingSelection;
+            this.agent.state.reasoningBaseline = previousReasoningBaseline;
+            this.agent.abortServerSideFallback = previousAbortServerSideFallback;
+            this._currentServiceTier = previousTier;
             throw error;
         }
     }
@@ -3929,6 +4017,14 @@ export class AgentSession {
         }
         if (isChanging || selectionChanged) {
             this.sessionManager.appendThinkingLevelChange(effectiveLevel, effectiveSelection);
+            const model = this.model;
+            if (isChanging &&
+                model?.id === "gpt-6-astra" &&
+                (model.provider === "openai" || model.provider === "openai-codex")) {
+                this.agent.state.reasoningBaseline ??= previousLevel;
+                this.sessionManager.appendConfigurationUpdate(effectiveLevel);
+                this.agent.state.messages = this.sessionManager.buildSessionContext().messages;
+            }
             if (updateGlobalDefault && (this.supportsThinking() || effectiveLevel !== "off")) {
                 this.settingsManager.setDefaultThinkingLevel(effectiveLevel);
             }
@@ -4236,8 +4332,11 @@ export class AgentSession {
         const model = this.model;
         if (!model)
             throw new Error(formatNoModelSelectedMessage());
+        // Manual compaction is the user's explicit remedy for a blocked admission
+        // (#7921 case 6).
+        this._releaseBlockedPostCompactionAdmission();
         const pathEntries = this.sessionManager.getBranch();
-        const settings = cursorOverflowCompactionSettings(this.settingsManager.getCompactionSettings(), model.provider, "manual");
+        const settings = cursorOverflowCompactionSettings(this._getCompactionSettings(), model.provider, "manual");
         if (!prepareCompaction(pathEntries, settings)) {
             const requestId = randomUUID();
             const lastEntry = pathEntries[pathEntries.length - 1];
@@ -4477,7 +4576,7 @@ export class AgentSession {
                 throw new CompactionCancelledError();
             }
             const pathEntries = this.sessionManager.getBranch();
-            const settings = cursorOverflowCompactionSettings(this.settingsManager.getCompactionSettings(), this.model?.provider, request.reason);
+            const settings = cursorOverflowCompactionSettings(this._getCompactionSettings(), this.model?.provider, request.reason);
             let compactionResult = request.precomputed;
             let fromExtension = request.precomputed !== undefined;
             if (!compactionResult) {
@@ -4519,7 +4618,13 @@ export class AgentSession {
                     }
                 }
                 if (!compactionResult) {
-                    const { model: requestModel, apiKey, headers, extraBody, env, } = await this._getCompactionRequestAuth(model);
+                    // A configured compaction.model override redirects only the
+                    // summarization call to that model; every other part of the session
+                    // (lifecycle record, preparation, branch) still tracks the session
+                    // model. Falls back to the session model when the override is unset
+                    // or cannot be resolved.
+                    const compactionModel = this._resolveCompactionModel(model);
+                    const { model: requestModel, apiKey, headers, extraBody, env, } = await this._getCompactionRequestAuth(compactionModel);
                     compactionResult = await this._runDefaultCompaction(preparation, requestModel, apiKey, headers, extraBody, request.customInstructions, signal, env, request.reason);
                 }
             }
@@ -4550,11 +4655,20 @@ export class AgentSession {
             if (await this._wouldCompactionOverflow(pathEntries, compactionResult, fromExtension, model)) {
                 return await this._rejectCompaction(request, requestId, operationId, "would-overflow", false);
             }
+            const latestConfigurationEffort = this.sessionManager
+                .getBranch()
+                .findLast((entry) => entry.type === "configuration_update")?.reasoning.effort;
             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");
             }
+            const modelAfterCompaction = this.model;
+            if (latestConfigurationEffort !== undefined &&
+                modelAfterCompaction?.id === "gpt-6-astra" &&
+                (modelAfterCompaction.provider === "openai" || modelAfterCompaction.provider === "openai-codex")) {
+                this.sessionManager.appendConfigurationUpdate(latestConfigurationEffort);
+            }
             const sessionContext = this.sessionManager.buildSessionContext();
             const currentAgentMessages = this.agent.state.messages;
             const hasUnchangedPrefix = agentMessagesAtStart.every((message, index) => currentAgentMessages[index] === message);
@@ -4665,7 +4779,7 @@ export class AgentSession {
             simulatedMessages = truncateToolResultBodies(simulatedMessages).messages ?? simulatedMessages;
         }
         const contextTokens = estimateMessagesTokens(filterContextExcludedMessages(simulatedMessages));
-        const settings = this.settingsManager.getCompactionSettings();
+        const settings = this._getCompactionSettings();
         const reserveTokens = settings.reserveScalingEnabled === false
             ? settings.reserveTokens
             : resolveReserveTokens(model.contextWindow, settings.reserveTokens);
@@ -4778,13 +4892,12 @@ export class AgentSession {
      * @returns Whether the post-run loop should call `agent.continue()` for overflow recovery or queued messages
      */
     async _enforceCompactionBeforeProvider(assistantMessage, skipAbortedCheck, inlineReason, retryAfterCompaction = false) {
+        this._releaseBlockedPostCompactionAdmissionIfReduced();
         const blockedAdmission = this._blockedPostCompactionAssistant;
-        if (blockedAdmission !== undefined &&
-            blockedAdmission.assistant === assistantMessage &&
-            blockedAdmission.revision === this._messageRevision) {
+        if (blockedAdmission !== undefined && blockedAdmission.assistant === assistantMessage) {
             throw new RequiredCompactionError();
         }
-        const settings = this.settingsManager.getCompactionSettings();
+        const settings = this._getCompactionSettings();
         const model = this.model;
         const contextTokens = estimateContextTokens(filterContextExcludedMessages(this.sessionManager.buildSessionContext().messages)).tokens;
         const compacted = assistantMessage
@@ -4813,12 +4926,28 @@ export class AgentSession {
         }
         throw new RequiredCompactionError();
     }
+    /**
+     * Pending queued input the provider will also carry on this turn. Steering and
+     * follow-up text enqueued after the admission projection was assembled - by a
+     * `before_agent_start` handler, an extension action, or the user racing the
+     * gate - is drained into the same run, so the final gate must measure it
+     * (#7921 case 5).
+     */
+    _pendingQueuedInputMessages() {
+        const timestamp = Date.now();
+        return [...this._steeringMessages, ...this._followUpMessages].map((text) => ({
+            role: "user",
+            content: [{ type: "text", text }],
+            timestamp,
+        }));
+    }
     /**
      * 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.
+     * the current prompt, next-turn custom messages, before_agent_start additions,
+     * and steering or follow-up input queued after that projection was assembled.
+     * Compaction rewrites only session context, so callers retain and reapply
+     * their already-assembled one-shot additions after it succeeds.
      */
     async _enforceFinalProviderAdmission(messages) {
         // User-only prompts are deliberately admitted without this gate: prompt
@@ -4826,18 +4955,24 @@ export class AgentSession {
         // (issues #531/#886), so oversized user prompts rely on threshold
         // compaction — which also samples the local transcript estimate — and on
         // provider-overflow recovery. This gate closes the separate gap opened by
-        // turn-local custom additions, which the pre-prompt check cannot observe.
-        if (!messages.some((message) => message.role === "custom"))
+        // turn-local custom additions and by late queued input, neither of which the
+        // pre-prompt check can observe.
+        const lateQueuedMessages = this._pendingQueuedInputMessages();
+        if (!messages.some((message) => message.role === "custom") && lateQueuedMessages.length === 0)
             return;
         const model = this.model;
         if (!model)
             return;
-        const settings = this.settingsManager.getCompactionSettings();
-        const reserveTokens = settings.reserveScalingEnabled === false
-            ? settings.reserveTokens
-            : resolveReserveTokens(model.contextWindow, settings.reserveTokens);
+        const settings = this._getCompactionSettings();
+        const reserveTokens = resolveEffectiveReserveTokens(model.contextWindow, settings);
         const isOversized = () => {
-            const providerMessages = filterContextExcludedMessages([...this.agent.state.messages, ...messages]);
+            const providerMessages = filterContextExcludedMessages([
+                ...this.agent.state.messages,
+                ...messages,
+                // Re-read the queues on every sample: this closure is evaluated again
+                // after compaction, when more input may have arrived.
+                ...this._pendingQueuedInputMessages(),
+            ]);
             const estimate = estimateContextTokens(providerMessages);
             const usageMessage = estimate.lastUsageIndex === null ? undefined : providerMessages[estimate.lastUsageIndex];
             // Kept assistant usage can describe the pre-compaction request. Once a
@@ -4866,9 +5001,7 @@ export class AgentSession {
         }
     }
     async _checkCompaction(assistantMessage, skipAbortedCheck = true, inlineReason, retryAfterCompaction = false) {
-        const settings = this.settingsManager.getCompactionSettings();
-        if (!settings.enabled)
-            return false;
+        const settings = this._getCompactionSettings();
         // Skip if message was aborted (user cancelled) - unless skipAbortedCheck is false
         if (skipAbortedCheck && assistantMessage.stopReason === "aborted")
             return false;
@@ -4883,7 +5016,12 @@ export class AgentSession {
         // compaction boundary. This prevents a stale pre-compaction usage/error
         // from retriggering compaction on the first prompt after compaction.
         const compactionEntry = getLatestCompactionEntry(this.sessionManager.getBranch());
-        if (this._isAssistantFromBeforeLatestCompaction(assistantMessage)) {
+        // The inline (pre-prompt) caller re-samples the current context itself and
+        // owns the fail-closed rejection, so only the automatic route needs the
+        // narrowed exemption here: fresh post-boundary content still counts even
+        // though this message's own usage predates the boundary (#7921 case 5).
+        if (this._isAssistantFromBeforeLatestCompaction(assistantMessage) &&
+            (inlineReason !== undefined || !this._exceedsPolicyByContentEstimate())) {
             return false;
         }
         // Case 1: Overflow - LLM returned context overflow error.
@@ -4897,6 +5035,9 @@ export class AgentSession {
         const isOverflow = (isContextOverflow(assistantMessage, contextWindow) && (sameModel || currentContextNeedsCompaction)) ||
             recoverableLength ||
             this._isCursorPayloadOverflow(assistantMessage);
+        if (isOverflow && !settings.enabled && !isTurnStuckOnContextOverflow(assistantMessage, contextWindow)) {
+            return false;
+        }
         if (isOverflow &&
             assistantMessage.stopReason === "stop" &&
             this._consumePostCompactionUsageExemption(assistantMessage)) {
@@ -4915,7 +5056,7 @@ export class AgentSession {
                     getLatestCompactionEntry(this.sessionManager.getBranch()) !== null) {
                     this._blockedPostCompactionAssistant = {
                         assistant: assistantMessage,
-                        revision: this._messageRevision,
+                        contentTokens: this._blockedAdmissionContentTokens(),
                     };
                 }
                 return compacted;
@@ -4967,6 +5108,10 @@ export class AgentSession {
             }
             return compacted;
         }
+        // Stuck-overflow recovery above runs regardless of the flag; threshold
+        // compaction below is the proactive path the user switched off (#1422).
+        if (!settings.enabled)
+            return false;
         // 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.
@@ -4977,6 +5122,7 @@ export class AgentSession {
         // This ensures sessions that hit persistent API errors (e.g. 529) or malformed zero-usage
         // responses can still compact and do not reset context accounting.
         let contextTokens;
+        let staleUsageContentTokens;
         if (inlineReason) {
             const messages = filterContextExcludedMessages(this.sessionManager.buildSessionContext().messages);
             contextTokens = estimateContextTokens(messages).tokens;
@@ -4997,10 +5143,13 @@ export class AgentSession {
                     if (compactionEntry &&
                         usageMsg.role === "assistant" &&
                         this._isAssistantFromBeforeLatestCompaction(usageMsg)) {
-                        return false;
+                        // Drop only the stale usage number; the messages themselves still count.
+                        staleUsageContentTokens = estimateMessagesTokens(messages);
+                        if (!shouldCompact(staleUsageContentTokens, contextWindow, settings))
+                            return false;
                     }
                 }
-                contextTokens = estimate.tokens;
+                contextTokens = staleUsageContentTokens ?? estimate.tokens;
             }
         }
         if (shouldCompact(contextTokens, contextWindow, settings)) {
@@ -5015,7 +5164,7 @@ export class AgentSession {
                     getLatestCompactionEntry(this.sessionManager.getBranch()) !== null) {
                     this._blockedPostCompactionAssistant = {
                         assistant: assistantMessage,
-                        revision: this._messageRevision,
+                        contentTokens: this._blockedAdmissionContentTokens(),
                     };
                 }
                 return compacted;
@@ -5099,7 +5248,7 @@ export class AgentSession {
     }
     async _revalidateScheduledContinuationAdmission() {
         const model = this.model;
-        const settings = this.settingsManager.getCompactionSettings();
+        const settings = this._getCompactionSettings();
         if (!model || !settings.enabled)
             return;
         const canonicalMessages = filterContextExcludedMessages(this.sessionManager.buildSessionContext().messages);
@@ -5108,11 +5257,27 @@ export class AgentSession {
         const contextTokens = usageMessage?.role === "assistant" && this._isAssistantFromBeforeLatestCompaction(usageMessage)
             ? estimateMessagesTokens(canonicalMessages)
             : estimate.tokens;
-        if (!shouldCompact(contextTokens, model.contextWindow, settings))
+        // An explicit user prompt passes the proactive policy in the compaction
+        // extension's before_agent_start, which automatic continuations never emit.
+        // Sampling the same predicate here makes both routes compact at the same
+        // usage instead of letting a continuation ride past the threshold up to the
+        // hard valve (#7921 case 4).
+        const atHardLimit = shouldCompact(contextTokens, model.contextWindow, settings);
+        const overProactiveThreshold = shouldTriggerCompaction({
+            tokens: contextTokens,
+            contextWindow: model.contextWindow,
+            percent: model.contextWindow > 0 ? (contextTokens / model.contextWindow) * 100 : 0,
+        }, model.contextWindow, settings);
+        if (!atHardLimit && !overProactiveThreshold)
             return;
         const compacted = await this._runPrePromptCompaction(this._findLastAssistantMessage(), true, "pre_prompt");
         if (!compacted) {
-            if (this._isCompactionOnCooldown() || this._isCompactionDelegated() || this._hasSupersedingCompactionClaim()) {
+            // Proactive pressure alone must never brick an automatic continuation:
+            // only the hard reserve valve stays fail-closed (#531/#886).
+            if (!atHardLimit ||
+                this._isCompactionOnCooldown() ||
+                this._isCompactionDelegated() ||
+                this._hasSupersedingCompactionClaim()) {
                 return;
             }
             throw new RequiredCompactionError();
@@ -5279,7 +5444,7 @@ export class AgentSession {
             }
             if (!this._ownsCompactionController(autoCompactionController, "auto"))
                 return false;
-            const preparation = prepareCompaction(this.sessionManager.getBranch(), cursorOverflowCompactionSettings(this.settingsManager.getCompactionSettings(), this.model?.provider, reason), reason === "overflow");
+            const preparation = prepareCompaction(this.sessionManager.getBranch(), cursorOverflowCompactionSettings(this._getCompactionSettings(), this.model?.provider, reason), reason === "overflow");
             if (!preparation) {
                 return endBeforeExecution();
             }
@@ -5363,12 +5528,21 @@ export class AgentSession {
         }
     }
     /**
-     * Toggle auto-compaction setting.
+     * Toggle auto-compaction for this session only. Persisting the flag is a
+     * settings-editor concern; a session-level command (RPC `set_auto_compaction`,
+     * one thread of a multi-session host) must never rewrite the global setting
+     * for every other session on the machine (#1422).
      */
     setAutoCompactionEnabled(enabled) {
-        this.settingsManager.setCompactionEnabled(enabled);
+        this._autoCompactionSessionOverride = enabled;
         this._emitSessionSettingsChanged();
     }
+    _getCompactionSettings() {
+        const settings = this.settingsManager.getCompactionSettings();
+        if (this._autoCompactionSessionOverride === undefined)
+            return settings;
+        return { ...settings, enabled: this._autoCompactionSessionOverride };
+    }
     _emitSessionSettingsChanged() {
         this._emit({
             type: "session_settings_changed",
@@ -5377,9 +5551,9 @@ export class AgentSession {
             autoCompactionEnabled: this.autoCompactionEnabled,
         });
     }
-    /** Whether auto-compaction is enabled */
+    /** Whether auto-compaction is enabled for this session */
     get autoCompactionEnabled() {
-        return this.settingsManager.getCompactionEnabled();
+        return this._autoCompactionSessionOverride ?? this.settingsManager.getCompactionEnabled();
     }
     async bindExtensions(bindings) {
         const finishBindingWork = this._sessionWorkBarrier.begin();
@@ -5616,7 +5790,7 @@ export class AgentSession {
                 this._extensionShutdownHandler?.();
             },
             getContextUsage: () => this.getContextUsage(),
-            getCompactionSettings: () => this.settingsManager.getCompactionSettings(),
+            getCompactionSettings: () => this._getCompactionSettings(),
             getPromptCacheSafeWaitSeconds: () => this.resolvePromptCacheSafeWaitSeconds(),
             getPromptCacheGoalBackstopMaxSeconds: () => this.settingsManager.getPromptCacheGoalBackstopMaxSeconds(),
             getPromptCacheKeepAliveSettings: () => this.settingsManager.getPromptCacheKeepAliveSettings(),
@@ -6214,6 +6388,18 @@ export class AgentSession {
         let switchedFallback = false;
         let is429TierRouted = false;
         let hintTierDelayMs;
+        const tryFallback = async (reason, failure) => {
+            try {
+                return await this._retryFallback.tryFallback(reason, failure);
+            }
+            catch (error) {
+                if (error instanceof ModelUsabilityBudgetError) {
+                    this._resolveRetry();
+                    return false;
+                }
+                throw error;
+            }
+        };
         if (sameModelRemint) {
             this._retryAttempt++;
             if (this._retryAttempt > retryProfile.turn.maxRetries) {
@@ -6236,9 +6422,7 @@ export class AgentSession {
             // Billing-class failures never recover on this account, so the fallback
             // switch pins as the session model instead of reverting after the cooldown.
             const reason = isBillingErrorMessage(errorMessage) ? "billing" : "hard-error";
-            switchedFallback = await this._retryFallback.tryFallback(reason, {
-                errorMessage,
-            });
+            switchedFallback = await tryFallback(reason, { errorMessage });
             if (!switchedFallback) {
                 const exhaustedChainKey = this._retryFallback.exhaustedChainKey;
                 if (exhaustedChainKey) {
@@ -6271,7 +6455,7 @@ export class AgentSession {
                 this._resolveRetry();
                 return "not-handled";
             }
-            switchedFallback = await this._retryFallback.tryFallback("refusal", {});
+            switchedFallback = await tryFallback("refusal", {});
             if (!switchedFallback) {
                 const exhaustedChainKey = this._retryFallback.exhaustedChainKey;
                 if (exhaustedChainKey) {
@@ -6317,7 +6501,7 @@ export class AgentSession {
                 is429TierRouted = true;
                 this._retryAttempt++;
                 if (this._retryAttempt > retryProfile.turn.maxRetries) {
-                    switchedFallback = await this._retryFallback.tryFallback("transient", {
+                    switchedFallback = await tryFallback("transient", {
                         errorMessage,
                         retryAfterMs: this._getProviderRetryDelayMs(errorMessage),
                     });
@@ -6354,7 +6538,7 @@ export class AgentSession {
                 if (tier === "no-hint-fast-fallback") {
                     // Fall back immediately when a candidate exists; otherwise degrade
                     // to same-model in-turn retries instead of failing the turn.
-                    switchedFallback = await this._retryFallback.tryFallback("transient", { errorMessage });
+                    switchedFallback = await tryFallback("transient", { errorMessage });
                     if (switchedFallback) {
                         this._retryAttempt = 1;
                     }
@@ -6369,7 +6553,7 @@ export class AgentSession {
                     this._retryAttempt++;
                     if (this._retryAttempt > retryProfile.turn.maxRetries) {
                         // Budget exhausted within tier1; fall back.
-                        switchedFallback = await this._retryFallback.tryFallback("transient", {
+                        switchedFallback = await tryFallback("transient", {
                             errorMessage,
                             retryAfterMs: this._getProviderRetryDelayMs(errorMessage),
                         });
@@ -6410,7 +6594,7 @@ export class AgentSession {
                         if (inTurnResult.demoteToProbeBack) {
                             // Cumulative hinted wait exceeded cap; demote to tier2 fallback path.
                             const remainingHintMs = Math.max(0, (this._hintDeadlineMs ?? Date.now()) - Date.now());
-                            switchedFallback = await this._retryFallback.tryFallback("transient", {
+                            switchedFallback = await tryFallback("transient", {
                                 errorMessage,
                                 retryAfterMs: remainingHintMs,
                             });
@@ -6446,7 +6630,7 @@ export class AgentSession {
                 else {
                     // tier2-fallback-probe-back or tier3-fallback-only: immediate fallback.
                     const remainingHintMs = hintMs ?? 0;
-                    switchedFallback = await this._retryFallback.tryFallback("transient", {
+                    switchedFallback = await tryFallback("transient", {
                         errorMessage,
                         retryAfterMs: remainingHintMs,
                     });
@@ -6469,7 +6653,7 @@ export class AgentSession {
                 this._retryAttempt++;
             }
             if (!is429TierRouted && this._retryAttempt > retryProfile.turn.maxRetries) {
-                switchedFallback = await this._retryFallback.tryFallback("transient", {
+                switchedFallback = await tryFallback("transient", {
                     errorMessage,
                     retryAfterMs: this._getProviderRetryDelayMs(errorMessage),
                 });
@@ -6513,7 +6697,7 @@ export class AgentSession {
             // branch above may have already switched on this same error, and hopping again
             // here would skip that candidate's own retry budget.
             if (!switchedFallback) {
-                switchedFallback = await this._retryFallback.tryFallback("transient", {
+                switchedFallback = await tryFallback("transient", {
                     errorMessage,
                     retryAfterMs: providerDelayMs,
                 });
@@ -6595,7 +6779,7 @@ export class AgentSession {
         // 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 compactionSettings = this._getCompactionSettings();
         const contextTokens = estimateContextTokens(filterContextExcludedMessages(this.sessionManager.buildSessionContext().messages)).tokens;
         if (compactionSettings.enabled &&
             model &&