@selesai/code 0.13.26 → 0.13.27

package/dist/core/agent-session.js

@@ -14,8 +14,8 @@
  */
 import { existsSync, mkdirSync, readFileSync, writeFileSync } 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 { contentText, getCurrentSystemMessage, retryDelayMs } from "@earendil-works/pi-ai";
+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 { resolvePath } from "../utils/paths.js";
@@ -23,6 +23,7 @@ import { sleep } from "../utils/sleep.js";
 import { normalizeAssistantThinkingTags } from "../utils/thinking-tags.js";
 import { formatNoApiKeyFoundMessage, formatNoModelSelectedMessage } from "./auth-guidance.js";
 import { executeBashWithOperations } from "./bash-executor.js";
+import { generateBugReportSummary } from "./bug-report.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";
@@ -34,7 +35,7 @@ import { ModelRegistry } from "./model-registry.js";
 import { expandPromptTemplate } from "./prompt-templates.js";
 import { CURRENT_SESSION_VERSION, getLatestCompactionEntry } from "./session-manager.js";
 import { createSyntheticSourceInfo } from "./source-info.js";
-import { buildSystemPrompt } from "./system-prompt.js";
+import { buildSystemPrompt, buildSystemPromptSections, diffSystemPromptSections, normalizeBuildSystemPromptOptions, } from "./system-prompt.js";
 import { createLocalBashOperations } from "./tools/bash.js";
 import { createAllToolDefinitions } from "./tools/index.js";
 import { createToolDefinitionFromAgentTool } from "./tools/tool-definition-wrapper.js";
@@ -99,6 +100,7 @@ export class AgentSession {
     _unsubscribeAgent;
     _eventListeners = [];
     _isAgentRunActive = false;
+    _agentRunAbortRequested = false;
     _idleWaitPromise;
     _resolveIdleWait;
     /** Tracks pending steering messages for UI display. Removed when delivered. */
@@ -144,15 +146,15 @@ export class AgentSession {
     _extensionErrorListener;
     _extensionErrorUnsubscriber;
     _modelRuntime;
+    _cacheWarmer;
     // Tool registry for extension getTools/setTools
     _toolRegistry = new Map();
     _toolDefinitions = new Map();
     _toolPromptSnippets = new Map();
     _toolPromptGuidelines = new Map();
-    // Base system prompt (without extension appends) - used to apply fresh appends each turn
-    _baseSystemPrompt = "";
     _baseSystemPromptOptions;
-    _systemPromptOverride;
+    /** Prompt options after before_agent_start mutations for the active run. */
+    _runSystemPromptOptions;
     constructor(config) {
         this.agent = config.agent;
         this.sessionManager = config.sessionManager;
@@ -162,6 +164,10 @@ export class AgentSession {
         this._customTools = config.customTools ?? [];
         this._cwd = config.cwd;
         this._modelRuntime = config.modelRuntime;
+        this._cacheWarmer = config.cacheWarmer;
+        if (this._cacheWarmer) {
+            this._cacheWarmer.onWarmed = (entry) => this._emit({ type: "entry_appended", entry });
+        }
         this._extensionRunnerRef = config.extensionRunnerRef;
         this._initialActiveToolNames = config.initialActiveToolNames;
         this._allowedToolNames = config.allowedToolNames ? new Set(config.allowedToolNames) : undefined;
@@ -173,18 +179,21 @@ export class AgentSession {
         this._unsubscribeAgent = this.agent.subscribe(this._handleAgentEvent);
         this._installAgentToolHooks();
         this._installAgentNextTurnRefresh();
+        this._installAgentForcedPromptProjection();
         this._buildRuntime({
             activeToolNames: this._initialActiveToolNames,
             includeAllExtensionTools: true,
         });
+        if (this._initialActiveToolNames === undefined)
+            this._restoreToolsFromTranscript();
     }
     get modelRuntime() {
         return this._modelRuntime;
     }
-    async _getRequiredRequestAuth(model) {
+    async _getRequiredRequestAuth(model, signal) {
         let result;
         try {
-            result = await this._modelRuntime.getAuth(model);
+            result = await this._modelRuntime.getAuth(model, { signal });
         }
         catch (error) {
             const cause = error instanceof Error ? error.cause : undefined;
@@ -194,7 +203,9 @@ export class AgentSession {
             throw error;
         }
         if (result && (result.auth.apiKey || result.auth.headers)) {
+            const requestModel = result.auth.baseUrl ? { ...model, baseUrl: result.auth.baseUrl } : model;
             return {
+                model: requestModel,
                 apiKey: result.auth.apiKey,
                 headers: withoutDeletedHeaders(result.auth.headers),
                 env: result.env,
@@ -208,18 +219,26 @@ export class AgentSession {
         }
         throw new Error(formatNoApiKeyFoundMessage(model.provider));
     }
-    async _getSummarizationRequestAuth(model) {
+    async _getSummarizationRequestAuth(model, signal) {
         if (this.agent.streamFunction === streamSimple) {
-            return this._getRequiredRequestAuth(model);
+            return this._getRequiredRequestAuth(model, signal);
         }
         try {
-            const result = await this._modelRuntime.getAuth(model);
-            return result
-                ? { apiKey: result.auth.apiKey, headers: withoutDeletedHeaders(result.auth.headers), env: result.env }
-                : {};
+            const result = await this._modelRuntime.getAuth(model, { signal });
+            if (!result)
+                return { model };
+            const requestModel = result.auth.baseUrl ? { ...model, baseUrl: result.auth.baseUrl } : model;
+            return {
+                model: requestModel,
+                apiKey: result.auth.apiKey,
+                headers: withoutDeletedHeaders(result.auth.headers),
+                env: result.env,
+            };
         }
-        catch {
-            return {};
+        catch (error) {
+            if (signal?.aborted)
+                throw error;
+            return { model };
         }
     }
     /**
@@ -280,7 +299,7 @@ export class AgentSession {
     }
     async _compactBeforeNextAssistantResponse(context) {
         const model = this.model;
-        const settings = this.settingsManager.getCompactionSettings();
+        const settings = this.settingsManager.getCompactionSettings(model);
         if (!model ||
             model.contextWindow <= 0 ||
             !shouldCompact(estimateContextTokens(context.messages).tokens, model.contextWindow, settings)) {
@@ -301,13 +320,25 @@ export class AgentSession {
             const context = await this._compactBeforeNextAssistantResponse(turn.context);
             const previousSnapshot = await previousPrepareNextTurnWithContext?.({ ...turn, context }, signal);
             const nextContext = previousSnapshot?.context ?? context;
+            const runOptions = this._runSystemPromptOptions ?? this._baseSystemPromptOptions;
+            const options = normalizeBuildSystemPromptOptions({
+                ...runOptions,
+                selectedTools: this.getActiveToolNames(),
+                toolSnippets: { ...this._baseSystemPromptOptions.toolSnippets, ...runOptions.toolSnippets },
+                toolGuidelines: { ...this._baseSystemPromptOptions.toolGuidelines, ...runOptions.toolGuidelines },
+            });
+            const updateMessage = this._preparePromptAndToolLoadout(options, nextContext.messages);
+            // Keep session.systemPrompt and ctx.getSystemPrompt() in step with what the provider sees.
+            this._runSystemPromptOptions = options;
             return {
                 ...previousSnapshot,
                 context: {
                     ...nextContext,
-                    systemPrompt: this._systemPromptOverride ?? this._baseSystemPrompt,
                     tools: this.agent.state.tools.slice(),
                 },
+                messages: updateMessage
+                    ? [...(previousSnapshot?.messages ?? []), updateMessage]
+                    : previousSnapshot?.messages,
                 model: this.agent.state.model,
                 thinkingLevel: this.agent.state.thinkingLevel,
             };
@@ -352,6 +383,7 @@ export class AgentSession {
         resolve();
     }
     async _emitAgentSettled() {
+        this._cacheWarmer?.onAgentSettled();
         this._isAgentRunActive = false;
         try {
             await this._extensionRunner.emit({ type: "agent_settled" });
@@ -436,7 +468,8 @@ export class AgentSession {
                 // Persist as CustomMessageEntry
                 this.sessionManager.appendCustomMessageEntry(event.message.customType, event.message.content, event.message.display, event.message.details);
             }
-            else if (event.message.role === "user" ||
+            else if (event.message.role === "system" ||
+                event.message.role === "user" ||
                 event.message.role === "assistant" ||
                 event.message.role === "toolResult") {
                 // Regular LLM message - persist as SessionMessageEntry
@@ -447,7 +480,9 @@ export class AgentSession {
             if (event.message.role === "assistant") {
                 this._lastAssistantMessage = event.message;
                 const assistantMsg = event.message;
-                if (assistantMsg.stopReason !== "error") {
+                // A length stop is itself a recovery trigger, so it must not clear the
+                // one-shot overflow-recovery guard before the retry has run.
+                if (assistantMsg.stopReason !== "error" && assistantMsg.stopReason !== "length") {
                     this._overflowRecoveryAttempted = false;
                 }
                 // Reset the length-continuation counter on any non-length stop so the
@@ -477,6 +512,8 @@ export class AgentSession {
         }
     };
     _willRetryAfterAgentEnd(event) {
+        if (this._agentRunAbortRequested)
+            return false;
         const settings = this.settingsManager.getRetrySettings();
         if (!settings.enabled || this._retryAttempt >= settings.maxRetries) {
             return false;
@@ -665,6 +702,10 @@ export class AgentSession {
         this._extensionRunner.invalidate("This extension ctx is stale after session replacement or reload. Do not use a captured pi or command ctx after ctx.newSession(), ctx.fork(), ctx.switchSession(), or ctx.reload(). For newSession, fork, and switchSession, move post-replacement work into withSession and use the ctx passed to withSession. For reload, do not use the old ctx after await ctx.reload().");
         this._disconnectFromAgent();
         this._eventListeners = [];
+        if (this._cacheWarmer) {
+            this._cacheWarmer.onWarmed = undefined;
+            this._cacheWarmer.cancel();
+        }
         cleanupSessionResources(this.sessionId);
     }
     // =========================================================================
@@ -674,6 +715,15 @@ export class AgentSession {
     get state() {
         return this.agent.state;
     }
+    /** Current cache-warming state and the policy inputs that produced it. */
+    get cacheWarmingStatus() {
+        return this._cacheWarmer?.status;
+    }
+    /** Persist the cache-warming mode and immediately reconcile active warming. */
+    setCacheWarmingMode(mode) {
+        this.settingsManager.setCacheWarmingMode(mode);
+        this._cacheWarmer?.onModeChanged();
+    }
     /** Current model (may be undefined if not yet selected) */
     get model() {
         return this.agent.state.model;
@@ -690,9 +740,9 @@ export class AgentSession {
     get isIdle() {
         return !this._isAgentRunActive && !this.isCompacting;
     }
-    /** Current effective system prompt (includes any per-turn extension modifications) */
+    /** Current effective system prompt, including changes not yet sent to the model. */
     get systemPrompt() {
-        return this.agent.state.systemPrompt;
+        return buildSystemPrompt(this._runSystemPromptOptions ?? this._baseSystemPromptOptions);
     }
     /** Current retry attempt (0 if not retrying) */
     get retryAttempt() {
@@ -738,9 +788,7 @@ export class AgentSession {
             }
         }
         this.agent.state.tools = tools;
-        // Rebuild base system prompt with new tool set
-        this._baseSystemPrompt = this._rebuildSystemPrompt(validToolNames);
-        this.agent.state.systemPrompt = this._systemPromptOverride ?? this._baseSystemPrompt;
+        this._rebuildSystemPrompt(validToolNames);
     }
     /** Whether compaction or branch summarization is currently running */
     get isCompacting() {
@@ -809,16 +857,10 @@ export class AgentSession {
     _rebuildSystemPrompt(toolNames) {
         const validToolNames = toolNames.filter((name) => this._toolRegistry.has(name));
         const toolSnippets = {};
-        const promptGuidelines = [];
-        for (const name of validToolNames) {
+        for (const name of this._toolRegistry.keys()) {
             const snippet = this._toolPromptSnippets.get(name);
-            if (snippet) {
+            if (snippet)
                 toolSnippets[name] = snippet;
-            }
-            const toolGuidelines = this._toolPromptGuidelines.get(name);
-            if (toolGuidelines) {
-                promptGuidelines.push(...toolGuidelines);
-            }
         }
         const loaderSystemPrompt = this._resourceLoader.getSystemPrompt();
         const loaderAppendSystemPrompt = this._resourceLoader.getAppendSystemPrompt();
@@ -826,7 +868,7 @@ export class AgentSession {
         const loadedSkills = this._resourceLoader.getPromptSkills();
         const loadedAgents = this._resourceLoader.getAgents().agents;
         const loadedContextFiles = this._resourceLoader.getAgentsFiles().agentsFiles;
-        this._baseSystemPromptOptions = {
+        this._baseSystemPromptOptions = normalizeBuildSystemPromptOptions({
             cwd: this._cwd,
             skills: loadedSkills,
             agents: loadedAgents,
@@ -835,23 +877,87 @@ export class AgentSession {
             appendSystemPrompt,
             selectedTools: validToolNames,
             toolSnippets,
-            promptGuidelines,
+            toolGuidelines: Object.fromEntries(this._toolPromptGuidelines),
+        });
+    }
+    /**
+     * Apply a prompt and tool loadout for the next request. Sets the executable tools and
+     * returns a system message patching the prompt sections the model currently has (replayed
+     * from `messages`), or undefined when the prompt is unchanged. Tool changes are declared by
+     * the agent loop before the request.
+     *
+     * A forced prompt does not affect the transcript: the structured sections are still diffed
+     * and persisted, and the forced text is projected onto the request by
+     * {@link _installAgentForcedPromptProjection}.
+     */
+    _preparePromptAndToolLoadout(options, messages = this.agent.state.messages) {
+        options.selectedTools = [...new Set(options.selectedTools)].filter((name) => this._toolRegistry.has(name));
+        this.agent.state.tools = options.selectedTools.flatMap((name) => {
+            const tool = this._toolRegistry.get(name);
+            return tool ? [tool] : [];
+        });
+        const sections = diffSystemPromptSections(getCurrentSystemMessage(messages)?.sections ?? {}, buildSystemPromptSections(options));
+        return sections ? { role: "system", content: "", sections, timestamp: Date.now() } : undefined;
+    }
+    /**
+     * Send a forced prompt as the provider's leading system prompt without recording it.
+     *
+     * A `before_agent_start` handler that returns `systemPrompt` needs that exact text at the
+     * head of the request; a mid-conversation system message would leave the original prompt
+     * in place. The forced text is a rendering of the current prompt, so the transcript keeps
+     * its structured sections and the request is projected instead: the system messages
+     * collapse into one head holding the forced text and the current tools. Runs after the
+     * `context` extension handlers.
+     */
+    _installAgentForcedPromptProjection() {
+        const previousTransformContext = this.agent.transformContext;
+        this.agent.transformContext = async (messages, signal) => {
+            const transformed = previousTransformContext ? await previousTransformContext(messages, signal) : messages;
+            const forced = this._runSystemPromptOptions?.forceSystemPrompt;
+            if (forced === undefined)
+                return transformed;
+            const current = getCurrentSystemMessage(transformed);
+            const head = {
+                role: "system",
+                content: forced,
+                ...(current?.toolsAdded ? { toolsAdded: current.toolsAdded } : {}),
+                timestamp: current?.timestamp ?? Date.now(),
+            };
+            return [head, ...transformed.filter((message) => message.role !== "system")];
         };
-        return buildSystemPrompt(this._baseSystemPromptOptions);
+    }
+    /** Restore the active tool loadout declared by the session transcript, if it declares one. */
+    _restoreToolsFromTranscript() {
+        const current = getCurrentSystemMessage(this.sessionManager.buildSessionContext().messages);
+        if (!current)
+            return;
+        const toolNames = (current.toolsAdded ?? [])
+            .map((tool) => tool.name)
+            .filter((name) => this._toolRegistry.has(name));
+        this.agent.state.tools = toolNames.flatMap((name) => {
+            const registered = this._toolRegistry.get(name);
+            return registered ? [registered] : [];
+        });
+        this._rebuildSystemPrompt(toolNames);
     }
     // =========================================================================
     // Prompting
     // =========================================================================
     async _runAgentPrompt(messages) {
+        this._agentRunAbortRequested = false;
         this._isAgentRunActive = true;
         try {
             await this.agent.prompt(messages);
             while (await this._handlePostAgentRun()) {
+                if (this._agentRunAbortRequested)
+                    break;
                 await this.agent.continue();
             }
         }
         finally {
-            this._systemPromptOverride = undefined;
+            if (this._agentRunAbortRequested)
+                this._finishCancelledRetry();
+            this._runSystemPromptOptions = undefined;
             this._flushPendingBashMessages();
             this._flushPendingCustomMessages();
             await this._emitAgentSettled();
@@ -860,11 +966,21 @@ export class AgentSession {
     async _handlePostAgentRun() {
         const msg = this._lastAssistantMessage;
         this._lastAssistantMessage = undefined;
+        if (this._agentRunAbortRequested) {
+            this._finishCancelledRetry();
+            return false;
+        }
         if (!msg) {
             return false;
         }
         if (this._isRetryableError(msg) && (await this._prepareRetry(msg))) {
-            return true;
+            if (this._agentRunAbortRequested)
+                this._finishCancelledRetry();
+            return !this._agentRunAbortRequested;
+        }
+        if (this._agentRunAbortRequested) {
+            this._finishCancelledRetry();
+            return false;
         }
         if (msg.stopReason === "error" && this._retryAttempt > 0) {
             this._emit({
@@ -876,7 +992,7 @@ export class AgentSession {
             this._retryAttempt = 0;
         }
         if (await this._checkCompaction(msg)) {
-            return true;
+            return !this._agentRunAbortRequested;
         }
         // A length stop means the model hit the output token limit mid-response.
         // The agent loop already re-prompts when truncated tool calls are present;
@@ -892,7 +1008,20 @@ export class AgentSession {
         }
         // 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();
+        return !this._agentRunAbortRequested && this.agent.hasQueuedMessages();
+    }
+    async _runInputHandlers(text, images, source, streamingBehavior) {
+        if (!this._extensionRunner.hasHandlers("input")) {
+            return { text, images };
+        }
+        const inputResult = await this._extensionRunner.emitInput(text, images, source, streamingBehavior);
+        if (inputResult.action === "handled") {
+            return undefined;
+        }
+        if (inputResult.action === "transform") {
+            return { text: inputResult.text, images: inputResult.images ?? images };
+        }
+        return { text, images };
     }
     /**
      * Send a prompt to the agent.
@@ -918,20 +1047,16 @@ export class AgentSession {
                     return;
                 }
             }
+            if (this._compactionAbortController !== undefined) {
+                throw new Error("Cannot submit a prompt while compaction is in progress. Wait for compaction to finish and retry.");
+            }
             // Emit input event for extension interception (before skill/template expansion)
-            let currentText = text;
-            let currentImages = options?.images;
-            if (this._extensionRunner.hasHandlers("input")) {
-                const inputResult = await this._extensionRunner.emitInput(currentText, currentImages, options?.source ?? "interactive", this.isStreaming ? options?.streamingBehavior : undefined);
-                if (inputResult.action === "handled") {
-                    preflightResult?.(true);
-                    return;
-                }
-                if (inputResult.action === "transform") {
-                    currentText = inputResult.text;
-                    currentImages = inputResult.images ?? currentImages;
-                }
+            const processedInput = await this._runInputHandlers(text, options?.images, options?.source ?? "interactive", this.isStreaming ? options?.streamingBehavior : undefined);
+            if (!processedInput) {
+                preflightResult?.(true);
+                return;
             }
+            const { text: currentText, images: currentImages } = processedInput;
             // Expand skill commands (/skill:name args) and prompt templates (/template args)
             let expandedText = currentText;
             if (expandPromptTemplates) {
@@ -1003,30 +1128,25 @@ export class AgentSession {
             }
             this._pendingNextTurnMessages = [];
             // Emit before_agent_start extension event
-            const result = await this._extensionRunner.emitBeforeAgentStart(expandedText, currentImages, this._baseSystemPrompt, this._baseSystemPromptOptions);
-            // Add all custom messages from extensions
-            if (result?.messages) {
-                for (const msg of result.messages) {
-                    messages.push({
-                        role: "custom",
-                        customType: msg.customType,
-                        // Untyped extensions can pass null/missing content; normalize at ingestion.
-                        content: msg.content ?? [],
-                        display: msg.display,
-                        details: msg.details,
-                        timestamp: Date.now(),
-                    });
-                }
-            }
-            // Apply extension-modified system prompt, or reset to base
-            if (result?.systemPrompt !== undefined) {
-                this._systemPromptOverride = result.systemPrompt;
-                this.agent.state.systemPrompt = result.systemPrompt;
-            }
-            else {
-                // Ensure we're using the base prompt (in case previous turn had modifications)
-                this._systemPromptOverride = undefined;
-                this.agent.state.systemPrompt = this._baseSystemPrompt;
+            const selectedToolsBefore = this._baseSystemPromptOptions.selectedTools;
+            const result = await this._extensionRunner.emitBeforeAgentStart(expandedText, currentImages, this._baseSystemPromptOptions);
+            // Handlers may edit event.systemPromptOptions.selectedTools or call setActiveTools(),
+            // which updates the live loadout instead. An explicit edit wins; otherwise the live
+            // loadout is authoritative, so a setActiveTools() call is not undone here.
+            const handlerEditedTools = result.systemPromptOptions.selectedTools.length !== selectedToolsBefore.length ||
+                result.systemPromptOptions.selectedTools.some((name, index) => name !== selectedToolsBefore[index]);
+            if (!handlerEditedTools)
+                result.systemPromptOptions.selectedTools = this.getActiveToolNames();
+            for (const msg of result.messages) {
+                messages.push({
+                    role: "custom",
+                    customType: msg.customType,
+                    // Untyped extensions can pass null/missing content; normalize at ingestion.
+                    content: msg.content ?? [],
+                    display: msg.display,
+                    details: msg.details,
+                    timestamp: Date.now(),
+                });
             }
             // Another prompt may have started while this one was preflighting (auth
             // checks, compaction, and extension events can take seconds). The agent is
@@ -1043,6 +1163,10 @@ export class AgentSession {
                 preflightResult?.(true);
                 return;
             }
+            const updateMessage = this._preparePromptAndToolLoadout(result.systemPromptOptions);
+            this._runSystemPromptOptions = result.systemPromptOptions;
+            if (updateMessage)
+                messages.unshift(updateMessage);
         }
         catch (error) {
             preflightResult?.(false);
@@ -1111,40 +1235,44 @@ export class AgentSession {
             return text; // Return original on error
         }
     }
+    async _queueUserInput(text, images, behavior, source) {
+        if (text.startsWith("/")) {
+            this._throwIfExtensionCommand(text);
+        }
+        const processedInput = await this._runInputHandlers(text, images, source, this.isStreaming ? behavior : undefined);
+        if (!processedInput)
+            return;
+        let expandedText = this._expandSkillCommand(processedInput.text);
+        expandedText = expandPromptTemplate(expandedText, [...this.promptTemplates]);
+        if (behavior === "steer") {
+            await this._queueSteer(expandedText, processedInput.images);
+        }
+        else {
+            await this._queueFollowUp(expandedText, processedInput.images);
+        }
+    }
     /**
      * Queue a steering message while the agent is running.
      * Delivered after the current assistant turn finishes executing its tool calls,
      * before the next LLM call.
      * Expands skill commands and prompt templates. Errors on extension commands.
      * @param images Optional image attachments to include with the message
+     * @param options Input source; defaults to interactive
      * @throws Error if text is an extension command
      */
-    async steer(text, images) {
-        // Check for extension commands (cannot be queued)
-        if (text.startsWith("/")) {
-            this._throwIfExtensionCommand(text);
-        }
-        // Expand skill commands and prompt templates
-        let expandedText = this._expandSkillCommand(text);
-        expandedText = expandPromptTemplate(expandedText, [...this.promptTemplates]);
-        await this._queueSteer(expandedText, images);
+    async steer(text, images, options) {
+        await this._queueUserInput(text, images, "steer", options?.source ?? "interactive");
     }
     /**
      * Queue a follow-up message to be processed after the agent finishes.
      * Delivered only when agent has no more tool calls or steering messages.
      * Expands skill commands and prompt templates. Errors on extension commands.
      * @param images Optional image attachments to include with the message
+     * @param options Input source; defaults to interactive
      * @throws Error if text is an extension command
      */
-    async followUp(text, images) {
-        // Check for extension commands (cannot be queued)
-        if (text.startsWith("/")) {
-            this._throwIfExtensionCommand(text);
-        }
-        // Expand skill commands and prompt templates
-        let expandedText = this._expandSkillCommand(text);
-        expandedText = expandPromptTemplate(expandedText, [...this.promptTemplates]);
-        await this._queueFollowUp(expandedText, images);
+    async followUp(text, images, options) {
+        await this._queueUserInput(text, images, "followUp", options?.source ?? "interactive");
     }
     /**
      * Internal: Queue a steering message (already expanded, no extension command check).
@@ -1488,6 +1616,9 @@ export class AgentSession {
      * Abort current operation and wait for agent to become idle.
      */
     async abort() {
+        if (this._isAgentRunActive) {
+            this._agentRunAbortRequested = true;
+        }
         this.abortRetry();
         this.abortCompaction();
         this.abortBranchSummary();
@@ -1710,6 +1841,10 @@ export class AgentSession {
     // =========================================================================
     // Compaction
     // =========================================================================
+    /** Generate the built-in compaction summary for manual and automatic compaction. */
+    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);
+    }
     _clearManualCompactionState() {
         this._compactionAbortController = undefined;
         this._resolveIdleWaitIfIdle();
@@ -1724,13 +1859,16 @@ export class AgentSession {
         await this.abort();
         this._compactionAbortController = new AbortController();
         this._emit({ type: "compaction_start", reason: "manual" });
+        let fromExtension = false;
+        let cancelledByExtension = false;
         try {
-            if (!this.model) {
+            const model = this.model;
+            if (!model) {
                 throw new Error(formatNoModelSelectedMessage());
             }
-            const { apiKey, headers, env } = await this._getSummarizationRequestAuth(this.model);
+            const settings = this.settingsManager.getCompactionSettings(model);
+            const { model: requestModel, apiKey, headers, env, } = await this._getSummarizationRequestAuth(model, this._compactionAbortController.signal);
             const pathEntries = this.sessionManager.getBranch();
-            const settings = this.settingsManager.getCompactionSettings();
             const preparation = prepareCompaction(pathEntries, settings);
             if (!preparation) {
                 // Check why we can't compact
@@ -1753,6 +1891,7 @@ export class AgentSession {
                     signal: this._compactionAbortController.signal,
                 }));
                 if (result?.cancel) {
+                    cancelledByExtension = true;
                     throw new Error("Compaction cancelled");
                 }
                 if (result?.compaction) {
@@ -1774,8 +1913,8 @@ export class AgentSession {
                 details = extensionCompaction.details;
             }
             else {
-                // Generate compaction result
-                const result = await compact(preparation, this.model, apiKey, headers, customInstructions, this._compactionAbortController.signal, this.thinkingLevel, this.agent.streamFunction, env, this.settingsManager.getRetrySettings(), this._summarizationRetryCallbacks({ source: "compaction", reason: "manual" }));
+                // Shared default summary generator, also used by automatic compaction.
+                const result = await this._runDefaultCompaction(preparation, requestModel, apiKey, headers, customInstructions, this._compactionAbortController.signal, env, "manual");
                 summary = result.summary;
                 firstKeptEntryId = result.firstKeptEntryId;
                 tokensBefore = result.tokensBefore;
@@ -1822,7 +1961,7 @@ export class AgentSession {
         }
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);
-            const aborted = message === "Compaction cancelled" || (error instanceof Error && error.name === "AbortError");
+            const aborted = this._compactionAbortController.signal.aborted || cancelledByExtension;
             const errorMessage = aborted ? undefined : `Compaction failed: ${message}`;
             this._clearManualCompactionState();
             this._emit({
@@ -1872,7 +2011,7 @@ export class AgentSession {
      * @param skipAbortedCheck If false, include aborted messages (for pre-prompt check). Default: true
      */
     async _checkCompaction(assistantMessage, skipAbortedCheck = true) {
-        const settings = this.settingsManager.getCompactionSettings();
+        const settings = this.settingsManager.getCompactionSettings(this.model);
         if (!settings.enabled)
             return false;
         // Skip if message was aborted (user cancelled) - unless skipAbortedCheck is false
@@ -1892,11 +2031,12 @@ export class AgentSession {
         if (assistantIsFromBeforeCompaction) {
             return false;
         }
-        // Case 1: Overflow - LLM returned context overflow error, or reported usage exceeded
-        // the configured window. A successful response over the configured window should compact
-        // but must not retry: the assistant answer already completed and agent.continue() cannot
-        // continue from an assistant message.
-        if (sameModel && isContextOverflow(assistantMessage, contextWindow)) {
+        // 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";
             if (!willRetry) {
                 return await this._runAutoCompaction("overflow", false);
@@ -1908,7 +2048,9 @@ export class AgentSession {
                     result: undefined,
                     aborted: false,
                     willRetry: false,
-                    errorMessage: "Context overflow recovery failed after one compact-and-retry attempt. Try reducing context or switching to a larger-context model.",
+                    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.",
                 });
                 return false;
             }
@@ -1955,30 +2097,28 @@ export class AgentSession {
      * Internal: Run auto-compaction with events.
      */
     async _runAutoCompaction(reason, willRetry) {
-        const settings = this.settingsManager.getCompactionSettings();
+        const model = this.model;
+        const settings = this.settingsManager.getCompactionSettings(model);
+        let abortController;
         let started = false;
         let fromExtension = false;
+        let cancelledByExtension = false;
         try {
-            if (!this.model) {
+            if (!model) {
                 return false;
             }
-            let apiKey;
-            let headers;
-            let env;
-            if (this.agent.streamFunction === streamSimple) {
-                ({ apiKey, headers, env } = await this._getRequiredRequestAuth(this.model));
-            }
-            else {
-                ({ apiKey, headers, env } = await this._getSummarizationRequestAuth(this.model));
-            }
             const pathEntries = this.sessionManager.getBranch();
             const preparation = prepareCompaction(pathEntries, settings);
             if (!preparation) {
                 return false;
             }
-            this._emit({ type: "compaction_start", reason });
-            this._autoCompactionAbortController = new AbortController();
+            abortController = new AbortController();
+            this._autoCompactionAbortController = abortController;
             started = true;
+            this._emit({ type: "compaction_start", reason });
+            abortController.signal.throwIfAborted();
+            const { model: requestModel, apiKey, headers, env, } = await this._getSummarizationRequestAuth(model, abortController.signal);
+            abortController.signal.throwIfAborted();
             let extensionCompaction;
             if (this._extensionRunner.hasHandlers("session_before_compact")) {
                 const extensionResult = (await this._extensionRunner.emit({
@@ -1988,24 +2128,18 @@ export class AgentSession {
                     customInstructions: undefined,
                     reason,
                     willRetry,
-                    signal: this._autoCompactionAbortController.signal,
+                    signal: abortController.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;
+                    cancelledByExtension = true;
+                    throw new Error("Compaction cancelled");
                 }
                 if (extensionResult?.compaction) {
                     extensionCompaction = extensionResult.compaction;
                     fromExtension = true;
                 }
             }
+            abortController.signal.throwIfAborted();
             let summary;
             let firstKeptEntryId;
             let tokensBefore;
@@ -2020,25 +2154,15 @@ export class AgentSession {
                 details = extensionCompaction.details;
             }
             else {
-                // Generate compaction result
-                const compactResult = await compact(preparation, this.model, apiKey, headers, undefined, this._autoCompactionAbortController.signal, this.thinkingLevel, this.agent.streamFunction, env, this.settingsManager.getRetrySettings(), this._summarizationRetryCallbacks({ source: "compaction", reason }));
+                // Shared default summary generator, also used by manual compaction.
+                const compactResult = await this._runDefaultCompaction(preparation, requestModel, apiKey, headers, undefined, abortController.signal, env, reason);
                 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;
-            }
+            abortController.signal.throwIfAborted();
             this.sessionManager.appendCompaction(summary, firstKeptEntryId, tokensBefore, details, fromExtension, usage);
             const newEntries = this.sessionManager.getEntries();
             const sessionContext = this.sessionManager.buildSessionContext();
@@ -2067,7 +2191,11 @@ export class AgentSession {
             if (willRetry) {
                 const messages = this.agent.state.messages;
                 const lastMsg = messages[messages.length - 1];
-                if (lastMsg?.role === "assistant" && lastMsg.stopReason === "error") {
+                // 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;
@@ -2077,23 +2205,26 @@ export class AgentSession {
             return this.agent.hasQueuedMessages();
         }
         catch (error) {
-            const errorMessage = error instanceof Error ? error.message : "compaction failed";
+            const message = error instanceof Error ? error.message : "compaction failed";
+            const aborted = abortController?.signal.aborted === true || cancelledByExtension;
             if (started) {
-                const formattedErrorMessage = reason === "overflow"
-                    ? `Context overflow recovery failed: ${errorMessage}`
-                    : `Auto-compaction failed: ${errorMessage}`;
+                const errorMessage = aborted
+                    ? undefined
+                    : reason === "overflow"
+                        ? `Context overflow recovery failed: ${message}`
+                        : `Auto-compaction failed: ${message}`;
                 this._emit({
                     type: "compaction_end",
                     reason,
                     result: undefined,
-                    aborted: false,
+                    aborted,
                     willRetry: false,
-                    errorMessage: formattedErrorMessage,
+                    errorMessage,
                 });
                 await this._emitSessionCompactFailed({
                     reason,
-                    errorMessage: formattedErrorMessage,
-                    aborted: false,
+                    errorMessage,
+                    aborted,
                     willRetry: false,
                     fromExtension,
                 });
@@ -2101,7 +2232,9 @@ export class AgentSession {
             return false;
         }
         finally {
-            this._autoCompactionAbortController = undefined;
+            if (this._autoCompactionAbortController === abortController) {
+                this._autoCompactionAbortController = undefined;
+            }
             this._resolveIdleWaitIfIdle();
         }
     }
@@ -2158,8 +2291,7 @@ export class AgentSession {
             themePaths: this.buildExtensionResourcePaths(themePaths),
         };
         this._resourceLoader.extendResources(extensionPaths);
-        this._baseSystemPrompt = this._rebuildSystemPrompt(this.getActiveToolNames());
-        this.agent.state.systemPrompt = this._baseSystemPrompt;
+        this._rebuildSystemPrompt(this.getActiveToolNames());
     }
     buildExtensionResourcePaths(entries) {
         return entries.map((entry) => {
@@ -2276,8 +2408,7 @@ export class AgentSession {
             }),
             setSkillsIndexFilter: (filter) => {
                 this._resourceLoader.setSkillsIndexFilter(filter);
-                this._baseSystemPrompt = this._rebuildSystemPrompt(this.getActiveToolNames());
-                this.agent.state.systemPrompt = this._systemPromptOverride ?? this._baseSystemPrompt;
+                this._rebuildSystemPrompt(this.getActiveToolNames());
             },
             refreshTools: () => this._refreshToolRegistry(),
             getCommands,
@@ -2511,6 +2642,18 @@ export class AgentSession {
             },
         };
     }
+    _finishCancelledRetry() {
+        if (this._retryAttempt === 0)
+            return;
+        const attempt = this._retryAttempt;
+        this._retryAttempt = 0;
+        this._emit({
+            type: "auto_retry_end",
+            success: false,
+            attempt,
+            finalError: "Retry cancelled",
+        });
+    }
     /**
      * Prepare a retryable error for continuation with exponential backoff.
      * @returns true if the caller should continue the agent, false otherwise
@@ -2526,7 +2669,7 @@ export class AgentSession {
             this._retryAttempt--;
             return false;
         }
-        const delayMs = settings.baseDelayMs * 2 ** (this._retryAttempt - 1);
+        const delayMs = retryDelayMs(settings, this._retryAttempt);
         this._emit({
             type: "auto_retry_start",
             attempt: this._retryAttempt,
@@ -2546,14 +2689,7 @@ export class AgentSession {
         }
         catch {
             // Aborted during sleep - emit end event so UI can clean up
-            const attempt = this._retryAttempt;
-            this._retryAttempt = 0;
-            this._emit({
-                type: "auto_retry_end",
-                success: false,
-                attempt,
-                finalError: "Retry cancelled",
-            });
+            this._finishCancelledRetry();
             return false;
         }
         finally {
@@ -2704,6 +2840,9 @@ export class AgentSession {
         if (this.isStreaming) {
             throw new Error("Wait for the current response to finish before navigating the session tree.");
         }
+        if (this.isCompacting) {
+            throw new Error("Wait for the current compaction or tree navigation to finish before navigating the session tree.");
+        }
         const oldLeafId = this.sessionManager.getLeafId();
         // No-op if already at target
         if (targetId === oldLeafId) {
@@ -2846,6 +2985,7 @@ export class AgentSession {
             // Update agent state
             const sessionContext = this.sessionManager.buildSessionContext();
             this.agent.state.messages = sessionContext.messages;
+            this._restoreToolsFromTranscript();
             // Emit session_tree event (extension runners + RPC stdout subscribers)
             const treeEvent = {
                 type: "session_tree",
@@ -2895,7 +3035,10 @@ export class AgentSession {
         let toolCalls = 0;
         const usageTotals = createUsageTotals();
         for (const entry of this.sessionManager.getEntries()) {
-            if ((entry.type === "branch_summary" || entry.type === "compaction") && entry.usage) {
+            if (entry.type === "usage") {
+                addUsageToTotals(usageTotals, entry.usage);
+            }
+            else if ((entry.type === "branch_summary" || entry.type === "compaction") && entry.usage) {
                 addUsageToTotals(usageTotals, entry.usage);
             }
             if (entry.type !== "message")
@@ -3030,6 +3173,30 @@ export class AgentSession {
         writeFileSync(filePath, `${lines.join("\n")}\n`);
         return filePath;
     }
+    /**
+     * Ask the current model to describe what went wrong in this session for a bug report.
+     * Used when the user declines to share the transcript itself.
+     */
+    async summarizeForBugReport(options) {
+        const model = this.model;
+        if (!model) {
+            throw new Error("No model selected");
+        }
+        const { model: requestModel, apiKey, headers, env } = await this._getSummarizationRequestAuth(model);
+        return generateBugReportSummary({
+            messages: this.messages,
+            hint: options.hint,
+            model: requestModel,
+            apiKey,
+            headers,
+            env,
+            signal: options.signal,
+            thinkingLevel: this.thinkingLevel,
+            streamFn: this.agent.streamFunction,
+            retry: this.settingsManager.getRetrySettings(),
+            sessionId: this.sessionId,
+        });
+    }
     // =========================================================================
     // Utilities
     // =========================================================================