@code-yeongyu/senpi 2026.9.7 → 2026.9.8

package/dist/core/agent-session.js

@@ -43,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";
@@ -1137,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() {
@@ -1386,7 +1411,11 @@ export class AgentSession {
             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);
@@ -1422,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) &&
@@ -4285,6 +4332,9 @@ 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._getCompactionSettings(), model.provider, "manual");
         if (!prepareCompaction(pathEntries, settings)) {
@@ -4842,10 +4892,9 @@ 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._getCompactionSettings();
@@ -4877,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
@@ -4890,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._getCompactionSettings();
-        const reserveTokens = settings.reserveScalingEnabled === false
-            ? settings.reserveTokens
-            : resolveReserveTokens(model.contextWindow, settings.reserveTokens);
+        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
@@ -4945,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.
@@ -4980,7 +5056,7 @@ export class AgentSession {
                     getLatestCompactionEntry(this.sessionManager.getBranch()) !== null) {
                     this._blockedPostCompactionAssistant = {
                         assistant: assistantMessage,
-                        revision: this._messageRevision,
+                        contentTokens: this._blockedAdmissionContentTokens(),
                     };
                 }
                 return compacted;
@@ -5046,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;
@@ -5066,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)) {
@@ -5084,7 +5164,7 @@ export class AgentSession {
                     getLatestCompactionEntry(this.sessionManager.getBranch()) !== null) {
                     this._blockedPostCompactionAssistant = {
                         assistant: assistantMessage,
-                        revision: this._messageRevision,
+                        contentTokens: this._blockedAdmissionContentTokens(),
                     };
                 }
                 return compacted;
@@ -5177,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();
@@ -5675,6 +5771,7 @@ export class AgentSession {
         }, {
             getModel: () => this.model,
             getServiceTier: () => this.serviceTier,
+            getEffectiveServiceTier: () => this.effectiveServiceTier,
             getScopedModels: () => this._scopedModels,
             isIdle: () => this.isIdle,
             getAgentDir: () => this._agentDir,
@@ -6182,6 +6279,14 @@ export class AgentSession {
             !message.content.some((content) => content.type === "toolCall") &&
             this._retryFallback.canTryFallback());
     }
+    _takeNativeToolSearchInjectionFailure() {
+        try {
+            return getToolSearchService().takeNativeInjectionFailure();
+        }
+        catch {
+            return null;
+        }
+    }
     _getProviderRetryDelayMs(errorMessage) {
         const markerMs = parseRetryAfterMsMarker(errorMessage);
         if (markerMs !== undefined)
@@ -6290,6 +6395,7 @@ export class AgentSession {
         const hardErrorFallback = options.hardErrorFallback === true;
         const sameModelRemint = options.sameModelRemint === true;
         let switchedFallback = false;
+        let sameModelNativeRecovery = false;
         let is429TierRouted = false;
         let hintTierDelayMs;
         const tryFallback = async (reason, failure) => {
@@ -6322,25 +6428,38 @@ export class AgentSession {
             }
         }
         else if (hardErrorFallback) {
-            // A non-retryable provider failure must never replay on the same model.
-            // Billing-class failures never recover on this account, so the fallback
-            // switch pins as the session model instead of reverting after the cooldown.
-            const reason = isBillingErrorMessage(errorMessage) ? "billing" : "hard-error";
-            switchedFallback = await tryFallback(reason, { errorMessage });
-            if (!switchedFallback) {
-                const exhaustedChainKey = this._retryFallback.exhaustedChainKey;
-                if (exhaustedChainKey) {
-                    this._emit({
-                        type: "retry_fallback_exhausted",
-                        chainKey: exhaustedChainKey,
-                        lastError: errorMessage,
-                    });
+            // A rejected native tool-search request is recoverable in place: the
+            // adapter is disabled for the session on the 400, so the SAME model can
+            // succeed on the immediate next attempt and the fallback chain must not
+            // demote the user to a weaker model. The pending flag is consumed once,
+            // so a second rejection takes the ordinary hard-error path below.
+            const nativeSearchFailure = this._takeNativeToolSearchInjectionFailure();
+            if (nativeSearchFailure !== null) {
+                sameModelNativeRecovery = true;
+                // The recovery starts fresh, mirroring the fallback branch's attempt bookkeeping.
+                this._retryAttempt = 1;
+            }
+            else {
+                // A non-retryable provider failure must never replay on the same model.
+                // 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 tryFallback(reason, { errorMessage });
+                if (!switchedFallback) {
+                    const exhaustedChainKey = this._retryFallback.exhaustedChainKey;
+                    if (exhaustedChainKey) {
+                        this._emit({
+                            type: "retry_fallback_exhausted",
+                            chainKey: exhaustedChainKey,
+                            lastError: errorMessage,
+                        });
+                    }
+                    this._resolveRetry();
+                    return "not-handled";
                 }
-                this._resolveRetry();
-                return "not-handled";
+                // The fallback starts fresh; the failed model's transient attempts do not carry over.
+                this._retryAttempt = 1;
             }
-            // The fallback starts fresh; the failed model's transient attempts do not carry over.
-            this._retryAttempt = 1;
         }
         else if (isRefusal) {
             // Refusals are only retried through a new chain candidate. They never use
@@ -6635,7 +6754,7 @@ export class AgentSession {
         // stay deterministic; provider-derived hints on the non-429 path remain
         // authoritative and fallback switches stay exact.
         const localExponentialMs = retryBackoffDelayMs(retryProfile.turn.backoff, this._retryAttempt, this._retryRandom());
-        const delayMs = switchedFallback
+        const delayMs = switchedFallback || sameModelNativeRecovery
             ? 0
             : is429TierRouted
                 ? (hintTierDelayMs ?? providerDelayMs ?? localExponentialMs)