@leanandmean/coding-agent 0.74.1-scramjet.72 → 0.74.1-scramjet.74

package/dist/core/agent-session.js

@@ -86,6 +86,15 @@ function rejectDeferred(deferred, error) {
 function settleDeferred(deferred, error) {
     return error ? rejectDeferred(deferred, error) : resolveDeferred(deferred, undefined);
 }
+function createRetryChain() {
+    return {
+        ...createDeferred(),
+        result: createDeferred(),
+        executions: 0,
+        terminal: false,
+        cancelled: false,
+    };
+}
 function validRecordedCost(value) {
     return typeof value === "number" && Number.isFinite(value) && value >= 0;
 }
@@ -320,6 +329,8 @@ export class AgentSession {
         this._agentEventQueue = processing;
         if (harnessAck)
             harnessAck.persistenceTail = processing;
+        if (runSettlement && this.agent.getRunExecution())
+            runSettlement.processingTail = processing;
         // Keep queue alive if an event handler fails
         processing.catch(() => { });
         // SCRAMJET-DIVERGENCE: turn_end tool/prompt changes must settle before Agent snapshots
@@ -396,11 +407,44 @@ export class AgentSession {
         if (event.type === "agent_start") {
             // A retry continuation's run adopts the chain its originating prompt awaits; the chain stays
             // bound to the retry phase until this start consumes it, however late Agent emits it.
-            const chain = this._retry?.phase === "continuing" ? this._retry.chain : createDeferred();
+            const chain = this._pendingAgentRunStart?.chain ??
+                (this._retry?.phase === "continuing" ? this._retry.chain : createRetryChain());
             this._unsettledRetryChains.add(chain);
-            const run = { ...createDeferred(), chain };
+            const run = {
+                ...createDeferred(),
+                chain,
+                execution: this._pendingAgentRunStart?.execution ?? createDeferred(),
+                processingTail: Promise.resolve(),
+            };
+            if (!this._pendingAgentRunStart) {
+                chain.executions++;
+                void this.agent
+                    .getRunExecution()
+                    .catch((error) => {
+                    chain.error ??= error instanceof Error ? error : new Error(String(error));
+                })
+                    .then(async () => {
+                    resolveDeferred(run.execution, undefined);
+                    try {
+                        await run.processingTail;
+                    }
+                    catch (error) {
+                        chain.error ??= error instanceof Error ? error : new Error(String(error));
+                    }
+                    finally {
+                        chain.executions--;
+                        this._trySettleRetryChain(chain);
+                    }
+                });
+            }
             this._activeAgentRunSettlement = run;
+            void run.execution.promise.then(() => {
+                if (this._activeAgentRunSettlement === run)
+                    this._activeAgentRunSettlement = undefined;
+            });
             this._unsettledAgentRuns.add(run);
+            if (chain.cancelled)
+                this.agent.abort();
             const reservation = this._pendingAgentRunStart;
             if (reservation) {
                 this._pendingAgentRunStart = undefined;
@@ -410,9 +454,9 @@ export class AgentSession {
             return run;
         }
         const run = this._activeAgentRunSettlement;
-        if (event.type === "agent_end" && this._activeAgentRunSettlement === run) {
-            this._activeAgentRunSettlement = undefined;
-        }
+        // An awaited end listener can still fail and emit another end before execution unwinds.
+        if (event.type === "agent_end" && run)
+            run.chain.terminal = false;
         return run;
     }
     _settleAgentRun(run, error) {
@@ -420,17 +464,50 @@ export class AgentSession {
             this._unsettledAgentRuns.delete(run);
     }
     _settleRetryChain(chain, error) {
-        if (settleDeferred(chain, error))
+        chain.terminal = true;
+        if (error)
+            chain.error = error;
+        this._trySettleRetryChain(chain);
+    }
+    _trySettleRetryChain(chain) {
+        if (!chain.terminal || chain.executions > 0 || chain.handoff)
+            return;
+        if (chain.error || chain.resultError) {
+            rejectDeferred(chain.result, chain.error ?? chain.resultError);
+        }
+        else {
+            const assistantMessage = chain.assistantMessage;
+            const result = chain.cancelled || assistantMessage?.stopReason === "aborted"
+                ? { status: "cancelled", assistantMessage }
+                : chain.errorMessage || !assistantMessage || assistantMessage.stopReason === "error"
+                    ? {
+                        status: "failed",
+                        assistantMessage,
+                        errorMessage: chain.errorMessage ??
+                            assistantMessage?.errorMessage ??
+                            "Run ended without a provider assistant result.",
+                    }
+                    : { status: "completed", assistantMessage };
+            resolveDeferred(chain.result, result);
+        }
+        if (settleDeferred(chain, chain.error))
             this._unsettledRetryChains.delete(chain);
     }
     _completeAgentRun(run, error) {
         this._settleAgentRun(run, error);
         this._settleRetryChain(run.chain, error);
     }
-    _reserveAgentRunStart() {
+    _reserveAgentRunStart(chain = createRetryChain()) {
+        if (this._disposed)
+            throw new Error("AgentSession disposed before run start.");
         if (this._pendingAgentRunStart)
             throw new Error("An Agent prompt is already waiting to start.");
-        const reservation = createDeferred();
+        this._unsettledRetryChains.add(chain);
+        const reservation = {
+            ...createDeferred(),
+            chain,
+            execution: createDeferred(),
+        };
         this._pendingAgentRunStart = reservation;
         return reservation;
     }
@@ -438,6 +515,7 @@ export class AgentSession {
         if (this._pendingAgentRunStart === reservation)
             this._pendingAgentRunStart = undefined;
         rejectDeferred(reservation, error);
+        this._settleRetryChain(reservation.chain, error);
     }
     // SCRAMJET-DIVERGENCE: harness-tool persisted settlement (#341). Synchronous ownership keeps queued
     // invocation events attributed after early failures; public settlement awaits execution and the final persistence tail.
@@ -525,7 +603,7 @@ export class AgentSession {
             }
         }
         // Emit to extensions first
-        await this._emitExtensionEvent(event);
+        await this._emitExtensionEvent(event, fromHarnessInvocation ? undefined : run?.chain.result.promise);
         if (event.type === "message_end" && event.message.role === "toolResult" && toolCost?.cost !== undefined) {
             event.message.cost = toolCost.cost;
         }
@@ -617,6 +695,14 @@ export class AgentSession {
             }
             const msg = run.persistedAssistantSnapshot;
             run.persistedAssistantSnapshot = undefined;
+            if (msg && msg.origin !== "harness")
+                run.chain.assistantMessage = msg;
+            if (run.chain.cancelled) {
+                if (this._retry)
+                    this._finishCancelledRetry("cancelled_during_continuation");
+                this._completeAgentRun(run);
+                return;
+            }
             if (!msg) {
                 this._releaseRetryForFailedRun(new Error("Retry continuation ended without an assistant message."));
                 this._completeAgentRun(run);
@@ -628,6 +714,8 @@ export class AgentSession {
                 return;
             }
             if (msg.stopReason !== "error") {
+                if (msg.stopReason === "aborted")
+                    run.chain.cancelled = true;
                 if (this._retry) {
                     const attempt = this._runRetryCount;
                     this._finishRetry({
@@ -637,11 +725,17 @@ export class AgentSession {
                         cumulativeErrors: this._bounded(attempt),
                     }, { type: "auto_retry_end", success: true, attempt });
                 }
+                await this._checkCompaction(msg, "settlement", run);
                 this._completeAgentRun(run);
-                await this._checkCompaction(msg);
                 return;
             }
             const classification = this._classifyRetry(msg);
+            if (msg.origin === "harness" && classification.kind !== "context_overflow") {
+                this._releaseRetryForFailedRun(new Error(msg.errorMessage ?? "Agent execution failed."));
+                run.chain.resultError = new Error(msg.errorMessage ?? "Agent execution failed.");
+                this._completeAgentRun(run);
+                return;
+            }
             if (classification.kind === "context_overflow") {
                 this._finishRetryWithoutSuccess({
                     schemaVersion: 1,
@@ -649,8 +743,8 @@ export class AgentSession {
                     reason: "context_overflow_compaction",
                     evidence: "context_overflow",
                 }, msg);
+                await this._checkCompaction(msg, "settlement", run);
                 this._completeAgentRun(run);
-                await this._checkCompaction(msg);
                 return;
             }
             const settings = this.settingsManager.getRetrySettings();
@@ -661,12 +755,12 @@ export class AgentSession {
                     reason: "retry_disabled",
                     evidence: classification.evidence,
                 }, msg);
+                await this._checkCompaction(msg, "settlement", run);
                 this._completeAgentRun(run);
-                await this._checkCompaction(msg);
                 return;
             }
             if (classification.kind === "retry") {
-                const didRetry = await this._handleRetryableError(msg, classification.evidence, run);
+                const didRetry = this._handleRetryableError(msg, classification.evidence, run);
                 if (didRetry)
                     return;
             }
@@ -674,8 +768,8 @@ export class AgentSession {
                 const { kind: _kind, ...cause } = classification;
                 this._finishRetryWithoutSuccess({ schemaVersion: 1, outcome: "not_attempted", ...cause }, msg);
             }
+            await this._checkCompaction(msg, "settlement", run);
             this._completeAgentRun(run);
-            await this._checkCompaction(msg);
         }
     }
     /** Extract text content from a message */
@@ -714,13 +808,19 @@ export class AgentSession {
         Object.assign(targetRecord, replacement);
     }
     /** Emit extension events based on agent events */
-    async _emitExtensionEvent(event) {
+    async _emitExtensionEvent(event, settlement) {
+        // SCRAMJET-DIVERGENCE: message provenance is independent of Session persistence acknowledgements (#611).
+        if ((event.type === "message_start" || event.type === "message_update" || event.type === "message_end") &&
+            event.message.role === "assistant" &&
+            event.message.origin === "harness") {
+            settlement = undefined;
+        }
         if (event.type === "agent_start") {
             this._turnIndex = 0;
-            await this._extensionRunner.emit({ type: "agent_start" });
+            await this._extensionRunner.emit({ type: "agent_start" }, settlement);
         }
         else if (event.type === "agent_end") {
-            await this._extensionRunner.emit({ type: "agent_end", messages: event.messages });
+            await this._extensionRunner.emit({ type: "agent_end", messages: event.messages }, settlement);
         }
         else if (event.type === "turn_start") {
             const extensionEvent = {
@@ -728,7 +828,7 @@ export class AgentSession {
                 turnIndex: this._turnIndex,
                 timestamp: Date.now(),
             };
-            await this._extensionRunner.emit(extensionEvent);
+            await this._extensionRunner.emit(extensionEvent, settlement);
         }
         else if (event.type === "turn_end") {
             const extensionEvent = {
@@ -737,7 +837,7 @@ export class AgentSession {
                 message: event.message,
                 toolResults: event.toolResults,
             };
-            await this._extensionRunner.emit(extensionEvent);
+            await this._extensionRunner.emit(extensionEvent, settlement);
             this._turnIndex++;
         }
         else if (event.type === "message_start") {
@@ -745,7 +845,7 @@ export class AgentSession {
                 type: "message_start",
                 message: event.message,
             };
-            await this._extensionRunner.emit(extensionEvent);
+            await this._extensionRunner.emit(extensionEvent, settlement);
         }
         else if (event.type === "message_update") {
             const extensionEvent = {
@@ -753,14 +853,14 @@ export class AgentSession {
                 message: event.message,
                 assistantMessageEvent: event.assistantMessageEvent,
             };
-            await this._extensionRunner.emit(extensionEvent);
+            await this._extensionRunner.emit(extensionEvent, settlement);
         }
         else if (event.type === "message_end") {
             const extensionEvent = {
                 type: "message_end",
                 message: event.message,
             };
-            const replacement = await this._extensionRunner.emitMessageEnd(extensionEvent);
+            const replacement = await this._extensionRunner.emitMessageEnd(extensionEvent, settlement);
             if (replacement) {
                 this._replaceMessageInPlace(event.message, replacement);
             }
@@ -772,7 +872,7 @@ export class AgentSession {
                 toolName: event.toolName,
                 args: event.args,
             };
-            await this._extensionRunner.emit(extensionEvent);
+            await this._extensionRunner.emit(extensionEvent, settlement);
         }
         else if (event.type === "tool_execution_update") {
             const extensionEvent = {
@@ -782,7 +882,7 @@ export class AgentSession {
                 args: event.args,
                 partialResult: event.partialResult,
             };
-            await this._extensionRunner.emit(extensionEvent);
+            await this._extensionRunner.emit(extensionEvent, settlement);
         }
         else if (event.type === "tool_execution_end") {
             const extensionEvent = {
@@ -792,7 +892,7 @@ export class AgentSession {
                 result: event.result,
                 isError: event.isError,
             };
-            await this._extensionRunner.emit(extensionEvent);
+            await this._extensionRunner.emit(extensionEvent, settlement);
         }
     }
     /**
@@ -844,6 +944,13 @@ export class AgentSession {
         this._pendingToolCosts.clear();
         this._resetOutputThroughput();
         const retryDisposeError = new Error("AgentSession disposed before retry settlement completed.");
+        for (const chain of this._unsettledRetryChains) {
+            if (chain.handoff)
+                clearTimeout(chain.handoff);
+            chain.handoff = undefined;
+            rejectDeferred(chain.result, retryDisposeError);
+        }
+        this._autoCompactionAbortController?.abort();
         const unsettledRuns = [...this._unsettledAgentRuns];
         const retry = this._retry;
         const unclassifiedError = unsettledRuns.find((run) => run.persistedAssistantSnapshot?.stopReason === "error")?.persistedAssistantSnapshot;
@@ -896,8 +1003,10 @@ export class AgentSession {
             retryChains.add(pendingRetryContinuation);
         for (const run of unsettledRuns)
             this._settleAgentRun(run, retryDisposeError);
-        for (const chain of retryChains)
-            this._settleRetryChain(chain, retryDisposeError);
+        for (const chain of retryChains) {
+            settleDeferred(chain, retryDisposeError);
+            this._unsettledRetryChains.delete(chain);
+        }
         this._disconnectFromAgent();
         this._eventListeners = [];
         cleanupSessionResources(this.sessionId);
@@ -1387,7 +1496,7 @@ export class AgentSession {
         }
         acceptInput?.();
         preflightResult?.(true);
-        await this._runAgentPrompt(messages);
+        await this._runAgentPrompt(messages, options?.onRunSettlement);
     }
     /**
      * Try to execute an extension command. Returns true if command was found and executed.
@@ -2003,6 +2112,7 @@ export class AgentSession {
      * Cancel in-progress compaction (manual or auto).
      */
     abortCompaction() {
+        this._cancelRunSettlements();
         this._compactionAbortController?.abort();
         this._autoCompactionAbortController?.abort();
     }
@@ -2022,8 +2132,8 @@ export class AgentSession {
      *
      * @param assistantMessage The assistant message to check
      */
-    async _checkCompaction(assistantMessage, trigger = "settlement") {
-        if (this._manualCompactionDrain)
+    async _checkCompaction(assistantMessage, trigger = "settlement", run) {
+        if (this._manualCompactionDrain || run?.chain.cancelled)
             return;
         const settings = this.settingsManager.getCompactionSettings();
         if (!settings.enabled)
@@ -2055,7 +2165,7 @@ export class AgentSession {
             const window = this.model?.contextWindow ?? 0;
             if (shouldCompact(tokens, window, settings) ||
                 (window > settings.reserveTokens && tokens > (this.model?.maxInputTokens ?? Infinity)))
-                await this._runAutoCompaction("threshold", false);
+                await this._runAutoCompaction("threshold", false, undefined, false);
             return;
         }
         // SCRAMJET-DIVERGENCE: Total context and independent input limits are separate constraints.
@@ -2094,7 +2204,7 @@ export class AgentSession {
             if (messages.length > 0 && messages[messages.length - 1].role === "assistant") {
                 this.agent.state.messages = messages.slice(0, -1);
             }
-            await this._runAutoCompaction("overflow", true);
+            await this._runAutoCompaction("overflow", true, run);
             return;
         }
         // Case 2: Threshold - context is getting large
@@ -2122,14 +2232,19 @@ export class AgentSession {
         }
         if (shouldCompact(contextTokens, contextWindow, settings) ||
             (contextWindow > settings.reserveTokens && contextTokens > (this.model?.maxInputTokens ?? Infinity))) {
-            await this._runAutoCompaction("threshold", false);
+            await this._runAutoCompaction("threshold", false, run);
         }
     }
     /**
      * Internal: Run auto-compaction with events.
      */
-    async _runAutoCompaction(reason, willRetry) {
+    async _runAutoCompaction(reason, willRetry, run, continueQueued = true) {
         const settings = this.settingsManager.getCompactionSettings();
+        const chain = run?.chain;
+        let compacted = false;
+        let persisting = false;
+        if (chain?.cancelled || this._disposed)
+            return;
         // SCRAMJET-DIVERGENCE: reentrant subscribers must observe compaction ownership (#598).
         this._autoCompactionAbortController = new AbortController();
         try {
@@ -2177,7 +2292,7 @@ export class AgentSession {
                     branchEntries: pathEntries,
                     customInstructions: undefined,
                     signal: this._autoCompactionAbortController.signal,
-                }));
+                }, chain?.result.promise));
                 if (extensionResult?.cancel) {
                     this._emit({
                         type: "compaction_end",
@@ -2212,7 +2327,7 @@ export class AgentSession {
                 tokensBefore = compactResult.tokensBefore;
                 details = compactResult.details;
             }
-            if (this._autoCompactionAbortController.signal.aborted) {
+            if (this._autoCompactionAbortController.signal.aborted || chain?.cancelled || this._disposed) {
                 this._emit({
                     type: "compaction_end",
                     reason,
@@ -2222,7 +2337,9 @@ export class AgentSession {
                 });
                 return;
             }
+            persisting = true;
             this.sessionManager.appendCompaction(summary, firstKeptEntryId, tokensBefore, details, fromExtension);
+            compacted = true;
             const newEntries = this.sessionManager.getEntries();
             const sessionContext = this.sessionManager.buildSessionContext();
             this.agent.state.messages = sessionContext.messages;
@@ -2233,7 +2350,7 @@ export class AgentSession {
                     type: "session_compact",
                     compactionEntry: savedCompactionEntry,
                     fromExtension,
-                });
+                }, chain?.result.promise);
             }
             const result = {
                 summary,
@@ -2248,20 +2365,23 @@ export class AgentSession {
                 if (lastMsg?.role === "assistant" && lastMsg.stopReason === "error") {
                     this.agent.state.messages = messages.slice(0, -1);
                 }
-                setTimeout(() => {
-                    this.agent.continue().catch(() => { });
-                }, 100);
             }
-            else if (this.agent.hasQueuedMessages()) {
-                // Auto-compaction can complete while follow-up/steering/custom messages are waiting.
-                // Kick the loop so queued messages are actually delivered.
-                setTimeout(() => {
-                    this.agent.continue().catch(() => { });
-                }, 100);
+            if (!chain?.cancelled &&
+                !this._disposed &&
+                (willRetry || (continueQueued && this.agent.hasQueuedMessages()))) {
+                this._scheduleCompactionContinuation(chain, run?.execution.promise);
             }
         }
         catch (error) {
             const errorMessage = error instanceof Error ? error.message : "compaction failed";
+            if (chain) {
+                if (persisting)
+                    chain.error = error instanceof Error ? error : new Error(String(error));
+                chain.errorMessage =
+                    reason === "overflow"
+                        ? `Context overflow recovery failed: ${errorMessage}`
+                        : `Auto-compaction failed: ${errorMessage}`;
+            }
             this._emit({
                 type: "compaction_end",
                 reason,
@@ -2274,9 +2394,34 @@ export class AgentSession {
             });
         }
         finally {
+            if (chain) {
+                if (this._autoCompactionAbortController?.signal.aborted)
+                    chain.cancelled = true;
+                if (willRetry && !compacted && !chain.cancelled)
+                    chain.errorMessage ??=
+                        "Context overflow recovery could not compact. Reduce context or select a larger-context model.";
+            }
             this._autoCompactionAbortController = undefined;
         }
     }
+    _scheduleCompactionContinuation(chain, execution) {
+        const owner = chain ?? createRetryChain();
+        this._unsettledRetryChains.add(owner);
+        owner.handoff = setTimeout(() => {
+            void (async () => {
+                await execution;
+                owner.handoff = undefined;
+                if (owner.cancelled || this._disposed || this._manualCompactionDrain || owner.error) {
+                    this._settleRetryChain(owner);
+                    return;
+                }
+                owner.terminal = false;
+                await this._continueAgentRun(owner);
+            })().catch((error) => {
+                this._settleRetryChain(owner, this._reportRetryFailure(error));
+            });
+        }, 100);
+    }
     /**
      * Toggle auto-compaction setting.
      */
@@ -2454,6 +2599,7 @@ export class AgentSession {
                 })();
             },
             getSystemPrompt: () => this.systemPrompt,
+            sendMessage: (message, options) => this.sendCustomMessage(message, options),
             dispatchUserInput: (input, options) => this.dispatchUserInput(input, options),
         }, {
             registerProvider: (name, config) => {
@@ -2736,7 +2882,7 @@ export class AgentSession {
         });
         return normalized;
     }
-    async _handleRetryableError(message, evidence, run) {
+    _handleRetryableError(message, evidence, run) {
         const settings = this.settingsManager.getRetrySettings();
         const attempt = (this._retry?.attempt ?? 0) + 1;
         const cumulativeCap = Math.min(Number.MAX_SAFE_INTEGER, settings.maxRetries * 2);
@@ -2808,51 +2954,72 @@ export class AgentSession {
             errorMessage: message.errorMessage || "Unknown error",
             cumulativeErrors: this._runRetryCount,
         });
-        if (controller.signal.aborted || this._disposed) {
+        if (controller.signal.aborted || run.chain.cancelled || this._disposed) {
             return this._finishCancelledRetry("cancelled_during_backoff", backoff);
         }
         const messages = this.agent.state.messages;
         if (messages.length > 0 && messages[messages.length - 1].role === "assistant") {
             this.agent.state.messages = messages.slice(0, -1);
         }
+        // Execution unwind may need queued failure events, so retry waiting cannot occupy that queue.
+        void this._resumeRetry(backoff, delayMs).catch((error) => {
+            if (this._disposed)
+                return;
+            const failure = this._reportRetryFailure(error);
+            if (this._retry === backoff)
+                this._releaseRetryForFailedRun(failure);
+            this._completeAgentRun(run, failure);
+        });
+        return true;
+    }
+    async _resumeRetry(backoff, delayMs) {
+        const { controller, run, attempt } = backoff;
         try {
             await sleep(delayMs, controller.signal);
             await sleep(0, controller.signal);
         }
         catch {
-            return this._finishCancelledRetry("cancelled_during_backoff", backoff);
+            this._finishCancelledRetry("cancelled_during_backoff", backoff);
+            this._completeAgentRun(run);
+            return;
         }
-        if (controller.signal.aborted || this._disposed) {
-            return this._finishCancelledRetry("cancelled_during_backoff", backoff);
+        await run.execution.promise;
+        await this._drainAgentEventQueue();
+        if (this._disposed || this._retry !== backoff)
+            return;
+        if (run.chain.error || run.chain.resultError)
+            throw run.chain.error ?? run.chain.resultError;
+        if (controller.signal.aborted || run.chain.cancelled || this._manualCompactionDrain) {
+            this._finishCancelledRetry("cancelled_during_backoff", backoff);
+            this._completeAgentRun(run);
+            return;
         }
-        if (this._manualCompactionDrain)
-            return this._finishCancelledRetry("cancelled_during_backoff", backoff);
         // Hand the chain to the continuation before `continue()`; the run that eventually emits
         // `agent_start` adopts it (see `_captureAgentRunSettlement`), however long Agent defers that start.
         const continuing = { phase: "continuing", attempt, chain: run.chain };
         this._retry = continuing;
-        const continuation = this.agent.continue();
+        const continuation = this._continueAgentRun(run.chain);
         this._settleAgentRun(run);
         continuation.catch((error) => {
-            if (this._disposed || this._retry !== continuing)
+            if (this._disposed)
                 return;
             const continuationError = this._reportRetryFailure(error);
             let settlementError = continuationError;
             try {
-                this._finishRetry({
-                    schemaVersion: 1,
-                    outcome: "failed",
-                    reason: "continuation_rejected",
-                    attempt: this._bounded(attempt),
-                    cumulativeErrors: this._bounded(this._runRetryCount),
-                }, { type: "auto_retry_end", success: false, attempt, finalError: continuationError.message });
+                if (this._retry === continuing)
+                    this._finishRetry({
+                        schemaVersion: 1,
+                        outcome: "failed",
+                        reason: "continuation_rejected",
+                        attempt: this._bounded(attempt),
+                        cumulativeErrors: this._bounded(this._runRetryCount),
+                    }, { type: "auto_retry_end", success: false, attempt, finalError: continuationError.message });
             }
             catch (persistenceError) {
                 settlementError = new AggregateError([continuationError, persistenceError], "Retry continuation and outcome persistence both failed.", { cause: continuationError });
             }
             this._settleRetryChain(run.chain, settlementError);
         });
-        return true;
     }
     _finishCancelledRetry(reason, expected) {
         if (this._disposed) {
@@ -2876,29 +3043,46 @@ export class AgentSession {
      * Cancel in-progress retry.
      */
     abortRetry() {
+        this._cancelRunSettlements();
         const retry = this._retry;
-        if (!retry)
+        if (!retry) {
+            this.agent.abort();
             return;
+        }
         if (retry.phase === "backoff")
             retry.controller.abort();
         this.agent.abort();
     }
     /** Agent's own `activeRun` guard is false during backoff; the retry phase owns the idle Agent then. */
     _assertRetryNotOwningIdleAgent() {
-        if (this._retry && !this.isStreaming) {
+        if ((this._retry || [...this._unsettledRetryChains].some((chain) => chain.handoff)) && !this.isStreaming) {
             throw new Error("Automatic retry is in progress. Cancel the retry before starting another prompt.");
         }
     }
-    async _runAgentPrompt(messages) {
+    async _runAgentPrompt(messages, onRunSettlement) {
         this._assertRetryNotOwningIdleAgent();
         const start = this._reserveAgentRunStart();
+        try {
+            onRunSettlement?.(start.chain.result.promise);
+        }
+        catch (error) {
+            this._rejectAgentRunStart(start, error instanceof Error ? error : new Error(String(error)));
+            throw error;
+        }
         this._runRetryCount = 0;
         let promptFailure;
+        start.chain.executions++;
         try {
             await this.agent.prompt(messages);
         }
         catch (error) {
             promptFailure = { error };
+            start.chain.error ??= error instanceof Error ? error : new Error(String(error));
+        }
+        finally {
+            start.chain.executions--;
+            resolveDeferred(start.execution, undefined);
+            this._trySettleRetryChain(start.chain);
         }
         if (!start.run && this._pendingAgentRunStart === start) {
             const startError = promptFailure
@@ -2918,7 +3102,7 @@ export class AgentSession {
         catch (error) {
             settlementFailure = { error };
         }
-        if (promptFailure && settlementFailure) {
+        if (promptFailure && settlementFailure && promptFailure.error !== settlementFailure.error) {
             throw new AggregateError([promptFailure.error, settlementFailure.error], "Agent prompt and retry settlement both failed.", { cause: promptFailure.error });
         }
         if (promptFailure)
@@ -2926,12 +3110,53 @@ export class AgentSession {
         if (settlementFailure)
             throw settlementFailure.error;
     }
+    async _continueAgentRun(chain) {
+        const start = this._reserveAgentRunStart(chain);
+        chain.executions++;
+        let failure;
+        try {
+            if (!chain.cancelled)
+                await this.agent.continue();
+        }
+        catch (error) {
+            failure = error instanceof Error ? error : new Error(String(error));
+            throw error;
+        }
+        finally {
+            chain.executions--;
+            if (failure)
+                chain.error ??= failure;
+            resolveDeferred(start.execution, undefined);
+            if (!start.run) {
+                if (failure) {
+                    if (this._pendingAgentRunStart === start)
+                        this._pendingAgentRunStart = undefined;
+                    rejectDeferred(start, failure);
+                }
+                else {
+                    this._rejectAgentRunStart(start, new Error("Agent continuation completed before agent_start."));
+                }
+            }
+            if (!failure)
+                this._trySettleRetryChain(chain);
+        }
+    }
+    _cancelRunSettlements() {
+        for (const chain of this._unsettledRetryChains) {
+            chain.cancelled = true;
+            if (chain.handoff) {
+                clearTimeout(chain.handoff);
+                chain.handoff = undefined;
+                this._settleRetryChain(chain);
+            }
+        }
+        this._autoCompactionAbortController?.abort();
+    }
     async waitForRetry(settlement) {
         if (!settlement)
             return;
         await settlement.promise;
         await settlement.chain.promise;
-        await this.agent.waitForIdle();
     }
     /** Whether auto-retry is currently in progress */
     get isRetrying() {