@code-yeongyu/senpi 2026.9.6 → 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";
@@ -766,7 +767,7 @@ export class AgentSession {
      * session model so compaction never silently breaks.
      */
     _resolveCompactionModel(sessionModel) {
-        const override = this.settingsManager.getCompactionSettings().model;
+        const override = this._getCompactionSettings().model;
         if (!override)
             return sessionModel;
         const slash = override.indexOf("/");
@@ -1136,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() {
@@ -1184,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;
     }
@@ -1374,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);
@@ -1388,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;
@@ -1412,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) &&
@@ -3642,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,
         });
@@ -3653,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,
@@ -4275,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];
@@ -4516,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) {
@@ -4719,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);
@@ -4832,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
@@ -4867,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
@@ -4880,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
@@ -4920,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;
@@ -4937,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.
@@ -4951,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)) {
@@ -4969,7 +5056,7 @@ export class AgentSession {
                     getLatestCompactionEntry(this.sessionManager.getBranch()) !== null) {
                     this._blockedPostCompactionAssistant = {
                         assistant: assistantMessage,
-                        revision: this._messageRevision,
+                        contentTokens: this._blockedAdmissionContentTokens(),
                     };
                 }
                 return compacted;
@@ -5021,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.
@@ -5031,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;
@@ -5051,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)) {
@@ -5069,7 +5164,7 @@ export class AgentSession {
                     getLatestCompactionEntry(this.sessionManager.getBranch()) !== null) {
                     this._blockedPostCompactionAssistant = {
                         assistant: assistantMessage,
-                        revision: this._messageRevision,
+                        contentTokens: this._blockedAdmissionContentTokens(),
                     };
                 }
                 return compacted;
@@ -5153,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);
@@ -5162,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();
@@ -5333,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();
             }
@@ -5417,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",
@@ -5431,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();
@@ -5670,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(),
@@ -6659,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 &&