@codex-infinity/pi-infinity 0.52.2 → 0.60.1

package/dist/core/agent-session.js

@@ -24,7 +24,7 @@ import { calculateContextTokens, collectEntriesForBranchSummary, compact, estima
 import { DEFAULT_THINKING_LEVEL } from "./defaults.js";
 import { exportSessionToHtml } from "./export-html/index.js";
 import { createToolHtmlRenderer } from "./export-html/tool-renderer.js";
-import { ExtensionRunner, wrapRegisteredTools, wrapToolsWithExtensions, } from "./extensions/index.js";
+import { ExtensionRunner, wrapRegisteredTools, } from "./extensions/index.js";
 import { expandPromptTemplate } from "./prompt-templates.js";
 import { getLatestCompactionEntry } from "./session-manager.js";
 import { BUILTIN_SLASH_COMMANDS } from "./slash-commands.js";
@@ -63,6 +63,7 @@ export class AgentSession {
     // Event subscription state
     _unsubscribeAgent;
     _eventListeners = [];
+    _agentEventQueue = Promise.resolve();
     /** Tracks pending steering messages for UI display. Removed when delivered. */
     _steeringMessages = [];
     /** Tracks pending follow-up messages for UI display. Removed when delivered. */
@@ -72,6 +73,7 @@ export class AgentSession {
     // Compaction state
     _compactionAbortController = undefined;
     _autoCompactionAbortController = undefined;
+    _overflowRecoveryAttempted = false;
     // Branch summarization state
     _branchSummaryAbortController = undefined;
     // Retry state
@@ -104,6 +106,8 @@ export class AgentSession {
     _modelRegistry;
     // Tool registry for extension getTools/setTools
     _toolRegistry = new Map();
+    _toolPromptSnippets = new Map();
+    _toolPromptGuidelines = new Map();
     // Base system prompt (without extension appends) - used to apply fresh appends each turn
     _baseSystemPrompt = "";
     constructor(config) {
@@ -123,6 +127,7 @@ export class AgentSession {
         // Always subscribe to agent events for internal handling
         // (session persistence, extensions, auto-compaction, retry logic)
         this._unsubscribeAgent = this.agent.subscribe(this._handleAgentEvent);
+        this._installAgentToolHooks();
         this._buildRuntime({
             activeToolNames: this._initialActiveToolNames,
             includeAllExtensionTools: true,
@@ -132,6 +137,59 @@ export class AgentSession {
     get modelRegistry() {
         return this._modelRegistry;
     }
+    /**
+     * Install tool hooks once on the Agent instance.
+     *
+     * The callbacks read `this._extensionRunner` at execution time, so extension reload swaps in the
+     * new runner without reinstalling hooks. Extension-specific tool wrappers are still used to adapt
+     * registered tool execution to the extension context. Tool call and tool result interception now
+     * happens here instead of in wrappers.
+     */
+    _installAgentToolHooks() {
+        this.agent.setBeforeToolCall(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)}`);
+            }
+        });
+        this.agent.setAfterToolCall(async ({ 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: isError ? undefined : result.details,
+                isError,
+            });
+            if (!hookResult || isError) {
+                return undefined;
+            }
+            return {
+                content: hookResult.content,
+                details: hookResult.details,
+            };
+        });
+    }
     // =========================================================================
     // Event Subscription
     // =========================================================================
@@ -144,10 +202,47 @@ export class AgentSession {
     // Track last assistant message for auto-compaction check
     _lastAssistantMessage = undefined;
     /** Internal handler for agent events - shared by subscribe and reconnect */
-    _handleAgentEvent = async (event) => {
+    _handleAgentEvent = (event) => {
+        // Create retry promise synchronously before queueing async processing.
+        // Agent.emit() calls this handler synchronously, and prompt() calls waitForRetry()
+        // as soon as agent.prompt() resolves. If _retryPromise is created only inside
+        // _processAgentEvent, slow earlier queued events can delay agent_end processing
+        // and waitForRetry() can miss the in-flight retry.
+        this._createRetryPromiseForAgentEnd(event);
+        this._agentEventQueue = this._agentEventQueue.then(() => this._processAgentEvent(event), () => this._processAgentEvent(event));
+        // Keep queue alive if an event handler fails
+        this._agentEventQueue.catch(() => { });
+    };
+    _createRetryPromiseForAgentEnd(event) {
+        if (event.type !== "agent_end" || this._retryPromise) {
+            return;
+        }
+        const settings = this.settingsManager.getRetrySettings();
+        if (!settings.enabled) {
+            return;
+        }
+        const lastAssistant = this._findLastAssistantInMessages(event.messages);
+        if (!lastAssistant || !this._isRetryableError(lastAssistant)) {
+            return;
+        }
+        this._retryPromise = new Promise((resolve) => {
+            this._retryResolve = resolve;
+        });
+    }
+    _findLastAssistantInMessages(messages) {
+        for (let i = messages.length - 1; i >= 0; i--) {
+            const message = messages[i];
+            if (message.role === "assistant") {
+                return message;
+            }
+        }
+        return undefined;
+    }
+    async _processAgentEvent(event) {
         // When a user message starts, check if it's from either queue and remove it BEFORE emitting
         // This ensures the UI sees the updated queue state
         if (event.type === "message_start" && event.message.role === "user") {
+            this._overflowRecoveryAttempted = false;
             const messageText = this._getUserMessageText(event.message);
             if (messageText) {
                 // Check steering queue first
@@ -185,9 +280,12 @@ export class AgentSession {
             // Track assistant message for auto-compaction (checked on agent_end)
             if (event.message.role === "assistant") {
                 this._lastAssistantMessage = event.message;
+                const assistantMsg = event.message;
+                if (assistantMsg.stopReason !== "error") {
+                    this._overflowRecoveryAttempted = false;
+                }
                 // Reset retry counter immediately on successful assistant response
                 // This prevents accumulation across multiple LLM calls within a turn
-                const assistantMsg = event.message;
                 if (assistantMsg.stopReason !== "error" && this._retryAttempt > 0) {
                     this._emit({
                         type: "auto_retry_end",
@@ -213,7 +311,7 @@ export class AgentSession {
             // Queue autonomous follow-up if enabled (after compaction, so it has full context)
             this._maybeQueueAutonomousFollowUp(msg);
         }
-    };
+    }
     /** Resolve the pending retry promise */
     _resolveRetry() {
         if (this._retryResolve) {
@@ -432,9 +530,11 @@ export class AgentSession {
         this._baseSystemPrompt = this._rebuildSystemPrompt(validToolNames);
         this.agent.setSystemPrompt(this._baseSystemPrompt);
     }
-    /** Whether auto-compaction is currently running */
+    /** Whether compaction or branch summarization is currently running */
     get isCompacting() {
-        return this._autoCompactionAbortController !== undefined || this._compactionAbortController !== undefined;
+        return (this._autoCompactionAbortController !== undefined ||
+            this._compactionAbortController !== undefined ||
+            this._branchSummaryAbortController !== undefined);
     }
     /** All messages including custom types like BashExecutionMessage */
     get messages() {
@@ -472,8 +572,42 @@ export class AgentSession {
     get promptTemplates() {
         return this._resourceLoader.getPrompts().prompts;
     }
+    _normalizePromptSnippet(text) {
+        if (!text)
+            return undefined;
+        const oneLine = text
+            .replace(/[\r\n]+/g, " ")
+            .replace(/\s+/g, " ")
+            .trim();
+        return oneLine.length > 0 ? oneLine : undefined;
+    }
+    _normalizePromptGuidelines(guidelines) {
+        if (!guidelines || guidelines.length === 0) {
+            return [];
+        }
+        const unique = new Set();
+        for (const guideline of guidelines) {
+            const normalized = guideline.trim();
+            if (normalized.length > 0) {
+                unique.add(normalized);
+            }
+        }
+        return Array.from(unique);
+    }
     _rebuildSystemPrompt(toolNames) {
-        const validToolNames = toolNames.filter((name) => this._baseToolRegistry.has(name));
+        const validToolNames = toolNames.filter((name) => this._toolRegistry.has(name));
+        const toolSnippets = {};
+        const promptGuidelines = [];
+        for (const name of validToolNames) {
+            const snippet = this._toolPromptSnippets.get(name);
+            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;
@@ -486,6 +620,8 @@ export class AgentSession {
             customPrompt: loaderSystemPrompt,
             appendSystemPrompt,
             selectedTools: validToolNames,
+            toolSnippets,
+            promptGuidelines,
         });
     }
     // =========================================================================
@@ -673,8 +809,9 @@ export class AgentSession {
         }
     }
     /**
-     * Queue a steering message to interrupt the agent mid-run.
-     * Delivered after current tool execution, skips remaining tools.
+     * 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
      * @throws Error if text is an extension command
@@ -938,11 +1075,12 @@ export class AgentSession {
             throw new Error(`No API key for ${model.provider}/${model.id}`);
         }
         const previousModel = this.model;
+        const thinkingLevel = this._getThinkingLevelForModelSwitch();
         this.agent.setModel(model);
         this.sessionManager.appendModelChange(model.provider, model.id);
         this.settingsManager.setDefaultModelAndProvider(model.provider, model.id);
         // Re-clamp thinking level for new model's capabilities
-        this.setThinkingLevel(this.thinkingLevel);
+        this.setThinkingLevel(thinkingLevel);
         await this._emitModelSelect(model, previousModel, "set");
     }
     /**
@@ -987,12 +1125,16 @@ export class AgentSession {
         const len = scopedModels.length;
         const nextIndex = direction === "forward" ? (currentIndex + 1) % len : (currentIndex - 1 + len) % len;
         const next = scopedModels[nextIndex];
+        const thinkingLevel = this._getThinkingLevelForModelSwitch(next.thinkingLevel);
         // Apply model
         this.agent.setModel(next.model);
         this.sessionManager.appendModelChange(next.model.provider, next.model.id);
         this.settingsManager.setDefaultModelAndProvider(next.model.provider, next.model.id);
-        // Apply thinking level (setThinkingLevel clamps to model capabilities)
-        this.setThinkingLevel(next.thinkingLevel);
+        // Apply thinking level.
+        // - Explicit scoped model thinking level overrides current session level
+        // - Undefined scoped model thinking level inherits the current session preference
+        // setThinkingLevel clamps to model capabilities.
+        this.setThinkingLevel(thinkingLevel);
         await this._emitModelSelect(next.model, currentModel, "cycle");
         return { model: next.model, thinkingLevel: this.thinkingLevel, isScoped: true };
     }
@@ -1011,11 +1153,12 @@ export class AgentSession {
         if (!apiKey) {
             throw new Error(`No API key for ${nextModel.provider}/${nextModel.id}`);
         }
+        const thinkingLevel = this._getThinkingLevelForModelSwitch();
         this.agent.setModel(nextModel);
         this.sessionManager.appendModelChange(nextModel.provider, nextModel.id);
         this.settingsManager.setDefaultModelAndProvider(nextModel.provider, nextModel.id);
         // Re-clamp thinking level for new model's capabilities
-        this.setThinkingLevel(this.thinkingLevel);
+        this.setThinkingLevel(thinkingLevel);
         await this._emitModelSelect(nextModel, currentModel, "cycle");
         return { model: nextModel, thinkingLevel: this.thinkingLevel, isScoped: false };
     }
@@ -1035,7 +1178,9 @@ export class AgentSession {
         this.agent.setThinkingLevel(effectiveLevel);
         if (isChanging) {
             this.sessionManager.appendThinkingLevelChange(effectiveLevel);
-            this.settingsManager.setDefaultThinkingLevel(effectiveLevel);
+            if (this.supportsThinking() || effectiveLevel !== "off") {
+                this.settingsManager.setDefaultThinkingLevel(effectiveLevel);
+            }
         }
     }
     /**
@@ -1073,6 +1218,15 @@ export class AgentSession {
     supportsThinking() {
         return !!this.model?.reasoning;
     }
+    _getThinkingLevelForModelSwitch(explicitLevel) {
+        if (explicitLevel !== undefined) {
+            return explicitLevel;
+        }
+        if (!this.supportsThinking()) {
+            return this.settingsManager.getDefaultThinkingLevel() ?? DEFAULT_THINKING_LEVEL;
+        }
+        return this.thinkingLevel;
+    }
     _clampThinkingLevel(level, availableLevels) {
         const ordered = THINKING_LEVELS_WITH_XHIGH;
         const available = new Set(availableLevels);
@@ -1244,15 +1398,27 @@ export class AgentSession {
         // to a larger-context model (e.g. codex) - the overflow error from the old model
         // shouldn't trigger compaction for the new model.
         const sameModel = this.model && assistantMessage.provider === this.model.provider && assistantMessage.model === this.model.id;
-        // Skip overflow check if the error is from before a compaction in the current path.
-        // This handles the case where an error was kept after compaction (in the "kept" region).
-        // The error shouldn't trigger another compaction since we already compacted.
-        // Example: opus fails → switch to codex → compact → switch back to opus → opus error
-        // is still in context but shouldn't trigger compaction again.
+        // 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 errorIsFromBeforeCompaction = compactionEntry !== null && assistantMessage.timestamp < new Date(compactionEntry.timestamp).getTime();
+        const assistantIsFromBeforeCompaction = compactionEntry !== null && assistantMessage.timestamp <= new Date(compactionEntry.timestamp).getTime();
+        if (assistantIsFromBeforeCompaction) {
+            return;
+        }
         // Case 1: Overflow - LLM returned context overflow error
-        if (sameModel && !errorIsFromBeforeCompaction && isContextOverflow(assistantMessage, contextWindow)) {
+        if (sameModel && isContextOverflow(assistantMessage, contextWindow)) {
+            if (this._overflowRecoveryAttempted) {
+                this._emit({
+                    type: "auto_compaction_end",
+                    result: undefined,
+                    aborted: false,
+                    willRetry: false,
+                    errorMessage: "Context overflow recovery failed after one compact-and-retry attempt. Try reducing context or switching to a larger-context model.",
+                });
+                return;
+            }
+            this._overflowRecoveryAttempted = true;
             // Remove the error message from agent state (it IS saved to session for history,
             // but we don't want it in context for the retry)
             const messages = this.agent.state.messages;
@@ -1262,11 +1428,29 @@ export class AgentSession {
             await this._runAutoCompaction("overflow", true);
             return;
         }
-        // Case 2: Threshold - turn succeeded but context is getting large
-        // Skip if this was an error (non-overflow errors don't have usage data)
-        if (assistantMessage.stopReason === "error")
-            return;
-        const contextTokens = calculateContextTokens(assistantMessage.usage);
+        // Case 2: Threshold - context is getting large
+        // For error messages (no usage data), estimate from last successful response.
+        // This ensures sessions that hit persistent API errors (e.g. 529) can still compact.
+        let contextTokens;
+        if (assistantMessage.stopReason === "error") {
+            const messages = this.agent.state.messages;
+            const estimate = estimateContextTokens(messages);
+            if (estimate.lastUsageIndex === null)
+                return; // 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.
+            const usageMsg = messages[estimate.lastUsageIndex];
+            if (compactionEntry &&
+                usageMsg.role === "assistant" &&
+                usageMsg.timestamp <= new Date(compactionEntry.timestamp).getTime()) {
+                return;
+            }
+            contextTokens = estimate.tokens;
+        }
+        else {
+            contextTokens = calculateContextTokens(assistantMessage.usage);
+        }
         if (shouldCompact(contextTokens, contextWindow, settings)) {
             await this._runAutoCompaction("threshold", false);
         }
@@ -1467,6 +1651,17 @@ export class AgentSession {
             ? runner.onError(this._extensionErrorListener)
             : undefined;
     }
+    _refreshCurrentModelFromRegistry() {
+        const currentModel = this.model;
+        if (!currentModel) {
+            return;
+        }
+        const refreshedModel = this._modelRegistry.find(currentModel.provider, currentModel.id);
+        if (!refreshedModel || refreshedModel === currentModel) {
+            return;
+        }
+        this.agent.setModel(refreshedModel);
+    }
     _bindExtensionCore(runner) {
         const normalizeLocation = (source) => {
             if (source === "user" || source === "project" || source === "path") {
@@ -1535,6 +1730,7 @@ export class AgentSession {
             getActiveTools: () => this.getActiveToolNames(),
             getAllTools: () => this.getAllTools(),
             setActiveTools: (toolNames) => this.setActiveToolsByName(toolNames),
+            refreshTools: () => this._refreshToolRegistry(),
             getCommands,
             setModel: async (model) => {
                 const key = await this.modelRegistry.getApiKey(model);
@@ -1567,8 +1763,62 @@ export class AgentSession {
                 })();
             },
             getSystemPrompt: () => this.systemPrompt,
+        }, {
+            registerProvider: (name, config) => {
+                this._modelRegistry.registerProvider(name, config);
+                this._refreshCurrentModelFromRegistry();
+            },
+            unregisterProvider: (name) => {
+                this._modelRegistry.unregisterProvider(name);
+                this._refreshCurrentModelFromRegistry();
+            },
         });
     }
+    _refreshToolRegistry(options) {
+        const previousRegistryNames = new Set(this._toolRegistry.keys());
+        const previousActiveToolNames = this.getActiveToolNames();
+        const registeredTools = this._extensionRunner?.getAllRegisteredTools() ?? [];
+        const allCustomTools = [
+            ...registeredTools,
+            ...this._customTools.map((def) => ({ definition: def, extensionPath: "<sdk>" })),
+        ];
+        this._toolPromptSnippets = new Map(allCustomTools
+            .map((registeredTool) => {
+            const snippet = this._normalizePromptSnippet(registeredTool.definition.promptSnippet);
+            return snippet ? [registeredTool.definition.name, snippet] : undefined;
+        })
+            .filter((entry) => entry !== undefined));
+        this._toolPromptGuidelines = new Map(allCustomTools
+            .map((registeredTool) => {
+            const guidelines = this._normalizePromptGuidelines(registeredTool.definition.promptGuidelines);
+            return guidelines.length > 0 ? [registeredTool.definition.name, guidelines] : undefined;
+        })
+            .filter((entry) => entry !== undefined));
+        const wrappedExtensionTools = this._extensionRunner
+            ? wrapRegisteredTools(allCustomTools, this._extensionRunner)
+            : [];
+        const toolRegistry = new Map(this._baseToolRegistry);
+        for (const tool of wrappedExtensionTools) {
+            toolRegistry.set(tool.name, tool);
+        }
+        this._toolRegistry = toolRegistry;
+        const nextActiveToolNames = options?.activeToolNames
+            ? [...options.activeToolNames]
+            : [...previousActiveToolNames];
+        if (options?.includeAllExtensionTools) {
+            for (const tool of wrappedExtensionTools) {
+                nextActiveToolNames.push(tool.name);
+            }
+        }
+        else if (!options?.activeToolNames) {
+            for (const toolName of this._toolRegistry.keys()) {
+                if (!previousRegistryNames.has(toolName)) {
+                    nextActiveToolNames.push(toolName);
+                }
+            }
+        }
+        this.setActiveToolsByName([...new Set(nextActiveToolNames)]);
+    }
     _buildRuntime(options) {
         const autoResizeImages = this.settingsManager.getImageAutoResize();
         const shellCommandPrefix = this.settingsManager.getShellCommandPrefix();
@@ -1598,47 +1848,14 @@ export class AgentSession {
             this._bindExtensionCore(this._extensionRunner);
             this._applyExtensionBindings(this._extensionRunner);
         }
-        const registeredTools = this._extensionRunner?.getAllRegisteredTools() ?? [];
-        const allCustomTools = [
-            ...registeredTools,
-            ...this._customTools.map((def) => ({ definition: def, extensionPath: "<sdk>" })),
-        ];
-        const wrappedExtensionTools = this._extensionRunner
-            ? wrapRegisteredTools(allCustomTools, this._extensionRunner)
-            : [];
-        const toolRegistry = new Map(this._baseToolRegistry);
-        for (const tool of wrappedExtensionTools) {
-            toolRegistry.set(tool.name, tool);
-        }
         const defaultActiveToolNames = this._baseToolsOverride
             ? Object.keys(this._baseToolsOverride)
             : ["read", "bash", "edit", "write"];
         const baseActiveToolNames = options.activeToolNames ?? defaultActiveToolNames;
-        const activeToolNameSet = new Set(baseActiveToolNames);
-        if (options.includeAllExtensionTools) {
-            for (const tool of wrappedExtensionTools) {
-                activeToolNameSet.add(tool.name);
-            }
-        }
-        const extensionToolNames = new Set(wrappedExtensionTools.map((tool) => tool.name));
-        const activeBaseTools = Array.from(activeToolNameSet)
-            .filter((name) => this._baseToolRegistry.has(name) && !extensionToolNames.has(name))
-            .map((name) => this._baseToolRegistry.get(name));
-        const activeExtensionTools = wrappedExtensionTools.filter((tool) => activeToolNameSet.has(tool.name));
-        const activeToolsArray = [...activeBaseTools, ...activeExtensionTools];
-        if (this._extensionRunner) {
-            const wrappedActiveTools = wrapToolsWithExtensions(activeToolsArray, this._extensionRunner);
-            this.agent.setTools(wrappedActiveTools);
-            const wrappedAllTools = wrapToolsWithExtensions(Array.from(toolRegistry.values()), this._extensionRunner);
-            this._toolRegistry = new Map(wrappedAllTools.map((tool) => [tool.name, tool]));
-        }
-        else {
-            this.agent.setTools(activeToolsArray);
-            this._toolRegistry = toolRegistry;
-        }
-        const systemPromptToolNames = Array.from(activeToolNameSet).filter((name) => this._baseToolRegistry.has(name));
-        this._baseSystemPrompt = this._rebuildSystemPrompt(systemPromptToolNames);
-        this.agent.setSystemPrompt(this._baseSystemPrompt);
+        this._refreshToolRegistry({
+            activeToolNames: baseActiveToolNames,
+            includeAllExtensionTools: options.includeAllExtensionTools,
+        });
     }
     async reload() {
         const previousFlagValues = this._extensionRunner?.getFlagValues();
@@ -1675,8 +1892,8 @@ export class AgentSession {
         if (isContextOverflow(message, contextWindow))
             return false;
         const err = message.errorMessage;
-        // Match: overloaded_error, rate limit, 429, 500, 502, 503, 504, service unavailable, connection errors, fetch failed, terminated, retry delay exceeded
-        return /overloaded|rate.?limit|too many requests|429|500|502|503|504|service.?unavailable|server error|internal error|connection.?error|connection.?refused|other side closed|fetch failed|upstream.?connect|reset before headers|terminated|retry delay/i.test(err);
+        // Match: overloaded_error, provider returned error, rate limit, 429, 500, 502, 503, 504, service unavailable, network/connection errors, fetch failed, terminated, retry delay exceeded
+        return /overloaded|provider.?returned.?error|rate.?limit|too many requests|429|500|502|503|504|service.?unavailable|server.?error|internal.?error|network.?error|connection.?error|connection.?refused|other side closed|fetch failed|upstream.?connect|reset before headers|socket hang up|timed? out|timeout|terminated|retry delay/i.test(err);
     }
     /**
      * Check if autonomous mode is enabled and queue follow-up prompts.
@@ -1722,15 +1939,18 @@ export class AgentSession {
      */
     async _handleRetryableError(message) {
         const settings = this.settingsManager.getRetrySettings();
-        if (!settings.enabled)
+        if (!settings.enabled) {
+            this._resolveRetry();
             return false;
-        this._retryAttempt++;
-        // Create retry promise on first attempt so waitForRetry() can await it
-        if (this._retryAttempt === 1 && !this._retryPromise) {
+        }
+        // Retry promise is created synchronously in _handleAgentEvent for agent_end.
+        // Keep a defensive fallback here in case a future refactor bypasses that path.
+        if (!this._retryPromise) {
             this._retryPromise = new Promise((resolve) => {
                 this._retryResolve = resolve;
             });
         }
+        this._retryAttempt++;
         if (this._retryAttempt > settings.maxRetries) {
             // Max retries exceeded, emit final failure and reset
             this._emit({