@leanandmean/coding-agent 0.74.1-scramjet.67 → 0.74.1-scramjet.69

package/dist/core/agent-session.js

@@ -17,14 +17,13 @@ import { basename, dirname, resolve } from "node:path";
 // SCRAMJET-DIVERGENCE: provider-safe harness tool-call id generation for the persisted-settlement
 // acknowledgement key (#341).
 import { generateHarnessToolCallId } from "@leanandmean/agent";
-import { clampThinkingLevel, cleanupSessionResources, flattenSystemPrompt, getSupportedThinkingLevels, isContextOverflow, modelsAreEqual, resetApiProviders, } from "@leanandmean/ai";
-import { validateResponsesProviderFailure } from "@leanandmean/ai/openai-responses";
+import { blocksFailureRecovery, clampThinkingLevel, cleanupSessionResources, flattenSystemPrompt, getSupportedThinkingLevels, inspectFailureEvidence, isContextOverflow, modelsAreEqual, resetApiProviders, } from "@leanandmean/ai";
 import { theme } from "../modes/interactive/theme/theme.js";
 import { stripFrontmatter } from "../utils/frontmatter.js";
 import { sleep } from "../utils/sleep.js";
 import { formatNoApiKeyFoundMessage, formatNoModelSelectedMessage } from "./auth-guidance.js";
 import { executeBashWithOperations } from "./bash-executor.js";
-import { calculateContextTokens, collectEntriesForBranchSummary, compact, estimateContextTokens, generateBranchSummary, prepareCompaction, shouldCompact, } from "./compaction/index.js";
+import { calculateContextTokens, collectEntriesForBranchSummary, compact, estimateContextTokens, estimateTokens, generateBranchSummary, prepareCompaction, shouldCompact, } from "./compaction/index.js";
 import { DEFAULT_THINKING_LEVEL } from "./defaults.js";
 import { exportSessionToHtml } from "./export-html/index.js";
 import { createToolHtmlRenderer } from "./export-html/tool-renderer.js";
@@ -87,6 +86,9 @@ function rejectDeferred(deferred, error) {
 function settleDeferred(deferred, error) {
     return error ? rejectDeferred(deferred, error) : resolveDeferred(deferred, undefined);
 }
+function validRecordedCost(value) {
+    return typeof value === "number" && Number.isFinite(value) && value >= 0;
+}
 export class AgentSession {
     agent;
     sessionManager;
@@ -97,6 +99,10 @@ export class AgentSession {
     _unsubscribeAgent;
     _eventListeners = [];
     _agentEventQueue = Promise.resolve();
+    // SCRAMJET-DIVERGENCE: execution ownership survives final-event queue latency until append succeeds (#598).
+    _toolCostExecutions = new Map();
+    _pendingToolCosts = new Set();
+    _historicalCostDefinitions = new Map();
     _outputThroughputTracker = new OutputThroughputTracker();
     _outputThroughputHistory;
     _outputThroughputGeneration;
@@ -115,6 +121,7 @@ export class AgentSession {
     _inputSessionEntries = new WeakMap();
     // Compaction state
     _compactionAbortController = undefined;
+    _manualCompactionDrain;
     _autoCompactionAbortController = undefined;
     _overflowRecoveryAttempted = false;
     // Branch summarization state
@@ -299,10 +306,13 @@ export class AgentSession {
     }
     /** Internal handler for agent events - shared by subscribe and reconnect */
     _handleAgentEvent = (event) => {
+        if (this._disposed)
+            return;
         this._captureOutputThroughput(event);
+        const toolCost = this._captureToolCost(event);
         const runSettlement = this._captureAgentRunSettlement(event);
         const harnessAck = this._harnessPersistenceAckForEvent(event);
-        const processing = this._agentEventQueue.then(() => this._processAgentEventTracked(event, runSettlement, harnessAck), () => this._processAgentEventTracked(event, runSettlement, harnessAck));
+        const processing = this._agentEventQueue.then(() => this._processAgentEventTracked(event, runSettlement, harnessAck, toolCost), () => this._processAgentEventTracked(event, runSettlement, harnessAck, toolCost));
         this._agentEventQueue = processing;
         if (harnessAck)
             harnessAck.persistenceTail = processing;
@@ -313,6 +323,42 @@ export class AgentSession {
         if (event.type === "turn_end")
             return this._agentEventQueue;
     };
+    // SCRAMJET-DIVERGENCE: scalar reports are captured before mutable events enter async hooks (#598).
+    _captureToolCost(event) {
+        if (event.type === "tool_execution_start") {
+            const execution = {};
+            this._toolCostExecutions.set(event.toolCallId, execution);
+            this._pendingToolCosts.add(execution);
+            return;
+        }
+        let toolCallId;
+        let reported;
+        const final = event.type === "message_end" && event.message.role === "toolResult";
+        if (event.type === "tool_execution_update" || event.type === "tool_execution_end") {
+            toolCallId = event.toolCallId;
+            reported = event.type === "tool_execution_update" ? event.partialResult?.cost : event.result?.cost;
+        }
+        else if (event.type === "message_end" && event.message.role === "toolResult") {
+            toolCallId = event.message.toolCallId;
+            reported = event.message.cost;
+        }
+        else {
+            return;
+        }
+        let execution = this._toolCostExecutions.get(toolCallId);
+        if (!execution && validRecordedCost(reported)) {
+            execution = {};
+            this._toolCostExecutions.set(toolCallId, execution);
+            this._pendingToolCosts.add(execution);
+        }
+        if (execution && validRecordedCost(reported))
+            execution.cost = reported;
+        if (final) {
+            this._toolCostExecutions.delete(toolCallId);
+            return execution;
+        }
+        return;
+    }
     // SCRAMJET-DIVERGENCE: Capture provider events synchronously and reset stale throughput lifecycles (#476).
     _captureOutputThroughput(event) {
         if (event.type === "message_start" && event.message.role === "assistant" && event.message.origin === "provider") {
@@ -391,16 +437,18 @@ export class AgentSession {
     }
     // 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.
-    async _processAgentEventTracked(event, run, harnessAck) {
+    async _processAgentEventTracked(event, run, harnessAck, toolCost) {
         try {
-            await this._processAgentEvent(event, run, harnessAck !== undefined);
+            await this._processAgentEvent(event, run, harnessAck !== undefined, toolCost);
         }
         catch (err) {
             const error = err instanceof Error ? err : new Error(String(err));
+            if (this._manualCompactionDrain)
+                this._manualCompactionDrain.firstError ??= error;
             if (harnessAck) {
                 harnessAck.firstPersistenceError ??= error;
             }
-            else if (run) {
+            else if (run && !this._manualCompactionDrain) {
                 if (event.type === "message_end" && event.message.role === "assistant") {
                     run.assistantPersistenceError = error;
                 }
@@ -437,7 +485,19 @@ export class AgentSession {
         }
         return toolCallId === undefined ? undefined : this._harnessPersistenceAcks.get(toolCallId);
     }
-    async _processAgentEvent(event, run, fromHarnessInvocation = false) {
+    async _processAgentEvent(event, run, fromHarnessInvocation = false, toolCost) {
+        if (this._disposed)
+            return;
+        // SCRAMJET-DIVERGENCE: queued lifecycle events must respect manual compaction ownership (#598).
+        if (this._manualCompactionDrain && event.type !== "message_end" && event.type !== "agent_end")
+            return;
+        if (this._manualCompactionDrain && event.type === "agent_end") {
+            if (this._retry)
+                this._finishCancelledRetry("cancelled_during_continuation");
+            if (run)
+                this._completeAgentRun(run, this._manualCompactionDrain.firstError);
+            return;
+        }
         // 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") {
@@ -462,6 +522,18 @@ export class AgentSession {
         }
         // Emit to extensions first
         await this._emitExtensionEvent(event);
+        if (event.type === "message_end" && event.message.role === "toolResult" && toolCost?.cost !== undefined) {
+            event.message.cost = toolCost.cost;
+        }
+        // An awaited hook may have acquired manual ownership while this event was in flight.
+        if (this._manualCompactionDrain && event.type !== "message_end") {
+            if (event.type === "agent_end" && run) {
+                if (this._retry)
+                    this._finishCancelledRetry("cancelled_during_continuation");
+                this._completeAgentRun(run, this._manualCompactionDrain.firstError);
+            }
+            return;
+        }
         // Notify all listeners
         this._emit(event);
         if (this._disposed)
@@ -482,6 +554,8 @@ export class AgentSession {
                     ? JSON.parse(JSON.stringify(event.message))
                     : event.message;
                 const messageEntryId = this.sessionManager.appendMessage(persistedMessage);
+                if (toolCost)
+                    this._pendingToolCosts.delete(toolCost);
                 if (persistedMessage.role === "assistant" && !fromHarnessInvocation && run) {
                     run.persistedAssistantSnapshot = persistedMessage;
                 }
@@ -514,7 +588,8 @@ export class AgentSession {
             if (event.message.role === "assistant" &&
                 event.message.stopReason !== "error" &&
                 event.message.stopReason !== "aborted" &&
-                !fromHarnessInvocation) {
+                !fromHarnessInvocation &&
+                !this._manualCompactionDrain) {
                 this._overflowRecoveryAttempted = false;
                 if (this._retry)
                     this._retry = { ...this._retry, attempt: 0 };
@@ -523,6 +598,12 @@ export class AgentSession {
         if (event.type === "agent_end") {
             if (this._disposed || !run)
                 return;
+            if (this._manualCompactionDrain) {
+                if (this._retry)
+                    this._finishCancelledRetry("cancelled_during_continuation");
+                this._completeAgentRun(run, this._manualCompactionDrain.firstError);
+                return;
+            }
             if (run.assistantPersistenceError) {
                 const error = run.assistantPersistenceError;
                 run.assistantPersistenceError = undefined;
@@ -741,8 +822,8 @@ export class AgentSession {
      * Preserves all existing listeners.
      */
     _reconnectToAgent() {
-        if (this._unsubscribeAgent)
-            return; // Already connected
+        if (this._disposed || this._unsubscribeAgent)
+            return; // Already connected or disposed
         this._unsubscribeAgent = this.agent.subscribe(this._handleAgentEvent);
     }
     /**
@@ -755,6 +836,8 @@ export class AgentSession {
         if (this._disposed)
             return;
         this._disposed = true;
+        this._toolCostExecutions.clear();
+        this._pendingToolCosts.clear();
         this._resetOutputThroughput();
         const retryDisposeError = new Error("AgentSession disposed before retry settlement completed.");
         const unsettledRuns = [...this._unsettledAgentRuns];
@@ -966,6 +1049,10 @@ export class AgentSession {
         if (this._disposed) {
             throw new Error(`Cannot invoke harness tool "${name}": the session has been disposed.`);
         }
+        // SCRAMJET-DIVERGENCE: reject new session work before allocating invocation ownership (#598).
+        if (this._compactionAbortController) {
+            throw new Error(`Cannot invoke harness tool "${name}": manual compaction is in progress. Retry after it settles.`);
+        }
         const tool = this._toolRegistry.get(name);
         if (!tool) {
             throw new Error(`Cannot invoke harness tool "${name}": no tool with that name is registered.`);
@@ -1231,7 +1318,7 @@ export class AgentSession {
             // Check if we need to compact before sending (catches aborted responses)
             const lastAssistant = this._findLastAssistantMessage();
             if (lastAssistant) {
-                await this._checkCompaction(lastAssistant, false);
+                await this._checkCompaction(lastAssistant, "new_prompt");
             }
             // Build messages array (custom message if any, then user message)
             messages = [];
@@ -1759,12 +1846,32 @@ export class AgentSession {
      * @param customInstructions Optional instructions for the compaction summary
      */
     async compact(customInstructions) {
-        this._resetOutputThroughput();
-        this._disconnectFromAgent();
-        await this.abort();
-        this._compactionAbortController = new AbortController();
-        this._emit({ type: "compaction_start", reason: "manual" });
+        // SCRAMJET-DIVERGENCE: acquire one owner before awaits and drain terminal persistence (#598).
+        if (this._disposed)
+            throw new Error("Cannot compact a disposed session.");
+        if (this.isCompacting)
+            throw new Error("Compaction or branch summarization is already in progress. Retry after it settles.");
+        if (this.agent.hasActiveTransientHarnessTools) {
+            throw new Error("A harness tool is still executing outside an Agent run. Retry compaction after its persisted settlement.");
+        }
+        const controller = new AbortController();
+        this._compactionAbortController = controller;
+        const drain = {};
+        this._manualCompactionDrain = drain;
+        const runs = [...this._unsettledAgentRuns];
         try {
+            this._resetOutputThroughput();
+            this._disconnectFromAgent();
+            this._unsubscribeAgent = this.agent.subscribe((event) => this._handleAgentEvent(event));
+            this._emit({ type: "compaction_start", reason: "manual" });
+            await this.abort();
+            await this._agentEventQueue;
+            if (drain.firstError)
+                throw drain.firstError;
+            if (this._disposed)
+                throw new Error("Session disposed during compaction.");
+            if (controller.signal.aborted)
+                throw new Error("Compaction cancelled");
             if (!this.model) {
                 throw new Error(formatNoModelSelectedMessage());
             }
@@ -1788,7 +1895,7 @@ export class AgentSession {
                     preparation,
                     branchEntries: pathEntries,
                     customInstructions,
-                    signal: this._compactionAbortController.signal,
+                    signal: controller.signal,
                 }));
                 if (result?.cancel) {
                     throw new Error("Compaction cancelled");
@@ -1811,13 +1918,15 @@ export class AgentSession {
             }
             else {
                 // Generate compaction result
-                const result = await compact(preparation, this.model, apiKey, headers, customInstructions, this._compactionAbortController.signal, this.thinkingLevel);
+                const result = await compact(preparation, this.model, apiKey, headers, customInstructions, controller.signal, this.thinkingLevel);
                 summary = result.summary;
                 firstKeptEntryId = result.firstKeptEntryId;
                 tokensBefore = result.tokensBefore;
                 details = result.details;
             }
-            if (this._compactionAbortController.signal.aborted) {
+            if (this._disposed)
+                throw new Error("Session disposed during compaction.");
+            if (controller.signal.aborted) {
                 throw new Error("Compaction cancelled");
             }
             this.sessionManager.appendCompaction(summary, firstKeptEntryId, tokensBefore, details, fromExtension);
@@ -1849,8 +1958,13 @@ export class AgentSession {
             return compactionResult;
         }
         catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            const aborted = message === "Compaction cancelled" || (error instanceof Error && error.name === "AbortError");
+            const failure = drain.firstError ?? error;
+            const settlementError = failure instanceof Error ? failure : new Error(String(failure));
+            this._releaseRetryForFailedRun(settlementError);
+            for (const run of runs)
+                this._completeAgentRun(run, settlementError);
+            const message = settlementError.message;
+            const aborted = message === "Compaction cancelled" || settlementError.name === "AbortError";
             this._emit({
                 type: "compaction_end",
                 reason: "manual",
@@ -1859,9 +1973,11 @@ export class AgentSession {
                 willRetry: false,
                 errorMessage: aborted ? undefined : `Compaction failed: ${message}`,
             });
-            throw error;
+            throw failure;
         }
         finally {
+            this._disconnectFromAgent();
+            this._manualCompactionDrain = undefined;
             this._compactionAbortController = undefined;
             this._reconnectToAgent();
         }
@@ -1888,15 +2004,43 @@ export class AgentSession {
      * 2. Threshold: Context over threshold, compact, NO auto-retry (user continues manually)
      *
      * @param assistantMessage The assistant message to check
-     * @param skipAbortedCheck If false, include aborted messages (for pre-prompt check). Default: true
      */
-    async _checkCompaction(assistantMessage, skipAbortedCheck = true) {
+    async _checkCompaction(assistantMessage, trigger = "settlement") {
+        if (this._manualCompactionDrain)
+            return;
         const settings = this.settingsManager.getCompactionSettings();
         if (!settings.enabled)
             return;
-        // Skip if message was aborted (user cancelled) - unless skipAbortedCheck is false
-        if (skipAbortedCheck && assistantMessage.stopReason === "aborted")
+        // SCRAMJET-DIVERGENCE: New prompts maintain context independently of failed-turn recovery.
+        if (trigger === "settlement" && blocksFailureRecovery(assistantMessage))
             return;
+        if (trigger === "new_prompt") {
+            const boundary = getLatestCompactionEntry(this.sessionManager.getBranch());
+            const messages = this.agent.state.messages;
+            const reverseIndex = [...messages]
+                .reverse()
+                .findIndex((message) => message.role === "assistant" &&
+                message.origin !== "harness" &&
+                message.stopReason !== "error" &&
+                message.stopReason !== "aborted" &&
+                message.provider === this.model?.provider &&
+                message.model === this.model?.id &&
+                Number.isFinite(calculateContextTokens(message.usage)) &&
+                calculateContextTokens(message.usage) >= 0 &&
+                (!boundary || message.timestamp > new Date(boundary.timestamp).getTime()) &&
+                [message.usage.input, message.usage.output, message.usage.cacheRead, message.usage.cacheWrite].every((n) => Number.isFinite(n) && n >= 0));
+            if (reverseIndex < 0)
+                return;
+            const sourceIndex = messages.length - reverseIndex - 1;
+            const source = messages[sourceIndex];
+            const tokens = calculateContextTokens(source.usage) +
+                messages.slice(sourceIndex + 1).reduce((total, message) => total + estimateTokens(message), 0);
+            const window = this.model?.contextWindow ?? 0;
+            if (shouldCompact(tokens, window, settings) ||
+                (window > settings.reserveTokens && tokens > (this.model?.maxInputTokens ?? Infinity)))
+                await this._runAutoCompaction("threshold", false);
+            return;
+        }
         // SCRAMJET-DIVERGENCE: Total context and independent input limits are separate constraints.
         const contextWindow = this.model?.contextWindow ?? 0;
         // Skip overflow check if the message came from a different model.
@@ -1969,9 +2113,10 @@ export class AgentSession {
      */
     async _runAutoCompaction(reason, willRetry) {
         const settings = this.settingsManager.getCompactionSettings();
-        this._emit({ type: "compaction_start", reason });
+        // SCRAMJET-DIVERGENCE: reentrant subscribers must observe compaction ownership (#598).
         this._autoCompactionAbortController = new AbortController();
         try {
+            this._emit({ type: "compaction_start", reason });
             if (!this.model) {
                 this._emit({
                     type: "compaction_end",
@@ -2316,7 +2461,13 @@ export class AgentSession {
                 definition,
                 sourceInfo: createSyntheticSourceInfo(`<sdk:${definition.name}>`, { source: "sdk" }),
             })),
-        ].filter((tool) => isAllowedTool(tool.definition.name));
+        ];
+        // SCRAMJET-DIVERGENCE: historical interpretation follows definition collision winners, not execution allowlists (#598).
+        this._historicalCostDefinitions = new Map(this._baseToolDefinitions);
+        for (const tool of allCustomTools) {
+            this._historicalCostDefinitions.set(tool.definition.name, tool.definition);
+        }
+        const allowedCustomTools = allCustomTools.filter((tool) => isAllowedTool(tool.definition.name));
         const definitionRegistry = new Map(Array.from(this._baseToolDefinitions.entries())
             .filter(([name]) => isAllowedTool(name))
             .map(([name, definition]) => [
@@ -2326,7 +2477,7 @@ export class AgentSession {
                 sourceInfo: createSyntheticSourceInfo(`<builtin:${name}>`, { source: "builtin" }),
             },
         ]));
-        for (const tool of allCustomTools) {
+        for (const tool of allowedCustomTools) {
             definitionRegistry.set(tool.definition.name, {
                 definition: tool.definition,
                 sourceInfo: tool.sourceInfo,
@@ -2346,7 +2497,7 @@ export class AgentSession {
         })
             .filter((entry) => entry !== undefined));
         const runner = this._extensionRunner;
-        const wrappedExtensionTools = wrapRegisteredTools(allCustomTools, runner);
+        const wrappedExtensionTools = wrapRegisteredTools(allowedCustomTools, runner);
         const wrappedBuiltInTools = wrapRegisteredTools(Array.from(this._baseToolDefinitions.values())
             .filter((definition) => isAllowedTool(definition.name))
             .map((definition) => ({
@@ -2451,20 +2602,30 @@ export class AgentSession {
     // =========================================================================
     // SCRAMJET-DIVERGENCE: persisted post-extension snapshots authoritatively classify and settle retries (#553).
     _classifyRetry(message) {
+        if ((message.origin === "harness" || message.stopReason === "aborted") && blocksFailureRecovery(message))
+            return { kind: "do_not_retry", reason: "non_provider_failure", evidence: "none" };
         const contextWindow = this.model?.contextWindow ?? 0;
         if (isContextOverflow(message, Math.min(contextWindow, this.model?.maxInputTokens ?? Infinity))) {
             return { kind: "context_overflow" };
         }
-        const structured = validateResponsesProviderFailure(message.diagnostics);
+        const structured = inspectFailureEvidence(message.diagnostics);
         if (structured.status === "valid") {
-            if (structured.retryDisposition === "transient")
-                return { kind: "retry", evidence: "provider_failure" };
+            if (structured.source !== "provider")
+                return { kind: "do_not_retry", reason: "non_provider_failure", evidence: "none" };
+            if (structured.suppression)
+                return { kind: "do_not_retry", reason: structured.suppression, evidence: structured.family };
+            if (structured.transient || ["missing_terminal_event", "missing_body"].includes(structured.category))
+                return { kind: "retry", evidence: structured.family };
             return {
                 kind: "do_not_retry",
-                reason: structured.retryDisposition === "non_transient" ? "structured_non_transient" : "structured_unknown",
-                evidence: "provider_failure",
+                reason: ["unknown", "provider_error", "malformed_event"].includes(structured.category)
+                    ? "structured_unknown"
+                    : "structured_non_transient",
+                evidence: structured.family,
             };
         }
+        if (structured.status === "conflicting")
+            return { kind: "do_not_retry", reason: "invalid_failure_evidence", evidence: "none" };
         if (structured.status === "malformed") {
             return { kind: "do_not_retry", reason: "malformed_provider_diagnostic", evidence: "none" };
         }
@@ -2498,7 +2659,7 @@ export class AgentSession {
             this._appendAutoRetryRecord(record);
         }
         catch (error) {
-            if (retry) {
+            if (retry && !this._manualCompactionDrain) {
                 this._emit({
                     type: "auto_retry_end",
                     success: false,
@@ -2508,7 +2669,7 @@ export class AgentSession {
             }
             throw this._reportRetryFailure(error);
         }
-        if (retry && end)
+        if (retry && end && !this._manualCompactionDrain)
             this._emit(end);
     }
     _finishRetryWithoutSuccess(record, message) {
@@ -2561,9 +2722,8 @@ export class AgentSession {
     async _handleRetryableError(message, evidence, run) {
         const settings = this.settingsManager.getRetrySettings();
         const attempt = (this._retry?.attempt ?? 0) + 1;
-        this._runRetryCount++;
-        const cumulativeCap = settings.maxRetries * 2;
-        if (attempt > settings.maxRetries) {
+        const cumulativeCap = Math.min(Number.MAX_SAFE_INTEGER, settings.maxRetries * 2);
+        if ((this._retry?.attempt ?? 0) >= settings.maxRetries) {
             const attemptsCompleted = attempt - 1;
             this._finishRetry({
                 schemaVersion: 1,
@@ -2575,15 +2735,15 @@ export class AgentSession {
             }, { type: "auto_retry_end", success: false, attempt: attemptsCompleted, finalError: message.errorMessage });
             return false;
         }
-        if (this._runRetryCount > cumulativeCap) {
-            const attemptsCompleted = this._runRetryCount - 1;
+        if (this._runRetryCount >= cumulativeCap) {
+            const attemptsCompleted = this._runRetryCount;
             this._finishRetry({
                 schemaVersion: 1,
                 outcome: "exhausted",
                 reason: "cumulative_limit",
                 attemptsCompleted: this._bounded(attemptsCompleted),
                 maxAttempts: this._bounded(settings.maxRetries),
-                cumulativeErrors: this._bounded(this._runRetryCount),
+                cumulativeErrors: this._bounded(this._runRetryCount + 1),
             }, {
                 type: "auto_retry_end",
                 success: false,
@@ -2592,7 +2752,10 @@ export class AgentSession {
             });
             return false;
         }
-        const delayMs = settings.baseDelayMs * 2 ** (attempt - 1);
+        this._runRetryCount++;
+        const delayMs = settings.baseDelayMs === 0
+            ? 0
+            : Math.min(2_147_483_647, settings.baseDelayMs * 2 ** Math.min(31, attempt - 1));
         const previous = this._retry;
         this._retry = undefined;
         try {
@@ -2645,6 +2808,8 @@ export class AgentSession {
         if (controller.signal.aborted || this._disposed) {
             return this._finishCancelledRetry("cancelled_during_backoff", backoff);
         }
+        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 };
@@ -3051,6 +3216,43 @@ export class AgentSession {
         }
         return result;
     }
+    // SCRAMJET-DIVERGENCE: whole-journal parent/tool costs plus reports awaiting successful append (#598).
+    getRecordedSessionCost() {
+        let total = 0;
+        for (const entry of this.sessionManager.getEntries()) {
+            if (entry.type !== "message")
+                continue;
+            const message = entry.message;
+            if (message.role === "assistant") {
+                if (validRecordedCost(message.usage?.cost?.total))
+                    total += message.usage.cost.total;
+            }
+            else if (message.role === "toolResult") {
+                if (validRecordedCost(message.cost)) {
+                    total += message.cost;
+                    continue;
+                }
+                const definition = this._historicalCostDefinitions.get(message.toolName);
+                if (!definition?.getHistoricalCost)
+                    continue;
+                try {
+                    const cost = definition.getHistoricalCost(message.details);
+                    if (validRecordedCost(cost))
+                        total += cost;
+                }
+                catch (error) {
+                    this._extensionRunner.emitError({
+                        extensionPath: `tool:${message.toolName}`,
+                        event: "historical_cost",
+                        error: `Failed to interpret historical tool cost: ${error instanceof Error ? error.message : String(error)}`,
+                    });
+                }
+            }
+        }
+        for (const execution of this._pendingToolCosts)
+            total += execution.cost ?? 0;
+        return total;
+    }
     /**
      * Get session statistics.
      */