@code-yeongyu/senpi 2026.8.30 → 2026.9.2

package/dist/core/agent-session.js

@@ -41,6 +41,9 @@ import { buildDynamicSystemPrompt } from "./dynamic-prompt/index.js";
 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 { 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";
 import { getToolSearchService } from "./extensions/builtin/tool-search/service.js";
@@ -62,6 +65,7 @@ import { classifyRateLimitedWait, degradeWithoutFallback, nextInTurnDelayMs, pro
 import { createFallbackLogger } from "./retry-fallback/log.js";
 import { ProbeBackScheduler } from "./retry-fallback/probe-scheduler.js";
 import { validateFallbackChains } from "./retry-fallback/validate.js";
+import { isSessionBusySnapshot, WakeSourceTracker } from "./session-activity.js";
 import { createSessionLogger } from "./session-log.js";
 import { buildSessionContext, CURRENT_SESSION_VERSION, getLatestCompactionEntry, } from "./session-manager.js";
 import { generateSessionTitle, sessionTitleRetryPolicy, shouldSkipSessionTitle } from "./session-title-generator.js";
@@ -488,6 +492,13 @@ export class AgentSession {
         this._pendingCompactionAdmission = undefined;
         this._compactionLifecycle = new CompactionLifecycleCoordinator();
         this._sessionWorkBarrier = new SessionWorkBarrier();
+        /**
+         * Extension-published activity that outlives a turn (background terminal
+         * jobs, terminal monitors, loop-guard holds). Counts persist across extension
+         * reloads on purpose: a stale "busy" only delays reclamation, while a lost
+         * one would let the host evict a session still doing work.
+         */
+        this._wakeSources = new WakeSourceTracker();
         this._overflowRecoveryAttempted = false;
         this._compactionSkippedTooSmall = false;
         // A retry continuation immediately follows an accepted compaction. Its first
@@ -2014,9 +2025,31 @@ export class AgentSession {
         this._disconnectFromAgent();
         this._unsubscribeSettingsSource?.();
         this._unsubscribeSettingsSource = undefined;
+        this._unsubscribeWakeSources?.();
+        this._unsubscribeWakeSources = undefined;
         this._eventListeners = [];
         cleanupSessionResources(this.sessionId);
     }
+    /** Live in-session activity signals; see `session-activity.ts` for the contract. */
+    get activitySnapshot() {
+        return {
+            isStreaming: this._isAgentRunActive,
+            isBashRunning: this.isBashRunning,
+            isCompacting: this.isCompacting,
+            hasSessionWork: this._sessionWorkBarrier.hasActiveWork,
+            hasActiveWakeSource: this._wakeSources.hasActive,
+        };
+    }
+    /**
+     * Whether this session owns work that must outlive a teardown decision: an
+     * agent run, bash, compaction, barrier-held session work, or an
+     * extension-published wake source. Occupancy sweeps (the shared RPC host's
+     * idle eviction) MUST consult this rather than individual flags, so a new
+     * activity source is picked up by every call site at once.
+     */
+    get isSessionBusy() {
+        return isSessionBusySnapshot(this.activitySnapshot);
+    }
     // =========================================================================
     // Read-only State Access
     // =========================================================================
@@ -2331,8 +2364,14 @@ export class AgentSession {
         this._baseSystemPrompt = this._rebuildSystemPrompt(validToolNames);
         this.agent.state.systemPrompt = this._systemPromptOverride ?? this._baseSystemPrompt;
         if (activeToolNamesChanged) {
-            this.abortCompaction();
-            this._incrementMessageRevision();
+            // A tool change emitted while extensions are still binding belongs to the
+            // binding itself, not to a mid-session change. The session was already
+            // committed to the client, so cancelling or invalidating work it started
+            // against that session would be spurious.
+            if (this._extensionBindingPromptReadiness === undefined) {
+                this.abortCompaction();
+                this._incrementMessageRevision();
+            }
         }
     }
     /** Whether compaction or branch summarization is currently running */
@@ -3530,6 +3569,43 @@ export class AgentSession {
     async setModel(model) {
         return this._setModel(model, true);
     }
+    assertModelUsable(model = this.model, liveContextTokens = 0) {
+        if (!model || model.contextWindow <= 0)
+            return;
+        const projection = projectModelUsabilityBudget({
+            model,
+            systemPrompt: this.agent.state.systemPrompt,
+            tools: this.agent.state.tools,
+            liveContextTokens,
+            compaction: this.settingsManager.getCompactionSettings(),
+        });
+        if (!projection.usable)
+            throw new ModelUsabilityBudgetError(projection);
+    }
+    _getDownswitchLiveContextTokens(model) {
+        const currentModel = this.model;
+        if (!currentModel)
+            return 0;
+        const compaction = this.settingsManager.getCompactionSettings();
+        const currentBudget = projectModelUsabilityBudget({
+            model: currentModel,
+            systemPrompt: this.agent.state.systemPrompt,
+            tools: this.agent.state.tools,
+            compaction,
+        });
+        const targetBudget = projectModelUsabilityBudget({
+            model,
+            systemPrompt: this.agent.state.systemPrompt,
+            tools: this.agent.state.tools,
+            compaction,
+        });
+        const currentUsableContext = currentBudget.contextWindow - currentBudget.requiredTokens;
+        const targetUsableContext = targetBudget.contextWindow - targetBudget.requiredTokens;
+        if (targetUsableContext >= currentUsableContext)
+            return 0;
+        const fixedPrefixTokens = currentBudget.systemPromptTokens + currentBudget.activeToolSchemaTokens;
+        return Math.max(0, (this.getContextUsage()?.tokens ?? 0) - fixedPrefixTokens);
+    }
     /**
      * Set the model for this session without changing the global model defaults.
      * The selection is still persisted in this session's history.
@@ -3538,6 +3614,7 @@ export class AgentSession {
         return this._setModel(model, false);
     }
     async _setModel(model, updateGlobalDefaults) {
+        this.assertModelUsable(model, this._getDownswitchLiveContextTokens(model));
         if (!(await this._modelRuntime.checkAuth(model.provider))) {
             throw new Error(`No API key for ${model.provider}/${model.id}`);
         }
@@ -3566,6 +3643,17 @@ export class AgentSession {
             console.error("fallback revert failed; cleared fallback state", error);
         }
     }
+    /**
+     * A senpi-owned compaction just rewrote the conversation context: release any
+     * refusal-caused fallback pin (the "same context refuses again" assumption no
+     * longer holds) and, while no run is active, eagerly re-attempt the original
+     * model through the existing revert gate. Billing-caused pins never release.
+     */
+    async _onCompactionContextChanged() {
+        const released = this._retryFallback.notifyCompactionApplied();
+        if (released && !this.isStreaming)
+            await this._maybeRestoreFallbackPrimary();
+    }
     async _switchActiveModel(model, opts) {
         const previousModel = this.model;
         if (opts.invalidateCompaction &&
@@ -3575,6 +3663,7 @@ export class AgentSession {
             this._invalidateCompactionForModelSelection();
         }
         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();
@@ -3606,7 +3695,20 @@ export class AgentSession {
         this._emitServiceTierChangeIfNeeded(previousTier, previousFastMode);
         if (!opts.emitModelSelect)
             return undefined;
-        return await this._emitModelSelect(model, previousModel, opts.modelSelectSource);
+        const previousSystemPrompt = this.agent.state.systemPrompt;
+        try {
+            const systemPromptChange = await this._emitModelSelect(model, previousModel, opts.modelSelectSource);
+            this.assertModelUsable(model, liveContextTokens);
+            return systemPromptChange;
+        }
+        catch (error) {
+            if (previousModel)
+                this.agent.state.model = previousModel;
+            else
+                delete this.agent.state.model;
+            this.agent.state.systemPrompt = previousSystemPrompt;
+            throw error;
+        }
     }
     _applyEphemeralThinkingLevel(level) {
         const previousLevel = this.agent.state.thinkingLevel;
@@ -3643,6 +3745,8 @@ export class AgentSession {
             nextIndex = direction === "forward" ? (currentIndex + 1) % len : (currentIndex - 1 + len) % len;
         }
         const next = favoriteModels[nextIndex];
+        const liveContextTokens = this._getDownswitchLiveContextTokens(next.model);
+        this.assertModelUsable(next.model, liveContextTokens);
         const invalidatesCompaction = this._modelSelectionChangesContext(currentModel, next.model) ||
             currentModel?.provider !== next.model.provider ||
             currentModel?.id !== next.model.id;
@@ -3668,16 +3772,28 @@ export class AgentSession {
             source: "cycle",
         });
         this._emitServiceTierChangeIfNeeded(previousTier, previousFastMode);
-        const systemPromptChange = await this._emitModelSelect(next.model, currentModel, "cycle");
-        const cycleResult = {
-            model: next.model,
-            thinkingLevel: this.thinkingLevel,
-            isScoped: true,
-        };
-        if (systemPromptChange) {
-            cycleResult.systemPromptChange = systemPromptChange;
+        const previousSystemPrompt = this.agent.state.systemPrompt;
+        try {
+            const systemPromptChange = await this._emitModelSelect(next.model, currentModel, "cycle");
+            this.assertModelUsable(next.model, liveContextTokens);
+            const cycleResult = {
+                model: next.model,
+                thinkingLevel: this.thinkingLevel,
+                isScoped: true,
+            };
+            if (systemPromptChange) {
+                cycleResult.systemPromptChange = systemPromptChange;
+            }
+            return cycleResult;
+        }
+        catch (error) {
+            if (currentModel)
+                this.agent.state.model = currentModel;
+            else
+                delete this.agent.state.model;
+            this.agent.state.systemPrompt = previousSystemPrompt;
+            throw error;
         }
-        return cycleResult;
     }
     // =========================================================================
     // Thinking Level Management
@@ -4402,6 +4518,10 @@ export class AgentSession {
                 fromExtension,
                 willRetry: request.willRetry,
             });
+            // Shared success seam: every senpi-owned compaction apply (manual /compact,
+            // extension applyCompaction, pre-prompt and auto compaction) funnels through
+            // here after the compaction entry is appended and the success event emitted.
+            await this._onCompactionContextChanged();
             return {
                 accepted: true,
                 requestId,
@@ -4454,7 +4574,10 @@ export class AgentSession {
         }
         const contextTokens = estimateMessagesTokens(filterContextExcludedMessages(simulatedMessages));
         const settings = this.settingsManager.getCompactionSettings();
-        return contextTokens > model.contextWindow - settings.reserveTokens;
+        const reserveTokens = settings.reserveScalingEnabled === false
+            ? settings.reserveTokens
+            : resolveReserveTokens(model.contextWindow, settings.reserveTokens);
+        return contextTokens > model.contextWindow - reserveTokens;
     }
     /**
      * Replaces agent state with the canonical session context while keeping exact
@@ -4618,6 +4741,9 @@ export class AgentSession {
         if (!model)
             return;
         const settings = this.settingsManager.getCompactionSettings();
+        const reserveTokens = settings.reserveScalingEnabled === false
+            ? settings.reserveTokens
+            : resolveReserveTokens(model.contextWindow, settings.reserveTokens);
         const isOversized = () => {
             const providerMessages = filterContextExcludedMessages([...this.agent.state.messages, ...messages]);
             const estimate = estimateContextTokens(providerMessages);
@@ -4628,7 +4754,7 @@ export class AgentSession {
             const contextTokens = usageMessage?.role === "assistant" && this._isAssistantFromBeforeLatestCompaction(usageMessage)
                 ? estimateMessagesTokens(providerMessages)
                 : estimate.tokens;
-            return contextTokens > model.contextWindow - settings.reserveTokens;
+            return contextTokens > model.contextWindow - reserveTokens;
         };
         if (!settings.enabled || !isOversized())
             return;
@@ -4906,6 +5032,21 @@ export class AgentSession {
         try {
             if (this.agent.state.isStreaming)
                 return "taken-over";
+            // Pre-admission restore point. A senpi-owned compaction that succeeds
+            // while a run is still active releases its refusal pin through
+            // _onCompactionContextChanged() but cannot restore there: model-select
+            // work must stay ordered behind the session-work barrier while the run
+            // owns it. Every post-compaction continuation admission - auto/overflow
+            // compaction recovery, _resumeQueuedMessagesAfterCompaction(), the
+            // agent_end queued continuation and the retry continuation - is scheduled
+            // through _scheduleContinuationAfterCurrentEvent() and funnels here, so
+            // this is the single choke point every such request passes before
+            // reaching the provider. Restoring here (a no-op when nothing is pending)
+            // keeps the guarantee that the very next request after a compaction runs
+            // on the primary, and precedes the admission revalidation below so that
+            // check samples the restored model's context window - the same ordering
+            // the retry-continuation restore uses.
+            await this._maybeRestoreFallbackPrimary();
             await this._revalidateScheduledContinuationAdmission();
             if (this.agent.state.isStreaming)
                 return "taken-over";
@@ -5255,6 +5396,12 @@ export class AgentSession {
         this.agent.state.model = refreshedModel;
     }
     _bindExtensionCore(runner) {
+        // Activity extensions publish about work outliving a turn (background
+        // terminal jobs, monitors, holds) feeds the session-busy contract. Re-bound
+        // per runner; counts survive the swap so a reload cannot make live work
+        // look idle to an occupancy sweep.
+        this._unsubscribeWakeSources?.();
+        this._unsubscribeWakeSources = runner.onBusEvent(WAKE_SOURCE_STATE_EVENT, (data) => this._wakeSources.observe(data));
         const getCommands = () => {
             const extensionCommands = runner.getRegisteredCommands().map((command) => ({
                 name: command.invocationName,