@astralyn/pi 0.85.3 → 0.86.0

package/dist/core/agent-session.js

@@ -14,7 +14,7 @@
  */
 import { readFileSync } from "node:fs";
 import { basename, dirname } from "node:path";
-import { contentText } from "@earendil-works/pi-ai";
+import { contentText, getCurrentSystemMessage, getSystemMessageText, 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";
@@ -23,6 +23,7 @@ import { normalizeToolResultImages } from "../utils/tool-result-images.js";
 import { formatNoApiKeyFoundMessage, formatNoModelSelectedMessage } from "./auth-guidance.js";
 import { BackgroundSession } from "./background/session.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";
@@ -35,7 +36,7 @@ import { expandPromptTemplate } from "./prompt-templates.js";
 import { exportSessionToJsonl } from "./session-export.js";
 import { 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";
@@ -71,15 +72,13 @@ function estimateMessagesTokens(messages) {
     return tokens;
 }
 // ============================================================================
-// Constants
-// ============================================================================
-// ============================================================================
 // AgentSession Class
 // ============================================================================
 export class AgentSession {
     constructor(config) {
         this._eventListeners = [];
         this._isAgentRunActive = false;
+        this._agentRunAbortRequested = false;
         /** Tracks pending steering messages for UI display. Removed when delivered. */
         this._steeringMessages = [];
         /** Tracks pending follow-up messages for UI display. Removed when delivered. */
@@ -108,8 +107,6 @@ export class AgentSession {
         this._toolDefinitions = new Map();
         this._toolPromptSnippets = new Map();
         this._toolPromptGuidelines = new Map();
-        // Base system prompt (without extension appends) - used to apply fresh appends each turn
-        this._baseSystemPrompt = "";
         // Track last assistant message for auto-compaction check
         this._lastAssistantMessage = undefined;
         /** Internal handler for agent events - shared by subscribe and reconnect */
@@ -200,6 +197,10 @@ export class AgentSession {
         this._cwd = config.cwd;
         this._modelRuntime = config.modelRuntime;
         this._captureModelContext = config.captureModelContext;
+        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;
@@ -211,10 +212,13 @@ 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 background() {
         return this._backgroundHost.service;
@@ -244,7 +248,6 @@ export class AgentSession {
             leafId: this.sessionManager.getLeafId(),
             model: structuredClone(model),
             thinkingLevel: this.thinkingLevel,
-            systemPrompt: this.systemPrompt,
             tools: this.agent.state.tools.map(({ name, description, parameters, constrainedSampling }) => ({
                 name,
                 description,
@@ -260,18 +263,26 @@ export class AgentSession {
                 onResponse: this.agent.onResponse,
             }),
         };
+        const currentSystemPrompt = this.systemPrompt;
         const messages = structuredClone(this.agent.state.messages);
         const convert = this.agent.convertToLlm;
         const transform = this.agent.transformContext;
         const prepared = this._captureModelContext
             ? await this._captureModelContext(messages)
             : await convert(transform ? await transform(messages) : messages);
-        return { ...snapshot, messages: structuredClone(prepared) };
+        // The prepared transcript declares the prompt the provider received, including a forced
+        // prompt projected for the last request; before the first request there is none yet.
+        const declared = getCurrentSystemMessage(prepared);
+        return {
+            ...snapshot,
+            systemPrompt: declared ? getSystemMessageText(declared) : currentSystemPrompt,
+            messages: structuredClone(prepared),
+        };
     }
-    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;
@@ -297,20 +308,12 @@ 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) {
-        if (streamFunction === streamSimple) {
-            return this._getRequiredRequestAuth(model);
+    async _getSummarizationRequestAuth(model, signal) {
+        if (this.agent.streamFunction === streamSimple) {
+            return this._getRequiredRequestAuth(model, signal);
         }
         try {
-            const result = await this._modelRuntime.getAuth(model);
+            const result = await this._modelRuntime.getAuth(model, { signal });
             if (!result)
                 return { model };
             const requestModel = result.auth.baseUrl ? { ...model, baseUrl: result.auth.baseUrl } : model;
@@ -321,7 +324,9 @@ export class AgentSession {
                 env: result.env,
             };
         }
-        catch {
+        catch (error) {
+            if (signal?.aborted)
+                throw error;
             return { model };
         }
     }
@@ -386,7 +391,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)) {
@@ -407,13 +412,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,
             };
@@ -458,6 +475,7 @@ export class AgentSession {
         resolve();
     }
     async _emitAgentSettled() {
+        this._cacheWarmer?.onAgentSettled();
         const resumeBackground = this.pauseBackgroundNotifications();
         this._isAgentRunActive = false;
         try {
@@ -477,7 +495,10 @@ export class AgentSession {
             if (pendingIndex !== -1)
                 this._pendingNextTurnMessages.splice(pendingIndex, 1);
         }
-        else if (message.role === "user" || message.role === "assistant" || message.role === "toolResult") {
+        else if (message.role === "system" ||
+            message.role === "user" ||
+            message.role === "assistant" ||
+            message.role === "toolResult") {
             this.sessionManager.appendMessage(message);
         }
         else {
@@ -489,6 +510,8 @@ export class AgentSession {
         return true;
     }
     _willRetryAfterAgentEnd(event) {
+        if (this._agentRunAbortRequested)
+            return false;
         const settings = this.settingsManager.getRetrySettings();
         if (!settings.enabled || this._retryAttempt >= settings.maxRetries) {
             return false;
@@ -658,6 +681,10 @@ export class AgentSession {
         this._extensionRunner.invalidate(STALE_EXTENSION_CONTEXT_MESSAGE);
         this._disconnectFromAgent();
         this._eventListeners = [];
+        if (this._cacheWarmer) {
+            this._cacheWarmer.onWarmed = undefined;
+            this._cacheWarmer.cancel();
+        }
         cleanupSessionResources(this.sessionId);
     }
     // =========================================================================
@@ -667,6 +694,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;
@@ -683,9 +719,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() {
@@ -730,9 +766,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() {
@@ -801,23 +835,17 @@ 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();
-        const appendSystemPrompt = loaderAppendSystemPrompt.length > 0 ? loaderAppendSystemPrompt.join("\n\n") : undefined;
+        const appendSystemPrompt = loaderAppendSystemPrompt.length > 0 ? loaderAppendSystemPrompt.join("\n\n") : "";
         const loadedSkills = this._resourceLoader.getSkills().skills;
         const loadedContextFiles = this._resourceLoader.getAgentsFiles().agentsFiles;
-        this._baseSystemPromptOptions = {
+        this._baseSystemPromptOptions = normalizeBuildSystemPromptOptions({
             cwd: this._cwd,
             skills: loadedSkills,
             contextFiles: loadedContextFiles,
@@ -825,23 +853,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();
@@ -850,11 +942,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({
@@ -866,11 +968,24 @@ export class AgentSession {
             this._retryAttempt = 0;
         }
         if (await this._checkCompaction(msg)) {
-            return true;
+            return !this._agentRunAbortRequested;
         }
         // 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.
@@ -908,19 +1023,12 @@ export class AgentSession {
                     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) {
@@ -982,31 +1090,30 @@ export class AgentSession {
                     messages.push(msg);
                 }
                 // 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(),
+                    });
                 }
+                const updateMessage = this._preparePromptAndToolLoadout(result.systemPromptOptions);
+                this._runSystemPromptOptions = result.systemPromptOptions;
+                if (updateMessage)
+                    messages.unshift(updateMessage);
             }
             catch (error) {
                 preflightResult?.(false);
@@ -1079,40 +1186,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).
@@ -1295,6 +1406,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();
@@ -1524,8 +1638,8 @@ export class AgentSession {
     // Compaction
     // =========================================================================
     /** Generate Pi's built-in compaction summary for manual and automatic compaction. */
-    async _runDefaultCompaction(preparation, requestModel, apiKey, headers, customInstructions, signal, env, reason, streamFunction) {
-        return compact(preparation, requestModel, apiKey, headers, customInstructions, signal, this.thinkingLevel, streamFunction, env, this.settingsManager.getRetrySettings(), this._summarizationRetryCallbacks({ source: "compaction", reason }), undefined);
+    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;
@@ -1553,15 +1667,16 @@ export class AgentSession {
             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 streamFunction = this.agent.streamFunction;
-                const { model: requestModel, apiKey, headers, env, } = await this._getSummarizationRequestAuth(this.model, streamFunction);
+                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, requestModel.contextWindow);
+                const preparation = prepareCompaction(pathEntries, settings);
                 if (!preparation) {
                     // Check why we can't compact
                     const lastEntry = pathEntries[pathEntries.length - 1];
@@ -1582,6 +1697,7 @@ export class AgentSession {
                         signal: this._compactionAbortController.signal,
                     }));
                     if (result?.cancel) {
+                        cancelledByExtension = true;
                         throw new Error("Compaction cancelled");
                     }
                     if (result?.compaction) {
@@ -1604,7 +1720,7 @@ export class AgentSession {
                 }
                 else {
                     // Shared default summary generator, also used by automatic compaction.
-                    const result = await this._runDefaultCompaction(preparation, requestModel, apiKey, headers, customInstructions, this._compactionAbortController.signal, env, "manual", streamFunction);
+                    const result = await this._runDefaultCompaction(preparation, requestModel, apiKey, headers, customInstructions, this._compactionAbortController.signal, env, "manual");
                     summary = result.summary;
                     firstKeptEntryId = result.firstKeptEntryId;
                     tokensBefore = result.tokensBefore;
@@ -1651,7 +1767,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 === true || cancelledByExtension;
                 const errorMessage = aborted ? undefined : `Compaction failed: ${message}`;
                 this._clearManualCompactionState();
                 this._emit({
@@ -1714,7 +1830,7 @@ export class AgentSession {
      * @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();
+        const settings = this.settingsManager.getCompactionSettings(this.model);
         if (!settings.enabled)
             return false;
         // Skip if message was aborted (user cancelled) - unless skipAbortedCheck is false
@@ -1821,25 +1937,28 @@ export class AgentSession {
     async _runAutoCompaction(reason, willRetry) {
         const resumeBackground = this.pauseBackgroundNotifications();
         try {
-            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;
                 }
-                // 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, requestModel.contextWindow);
+                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({
@@ -1849,29 +1968,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;
@@ -1887,29 +1995,14 @@ export class AgentSession {
                 }
                 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);
+                    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();
@@ -1953,23 +2046,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,
                     });
@@ -1977,7 +2073,9 @@ export class AgentSession {
                 return false;
             }
             finally {
-                this._autoCompactionAbortController = undefined;
+                if (this._autoCompactionAbortController === abortController) {
+                    this._autoCompactionAbortController = undefined;
+                }
                 this._resolveIdleWaitIfIdle();
             }
         }
@@ -2041,8 +2139,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) => {
@@ -2392,6 +2489,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
@@ -2407,7 +2516,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,
@@ -2427,14 +2536,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 {
@@ -2585,6 +2687,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) {
@@ -2651,8 +2756,7 @@ export class AgentSession {
             let summaryUsage;
             if (options.summarize && entriesToSummarize.length > 0 && !extensionSummary) {
                 const model = this.model;
-                const streamFunction = this.agent.streamFunction;
-                const { model: requestModel, apiKey, headers, env, } = await this._getSummarizationRequestAuth(model, streamFunction);
+                const { model: requestModel, apiKey, headers, env } = await this._getSummarizationRequestAuth(model);
                 const branchSummarySettings = this.settingsManager.getBranchSummarySettings();
                 const result = await generateBranchSummary(entriesToSummarize, {
                     model: requestModel,
@@ -2663,7 +2767,7 @@ export class AgentSession {
                     customInstructions,
                     replaceInstructions,
                     reserveTokens: branchSummarySettings.reserveTokens,
-                    streamFn: streamFunction,
+                    streamFn: this.agent.streamFunction,
                     retry: this.settingsManager.getRetrySettings(),
                     callbacks: this._summarizationRetryCallbacks({ source: "branchSummary" }),
                 });
@@ -2731,6 +2835,7 @@ export class AgentSession {
             // Update agent state
             const sessionContext = this.sessionManager.buildSessionContext();
             this.agent.state.messages = sessionContext.messages;
+            this._restoreToolsFromTranscript();
             // Emit session_tree event
             await this._extensionRunner.emit({
                 type: "session_tree",
@@ -2889,6 +2994,30 @@ export class AgentSession {
     exportToJsonl(outputPath) {
         return exportSessionToJsonl(this.sessionManager, outputPath);
     }
+    /**
+     * 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, options.signal);
+        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
     // =========================================================================