@averyyy/pi-coding-agent 0.85.1-piclient.9 → 0.86.1-piclient.2

package/dist/core/agent-session.js

@@ -14,7 +14,7 @@
  */
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { basename, dirname } from "node:path";
-import { contentText } from "@earendil-works/pi-ai";
+import { contentText, getCurrentSystemMessage, normalizeContext, 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 { sleep } from "../utils/sleep.js";
 import { normalizeToolResultImages } from "../utils/tool-result-images.js";
 import { formatNoApiKeyFoundMessage, formatNoModelSelectedMessage } from "./auth-guidance.js";
 import { executeBashWithOperations } from "./bash-executor.js";
+import { 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 { cancelPiServerOperations, compactPiServer, } from "./pi-server-client.j
 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";
@@ -80,6 +81,26 @@ const AUTO_SESSION_NAME_PROMPT = "Name this coding session from the transcript b
 function isPiServerMode() {
     return process.env.PI_SERVER_MODE === "true";
 }
+/** Project the coding-agent session tree into the legacy pi-server wire tree. */
+function buildPiServerSessionTree(entries, leafId) {
+    const byId = new Map(entries.map((entry) => [entry.id, entry]));
+    const usageIds = new Set(entries.filter((entry) => entry.type === "usage").map((entry) => entry.id));
+    const resolveParentId = (parentId) => {
+        let current = parentId;
+        const visited = new Set();
+        while (current !== null && usageIds.has(current)) {
+            if (visited.has(current))
+                throw new Error(`Usage entry parent cycle at ${current}`);
+            visited.add(current);
+            current = byId.get(current)?.parentId ?? null;
+        }
+        return current;
+    };
+    const legacyEntries = entries
+        .filter((entry) => entry.type !== "usage")
+        .map((entry) => ({ ...entry, parentId: resolveParentId(entry.parentId) }));
+    return { entries: legacyEntries, leafId: resolveParentId(leafId) };
+}
 function toProviderReasoning(thinkingLevel) {
     return thinkingLevel === "off" ? undefined : thinkingLevel;
 }
@@ -138,7 +159,6 @@ function sanitizeGeneratedSessionName(text) {
         return undefined;
     return title.length > AUTO_SESSION_NAME_MAX_CHARS ? title.slice(0, AUTO_SESSION_NAME_MAX_CHARS).trim() : title;
 }
-// ============================================================================
 // AgentSession Class
 // ============================================================================
 export class AgentSession {
@@ -150,6 +170,7 @@ export class AgentSession {
     _unsubscribeAgent;
     _eventListeners = [];
     _isAgentRunActive = false;
+    _agentRunAbortRequested = false;
     _idleWaitPromise;
     _resolveIdleWait;
     _abortPromise;
@@ -207,15 +228,15 @@ export class AgentSession {
     _autoSessionNameEnabled;
     _autoSessionNameAttempted = false;
     _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;
@@ -225,6 +246,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;
@@ -240,10 +265,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 modelRuntime() {
         return this._modelRuntime;
@@ -258,10 +286,10 @@ export class AgentSession {
             messageCount: snapshot.messages.length,
         });
     }
-    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;
@@ -287,12 +315,12 @@ 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);
+            const result = await this._modelRuntime.getAuth(model, { signal });
             if (!result)
                 return { model };
             const requestModel = result.auth.baseUrl ? { ...model, baseUrl: result.auth.baseUrl } : model;
@@ -303,7 +331,9 @@ export class AgentSession {
                 env: result.env,
             };
         }
-        catch {
+        catch (error) {
+            if (signal?.aborted)
+                throw error;
             return { model };
         }
     }
@@ -375,14 +405,26 @@ export class AgentSession {
             const compactedContext = await this._compactBeforeNextProviderRequest(turn, signal);
             const nextTurn = compactedContext ? { ...turn, context: compactedContext } : turn;
             const previousSnapshot = await previousPrepareNextTurnWithContext?.(nextTurn, signal);
-            const previousContext = previousSnapshot?.context ?? nextTurn.context;
+            const nextContext = previousSnapshot?.context ?? nextTurn.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: {
-                    ...previousContext,
-                    systemPrompt: this._systemPromptOverride ?? this._baseSystemPrompt,
+                    ...nextContext,
                     tools: this.agent.state.tools.slice(),
                 },
+                messages: updateMessage
+                    ? [...(previousSnapshot?.messages ?? []), updateMessage]
+                    : previousSnapshot?.messages,
                 model: this.agent.state.model,
                 thinkingLevel: this.agent.state.thinkingLevel,
             };
@@ -427,6 +469,7 @@ export class AgentSession {
         resolve();
     }
     async _emitAgentSettled() {
+        this._cacheWarmer?.onAgentSettled();
         this._isAgentRunActive = false;
         try {
             await this._extensionRunner.emit({ type: "agent_settled" });
@@ -473,7 +516,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
@@ -509,6 +553,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;
@@ -733,6 +779,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);
     }
     // =========================================================================
@@ -742,6 +792,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;
@@ -766,9 +825,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() {
@@ -813,9 +872,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() {
@@ -884,23 +941,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,
@@ -908,21 +959,81 @@ 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 _runAgentOperation(start) {
+        this._agentRunAbortRequested = false;
         this._isAgentRunActive = true;
         try {
             await start();
             while (await this._handlePostAgentRun()) {
                 // Esc cancels the current agent run. Keep messages queued during that
                 // cancellation for the single deferred continuation in abort().
-                if (this._isAborting) {
+                if (this._isAborting || this._agentRunAbortRequested) {
                     break;
                 }
                 try {
@@ -942,12 +1053,14 @@ export class AgentSession {
                     throw error;
                 }
             }
-            if (!this._isAborting) {
+            if (!this._isAborting && !this._agentRunAbortRequested) {
                 await this._maybeGenerateSessionName();
             }
         }
         finally {
-            this._systemPromptOverride = undefined;
+            if (this._agentRunAbortRequested)
+                this._finishCancelledRetry();
+            this._runSystemPromptOptions = undefined;
             this._flushPendingBashMessages();
             this._flushPendingCustomMessages();
             await this._emitAgentSettled();
@@ -991,7 +1104,7 @@ export class AgentSession {
             return;
         this._sessionNameAbortController = new AbortController();
         try {
-            const stream = await this.agent.streamFunction(model, {
+            const stream = await this.agent.streamFunction(model, normalizeContext({
                 systemPrompt: this.systemPrompt,
                 messages: [
                     {
@@ -1001,7 +1114,7 @@ export class AgentSession {
                     },
                 ],
                 tools: this.agent.state.tools,
-            }, {
+            }), {
                 maxTokens: 32,
                 reasoning: undefined,
                 sessionId: this.sessionId,
@@ -1030,6 +1143,10 @@ export class AgentSession {
     async _handlePostAgentRun() {
         const msg = this._lastAssistantMessage;
         this._lastAssistantMessage = undefined;
+        if (this._agentRunAbortRequested) {
+            this._finishCancelledRetry();
+            return false;
+        }
         if (!msg) {
             return false;
         }
@@ -1040,7 +1157,13 @@ export class AgentSession {
             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 (this._isAborting) {
             return false;
@@ -1055,14 +1178,27 @@ export class AgentSession {
             this._retryAttempt = 0;
         }
         if (await this._checkCompaction(msg)) {
-            return true;
+            return !this._agentRunAbortRequested;
         }
         if (isPiServerMode() && this._isTerminalAssistantFailure(msg)) {
             this._detachPiServerTerminalAssistantFailure();
         }
         // 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.
@@ -1092,19 +1228,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) {
@@ -1196,31 +1325,30 @@ 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(),
+                });
             }
+            const updateMessage = this._preparePromptAndToolLoadout(result.systemPromptOptions);
+            this._runSystemPromptOptions = result.systemPromptOptions;
+            if (updateMessage)
+                messages.unshift(updateMessage);
         }
         catch (error) {
             preflightResult?.(false);
@@ -1289,40 +1417,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).
@@ -1525,6 +1657,9 @@ export class AgentSession {
         });
     }
     async _performAbort() {
+        if (this._isAgentRunActive) {
+            this._agentRunAbortRequested = true;
+        }
         this.abortRetry();
         this.abortCompaction();
         this.abortBranchSummary();
@@ -1550,6 +1685,11 @@ export class AgentSession {
             if (cleanupFailure?.status === "rejected") {
                 throw cleanupFailure.reason;
             }
+            if (isPiServerMode()) {
+                // The provider may persist a terminal assistant after agent.abort() without
+                // routing through _handlePostAgentRun; keep the durable leaf resumable.
+                this._detachPiServerTerminalAssistantFailure();
+            }
         }
         catch (error) {
             this._abortError = error instanceof Error ? error.message : String(error);
@@ -1572,6 +1712,9 @@ export class AgentSession {
      * Messages queued while cancellation is in progress are sent in one deferred continuation.
      */
     abort() {
+        if (this._isAgentRunActive) {
+            this._agentRunAbortRequested = true;
+        }
         if (this._abortPromise) {
             return this._abortPromise;
         }
@@ -1851,6 +1994,8 @@ export class AgentSession {
     async compact(customInstructions) {
         await this.abort();
         this._compactionAbortController = new AbortController();
+        let fromExtension = false;
+        let cancelledByExtension = false;
         let resolveCompactionCompletion;
         const compactionCompletion = new Promise((resolve) => {
             resolveCompactionCompletion = resolve;
@@ -1858,10 +2003,12 @@ export class AgentSession {
         this._compactionCompletionPromise = compactionCompletion;
         try {
             this._emit({ type: "compaction_start", reason: "manual" });
-            if (!this.model) {
+            const model = this.model;
+            if (!model) {
                 throw new Error(formatNoModelSelectedMessage());
             }
-            const { model: requestModel, 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);
             if (isPiServerMode()) {
                 this._detachPiServerTerminalAssistantFailure();
                 const piServerResult = await compactPiServer(requestModel, {
@@ -1874,7 +2021,7 @@ export class AgentSession {
                     headers,
                     customInstructions,
                     settings: this.settingsManager.getCompactionSettings(),
-                    sessionTree: { entries: this.sessionManager.getEntries(), leafId: this.sessionManager.getLeafId() },
+                    sessionTree: buildPiServerSessionTree(this.sessionManager.getEntries(), this.sessionManager.getLeafId()),
                     signal: this._compactionAbortController.signal,
                     reasoning: toProviderReasoning(this.thinkingLevel),
                     onHistoryReconciled: (snapshot) => this.reconcilePiServerHistory(snapshot),
@@ -1891,7 +2038,6 @@ export class AgentSession {
                 return result;
             }
             const pathEntries = this.sessionManager.getBranch();
-            const settings = this.settingsManager.getCompactionSettings();
             const preparation = prepareCompaction(pathEntries, settings);
             if (!preparation) {
                 // Check why we can't compact
@@ -1902,7 +2048,6 @@ export class AgentSession {
                 throw new Error("Nothing to compact (session too small)");
             }
             let extensionCompaction;
-            let fromExtension = false;
             if (this._extensionRunner.hasHandlers("session_before_compact")) {
                 const result = (await this._extensionRunner.emit({
                     type: "session_before_compact",
@@ -1914,6 +2059,7 @@ export class AgentSession {
                     signal: this._compactionAbortController.signal,
                 }));
                 if (result?.cancel) {
+                    cancelledByExtension = true;
                     throw new Error("Compaction cancelled");
                 }
                 if (result?.compaction) {
@@ -1983,8 +2129,10 @@ 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");
-            this._compactionAbortController = undefined;
+            const aborted = this._compactionAbortController?.signal.aborted === true ||
+                cancelledByExtension ||
+                message === "Compaction cancelled" ||
+                (error instanceof Error && error.name === "AbortError");
             const errorMessage = aborted ? undefined : `Compaction failed: ${message}`;
             this._clearManualCompactionState();
             this._emit({
@@ -1995,6 +2143,13 @@ export class AgentSession {
                 willRetry: false,
                 errorMessage,
             });
+            await this._emitSessionCompactFailed({
+                reason: "manual",
+                errorMessage,
+                aborted,
+                willRetry: false,
+                fromExtension,
+            });
             throw error;
         }
         finally {
@@ -2034,7 +2189,7 @@ export class AgentSession {
     async _checkCompaction(assistantMessage, skipAbortedCheck = true, externalSignal) {
         if (externalSignal?.aborted)
             return false;
-        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
@@ -2066,7 +2221,9 @@ export class AgentSession {
         if (contextOverflow || recoverableLength) {
             const willRetry = assistantMessage.stopReason !== "stop";
             if (!willRetry) {
-                return await this._runAutoCompaction("overflow", false, undefined, undefined, externalSignal);
+                return externalSignal
+                    ? await this._runAutoCompaction("overflow", false, undefined, undefined, externalSignal)
+                    : await this._runAutoCompaction("overflow", false);
             }
             if (this._overflowRecoveryAttempted) {
                 const errorMessage = contextOverflow
@@ -2125,7 +2282,9 @@ export class AgentSession {
             contextTokens = directContextTokens;
         }
         if (shouldCompact(contextTokens, contextWindow, settings)) {
-            return await this._runAutoCompaction("threshold", false, undefined, undefined, externalSignal);
+            return externalSignal
+                ? await this._runAutoCompaction("threshold", false, undefined, undefined, externalSignal)
+                : await this._runAutoCompaction("threshold", false);
         }
         return false;
     }
@@ -2133,27 +2292,28 @@ export class AgentSession {
      * Internal: Run auto-compaction with events.
      */
     async _runAutoCompaction(reason, willRetry, preparationOverride, preparationOptions, externalSignal) {
-        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;
         if (externalSignal?.aborted)
             return false;
-        const abortExternal = () => this._autoCompactionAbortController?.abort();
+        const abortExternal = () => abortController?.abort();
         externalSignal?.addEventListener("abort", abortExternal, { once: true });
         try {
-            if (!this.model) {
+            if (!model) {
                 return false;
             }
-            const { model: requestModel, apiKey, headers, env } = await this._getSummarizationRequestAuth(this.model);
-            if (externalSignal?.aborted)
-                return false;
             if (isPiServerMode()) {
-                this._emit({ type: "compaction_start", reason });
-                this._autoCompactionAbortController = new AbortController();
-                if (externalSignal?.aborted)
-                    this._autoCompactionAbortController.abort();
+                abortController = new AbortController();
+                this._autoCompactionAbortController = abortController;
                 started = true;
-                const signal = this._autoCompactionAbortController.signal;
+                this._emit({ type: "compaction_start", reason });
+                abortController.signal.throwIfAborted();
+                const { model: requestModel, apiKey, headers, } = await this._getSummarizationRequestAuth(model, abortController.signal);
+                abortController.signal.throwIfAborted();
                 const piServerResult = await compactPiServer(requestModel, {
                     systemPrompt: this.systemPrompt,
                     messages: this.agent.state.messages,
@@ -2164,13 +2324,19 @@ export class AgentSession {
                     headers,
                     settings,
                     preparation: preparationOptions,
-                    sessionTree: { entries: this.sessionManager.getEntries(), leafId: this.sessionManager.getLeafId() },
-                    signal,
+                    sessionTree: buildPiServerSessionTree(this.sessionManager.getEntries(), this.sessionManager.getLeafId()),
+                    signal: abortController.signal,
                     reasoning: toProviderReasoning(this.thinkingLevel),
                     onHistoryReconciled: (snapshot) => this.reconcilePiServerHistory(snapshot),
                 });
-                if (externalSignal?.aborted || signal.aborted) {
+                if (externalSignal?.aborted || abortController.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;
                 }
                 const result = await this._applyPiServerCompactionResult(piServerResult, reason, willRetry);
@@ -2179,17 +2345,17 @@ export class AgentSession {
                 return willRetry ? true : this.agent.hasQueuedMessages();
             }
             const pathEntries = this.sessionManager.getBranch();
-            if (externalSignal?.aborted)
-                return false;
             const preparation = preparationOverride ?? prepareCompaction(pathEntries, settings);
             if (!preparation) {
                 return false;
             }
-            this._emit({ type: "compaction_start", reason });
-            this._autoCompactionAbortController = new AbortController();
-            if (externalSignal?.aborted)
-                this._autoCompactionAbortController.abort();
+            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({
@@ -2199,36 +2365,24 @@ 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;
             let usage;
             let details;
             if (extensionCompaction) {
-                // Extension provided compaction content
                 summary = extensionCompaction.summary;
                 firstKeptEntryId = extensionCompaction.firstKeptEntryId;
                 tokensBefore = extensionCompaction.tokensBefore;
@@ -2236,22 +2390,15 @@ export class AgentSession {
                 details = extensionCompaction.details;
             }
             else {
-                // Generate compaction result
-                const compactResult = await compact(preparation, requestModel, apiKey, headers, undefined, this._autoCompactionAbortController.signal, this.thinkingLevel, this.agent.streamFunction, env, this.settingsManager.getRetrySettings(), this._summarizationRetryCallbacks({ source: "compaction", reason }));
+                const compactResult = await compact(preparation, requestModel, apiKey, headers, undefined, abortController.signal, this.thinkingLevel, this.agent.streamFunction, env, this.settingsManager.getRetrySettings(), this._summarizationRetryCallbacks({ source: "compaction", reason }));
                 summary = compactResult.summary;
                 firstKeptEntryId = compactResult.firstKeptEntryId;
                 tokensBefore = compactResult.tokensBefore;
                 usage = compactResult.usage;
                 details = compactResult.details;
             }
-            if (externalSignal?.aborted || this._autoCompactionAbortController.signal.aborted) {
-                this._emit({
-                    type: "compaction_end",
-                    reason,
-                    result: undefined,
-                    aborted: true,
-                    willRetry: false,
-                });
+            if (externalSignal?.aborted || abortController.signal.aborted) {
+                this._emit({ type: "compaction_end", reason, result: undefined, aborted: true, willRetry: false });
                 await this._emitSessionCompactFailed({
                     reason,
                     aborted: true,
@@ -2260,12 +2407,12 @@ export class AgentSession {
                 });
                 return false;
             }
+            abortController.signal.throwIfAborted();
             this.sessionManager.appendCompaction(summary, firstKeptEntryId, tokensBefore, details, fromExtension, usage);
             const newEntries = this.sessionManager.getEntries();
             const sessionContext = this.sessionManager.buildSessionContext();
             this.agent.state.messages = sessionContext.messages;
             const estimatedTokensAfter = estimateMessagesTokens(sessionContext.messages);
-            // Get the saved compaction entry for the extension event
             const savedCompactionEntry = newEntries.find((e) => e.type === "compaction" && e.summary === summary);
             if (this._extensionRunner && savedCompactionEntry) {
                 await this._extensionRunner.emit({
@@ -2288,38 +2435,34 @@ export class AgentSession {
             if (willRetry) {
                 const messages = this.agent.state.messages;
                 const lastMsg = messages[messages.length - 1];
-                // The overflow response was persisted on message_end before _checkCompaction() removed it
-                // from agent state. Rebuilding state from the new compaction can restore that kept entry,
-                // leaving an assistant as the final message. agent.continue() rejects that state, so remove
-                // the retriable error or truncated-length response again before continuing the interrupted turn.
                 if (lastMsg?.role === "assistant" && (lastMsg.stopReason === "error" || lastMsg.stopReason === "length")) {
                     this.agent.state.messages = messages.slice(0, -1);
                 }
                 return true;
             }
-            // Auto-compaction can complete while follow-up/steering/custom messages are waiting.
-            // Continue once so queued messages are delivered.
             return this.agent.hasQueuedMessages();
         }
         catch (error) {
-            const errorMessage = error instanceof Error ? error.message : "compaction failed";
+            const message = error instanceof Error ? error.message : "compaction failed";
+            const aborted = externalSignal?.aborted === true || abortController?.signal.aborted === true || cancelledByExtension;
             if (started) {
+                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: reason === "overflow"
-                        ? `Context overflow recovery failed: ${errorMessage}`
-                        : `Auto-compaction failed: ${errorMessage}`,
+                    errorMessage,
                 });
                 await this._emitSessionCompactFailed({
                     reason,
-                    errorMessage: reason === "overflow"
-                        ? `Context overflow recovery failed: ${errorMessage}`
-                        : `Auto-compaction failed: ${errorMessage}`,
-                    aborted: false,
+                    errorMessage,
+                    aborted,
                     willRetry: false,
                     fromExtension,
                 });
@@ -2328,7 +2471,9 @@ export class AgentSession {
         }
         finally {
             externalSignal?.removeEventListener("abort", abortExternal);
-            this._autoCompactionAbortController = undefined;
+            if (this._autoCompactionAbortController === abortController) {
+                this._autoCompactionAbortController = undefined;
+            }
             this._resolveIdleWaitIfIdle();
         }
     }
@@ -2343,7 +2488,7 @@ export class AgentSession {
         return this.settingsManager.getCompactionEnabled();
     }
     _shouldCompactBeforeNextProviderRequest(turn) {
-        const settings = this.settingsManager.getCompactionSettings();
+        const settings = this.settingsManager.getCompactionSettings(this.model);
         if (!settings.enabled || turn.toolResults.length === 0)
             return false;
         const contextWindow = this.model?.contextWindow ?? 0;
@@ -2369,7 +2514,6 @@ export class AgentSession {
         return {
             ...baseContext,
             messages: this.agent.state.messages.slice(),
-            systemPrompt: this._systemPromptOverride ?? this._baseSystemPrompt,
             tools: this.agent.state.tools.slice(),
         };
     }
@@ -2377,7 +2521,7 @@ export class AgentSession {
         if (signal?.aborted || !this._shouldCompactBeforeNextProviderRequest(turn)) {
             return undefined;
         }
-        const settings = this.settingsManager.getCompactionSettings();
+        const settings = this.settingsManager.getCompactionSettings(this.model);
         const markerParentId = this.sessionManager.getLeafId();
         const markerId = this._appendIntraTurnCompactionMarker();
         const preparationOptions = { firstKeptEntryId: markerId };
@@ -2433,8 +2577,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) => {
@@ -2786,6 +2929,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
@@ -2801,7 +2956,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,
@@ -2838,14 +2993,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 {
@@ -3003,6 +3151,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) {
@@ -3150,6 +3301,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",
@@ -3201,7 +3353,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")
@@ -3337,6 +3492,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
     // =========================================================================