@code-yeongyu/senpi 2026.9.5 → 2026.9.7

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";
@@ -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 {
@@ -1163,7 +1185,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,9 +1375,14 @@ 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;
@@ -1367,11 +1394,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;
@@ -3621,7 +3652,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 +3663,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 +3742,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 +3762,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 +3789,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 +3970,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);
             }
@@ -4237,7 +4286,7 @@ export class AgentSession {
         if (!model)
             throw new Error(formatNoModelSelectedMessage());
         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 +4526,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 +4568,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 +4605,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 +4729,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);
@@ -4784,7 +4848,7 @@ export class AgentSession {
             blockedAdmission.revision === this._messageRevision) {
             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
@@ -4832,7 +4896,7 @@ export class AgentSession {
         const model = this.model;
         if (!model)
             return;
-        const settings = this.settingsManager.getCompactionSettings();
+        const settings = this._getCompactionSettings();
         const reserveTokens = settings.reserveScalingEnabled === false
             ? settings.reserveTokens
             : resolveReserveTokens(model.contextWindow, settings.reserveTokens);
@@ -4866,9 +4930,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;
@@ -4897,6 +4959,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)) {
@@ -4967,6 +5032,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.
@@ -5099,7 +5168,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);
@@ -5279,7 +5348,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 +5432,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 +5455,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 +5694,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 +6292,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 +6326,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 +6359,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 +6405,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 +6442,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 +6457,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 +6498,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 +6534,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 +6557,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 +6601,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 +6683,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 &&