@astralyn/pi 0.84.10 → 0.84.12

package/dist/core/agent-session.js

@@ -15,15 +15,14 @@
 import { readFileSync } from "node:fs";
 import { basename, dirname } from "node:path";
 import { contentText } from "@earendil-works/pi-ai";
-import { clampThinkingLevel, cleanupSessionResources, getSupportedThinkingLevels, isContextOverflow, isRetryableAssistantError, modelsAreEqual, resetApiProviders, streamSimple, } from "@earendil-works/pi-ai/compat";
+import { clampThinkingLevel, cleanupSessionResources, getSupportedThinkingLevels, isContextOverflow, isRecoverableLength, isRetryableAssistantError, modelsAreEqual, resetApiProviders, streamSimple, } from "@earendil-works/pi-ai/compat";
 import { getThemeByName, theme } from "../modes/interactive/theme/theme.js";
 import { stripFrontmatter } from "../utils/frontmatter.js";
 import { sleep } from "../utils/sleep.js";
 import { normalizeToolResultImages } from "../utils/tool-result-images.js";
 import { formatNoApiKeyFoundMessage, formatNoModelSelectedMessage } from "./auth-guidance.js";
 import { executeBashWithOperations } from "./bash-executor.js";
-import { calculateContextTokens, collectEntriesForBranchSummary, compact, estimateContextTokens, generateBranchSummary, prepareCompaction, shouldCompact, } from "./compaction/index.js";
-import { CONTEXT_REMAINS_OVER_COMPACTION_THRESHOLD, CompactionController, estimateMessagesTokens, } from "./compaction-controller.js";
+import { calculateContextTokens, collectEntriesForBranchSummary, compact, estimateContextTokens, estimateTokens, generateBranchSummary, prepareCompaction, shouldCompact, } from "./compaction/index.js";
 import { DEFAULT_THINKING_LEVEL, THINKING_LEVEL_OPTIONS } from "./defaults.js";
 import { exportSessionToHtml } from "./export-html/index.js";
 import { createToolHtmlRenderer } from "./export-html/tool-renderer.js";
@@ -62,6 +61,13 @@ function withoutDeletedHeaders(headers) {
         ? Object.fromEntries(Object.entries(headers).filter((entry) => entry[1] !== null))
         : undefined;
 }
+function estimateMessagesTokens(messages) {
+    let tokens = 0;
+    for (const message of messages) {
+        tokens += estimateTokens(message);
+    }
+    return tokens;
+}
 // ============================================================================
 // Constants
 // ============================================================================
@@ -78,8 +84,12 @@ export class AgentSession {
         this._followUpMessages = [];
         /** Messages queued to be included with the next user prompt as context ("asides"). */
         this._pendingNextTurnMessages = [];
+        /** Context-only custom messages queued during a run, flushed once the current turn's tool results are in. */
+        this._pendingCustomMessages = [];
         // Compaction state
         this._compactionAbortController = undefined;
+        this._autoCompactionAbortController = undefined;
+        this._overflowRecoveryAttempted = false;
         // Branch summarization state
         this._branchSummaryAbortController = undefined;
         // Retry state
@@ -105,7 +115,7 @@ export class AgentSession {
             // When a user message starts, check if it's from either queue and remove it BEFORE emitting
             // This ensures the UI sees the updated queue state
             if (event.type === "message_start" && event.message.role === "user") {
-                this._compaction.resetOverflowRecovery();
+                this._overflowRecoveryAttempted = false;
                 const messageText = contentText(event.message.content, "");
                 if (messageText) {
                     // Check steering queue first
@@ -147,7 +157,7 @@ export class AgentSession {
                     this._lastAssistantMessage = event.message;
                     const assistantMsg = event.message;
                     if (assistantMsg.stopReason !== "error" && assistantMsg.stopReason !== "length") {
-                        this._compaction.resetOverflowRecovery();
+                        this._overflowRecoveryAttempted = false;
                     }
                     // Reset retry counter immediately on successful assistant response
                     // This prevents accumulation across multiple LLM calls within a turn
@@ -161,6 +171,14 @@ export class AgentSession {
                     }
                 }
             }
+            // A turn ends after its assistant message and every tool result has been appended,
+            // so this is the first point in the run where a context-only custom message can be
+            // inserted without landing between a tool call and its result. Flushing after the
+            // extension and listener dispatch above also picks up messages that turn_end
+            // handlers queued.
+            if (event.type === "turn_end") {
+                this._flushPendingCustomMessages();
+            }
         };
         this.agent = config.agent;
         this.sessionManager = config.sessionManager;
@@ -176,20 +194,6 @@ export class AgentSession {
         this._excludedToolNames = config.excludedToolNames ? new Set(config.excludedToolNames) : undefined;
         this._baseToolsOverride = config.baseToolsOverride;
         this._sessionStartEvent = config.sessionStartEvent ?? { type: "session_start", reason: "startup" };
-        this._compaction = new CompactionController({
-            agent: this.agent,
-            sessionManager: this.sessionManager,
-            settingsManager: this.settingsManager,
-            getModel: () => this.model,
-            getThinkingLevel: () => this.thinkingLevel,
-            getExtensionRunner: () => this._extensionRunner,
-            isManualCompactionActive: () => this._compactionAbortController !== undefined,
-            emit: (event) => this._emit(event),
-            emitSessionCompactFailed: (event) => this._emitSessionCompactFailed(event),
-            getRequiredRequestAuth: (model) => this._getRequiredRequestAuth(model),
-            getSummarizationRequestAuth: (model, streamFunction) => this._getSummarizationRequestAuth(model, streamFunction),
-            summarizationRetryCallbacks: (source) => this._summarizationRetryCallbacks(source),
-        });
         // Always subscribe to agent events for internal handling
         // (session persistence, extensions, auto-compaction, retry logic)
         this._unsubscribeAgent = this.agent.subscribe(this._handleAgentEvent);
@@ -232,6 +236,14 @@ export class AgentSession {
         }
         throw new Error(formatNoApiKeyFoundMessage(model.provider));
     }
+    /**
+     * Resolve summarization auth against a caller-supplied stream function.
+     *
+     * Callers that await this while the session stays live must capture
+     * `this.agent.streamFunction` first and pass it in: a model switch during the
+     * await would otherwise select auth for one stream function and generate the
+     * summary with another.
+     */
     async _getSummarizationRequestAuth(model, streamFunction = this.agent.streamFunction) {
         if (streamFunction === streamSimple) {
             return this._getRequiredRequestAuth(model);
@@ -311,35 +323,33 @@ export class AgentSession {
             };
         };
     }
+    async _compactBeforeNextAssistantResponse(context) {
+        const model = this.model;
+        const settings = this.settingsManager.getCompactionSettings();
+        if (!model ||
+            model.contextWindow <= 0 ||
+            !shouldCompact(estimateContextTokens(context.messages).tokens, model.contextWindow, settings)) {
+            return context;
+        }
+        await this._runAutoCompaction("threshold", false);
+        return {
+            ...context,
+            messages: this.agent.state.messages.slice(),
+        };
+    }
     _installAgentNextTurnRefresh() {
         const previousPrepareNextTurnWithContext = this.agent.prepareNextTurnWithContext ??
             (this.agent.prepareNextTurn
                 ? async (_turn, signal) => await this.agent.prepareNextTurn?.(signal)
                 : undefined);
         this.agent.prepareNextTurnWithContext = async (turn, signal) => {
-            const compaction = await this._compaction.maybeCompactBeforeNextToolTurn(turn, signal);
-            if (compaction.stopErrorMessage) {
-                // Agent does not expose the low-level graceful turn-stop hook. Throwing here
-                // exits before queue polling or another provider request; the run records a
-                // normal error/aborted lifecycle instead of risking an oversized context.
-                this._compaction.requestStopAfterTurn();
-                throw new Error(compaction.stopErrorMessage);
-            }
-            const effectiveTurn = compaction.messages === undefined
-                ? turn
-                : {
-                    ...turn,
-                    context: {
-                        ...turn.context,
-                        messages: compaction.messages,
-                    },
-                };
-            const previousSnapshot = await previousPrepareNextTurnWithContext?.(effectiveTurn, signal);
-            const previousContext = previousSnapshot?.context ?? effectiveTurn.context;
+            const context = await this._compactBeforeNextAssistantResponse(turn.context);
+            const previousSnapshot = await previousPrepareNextTurnWithContext?.({ ...turn, context }, signal);
+            const nextContext = previousSnapshot?.context ?? context;
             return {
                 ...previousSnapshot,
                 context: {
-                    ...previousContext,
+                    ...nextContext,
                     systemPrompt: this._systemPromptOverride ?? this._baseSystemPrompt,
                     tools: this.agent.state.tools.slice(),
                 },
@@ -643,7 +653,7 @@ export class AgentSession {
     }
     /** Whether compaction or branch summarization is currently running */
     get isCompacting() {
-        return (this._compaction.isAutoCompacting ||
+        return (this._autoCompactionAbortController !== undefined ||
             this._compactionAbortController !== undefined ||
             this._branchSummaryAbortController !== undefined);
     }
@@ -741,7 +751,6 @@ export class AgentSession {
     // =========================================================================
     async _runAgentPrompt(messages) {
         this._isAgentRunActive = true;
-        this._compaction.noteRunStart();
         try {
             await this.agent.prompt(messages);
             while (await this._handlePostAgentRun()) {
@@ -751,6 +760,7 @@ export class AgentSession {
         finally {
             this._systemPromptOverride = undefined;
             this._flushPendingBashMessages();
+            this._flushPendingCustomMessages();
             await this._emitAgentSettled();
         }
     }
@@ -758,10 +768,6 @@ export class AgentSession {
         const msg = this._lastAssistantMessage;
         this._lastAssistantMessage = undefined;
         if (!msg) {
-            this._compaction.consumeStopAfterTurn();
-            return false;
-        }
-        if (this._compaction.consumeStopAfterTurn()) {
             return false;
         }
         if (this._isRetryableError(msg) && (await this._prepareRetry(msg))) {
@@ -776,12 +782,9 @@ export class AgentSession {
             });
             this._retryAttempt = 0;
         }
-        if (await this._compaction.checkCompaction(msg)) {
+        if (await this._checkCompaction(msg)) {
             return true;
         }
-        if (this._compaction.consumeStopAfterTurn()) {
-            return false;
-        }
         // The agent loop drains both queues before emitting agent_end. Any messages
         // here were queued by agent_end extension handlers and need a continuation.
         return this.agent.hasQueuedMessages();
@@ -847,8 +850,9 @@ export class AgentSession {
                 preflightResult?.(true);
                 return;
             }
-            // Flush any pending bash messages before the new prompt
+            // Flush any pending bash and custom messages before the new prompt
             this._flushPendingBashMessages();
+            this._flushPendingCustomMessages();
             // Validate model
             if (!this.model) {
                 throw new Error(formatNoModelSelectedMessage());
@@ -868,14 +872,7 @@ export class AgentSession {
             // The user's new prompt is sent below, so do not call agent.continue() here.
             const lastAssistant = this._findLastAssistantMessage();
             if (lastAssistant) {
-                await this._compaction.checkCompaction(lastAssistant, false, "prePrompt");
-            }
-            const compactionSettings = this.settingsManager.getCompactionSettings();
-            // A compaction entry can be valid while its retained suffix is still too large.
-            // Refuse the existing context here rather than discovering that via provider overflow.
-            if (compactionSettings.enabled &&
-                shouldCompact(this._compaction.estimateContextTokens(this.agent.state.messages), this.model.contextWindow, compactionSettings)) {
-                throw new Error(CONTEXT_REMAINS_OVER_COMPACTION_THRESHOLD);
+                await this._checkCompaction(lastAssistant, false);
             }
             // Build messages array (custom message if any, then user message)
             messages = [];
@@ -1069,8 +1066,9 @@ export class AgentSession {
     /**
      * Send a custom message to the session. Creates a CustomMessageEntry.
      *
-     * Handles three cases:
+     * Handles four cases:
      * - Streaming: queues message, processed when loop pulls from queue
+     * - Streaming + triggerTurn false: appended to state/session once the current turn ends
      * - Not streaming + triggerTurn: appends to state/session, starts new turn
      * - Not streaming + no trigger: appends to state/session, no turn
      *
@@ -1102,11 +1100,34 @@ export class AgentSession {
         else if (options?.triggerTurn) {
             await this._runAgentPrompt(appMessage);
         }
+        else if (this.isStreaming) {
+            // Appending now would put the message between an assistant tool call and its
+            // result, which providers that validate message order reject on replay. Defer
+            // to the end of the turn. Nothing is emitted yet: message events must not
+            // describe messages the session tree does not contain.
+            this._pendingCustomMessages.push(appMessage);
+        }
         else {
-            this.agent.state.messages.push(appMessage);
-            this.sessionManager.appendCustomMessageEntry(message.customType, message.content, message.display, message.details);
-            this._emit({ type: "message_start", message: appMessage });
-            this._emit({ type: "message_end", message: appMessage });
+            this._appendCustomMessage(appMessage);
+        }
+    }
+    _appendCustomMessage(appMessage) {
+        this.agent.state.messages.push(appMessage);
+        this.sessionManager.appendCustomMessageEntry(appMessage.customType, appMessage.content, appMessage.display, appMessage.details);
+        this._emit({ type: "message_start", message: appMessage });
+        this._emit({ type: "message_end", message: appMessage });
+    }
+    /**
+     * Append custom messages queued while the agent was running.
+     * Called once the current turn's tool results are in agent state and session history.
+     */
+    _flushPendingCustomMessages() {
+        if (this._pendingCustomMessages.length === 0)
+            return;
+        const pending = this._pendingCustomMessages;
+        this._pendingCustomMessages = [];
+        for (const appMessage of pending) {
+            this._appendCustomMessage(appMessage);
         }
     }
     /**
@@ -1139,7 +1160,6 @@ export class AgentSession {
             if (images.length === 0)
                 images = undefined;
         }
-        // Use prompt() with the requested command and template expansion behavior
         await this.prompt(text, {
             expandPromptTemplates: options?.expandPromptTemplates ?? false,
             streamingBehavior: options?.deliverAs,
@@ -1181,7 +1201,6 @@ export class AgentSession {
      */
     async abort() {
         this.abortRetry();
-        this.abortCompaction();
         this.agent.abort();
         await this.waitForIdle();
     }
@@ -1220,6 +1239,7 @@ export class AgentSession {
         this.sessionManager.appendModelChange(model.provider, model.id);
         if (options.persist) {
             this.settingsManager.setDefaultModelAndProvider(model.provider, model.id);
+            this._addPersistedDefaultToNonEmptyScope(model);
         }
         // Apply thinking level for the new model.
         // Per-model thinking level overrides take priority over the global default.
@@ -1227,6 +1247,20 @@ export class AgentSession {
         this.setThinkingLevel(thinkingLevel);
         await this._emitModelSelect(model, previousModel, "set");
     }
+    _addPersistedDefaultToNonEmptyScope(model) {
+        if (this._scopedModels.length === 0)
+            return;
+        if (this._scopedModels.some((scoped) => modelsAreEqual(scoped.model, model)))
+            return;
+        this._scopedModels = [...this._scopedModels, { model }];
+        const enabledModels = this.settingsManager.getEnabledModels();
+        if (!enabledModels?.length)
+            return;
+        const modelReference = `${model.provider}/${model.id}`;
+        if (enabledModels.some((pattern) => pattern.toLowerCase() === modelReference.toLowerCase()))
+            return;
+        this.settingsManager.setEnabledModels([...enabledModels, modelReference]);
+    }
     /**
      * Cycle to next/previous model.
      * Uses scoped models (from --models flag) if available, otherwise all available models.
@@ -1257,6 +1291,7 @@ export class AgentSession {
         this.sessionManager.appendModelChange(next.model.provider, next.model.id);
         if (options.persist) {
             this.settingsManager.setDefaultModelAndProvider(next.model.provider, next.model.id);
+            this._addPersistedDefaultToNonEmptyScope(next.model);
         }
         // Apply thinking level for the new model.
         // - Explicit scoped model thinking level overrides defaults
@@ -1283,6 +1318,7 @@ export class AgentSession {
         this.sessionManager.appendModelChange(nextModel.provider, nextModel.id);
         if (options.persist) {
             this.settingsManager.setDefaultModelAndProvider(nextModel.provider, nextModel.id);
+            this._addPersistedDefaultToNonEmptyScope(nextModel);
         }
         // Apply thinking level for the new model.
         // Model persistence does not implicitly rewrite the global thinking default.
@@ -1390,18 +1426,19 @@ export class AgentSession {
     // =========================================================================
     // Compaction
     // =========================================================================
-    /** Generate Pi's built-in manual compaction summary. */
-    async _runDefaultCompaction(preparation, requestModel, apiKey, headers, customInstructions, signal, env, reason) {
-        return compact(preparation, requestModel, apiKey, headers, customInstructions, signal, this.thinkingLevel, this.agent.streamFunction, env, this.settingsManager.getRetrySettings(), this._summarizationRetryCallbacks({ source: "compaction", reason }), undefined);
+    /** Generate Pi's built-in compaction summary for manual and automatic compaction. */
+    async _runDefaultCompaction(preparation, requestModel, apiKey, headers, customInstructions, signal, env, reason, streamFunction = this.agent.streamFunction) {
+        return compact(preparation, requestModel, apiKey, headers, customInstructions, signal, this.thinkingLevel, streamFunction, env, this.settingsManager.getRetrySettings(), this._summarizationRetryCallbacks({ source: "compaction", reason }), undefined);
     }
     /**
      * Manually compact the session context.
      *
      * This is the manual entry point used by `/compact`, RPC, and extensions. It is
-     * separate from automatic threshold/overflow compaction, which is delegated to
-     * CompactionController. After preparation and the `session_before_compact` hook,
-     * the default manual path calls the lower-level `compact()` function imported
-     * from `./compaction/index.ts`, unless the hook cancels or supplies a custom result.
+     * separate from automatic threshold/overflow compaction, which enters through
+     * `_checkCompaction()` and `_runAutoCompaction()`. After preparation and the
+     * `session_before_compact` hook, both paths call the lower-level `compact()`
+     * function imported from `./compaction/index.ts`, unless the hook cancels or
+     * supplies a custom result.
      *
      * Aborts the current agent operation first. Manual compaction never retries or
      * continues the interrupted agent turn.
@@ -1437,7 +1474,6 @@ export class AgentSession {
                     branchEntries: pathEntries,
                     customInstructions,
                     reason: "manual",
-                    timing: "manual",
                     willRetry: false,
                     signal: this._compactionAbortController.signal,
                 }));
@@ -1540,7 +1576,7 @@ export class AgentSession {
      */
     abortCompaction() {
         this._compactionAbortController?.abort();
-        this._compaction.abort();
+        this._autoCompactionAbortController?.abort();
     }
     /**
      * Cancel in-progress branch summarization.
@@ -1548,6 +1584,291 @@ export class AgentSession {
     abortBranchSummary() {
         this._branchSummaryAbortController?.abort();
     }
+    /**
+     * Dispatch automatic compaction after `agent_end` or before prompt submission.
+     * Manual compaction does not call this method; it enters through `compact()`.
+     *
+     * Automatic cases:
+     * 1. Overflow with retry: a context-overflow error or recoverable length stop;
+     *    remove the failed assistant message, compact, and retry the turn once.
+     * 2. Overflow without retry: a successful response exceeded the configured
+     *    context window; compact but preserve the completed response.
+     * 3. Threshold without retry: valid or estimated context usage crossed the
+     *    configured threshold; compact without retrying the completed response.
+     *
+     * Each case calls `_runAutoCompaction()`. After preparation and the
+     * `session_before_compact` hook, that method calls the lower-level `compact()`
+     * function imported from `./compaction/index.ts`, unless the hook cancels or
+     * supplies a custom result.
+     *
+     * @param assistantMessage The assistant message to check
+     * @param skipAbortedCheck If false, include aborted messages (for pre-prompt check). Default: true
+     * @returns Whether the post-run loop should call `agent.continue()` for overflow recovery or queued messages
+     */
+    async _checkCompaction(assistantMessage, skipAbortedCheck = true) {
+        const settings = this.settingsManager.getCompactionSettings();
+        if (!settings.enabled)
+            return false;
+        // Skip if message was aborted (user cancelled) - unless skipAbortedCheck is false
+        if (skipAbortedCheck && assistantMessage.stopReason === "aborted")
+            return false;
+        const contextWindow = this.model?.contextWindow ?? 0;
+        // Skip overflow check if the message came from a different model.
+        // This handles the case where user switched from a smaller-context model (e.g. opus)
+        // to a larger-context model (e.g. codex) - the overflow error from the old model
+        // shouldn't trigger compaction for the new model.
+        const sameModel = this.model && assistantMessage.provider === this.model.provider && assistantMessage.model === this.model.id;
+        // Skip compaction checks if this assistant message is older than the latest
+        // 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());
+        const assistantIsFromBeforeCompaction = compactionEntry !== null && assistantMessage.timestamp <= new Date(compactionEntry.timestamp).getTime();
+        if (assistantIsFromBeforeCompaction) {
+            return false;
+        }
+        // Automatic cases 1 and 2: context overflow.
+        // A length stop is recoverable when output ended below the model's original desired limit,
+        // independent of the configured context size or any context-clamped provider request limit.
+        const contextOverflow = sameModel && isContextOverflow(assistantMessage, contextWindow);
+        const recoverableLength = sameModel && isRecoverableLength(assistantMessage, this.model?.maxTokens ?? 0);
+        if (contextOverflow || recoverableLength) {
+            const willRetry = assistantMessage.stopReason !== "stop";
+            // Case 2: the response completed successfully. Compact, but do not retry because
+            // agent.continue() cannot continue from a completed assistant response.
+            if (!willRetry) {
+                return await this._runAutoCompaction("overflow", false);
+            }
+            if (this._overflowRecoveryAttempted) {
+                const errorMessage = contextOverflow
+                    ? "Context overflow recovery failed after one compact-and-retry attempt. Try reducing context or switching to a larger-context model."
+                    : "Truncated response recovery failed after one compact-and-retry attempt.";
+                this._emit({
+                    type: "compaction_end",
+                    reason: "overflow",
+                    result: undefined,
+                    aborted: false,
+                    willRetry: false,
+                    errorMessage,
+                });
+                await this._emitSessionCompactFailed({
+                    reason: "overflow",
+                    errorMessage,
+                    aborted: false,
+                    willRetry: false,
+                    fromExtension: false,
+                });
+                return false;
+            }
+            // Case 1: remove the failed or truncated message from agent state, compact, and
+            // retry once. The message remains in session history but is excluded from retry context.
+            this._overflowRecoveryAttempted = true;
+            const messages = this.agent.state.messages;
+            if (messages.length > 0 && messages[messages.length - 1].role === "assistant") {
+                this.agent.state.messages = messages.slice(0, -1);
+            }
+            return await this._runAutoCompaction("overflow", willRetry);
+        }
+        // Case 3: threshold compaction without retry.
+        // For error messages or all-zero usage messages, estimate from the last valid response.
+        // 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;
+        const directContextTokens = assistantMessage.usage ? calculateContextTokens(assistantMessage.usage) : 0;
+        if (assistantMessage.stopReason === "error" || directContextTokens === 0) {
+            const messages = this.agent.state.messages;
+            const estimate = estimateContextTokens(messages);
+            // Without provider usage, estimate.tokens is the pure message-size estimate.
+            // Only usage-backed estimates need the stale pre-compaction check.
+            if (estimate.lastUsageIndex !== null) {
+                // Verify the usage source is post-compaction. Kept pre-compaction messages
+                // have stale usage reflecting the old (larger) context and would falsely
+                // trigger compaction right after one just finished.
+                const usageMsg = messages[estimate.lastUsageIndex];
+                if (compactionEntry &&
+                    usageMsg.role === "assistant" &&
+                    usageMsg.timestamp <= new Date(compactionEntry.timestamp).getTime()) {
+                    return false;
+                }
+            }
+            contextTokens = estimate.tokens;
+        }
+        else {
+            contextTokens = directContextTokens;
+        }
+        if (shouldCompact(contextTokens, contextWindow, settings)) {
+            return await this._runAutoCompaction("threshold", false);
+        }
+        return false;
+    }
+    /**
+     * Execute threshold or overflow compaction. Manual compaction uses
+     * `AgentSession.compact()` instead. Both paths call the lower-level `compact()`
+     * function imported from `./compaction/index.ts` after preparation and extension
+     * interception.
+     *
+     * @param reason Automatic trigger selected by `_checkCompaction()`
+     * @param willRetry Whether to continue the interrupted turn after overflow compaction
+     * @returns Whether the post-run loop should call `agent.continue()`
+     */
+    async _runAutoCompaction(reason, willRetry) {
+        const settings = this.settingsManager.getCompactionSettings();
+        let started = false;
+        let fromExtension = false;
+        try {
+            if (!this.model) {
+                return false;
+            }
+            // Capture before awaiting auth: a model switch during the await would leave the
+            // resolved auth and the summary generator disagreeing about the stream function.
+            const streamFunction = this.agent.streamFunction;
+            const { model: requestModel, apiKey, headers, env, } = await this._getSummarizationRequestAuth(this.model, streamFunction);
+            const pathEntries = this.sessionManager.getBranch();
+            const preparation = prepareCompaction(pathEntries, settings);
+            if (!preparation) {
+                return false;
+            }
+            this._emit({ type: "compaction_start", reason });
+            this._autoCompactionAbortController = new AbortController();
+            started = true;
+            let extensionCompaction;
+            if (this._extensionRunner.hasHandlers("session_before_compact")) {
+                const extensionResult = (await this._extensionRunner.emit({
+                    type: "session_before_compact",
+                    preparation,
+                    branchEntries: pathEntries,
+                    customInstructions: undefined,
+                    reason,
+                    willRetry,
+                    signal: this._autoCompactionAbortController.signal,
+                }));
+                if (extensionResult?.cancel) {
+                    this._emit({
+                        type: "compaction_end",
+                        reason,
+                        result: undefined,
+                        aborted: true,
+                        willRetry: false,
+                    });
+                    await this._emitSessionCompactFailed({
+                        reason,
+                        aborted: true,
+                        willRetry: false,
+                        fromExtension: false,
+                    });
+                    return false;
+                }
+                if (extensionResult?.compaction) {
+                    extensionCompaction = extensionResult.compaction;
+                    fromExtension = true;
+                }
+            }
+            let summary;
+            let firstKeptEntryId;
+            let tokensBefore;
+            let usage;
+            let details;
+            if (extensionCompaction) {
+                // Extension provided compaction content
+                summary = extensionCompaction.summary;
+                firstKeptEntryId = extensionCompaction.firstKeptEntryId;
+                tokensBefore = extensionCompaction.tokensBefore;
+                usage = extensionCompaction.usage;
+                details = extensionCompaction.details;
+            }
+            else {
+                // Shared default summary generator, also used by manual compaction.
+                const compactResult = await this._runDefaultCompaction(preparation, requestModel, apiKey, headers, undefined, this._autoCompactionAbortController.signal, env, reason, streamFunction);
+                summary = compactResult.summary;
+                firstKeptEntryId = compactResult.firstKeptEntryId;
+                tokensBefore = compactResult.tokensBefore;
+                usage = compactResult.usage;
+                details = compactResult.details;
+            }
+            if (this._autoCompactionAbortController.signal.aborted) {
+                this._emit({
+                    type: "compaction_end",
+                    reason,
+                    result: undefined,
+                    aborted: true,
+                    willRetry: false,
+                });
+                await this._emitSessionCompactFailed({
+                    reason,
+                    aborted: true,
+                    willRetry: false,
+                    fromExtension,
+                });
+                return false;
+            }
+            this.sessionManager.appendCompaction(summary, firstKeptEntryId, tokensBefore, details, fromExtension, usage);
+            const newEntries = this.sessionManager.getEntries();
+            const sessionContext = this.sessionManager.buildSessionContext();
+            this.agent.state.messages = sessionContext.messages;
+            const estimatedTokensAfter = estimateMessagesTokens(sessionContext.messages);
+            // Get the saved compaction entry for the extension event
+            const savedCompactionEntry = newEntries.find((e) => e.type === "compaction" && e.summary === summary);
+            if (this._extensionRunner && savedCompactionEntry) {
+                await this._extensionRunner.emit({
+                    type: "session_compact",
+                    compactionEntry: savedCompactionEntry,
+                    fromExtension,
+                    reason,
+                    willRetry,
+                });
+            }
+            const result = {
+                summary,
+                firstKeptEntryId,
+                tokensBefore,
+                estimatedTokensAfter,
+                usage,
+                details,
+            };
+            this._emit({ type: "compaction_end", reason, result, aborted: false, willRetry });
+            if (willRetry) {
+                const messages = this.agent.state.messages;
+                const lastMsg = messages[messages.length - 1];
+                // The overflow response was persisted on message_end before _checkCompaction() removed it
+                // from agent state. Rebuilding state from the new compaction can restore that kept entry,
+                // leaving an assistant as the final message. agent.continue() rejects that state, so remove
+                // the retriable error or truncated-length response again before continuing the interrupted turn.
+                if (lastMsg?.role === "assistant" && (lastMsg.stopReason === "error" || lastMsg.stopReason === "length")) {
+                    this.agent.state.messages = messages.slice(0, -1);
+                }
+                return true;
+            }
+            // Auto-compaction can complete while follow-up/steering/custom messages are waiting.
+            // Continue once so queued messages are delivered.
+            return this.agent.hasQueuedMessages();
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : "compaction failed";
+            if (started) {
+                const formattedErrorMessage = reason === "overflow"
+                    ? `Context overflow recovery failed: ${errorMessage}`
+                    : `Auto-compaction failed: ${errorMessage}`;
+                this._emit({
+                    type: "compaction_end",
+                    reason,
+                    result: undefined,
+                    aborted: false,
+                    willRetry: false,
+                    errorMessage: formattedErrorMessage,
+                });
+                await this._emitSessionCompactFailed({
+                    reason,
+                    errorMessage: formattedErrorMessage,
+                    aborted: false,
+                    willRetry: false,
+                    fromExtension,
+                });
+            }
+            return false;
+        }
+        finally {
+            this._autoCompactionAbortController = undefined;
+        }
+    }
     /**
      * Toggle auto-compaction setting.
      */
@@ -1742,10 +2063,6 @@ export class AgentSession {
             },
             getSystemPrompt: () => this.systemPrompt,
             getSystemPromptOptions: () => this._baseSystemPromptOptions,
-            getShellSettings: () => ({
-                shellPath: this.settingsManager.getShellPath(),
-                commandPrefix: this.settingsManager.getShellCommandPrefix(),
-            }),
         }, {
             registerProvider: (name, config) => {
                 this._modelRuntime.registerProvider(name, config);