@code-yeongyu/senpi 2026.7.4 → 2026.7.9-2

package/dist/core/agent-session.js

@@ -15,6 +15,7 @@
 import { randomUUID } from "node:crypto";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { basename, dirname } from "node:path";
+import { prepareAgentToolCall } from "@earendil-works/pi-agent-core";
 import { cleanupSessionResources, isContextOverflow, 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";
@@ -27,12 +28,13 @@ import { DEFAULT_THINKING_LEVEL } from "./defaults.js";
 import { buildDynamicSystemPrompt } from "./dynamic-prompt/index.js";
 import { exportSessionToHtml } from "./export-html/index.js";
 import { createToolHtmlRenderer } from "./export-html/tool-renderer.js";
-import { ExtensionRunner, wrapRegisteredTools, } from "./extensions/index.js";
+import { ExecuteToolError, ExtensionRunner, wrapRegisteredTools, } from "./extensions/index.js";
 import { emitSessionShutdownEvent } from "./extensions/runner.js";
 import { filterContextExcludedMessages } from "./messages.js";
 import { getModelNarrowingPatterns, resolveModelScope } from "./model-resolver.js";
 import { expandPromptTemplate } from "./prompt-templates.js";
 import { buildSessionContext, CURRENT_SESSION_VERSION, getLatestCompactionEntry, } from "./session-manager.js";
+import { generateSessionTitle, shouldSkipSessionTitle } from "./session-title-generator.js";
 import { SessionWorkBarrier } from "./session-work-barrier.js";
 import { createSyntheticSourceInfo } from "./source-info.js";
 import { getSupportedThinkingLevels, supportsMax, supportsXhigh } from "./thinking-levels.js";
@@ -68,6 +70,13 @@ function estimateMessagesTokens(messages) {
     }
     return tokens;
 }
+function isSameOverflowSource(message, model, upstreamModelId) {
+    if (message.provider !== model.provider)
+        return false;
+    if (message.model === model.id)
+        return true;
+    return message.model === upstreamModelId;
+}
 // ============================================================================
 // Constants
 // ============================================================================
@@ -80,6 +89,7 @@ export class AgentSession {
     constructor(config) {
         this._eventListeners = [];
         this._agentEventQueue = Promise.resolve();
+        this._isAgentRunActive = false;
         /** Tracks pending steering messages for UI display. Removed when delivered. */
         this._steeringMessages = [];
         /** Tracks pending follow-up messages for UI display. Removed when delivered. */
@@ -94,6 +104,8 @@ export class AgentSession {
         this._messageRevision = 0;
         // Branch summarization state
         this._branchSummaryAbortController = undefined;
+        this._sessionTitleAbortController = undefined;
+        this._sessionTitlePromise = undefined;
         // Retry state
         this._retryAbortController = undefined;
         this._retryAttempt = 0;
@@ -143,6 +155,7 @@ export class AgentSession {
         this._excludedToolNames = config.excludedToolNames ? new Set(config.excludedToolNames) : undefined;
         this._baseToolsOverride = config.baseToolsOverride;
         this._sessionStartEvent = config.sessionStartEvent ?? { type: "session_start", reason: "startup" };
+        this._autoTitleSessions = config.autoTitleSessions ?? false;
         const initialModel = this.agent.state.model;
         if (initialModel) {
             const scopedMatch = this._scopedModels.find((sm) => modelsAreEqual(sm.model, initialModel));
@@ -198,48 +211,54 @@ export class AgentSession {
      */
     _installAgentToolHooks() {
         this.agent.beforeToolCall = async ({ toolCall, args }) => {
-            const runner = this._extensionRunner;
-            if (!runner.hasHandlers("tool_call")) {
-                return undefined;
-            }
-            await this._agentEventQueue;
-            try {
-                return await runner.emitToolCall({
-                    type: "tool_call",
-                    toolName: toolCall.name,
-                    toolCallId: toolCall.id,
-                    input: args,
-                });
-            }
-            catch (err) {
-                if (err instanceof Error) {
-                    throw err;
-                }
-                throw new Error(`Extension failed, blocking execution: ${String(err)}`);
-            }
+            return this._emitBeforeToolCallHooks(toolCall, args);
         };
         this.agent.afterToolCall = async ({ toolCall, args, result, isError }) => {
-            const runner = this._extensionRunner;
-            if (!runner.hasHandlers("tool_result")) {
-                return undefined;
-            }
-            const hookResult = await runner.emitToolResult({
-                type: "tool_result",
+            return this._emitAfterToolCallHooks(toolCall, args, result, isError);
+        };
+    }
+    async _emitBeforeToolCallHooks(toolCall, args) {
+        await this._agentEventQueue;
+        const runner = this._extensionRunner;
+        if (!runner.hasHandlers("tool_call")) {
+            return undefined;
+        }
+        try {
+            return await runner.emitToolCall({
+                type: "tool_call",
                 toolName: toolCall.name,
                 toolCallId: toolCall.id,
                 input: args,
-                content: result.content,
-                details: result.details,
-                isError,
             });
-            if (!hookResult) {
-                return undefined;
+        }
+        catch (err) {
+            if (err instanceof Error) {
+                throw err;
             }
-            return {
-                content: hookResult.content,
-                details: hookResult.details,
-                isError: hookResult.isError ?? isError,
-            };
+            throw new Error(`Extension failed, blocking execution: ${String(err)}`);
+        }
+    }
+    async _emitAfterToolCallHooks(toolCall, args, result, isError) {
+        const runner = this._extensionRunner;
+        if (!runner.hasHandlers("tool_result")) {
+            return undefined;
+        }
+        const hookResult = await runner.emitToolResult({
+            type: "tool_result",
+            toolName: toolCall.name,
+            toolCallId: toolCall.id,
+            input: args,
+            content: result.content,
+            details: result.details,
+            isError,
+        });
+        if (!hookResult) {
+            return undefined;
+        }
+        return {
+            content: hookResult.content,
+            details: hookResult.details,
+            isError: hookResult.isError ?? isError,
         };
     }
     _installAgentNextTurnRefresh() {
@@ -287,6 +306,14 @@ export class AgentSession {
     async _waitForSettledSessionWork() {
         await this._sessionWorkBarrier.waitForSettled(() => this._agentEventQueue);
     }
+    async waitForSettledSessionWork() {
+        await this._waitForSettledSessionWork();
+        const titlePromise = this._sessionTitlePromise;
+        if (titlePromise !== undefined) {
+            await titlePromise;
+        }
+        await this._waitForSettledSessionWork();
+    }
     _modelSelectionChangesContext(previousModel, nextModel) {
         if (!modelsAreEqual(previousModel, nextModel))
             return true;
@@ -297,6 +324,47 @@ export class AgentSession {
         this.abortBranchSummary();
         this._incrementMessageRevision();
     }
+    _getIdleWaitPromise() {
+        if (!this._idleWaitPromise) {
+            this._idleWaitPromise = new Promise((resolve) => {
+                this._resolveIdleWait = resolve;
+            });
+        }
+        return this._idleWaitPromise;
+    }
+    _resolveIdleWaitIfIdle() {
+        if (this._isAgentRunActive || !this._resolveIdleWait) {
+            return;
+        }
+        const resolve = this._resolveIdleWait;
+        this._idleWaitPromise = undefined;
+        this._resolveIdleWait = undefined;
+        resolve();
+    }
+    async _emitAgentSettled() {
+        if (!this._isAgentRunActive) {
+            this._resolveIdleWaitIfIdle();
+            return;
+        }
+        this._isAgentRunActive = false;
+        try {
+            await this._extensionRunner.emit({ type: "agent_settled" });
+            this._emit({ type: "agent_settled" });
+        }
+        finally {
+            this._resolveIdleWaitIfIdle();
+        }
+    }
+    async _promptAgent(messages) {
+        this._isAgentRunActive = true;
+        try {
+            await this.agent.prompt(messages);
+        }
+        catch (error) {
+            await this._emitAgentSettled();
+            throw error;
+        }
+    }
     _createRetryPromiseForAgentEnd(event) {
         if (event.type !== "agent_end" || this._retryPromise) {
             return;
@@ -322,6 +390,34 @@ export class AgentSession {
         }
         return undefined;
     }
+    _agentEndAllowsQueuedContinuation(messages) {
+        let lastAssistantIndex = -1;
+        for (let index = messages.length - 1; index >= 0; index--) {
+            if (messages[index]?.role === "assistant") {
+                lastAssistantIndex = index;
+                break;
+            }
+        }
+        if (lastAssistantIndex === -1) {
+            return false;
+        }
+        const lastAssistant = messages[lastAssistantIndex];
+        if (lastAssistant?.role !== "assistant") {
+            return false;
+        }
+        if (lastAssistant.stopReason === "aborted" || lastAssistant.stopReason === "error") {
+            return false;
+        }
+        for (let index = lastAssistantIndex + 1; index < messages.length; index++) {
+            const message = messages[index];
+            if (message?.role === "toolResult" &&
+                message.isError &&
+                message.content.some((content) => content.type === "text" && /\babort(?:ed)?\b/i.test(content.text))) {
+                return false;
+            }
+        }
+        return true;
+    }
     _willRetryAfterAgentEnd(messages) {
         const settings = this.settingsManager.getRetrySettings();
         if (!settings.enabled) {
@@ -404,6 +500,8 @@ export class AgentSession {
             }
         }
         // Check auto-retry and auto-compaction after agent completes
+        let launchedContinuation = false;
+        const allowsQueuedContinuation = event.type === "agent_end" ? this._agentEndAllowsQueuedContinuation(event.messages) : false;
         if (event.type === "agent_end" && this._lastAssistantMessage) {
             const msg = this._lastAssistantMessage;
             this._lastAssistantMessage = undefined;
@@ -414,10 +512,16 @@ export class AgentSession {
                     return; // Retry was initiated, don't proceed to compaction
             }
             this._resolveRetry();
-            await this._checkCompaction(msg);
+            launchedContinuation = await this._checkCompaction(msg);
         }
         if (event.type === "agent_end") {
             this._flushPendingBashMessages();
+            if (!launchedContinuation && allowsQueuedContinuation && this.agent.hasQueuedMessages()) {
+                launchedContinuation = await this._continueAgentAfterCurrentRun();
+            }
+            if (!launchedContinuation) {
+                await this._emitAgentSettled();
+            }
         }
     }
     /** Resolve the pending retry promise */
@@ -511,7 +615,16 @@ export class AgentSession {
             };
             const replacement = await this._extensionRunner.emitMessageEnd(extensionEvent);
             if (replacement) {
-                this._replaceMessageInPlace(event.message, replacement);
+                // Untyped extension handlers can return messages with null/missing content;
+                // normalize so it never enters agent state or session history.
+                const normalized = (replacement.role === "user" ||
+                    replacement.role === "assistant" ||
+                    replacement.role === "toolResult" ||
+                    replacement.role === "custom") &&
+                    replacement.content == null
+                    ? { ...replacement, content: [] }
+                    : replacement;
+                this._replaceMessageInPlace(event.message, normalized);
             }
         }
         else if (event.type === "tool_execution_start") {
@@ -588,6 +701,7 @@ export class AgentSession {
             this.abortRetry();
             this.abortCompaction();
             this.abortBranchSummary();
+            this.abortSessionTitleGeneration();
             this.abortBash();
             this.agent.abort();
         }
@@ -617,9 +731,13 @@ export class AgentSession {
     get serviceTier() {
         return this._currentServiceTier;
     }
-    /** Whether agent is currently streaming a response */
+    /** Whether the session is currently processing an agent run or post-run continuation. */
     get isStreaming() {
-        return this.agent.state.isStreaming;
+        return this._isAgentRunActive;
+    }
+    /** Whether the session has no active agent run, retry, auto-compaction, or queued continuation. */
+    get isIdle() {
+        return !this._isAgentRunActive;
     }
     /** Current effective system prompt (includes any per-turn extension modifications) */
     get systemPrompt() {
@@ -651,6 +769,56 @@ export class AgentSession {
     getToolDefinition(name) {
         return this._toolDefinitions.get(name)?.definition;
     }
+    async executeTool(toolName, params, options) {
+        const activeTools = this.getActiveToolNames();
+        const tool = this.agent.state.tools.find((candidate) => candidate.name === toolName);
+        if (!tool) {
+            const knownToolNames = new Set(this._toolDefinitions.keys());
+            const code = knownToolNames.has(toolName) ? "inactive_tool" : "unknown_tool";
+            const activeList = activeTools.length > 0 ? activeTools.join(", ") : "(none)";
+            throw new ExecuteToolError(code, toolName, code === "inactive_tool"
+                ? `Tool ${toolName} is registered but inactive. Active tools: ${activeList}`
+                : `Unknown tool ${toolName}. Active tools: ${activeList}`, activeTools);
+        }
+        const toolCall = {
+            type: "toolCall",
+            id: `codemode-${randomUUID()}`,
+            name: toolName,
+            arguments: params,
+        };
+        let prepared;
+        try {
+            prepared = prepareAgentToolCall(tool, toolCall);
+        }
+        catch (err) {
+            throw new ExecuteToolError("invalid_params", toolName, err instanceof Error ? err.message : String(err), activeTools);
+        }
+        const beforeResult = await this._emitBeforeToolCallHooks(prepared.toolCall, prepared.args);
+        if (beforeResult?.block) {
+            throw new ExecuteToolError("blocked", toolName, beforeResult.reason || "Tool execution was blocked", activeTools);
+        }
+        let result;
+        let isError = false;
+        try {
+            result = await prepared.tool.execute(prepared.toolCall.id, prepared.args, options?.signal, options?.onUpdate);
+        }
+        catch (err) {
+            result = {
+                content: [{ type: "text", text: err instanceof Error ? err.message : String(err) }],
+                details: {},
+            };
+            isError = true;
+        }
+        const hookResult = await this._emitAfterToolCallHooks(prepared.toolCall, prepared.args, result, isError);
+        if (!hookResult) {
+            return result;
+        }
+        return {
+            content: hookResult.content ?? result.content,
+            details: (hookResult.details ?? result.details),
+            terminate: result.terminate,
+        };
+    }
     /**
      * Set active tools by name.
      * Only tools in the registry can be enabled. Unknown tool names are ignored.
@@ -817,6 +985,7 @@ export class AgentSession {
         const expandPromptTemplates = options?.expandPromptTemplates ?? true;
         const preflightResult = options?.preflightResult;
         let messages;
+        let titlePrompt;
         try {
             // Handle extension commands first (execute immediately, even during streaming)
             // Extension commands manage their own LLM interaction via pi.sendMessage()
@@ -848,6 +1017,7 @@ export class AgentSession {
                 expandedText = this._expandSkillCommand(expandedText);
                 expandedText = expandPromptTemplate(expandedText, [...this.promptTemplates]);
             }
+            titlePrompt = options?.sessionTitlePrompt === false ? undefined : (options?.sessionTitlePrompt ?? text);
             // If streaming, queue via steer() or followUp() based on option
             if (this.isStreaming) {
                 if (!options?.streamingBehavior) {
@@ -908,7 +1078,8 @@ export class AgentSession {
                     messages.push({
                         role: "custom",
                         customType: msg.customType,
-                        content: msg.content,
+                        // Untyped extensions can pass null/missing content; normalize at ingestion.
+                        content: msg.content ?? [],
                         display: msg.display,
                         details: msg.details,
                         timestamp: Date.now(),
@@ -934,14 +1105,18 @@ export class AgentSession {
             return;
         }
         preflightResult?.(true);
-        await this.agent.prompt(messages);
+        await this._promptAgent(messages);
         await this.waitForRetry();
+        await this.waitForIdle();
         if (shouldWaitForSessionWork) {
             await this._waitForSettledSessionWork();
         }
         else {
             await this.agent.waitForIdle();
         }
+        if (titlePrompt !== undefined) {
+            this._startSessionTitleGeneration(titlePrompt);
+        }
     }
     /**
      * Try to execute an extension command. Returns true if command was found and executed.
@@ -1035,6 +1210,74 @@ export class AgentSession {
         expandedText = expandPromptTemplate(expandedText, [...this.promptTemplates]);
         await this._queueFollowUp(expandedText, images);
     }
+    _startSessionTitleGeneration(firstPrompt) {
+        if (!this._autoTitleSessions || this.sessionManager.getSessionName() || shouldSkipSessionTitle(firstPrompt)) {
+            return;
+        }
+        if (this._sessionTitleAbortController !== undefined) {
+            return;
+        }
+        const model = this.model;
+        if (!model) {
+            return;
+        }
+        const abortController = new AbortController();
+        this._sessionTitleAbortController = abortController;
+        this._sessionTitlePromise = this._generateSessionTitle(firstPrompt, model, abortController);
+    }
+    async _generateSessionTitle(firstPrompt, model, abortController) {
+        try {
+            const auth = await this._getCompactionRequestAuth(model);
+            const title = await generateSessionTitle({
+                firstPrompt,
+                model,
+                auth,
+                sessionId: this.sessionId,
+                baseOptions: this._buildSessionTitleBaseOptions(),
+                signal: abortController.signal,
+                streamFn: this.agent.streamFn,
+            });
+            if (abortController.signal.aborted) {
+                return;
+            }
+            if (title && !this.sessionManager.getSessionName()) {
+                this.setSessionName(title);
+            }
+        }
+        catch (error) {
+            if (abortController.signal.aborted) {
+                return;
+            }
+            const message = error instanceof Error ? error.message : String(error);
+            this._extensionRunner.emitError({
+                extensionPath: "<runtime>",
+                event: "session_title_generation",
+                error: message,
+            });
+        }
+        finally {
+            if (this._sessionTitleAbortController === abortController) {
+                this._sessionTitleAbortController = undefined;
+            }
+            if (this._sessionTitlePromise !== undefined) {
+                this._sessionTitlePromise = undefined;
+            }
+        }
+    }
+    abortSessionTitleGeneration() {
+        this._sessionTitleAbortController?.abort();
+        this._sessionTitleAbortController = undefined;
+    }
+    _buildSessionTitleBaseOptions() {
+        return {
+            onPayload: this.agent.onPayload,
+            onResponse: this.agent.onResponse,
+            transport: this.agent.transport,
+            thinkingBudgets: this.agent.thinkingBudgets,
+            timeoutMs: this.agent.timeoutMs,
+            maxRetryDelayMs: this.agent.maxRetryDelayMs,
+        };
+    }
     /**
      * Internal: Queue a steering message (already expanded, no extension command check).
      */
@@ -1094,7 +1337,8 @@ export class AgentSession {
         const appMessage = {
             role: "custom",
             customType: message.customType,
-            content: message.content,
+            // Untyped extensions can pass null/missing content; normalize at ingestion.
+            content: message.content ?? [],
             display: message.display,
             details: message.details,
             timestamp: Date.now(),
@@ -1111,7 +1355,7 @@ export class AgentSession {
             }
         }
         else if (options?.triggerTurn) {
-            await this.agent.prompt(appMessage);
+            await this._promptAgent(appMessage);
         }
         else {
             this.agent.state.messages.push(appMessage);
@@ -1156,6 +1400,7 @@ export class AgentSession {
             streamingBehavior: options?.deliverAs,
             images,
             source: "extension",
+            sessionTitlePrompt: false,
         });
     }
     /**
@@ -1201,7 +1446,7 @@ export class AgentSession {
         }
         const abortPromise = (async () => {
             this.agent.abort();
-            await this.agent.waitForIdle();
+            await this.waitForIdle();
         })();
         this._userAbortPromise = abortPromise;
         try {
@@ -1213,6 +1458,12 @@ export class AgentSession {
             }
         }
     }
+    async waitForIdle() {
+        if (this.isIdle) {
+            return;
+        }
+        await this._getIdleWaitPromise();
+    }
     // =========================================================================
     // Model Management
     // =========================================================================
@@ -1697,23 +1948,24 @@ export class AgentSession {
     async _checkCompaction(assistantMessage, skipAbortedCheck = true, requestReason) {
         const settings = this.settingsManager.getCompactionSettings();
         if (!settings.enabled)
-            return;
+            return false;
         // Skip if message was aborted (user cancelled) - unless skipAbortedCheck is false
         if (skipAbortedCheck && assistantMessage.stopReason === "aborted")
-            return;
+            return false;
         const contextWindow = this.model?.contextWindow ?? 0;
         // Skip overflow check if the message came from a different model.
         // This handles the case where user switched from a smaller-context model (e.g. opus)
         // to a larger-context model (e.g. codex) - the overflow error from the old model
         // shouldn't trigger compaction for the new model.
-        const sameModel = this.model && assistantMessage.provider === this.model.provider && assistantMessage.model === this.model.id;
+        const sameModel = this.model &&
+            isSameOverflowSource(assistantMessage, this.model, this._modelRegistry.getUpstreamModelId(this.model));
         // Skip compaction checks if this assistant message is older than the latest
         // compaction boundary. This prevents a stale pre-compaction usage/error
         // from retriggering compaction on the first prompt after compaction.
         const compactionEntry = getLatestCompactionEntry(this.sessionManager.getBranch());
         const assistantIsFromBeforeCompaction = compactionEntry !== null && assistantMessage.timestamp <= new Date(compactionEntry.timestamp).getTime();
         if (assistantIsFromBeforeCompaction) {
-            return;
+            return false;
         }
         // Case 1: Overflow - LLM returned context overflow error.
         // If the saved assistant provider differs from the currently selected provider alias,
@@ -1725,8 +1977,7 @@ export class AgentSession {
         if (isContextOverflow(assistantMessage, contextWindow) && (sameModel || currentContextNeedsCompaction)) {
             const willRetry = assistantMessage.stopReason !== "stop";
             if (!willRetry) {
-                await this._runAutoCompaction("overflow", false);
-                return;
+                return await this._runAutoCompaction("overflow", false);
             }
             if (this._overflowRecoveryAttempted) {
                 const errorMessage = "Context overflow recovery failed after one compact-and-retry attempt. Try reducing context or switching to a larger-context model.";
@@ -1741,7 +1992,7 @@ export class AgentSession {
                 if (requestReason === "pre_prompt") {
                     throw new Error(errorMessage);
                 }
-                return;
+                return false;
             }
             this._overflowRecoveryAttempted = true;
             // Remove the error message from agent state (it IS saved to session for history,
@@ -1755,9 +2006,9 @@ export class AgentSession {
                 await this._runPrePromptCompaction(assistantMessage, skipAbortedCheck, "overflow", willRetry);
             }
             else {
-                await this._runAutoCompaction("overflow", willRetry);
+                return await this._runAutoCompaction("overflow", willRetry);
             }
-            return;
+            return false;
         }
         // Case 2: Threshold - context is getting large
         // For error messages or all-zero usage messages, estimate from the last valid response.
@@ -1769,7 +2020,7 @@ export class AgentSession {
             const messages = filterContextExcludedMessages(this.agent.state.messages);
             const estimate = estimateContextTokens(messages);
             if (estimate.lastUsageIndex === null)
-                return; // No usage data at all
+                return false; // No usage data at all
             // Verify the usage source is post-compaction. Kept pre-compaction messages
             // have stale usage reflecting the old (larger) context and would falsely
             // trigger compaction right after one just finished.
@@ -1777,7 +2028,7 @@ export class AgentSession {
             if (compactionEntry &&
                 usageMsg.role === "assistant" &&
                 usageMsg.timestamp <= new Date(compactionEntry.timestamp).getTime()) {
-                return;
+                return false;
             }
             contextTokens = estimate.tokens;
         }
@@ -1789,9 +2040,10 @@ export class AgentSession {
                 await this._runPrePromptCompaction(assistantMessage, skipAbortedCheck);
             }
             else {
-                await this._runAutoCompaction("threshold", false);
+                return await this._runAutoCompaction("threshold", false);
             }
         }
+        return false;
     }
     async _runPrePromptCompaction(lastAssistantMessage, skipAbortedCheck, reason = "pre_prompt", willRetry = false) {
         this._emit({ type: "compaction_start", reason });
@@ -2087,6 +2339,7 @@ export class AgentSession {
             setLabel: (entryId, label) => {
                 this.sessionManager.appendLabelChange(entryId, label);
             },
+            executeTool: (toolName, params, options) => this.executeTool(toolName, params, options),
             getActiveTools: () => this.getActiveToolNames(),
             getAllTools: () => this.getAllTools(),
             setActiveTools: (toolNames) => this.setActiveToolsByName(toolNames),
@@ -2103,7 +2356,7 @@ export class AgentSession {
         }, {
             getModel: () => this.model,
             getServiceTier: () => this.serviceTier,
-            isIdle: () => !this.isStreaming,
+            isIdle: () => this.isIdle,
             isProjectTrusted: () => this.settingsManager.isProjectTrusted(),
             getSignal: () => this.agent.signal,
             abort: () => {
@@ -2440,6 +2693,7 @@ export class AgentSession {
             const attempt = this._retryAttempt;
             this._retryAttempt = 0;
             this._retryAbortController = undefined;
+            await this._emitAgentSettled();
             this._emit({
                 type: "auto_retry_end",
                 success: false,
@@ -2796,28 +3050,44 @@ export class AgentSession {
         return "";
     }
     /**
-     * Get session statistics.
+     * Get session statistics. Aggregates over ALL session entries (including
+     * history that was compacted away), so token/cost totals reflect what was
+     * actually billed across the session.
      */
     getSessionStats() {
-        const state = this.state;
-        const userMessages = state.messages.filter((m) => m.role === "user").length;
-        const assistantMessages = state.messages.filter((m) => m.role === "assistant").length;
-        const toolResults = state.messages.filter((m) => m.role === "toolResult").length;
+        let userMessages = 0;
+        let assistantMessages = 0;
+        let toolResults = 0;
+        let totalMessages = 0;
         let toolCalls = 0;
         let totalInput = 0;
         let totalOutput = 0;
         let totalCacheRead = 0;
         let totalCacheWrite = 0;
         let totalCost = 0;
-        for (const message of state.messages) {
-            if (message.role === "assistant") {
+        for (const entry of this.sessionManager.getEntries()) {
+            if (entry.type !== "message")
+                continue;
+            totalMessages++;
+            const message = entry.message;
+            if (message.role === "user") {
+                userMessages++;
+            }
+            else if (message.role === "toolResult") {
+                toolResults++;
+            }
+            else if (message.role === "assistant") {
+                assistantMessages++;
                 const assistantMsg = message;
-                toolCalls += assistantMsg.content.filter((c) => c.type === "toolCall").length;
-                totalInput += assistantMsg.usage.input;
-                totalOutput += assistantMsg.usage.output;
-                totalCacheRead += assistantMsg.usage.cacheRead;
-                totalCacheWrite += assistantMsg.usage.cacheWrite;
-                totalCost += assistantMsg.usage.cost.total;
+                if (Array.isArray(assistantMsg.content)) {
+                    toolCalls += assistantMsg.content.filter((c) => c.type === "toolCall").length;
+                }
+                const usage = assistantMsg.usage;
+                totalInput += usage.input;
+                totalOutput += usage.output;
+                totalCacheRead += usage.cacheRead;
+                totalCacheWrite += usage.cacheWrite;
+                totalCost += usage.cost.total;
             }
         }
         return {
@@ -2827,7 +3097,7 @@ export class AgentSession {
             assistantMessages,
             toolCalls,
             toolResults,
-            totalMessages: state.messages.length,
+            totalMessages,
             tokens: {
                 input: totalInput,
                 output: totalOutput,