@qduc/term2 0.14.0 → 0.16.0

package/dist/services/agent-runtime/application-run-loop.js

@@ -5,13 +5,16 @@ import { isZodToolParameterSchema } from '../../tools/types.js';
 import { normalizeToolParameters } from '../../lib/tool-invoke.js';
 import { isCancellationError, isHarnessInvariantError } from '../../lib/harness-invariant-error.js';
 import { ApprovalLedger } from './tool-invocation-context.js';
+import { RunBudget, isRunBudgetInteraction, } from './run-budget.js';
 import { addTokenUsage, normalizeUsage } from '../../utils/ai/token-usage.js';
 import { computeModelCost } from '../../services/cost/model-cost.js';
 import { getCatalogPricingVersion, getModelPricing } from '../../services/cost/pricing.js';
-import { GenerationDeadline, GenerationGuard, GenerationGuardError, } from './generation-guard.js';
+import { GenerationGuard, GenerationGuardError, GenerationStreamDeadlines, } from './generation-guard.js';
+import { classifyInLoopModelRetry, sleepWithAbort } from '../retry/in-loop-model-retry.js';
 /**
- * Raised when a run exceeds its `maxTurns` budget. The loop owns turn counting
- * — the SDK-era `callModelInputFilter` hook is deliberately not reintroduced.
+ * Compatibility error for legacy callers without a staged run budget. The loop
+ * owns turn counting — the SDK-era `callModelInputFilter` hook is deliberately
+ * not reintroduced.
  */
 export class MaxTurnsExceededError extends Error {
     maxTurns;
@@ -66,7 +69,7 @@ class EventQueue {
  */
 let nextCostRequestSeq = 0;
 let nextToolBatchSeq = 0;
-const DEFAULT_MAX_PARALLEL_TOOL_CALLS = 4;
+const DEFAULT_MAX_PARALLEL_TOOL_CALLS = 3;
 /**
  * Small provider-neutral agent loop. It owns model-turn sequencing and tool
  * execution; providers only implement `StreamedModelTurn`.
@@ -74,7 +77,6 @@ const DEFAULT_MAX_PARALLEL_TOOL_CALLS = 4;
 export class ApplicationRunLoop {
     #deps;
     #contextCompactionSessionState;
-    #maxParallelToolCalls;
     #activeAbortController = null;
     #runInFlight = false;
     #segmentGeneration = 0;
@@ -97,10 +99,11 @@ export class ApplicationRunLoop {
      */
     #turnOpen = false;
     #pendingSteers = [];
+    /** The run whose budget an out-of-band grant applies to, held across a pause. */
+    #activeRunBudgetState;
     constructor(deps) {
         this.#deps = deps;
         this.#contextCompactionSessionState = deps.contextCompactionSessionState ?? { disabled: false };
-        this.#maxParallelToolCalls = Math.max(1, Math.floor(deps.maxParallelToolCalls ?? DEFAULT_MAX_PARALLEL_TOOL_CALLS));
     }
     /**
      * Declare a turn open, making it steerable before its first run exists.
@@ -139,6 +142,38 @@ export class ApplicationRunLoop {
         this.#activeAbortController?.abort();
         this.#activeAbortController = null;
     }
+    /**
+     * Grant one finite continuation extension to the current logical run.
+     *
+     * The interactive prompt calls this before resuming because it has to show
+     * the human a refusal rather than a silent stop. The grant is recorded so the
+     * matching `approve` does not charge a second one.
+     */
+    grantRunBudgetExtension(grantedBy = 'human') {
+        const state = this.#activeRunBudgetState;
+        if (!state?.runBudget)
+            return { granted: false, extensionsGranted: 0 };
+        const grant = state.runBudget.grantExtension(grantedBy);
+        if (grant.granted)
+            state.runBudgetGrantConsumed = true;
+        return grant;
+    }
+    /**
+     * Charge this interaction's extension unless a caller already took it.
+     *
+     * An ungranted arrival here means nobody was prompted — the continuation
+     * applier, non-interactive mode, `--auto-approve`. That is a parent-class
+     * grant, so it is capped and eventually refuses.
+     */
+    #takeRunBudgetGrant(state) {
+        if (state.runBudgetGrantConsumed) {
+            state.runBudgetGrantConsumed = false;
+            return true;
+        }
+        if (!state.runBudget)
+            return true;
+        return state.runBudget.grantExtension('parent').granted;
+    }
     /**
      * Hand the running turn a user message to send with its next model request.
      *
@@ -255,7 +290,9 @@ export class ApplicationRunLoop {
             history: normalizeHistory(input),
             // A response ID is usable only after its provider origin is recorded.
             // This also makes old callers that omit providerId fail closed.
-            responseId: options.providerId && options.supportsConversationChaining === true
+            responseId: options.disableChainingForAttempt !== true &&
+                options.providerId &&
+                options.supportsConversationChaining === true
                 ? options.previousResponseId ?? undefined
                 : undefined,
             pendingApprovals: [],
@@ -265,6 +302,7 @@ export class ApplicationRunLoop {
                 ? options.providerId
                 : undefined,
             requestPreparation: options.requestPreparation,
+            disableChainingForAttempt: options.disableChainingForAttempt === true,
             sessionId: options.sessionId,
             turnId: options.turnId,
             hookScope: options.hookScope,
@@ -272,13 +310,36 @@ export class ApplicationRunLoop {
             approvals: options.approvals ?? new ApprovalLedger(),
             turnCount: 0,
             maxTurns: options.maxTurns,
+            ...(options.runBudget
+                ? {
+                    runBudget: new RunBudget(options.runBudget),
+                    onRunBudgetEvent: options.onRunBudgetEvent,
+                    wrapUpOnCriticalRunBudget: options.wrapUpOnCriticalRunBudget,
+                    runBudgetEscalation: options.runBudget.escalation,
+                }
+                : {}),
             automaticCompactionsThisRun: 0,
         };
         state.approve = (interruption) => {
+            if (isRunBudgetInteraction(interruption)) {
+                // Continuing past an exhausted envelope must cost a finite extension no
+                // matter which surface answered. A caller that already took the grant
+                // (the interactive prompt, which needs the outcome before resuming)
+                // marks it consumed; every other path — the continuation applier,
+                // non-interactive, --auto-approve — lands here ungranted and takes it
+                // now. Without this, an auto-approved 'y' would resume with every stage
+                // still latched and never check in again.
+                state.runBudgetInteractionDecision = this.#takeRunBudgetGrant(state) ? 'continue' : 'stop';
+                return;
+            }
             state.approvalDecision = 'approved';
             state.approvalDecisionCallId = getInterruptionCallId(interruption);
         };
         state.reject = (interruption, approvalOptions) => {
+            if (isRunBudgetInteraction(interruption)) {
+                state.runBudgetInteractionDecision = 'stop';
+                return;
+            }
             state.approvalDecision = 'rejected';
             state.approvalDecisionCallId = getInterruptionCallId(interruption);
             state.approvalMessage = approvalOptions?.message;
@@ -304,6 +365,15 @@ export class ApplicationRunLoop {
         // Handles created before cost accounting existed have no record list.
         if (!state.costRecords)
             state.costRecords = [];
+        if (!state.runBudget && options.runBudget) {
+            state.runBudget = new RunBudget(options.runBudget);
+        }
+        if (options.runBudget)
+            state.runBudgetEscalation = options.runBudget.escalation;
+        if (options.onRunBudgetEvent)
+            state.onRunBudgetEvent = options.onRunBudgetEvent;
+        if (options.wrapUpOnCriticalRunBudget)
+            state.wrapUpOnCriticalRunBudget = true;
         // Response IDs are provider-owned. A handle from before provenance was
         // recorded, a missing providerId, or a provider switch must never forward
         // its opaque ID. In particular, do not use previousResponseId as a
@@ -342,6 +412,11 @@ export class ApplicationRunLoop {
         // root closure for callers that do not provide one again.
         if (options.requestPreparation)
             state.requestPreparation = options.requestPreparation;
+        if (options.disableChainingForAttempt === true) {
+            state.disableChainingForAttempt = true;
+            state.responseId = undefined;
+            state.responseProviderId = undefined;
+        }
         if (options.sessionId !== undefined)
             state.sessionId = options.sessionId;
         if (options.turnId !== undefined)
@@ -357,6 +432,7 @@ export class ApplicationRunLoop {
         const controller = new AbortController();
         this.#activeAbortController = controller;
         this.#runInFlight = true;
+        state.runBudget?.resume();
         // This segment is running, so the turn is no longer paused between them.
         this.#turnPaused = false;
         if (options.signal) {
@@ -375,6 +451,15 @@ export class ApplicationRunLoop {
             get turn() {
                 return { count: state.turnCount, max: state.maxTurns };
             },
+            get budget() {
+                return state.runBudget
+                    ? {
+                        takeSoftEvidence: () => state.runBudget?.takeSoftEvidence(),
+                        takeStallEvidence: () => state.runBudget?.takeStallEvidence(),
+                        remainingPolicy: () => state.runBudget?.remainingPolicy(),
+                    }
+                    : undefined;
+            },
         };
         const output = [];
         const stream = createAgentStream({
@@ -404,6 +489,7 @@ export class ApplicationRunLoop {
             throw error;
         })
             .finally(() => {
+            state.runBudget?.pause();
             if (segmentGeneration !== this.#segmentGeneration)
                 return;
             if (this.#activeAbortController === controller)
@@ -415,10 +501,13 @@ export class ApplicationRunLoop {
             // that ends with nothing outstanding has truly finished the turn, and
             // then anything still waiting has to be sent as its own turn instead.
             const pendingApprovals = state.pendingApprovals?.length ?? 0;
+            const pendingBudgetInteraction = state.pendingRunBudgetInteraction !== undefined;
             const cancelled = stream.cancelled === true;
-            this.#turnPaused = pendingApprovals > 0 && !cancelled && exitError === undefined;
+            this.#turnPaused = (pendingApprovals > 0 || pendingBudgetInteraction) && !cancelled && exitError === undefined;
             if (this.#turnPaused)
                 return;
+            if (this.#activeRunBudgetState === state)
+                this.#activeRunBudgetState = undefined;
             // A declared turn outlives its segments — this one may be about to be
             // retried, or resumed past a post-execute gate. Its owner says when it
             // is over.
@@ -426,17 +515,33 @@ export class ApplicationRunLoop {
                 return;
             this.#releasePendingSteers({
                 pendingApprovals,
+                pendingBudgetInteraction,
                 cancelled,
                 error: exitError instanceof Error ? exitError.name : exitError ? String(exitError) : undefined,
                 turnCount: state.turnCount,
             });
         });
+        this.#activeRunBudgetState = state.runBudget ? state : undefined;
         return stream;
     }
     async #execute(state, stream, queue, options, toolContext, requestAbortController) {
         while (true) {
             if (options.signal?.aborted)
                 throw Object.assign(new Error('Operation aborted'), { name: 'AbortError' });
+            if (state.pendingRunBudgetInteraction) {
+                if (state.runBudgetInteractionDecision === 'stop') {
+                    state.pendingRunBudgetInteraction = undefined;
+                    state.runBudgetInteractionDecision = undefined;
+                    return finish(stream, state, queue);
+                }
+                if (state.runBudgetInteractionDecision === 'continue') {
+                    state.pendingRunBudgetInteraction = undefined;
+                    state.runBudgetInteractionDecision = undefined;
+                }
+                else {
+                    return this.#pauseForRunBudgetInteraction(state, stream, queue);
+                }
+            }
             state.pendingApprovals ??= state.pendingApproval ? [state.pendingApproval] : [];
             if (state.pendingApprovals.length > 0 && state.approvalDecision) {
                 const selectedIndex = state.approvalDecisionCallId
@@ -475,184 +580,296 @@ export class ApplicationRunLoop {
                 if (options.stopAfterApprovalResolution)
                     return finish(stream, state, queue);
             }
+            // A budget interaction can park a response after its tool calls are
+            // recorded but before any body runs. Resume those retained calls only
+            // after processing an ordinary approval decision for that same plan.
+            if (state.toolPlan) {
+                await this.#settleToolPlan(state, stream, queue, toolContext);
+                if (state.pendingApprovals?.length) {
+                    stream.interruptions = state.pendingApprovals.map((item) => item.interruption);
+                    this.#turnPaused = true;
+                    return finish(stream, state, queue);
+                }
+            }
             // The request boundary: every tool result of the previous round is in
             // history, and the next request has not been built. A user message
             // admitted here reaches the model in sequence, mid-turn.
-            this.#admitPendingSteers(state, stream, queue);
-            if (options.boundaryCompaction) {
-                const compactionStartedAt = Date.now();
-                const compaction = await options.boundaryCompaction.compact({
-                    history: state.history,
-                    automaticCompactionsThisRun: state.automaticCompactionsThisRun ?? 0,
-                    signal: options.signal,
-                    onStarted: (provider) => outputPush(stream, queue, { type: 'context_compaction_started', provider, strategy: 'local' }),
-                });
-                if (compaction.kind === 'compacted') {
-                    state.history.splice(0, state.history.length, ...compaction.history);
-                    state.input.splice(0, state.input.length, ...normalizeApplicationInput(compaction.modelInput));
-                    state.responseId = undefined;
-                    state.responseProviderId = undefined;
-                    if (compaction.costRecords?.length) {
-                        state.costRecords ??= [];
-                        state.costRecords.push(...compaction.costRecords);
-                    }
-                    state.automaticCompactionsThisRun = (state.automaticCompactionsThisRun ?? 0) + 1;
-                    outputPush(stream, queue, {
-                        type: 'context_compaction_completed',
-                        provider: state.currentProviderId ?? 'unknown',
-                        strategy: 'local',
-                        durationMs: Math.max(0, Date.now() - compactionStartedAt),
+            if (!state.requestBoundaryReady) {
+                this.#admitPendingSteers(state, stream, queue);
+                this.#evaluateRunBudget(state, stream, queue);
+                if (state.pendingRunBudgetInteraction)
+                    return this.#pauseForRunBudgetInteraction(state, stream, queue);
+                if (options.boundaryCompaction) {
+                    const compactionStartedAt = Date.now();
+                    const compaction = await options.boundaryCompaction.compact({
+                        history: state.history,
+                        automaticCompactionsThisRun: state.automaticCompactionsThisRun ?? 0,
+                        signal: options.signal,
+                        onStarted: (provider) => outputPush(stream, queue, { type: 'context_compaction_started', provider, strategy: 'local' }),
                     });
+                    if (compaction.kind === 'compacted') {
+                        state.history.splice(0, state.history.length, ...compaction.history);
+                        state.input.splice(0, state.input.length, ...normalizeApplicationInput(compaction.modelInput));
+                        state.responseId = undefined;
+                        state.responseProviderId = undefined;
+                        if (compaction.costRecords?.length) {
+                            state.costRecords ??= [];
+                            state.costRecords.push(...compaction.costRecords);
+                        }
+                        state.automaticCompactionsThisRun = (state.automaticCompactionsThisRun ?? 0) + 1;
+                        outputPush(stream, queue, {
+                            type: 'context_compaction_completed',
+                            provider: state.currentProviderId ?? 'unknown',
+                            strategy: 'local',
+                            durationMs: Math.max(0, Date.now() - compactionStartedAt),
+                        });
+                    }
+                    else if (compaction.kind === 'failed') {
+                        outputPush(stream, queue, {
+                            type: 'context_compaction_failed',
+                            provider: compaction.provider,
+                            strategy: 'local',
+                            durationMs: Math.max(0, Date.now() - compactionStartedAt),
+                        });
+                    }
+                    // Summarization is an asynchronous part of this same request
+                    // boundary. Admit anything that arrived while it was in flight after
+                    // applying a replacement, so the steer cannot be overwritten by the
+                    // checkpoint or miss a terminal model request.
+                    this.#admitPendingSteers(state, stream, queue);
+                    this.#evaluateRunBudget(state, stream, queue);
+                    if (state.pendingRunBudgetInteraction)
+                        return this.#pauseForRunBudgetInteraction(state, stream, queue);
                 }
-                else if (compaction.kind === 'failed') {
-                    outputPush(stream, queue, {
-                        type: 'context_compaction_failed',
-                        provider: compaction.provider,
-                        strategy: 'local',
-                        durationMs: Math.max(0, Date.now() - compactionStartedAt),
-                    });
+                state.turnCount += 1;
+                this.#evaluateRunBudget(state, stream, queue);
+                if (state.pendingRunBudgetInteraction) {
+                    state.requestBoundaryReady = true;
+                    return this.#pauseForRunBudgetInteraction(state, stream, queue);
+                }
+                // Retain the legacy error only for callers that have not adopted staged
+                // budgets. A configured run budget turns the same count into critical
+                // evidence and lets the decision surface choose what happens next.
+                if (!state.runBudget && state.maxTurns !== undefined && state.turnCount > state.maxTurns) {
+                    throw new MaxTurnsExceededError(state.maxTurns);
                 }
-                // Summarization is an asynchronous part of this same request
-                // boundary. Admit anything that arrived while it was in flight after
-                // applying a replacement, so the steer cannot be overwritten by the
-                // checkpoint or miss a terminal model request.
-                this.#admitPendingSteers(state, stream, queue);
             }
-            state.turnCount += 1;
-            if (state.maxTurns !== undefined && state.turnCount > state.maxTurns) {
-                throw new MaxTurnsExceededError(state.maxTurns);
+            else {
+                state.requestBoundaryReady = undefined;
             }
             const model = await this.#deps.resolveModel(state.agent.model);
-            let sawToolCall = false;
-            const streamedToolCalls = [];
+            const maxRetries = state.agent.modelSettings?.retry?.maxRetries ?? 0;
+            let attempt = 0;
+            let streamedToolCalls = [];
             let completion;
+            let sawToolCall = false;
+            let activeRequestId = '';
+            let activeRequest;
             let pendingNativeReasoning;
-            // Stable process-unique request id, allocated immediately before dispatch
-            // so a cost record can be settled exactly once (success or failure).
-            const requestId = this.#nextRequestId();
-            const request = {
-                instructions: state.agent.instructions,
-                ...(state.supportsConversationChaining &&
-                    state.responseId &&
-                    state.responseProviderId !== undefined &&
-                    state.responseProviderId === state.currentProviderId
-                    ? { previousResponseId: state.responseId }
-                    : {}),
-                input: state.input,
-                tools: toModelTools(state.agent.tools),
-                applicationTools: state.agent.tools,
-                ...(state.agent.modelSettings?.temperature !== undefined
-                    ? { temperature: state.agent.modelSettings.temperature }
-                    : {}),
-                ...(state.agent.modelSettings?.reasoning ? { reasoning: state.agent.modelSettings.reasoning } : {}),
-                ...(state.agent.modelSettings?.maxTokens !== undefined
-                    ? { maxTokens: state.agent.modelSettings.maxTokens }
-                    : {}),
-                ...(state.agent.outputType !== undefined ? { outputType: state.agent.outputType } : {}),
-                ...(state.agent.modelSettings?.codex ? { codex: state.agent.modelSettings.codex } : {}),
-                ...(state.agent.modelSettings?.providerData
-                    ? {
-                        providerOptions: this.#contextCompactionSessionState.disabled
-                            ? Object.fromEntries(Object.entries(state.agent.modelSettings.providerData).filter(([key]) => key !== 'contextCompaction'))
-                            : state.agent.modelSettings.providerData,
-                    }
-                    : {}),
-                ...(options.signal ? { signal: options.signal } : {}),
-            };
-            const generationGuard = new GenerationGuard({
-                maxOutputCharacters: state.agent.modelSettings?.maxStreamOutputChars,
-                maxTextCharacters: state.agent.modelSettings?.maxStreamOutputChars,
-                maxReasoningCharacters: state.agent.modelSettings?.maxStreamOutputChars,
-                maxToolArgumentCharacters: state.agent.modelSettings?.maxStreamOutputChars,
-                maxCumulativeToolArgumentCharacters: state.agent.modelSettings?.maxStreamOutputChars,
-                requestDeadlineMs: state.agent.modelSettings?.maxModelRequestDurationMs,
-                ...options.generationGuard,
-            });
-            const consume = async () => {
-                const deadline = new GenerationDeadline(generationGuard.requestDeadlineMs, () => requestAbortController.abort(), () => generationGuard.progress);
-                let iterator;
-                let iteratorFinished = false;
-                try {
-                    iterator = model.stream(request)[Symbol.asyncIterator]();
-                    while (true) {
-                        const next = await deadline.wait(iterator.next());
-                        if (next.done) {
-                            iteratorFinished = true;
-                            return;
-                        }
-                        const event = next.value;
-                        if (event.type === 'completion') {
-                            generationGuard.observeCompletion(event.output);
-                            completion = event;
-                            continue;
-                        }
-                        if (event.type === 'text_delta') {
-                            generationGuard.observeText(event.text);
-                            outputPush(stream, queue, { type: 'text_delta', text: event.text });
-                            continue;
-                        }
-                        if (event.type === 'codex_rate_limits') {
-                            outputPush(stream, queue, { type: 'codex_rate_limits', rateLimits: event.rateLimits });
-                            continue;
+            let criticalWrapUp = false;
+            while (true) {
+                streamedToolCalls = [];
+                completion = undefined;
+                sawToolCall = false;
+                pendingNativeReasoning = undefined;
+                // Stable process-unique request id, allocated immediately before dispatch
+                // so a cost record can be settled exactly once (success or failure).
+                activeRequestId = this.#nextRequestId();
+                const requestId = activeRequestId;
+                const outputLengthBefore = stream.output.length;
+                const newItemsLengthBefore = stream.newItems.length;
+                const inputLengthBefore = state.input.length;
+                const historyLengthBefore = state.history.length;
+                const criticalWrapUpDispatchedBefore = state.criticalWrapUpDispatched;
+                let provisionalTextCharacters = 0;
+                let provisionalReasoningCharacters = 0;
+                let provisionalTextDeltas = 0;
+                let provisionalReasoningDeltas = 0;
+                criticalWrapUp = state.criticalWrapUpPending === true && state.criticalWrapUpDispatched !== true;
+                if (criticalWrapUp)
+                    state.criticalWrapUpDispatched = true;
+                const disableChaining = state.disableChainingForAttempt === true;
+                if (disableChaining) {
+                    state.disableChainingForAttempt = false;
+                    state.responseId = undefined;
+                    state.responseProviderId = undefined;
+                }
+                const request = {
+                    instructions: criticalWrapUp
+                        ? `${state.agent.instructions}\n\nBudget containment is terminal. Do not call tools. In this one final response, summarize what you completed, the evidence you have, and what remains.`
+                        : state.agent.instructions,
+                    ...(state.supportsConversationChaining &&
+                        !disableChaining &&
+                        state.responseId &&
+                        state.responseProviderId !== undefined &&
+                        state.responseProviderId === state.currentProviderId
+                        ? { previousResponseId: state.responseId }
+                        : {}),
+                    ...(disableChaining ? { disableChaining: true } : {}),
+                    input: state.input,
+                    tools: toModelTools(criticalWrapUp ? [] : state.agent.tools),
+                    applicationTools: criticalWrapUp ? [] : state.agent.tools,
+                    ...(state.agent.modelSettings?.temperature !== undefined
+                        ? { temperature: state.agent.modelSettings.temperature }
+                        : {}),
+                    ...(state.agent.modelSettings?.reasoning ? { reasoning: state.agent.modelSettings.reasoning } : {}),
+                    ...(state.agent.modelSettings?.maxTokens !== undefined
+                        ? { maxTokens: state.agent.modelSettings.maxTokens }
+                        : {}),
+                    ...(state.agent.outputType !== undefined ? { outputType: state.agent.outputType } : {}),
+                    ...(state.agent.modelSettings?.codex ? { codex: state.agent.modelSettings.codex } : {}),
+                    ...(state.agent.modelSettings?.providerData
+                        ? {
+                            providerOptions: this.#contextCompactionSessionState.disabled
+                                ? Object.fromEntries(Object.entries(state.agent.modelSettings.providerData).filter(([key]) => key !== 'contextCompaction'))
+                                : state.agent.modelSettings.providerData,
                         }
-                        if (event.type === 'reasoning_delta') {
-                            generationGuard.observeReasoning(event.text);
-                            pendingNativeReasoning = appendNativeReasoning(pendingNativeReasoning, event);
-                            outputPush(stream, queue, { type: 'reasoning_delta', text: event.text });
-                            continue;
+                        : {}),
+                    ...(options.signal ? { signal: options.signal } : {}),
+                };
+                activeRequest = request;
+                const generationGuard = new GenerationGuard({
+                    maxOutputCharacters: state.agent.modelSettings?.maxStreamOutputChars,
+                    maxTextCharacters: state.agent.modelSettings?.maxStreamOutputChars,
+                    maxReasoningCharacters: state.agent.modelSettings?.maxStreamOutputChars,
+                    maxToolArgumentCharacters: state.agent.modelSettings?.maxStreamOutputChars,
+                    maxCumulativeToolArgumentCharacters: state.agent.modelSettings?.maxStreamOutputChars,
+                    requestDeadlineMs: state.agent.modelSettings?.maxModelRequestDurationMs,
+                    maxStreamIdleMs: state.agent.modelSettings?.maxModelStreamIdleMs,
+                    ...options.generationGuard,
+                });
+                const consume = async () => {
+                    const deadline = new GenerationStreamDeadlines({ totalMs: generationGuard.requestDeadlineMs, idleMs: generationGuard.maxStreamIdleMs }, () => requestAbortController.abort(), () => generationGuard.progress);
+                    let iterator;
+                    let iteratorFinished = false;
+                    try {
+                        iterator = model.stream(request)[Symbol.asyncIterator]();
+                        while (true) {
+                            const next = await deadline.wait(iterator.next());
+                            if (next.done) {
+                                iteratorFinished = true;
+                                return;
+                            }
+                            // Any streamed event is transport activity: re-arm the inactivity
+                            // window so long legitimate reasoning is never mistaken for a stall.
+                            deadline.recordActivity();
+                            const event = next.value;
+                            if (event.type === 'completion') {
+                                generationGuard.observeCompletion(event.output);
+                                completion = event;
+                                continue;
+                            }
+                            if (event.type === 'text_delta') {
+                                generationGuard.observeText(event.text);
+                                provisionalTextCharacters += event.text.length;
+                                provisionalTextDeltas++;
+                                outputPush(stream, queue, { type: 'text_delta', text: event.text });
+                                continue;
+                            }
+                            if (event.type === 'codex_rate_limits') {
+                                outputPush(stream, queue, { type: 'codex_rate_limits', rateLimits: event.rateLimits });
+                                continue;
+                            }
+                            if (event.type === 'reasoning_delta') {
+                                const accepted = generationGuard.observeReasoning(event.text);
+                                if (!accepted)
+                                    continue;
+                                const forwarded = accepted === event.text ? event : { ...event, text: accepted };
+                                pendingNativeReasoning = appendNativeReasoning(pendingNativeReasoning, forwarded);
+                                provisionalReasoningCharacters += accepted.length;
+                                provisionalReasoningDeltas++;
+                                outputPush(stream, queue, { type: 'reasoning_delta', text: accepted });
+                                continue;
+                            }
+                            if (event.type === 'tool_call_streaming_delta') {
+                                generationGuard.observeToolArgumentProgress(event.argumentCharCount);
+                                outputPush(stream, queue, event);
+                                continue;
+                            }
+                            if (event.type === 'context_compaction_started' || event.type === 'context_compaction_completed') {
+                                outputPush(stream, queue, event);
+                                continue;
+                            }
+                            if (event.type === 'tool_call') {
+                                generationGuard.observeToolCall(event.arguments);
+                                pendingNativeReasoning = commitPendingNativeReasoning(state, stream, queue, pendingNativeReasoning);
+                                sawToolCall = true;
+                                streamedToolCalls.push(event);
+                            }
                         }
-                        if (event.type === 'tool_call_streaming_delta') {
-                            generationGuard.observeToolArgumentProgress(event.argumentCharCount);
-                            outputPush(stream, queue, event);
-                            continue;
+                    }
+                    finally {
+                        deadline.dispose();
+                        if (iterator && !iteratorFinished)
+                            void iterator.return?.().catch(() => undefined);
+                    }
+                };
+                const dispatch = async () => {
+                    state.requestPreparation?.prepare(request);
+                    await consume();
+                };
+                try {
+                    if (state.requestPreparation)
+                        await state.requestPreparation.run(dispatch);
+                    else
+                        await dispatch();
+                    break;
+                }
+                catch (error) {
+                    if (error instanceof GenerationGuardError)
+                        requestAbortController.abort();
+                    const decision = classifyInLoopModelRetry(error, attempt, maxRetries);
+                    if (decision.retryable && !options.signal?.aborted) {
+                        attempt++;
+                        state.input.splice(inputLengthBefore);
+                        state.history.splice(historyLengthBefore);
+                        state.criticalWrapUpDispatched = criticalWrapUpDispatchedBefore;
+                        stream.output.splice(outputLengthBefore);
+                        if (stream.newItems !== stream.output) {
+                            stream.newItems.splice(newItemsLengthBefore);
                         }
-                        if (event.type === 'context_compaction_started' || event.type === 'context_compaction_completed') {
-                            outputPush(stream, queue, event);
-                            continue;
+                        if (provisionalTextDeltas > 0 || provisionalReasoningDeltas > 0) {
+                            queue.push({
+                                type: 'model_attempt_rollback',
+                                textCharacters: provisionalTextCharacters,
+                                reasoningCharacters: provisionalReasoningCharacters,
+                                textDeltas: provisionalTextDeltas,
+                                reasoningDeltas: provisionalReasoningDeltas,
+                            });
                         }
-                        if (event.type === 'tool_call') {
-                            generationGuard.observeToolCall(event.arguments);
-                            pendingNativeReasoning = commitPendingNativeReasoning(state, stream, queue, pendingNativeReasoning);
-                            sawToolCall = true;
-                            streamedToolCalls.push(event);
+                        if (decision.kind === 'chain_recovery') {
+                            state.disableChainingForAttempt = true;
+                            state.responseId = undefined;
+                            state.responseProviderId = undefined;
                         }
+                        this.#deps.logDiagnostic?.('Retrying model request in run loop', {
+                            attempt,
+                            maxRetries,
+                            kind: decision.kind,
+                            delayMs: decision.delayMs,
+                            error: error instanceof Error ? error.message : String(error),
+                        });
+                        await (this.#deps.waitBeforeModelRetry ?? sleepWithAbort)(decision.delayMs, options.signal);
+                        continue;
                     }
+                    // Dispatch began, but no terminal completion was accepted. Record an
+                    // unpriced marker so the summary stays honest (partial) rather than
+                    // appearing exact. Observational only: the error still propagates.
+                    const cancelled = error instanceof Error && error.name === 'AbortError';
+                    const record = this.#appendCostRecord(state, {
+                        requestId,
+                        provider: state.currentProviderId,
+                        model: state.agent.model,
+                        tier: resolveServiceTier(request),
+                        outcome: cancelled ? 'cancelled' : 'failed',
+                    });
+                    // Only the live queue sees cost records: `output`/`newItems` feed
+                    // persistence and replay, and a cost event must never become a
+                    // restored history item.
+                    queue.push({ type: 'cost_update', record });
+                    this.#evaluateRunBudget(state, stream, queue);
+                    throw error;
                 }
-                finally {
-                    deadline.dispose();
-                    if (iterator && !iteratorFinished)
-                        void iterator.return?.().catch(() => undefined);
-                }
-            };
-            const dispatch = async () => {
-                state.requestPreparation?.prepare(request);
-                await consume();
-            };
-            try {
-                if (state.requestPreparation)
-                    await state.requestPreparation.run(dispatch);
-                else
-                    await dispatch();
-            }
-            catch (error) {
-                if (error instanceof GenerationGuardError)
-                    requestAbortController.abort();
-                // Dispatch began, but no terminal completion was accepted. Record an
-                // unpriced marker so the summary stays honest (partial) rather than
-                // appearing exact. Observational only: the error still propagates.
-                const cancelled = error instanceof Error && error.name === 'AbortError';
-                const record = this.#appendCostRecord(state, {
-                    requestId,
-                    provider: state.currentProviderId,
-                    model: state.agent.model,
-                    tier: resolveServiceTier(request),
-                    outcome: cancelled ? 'cancelled' : 'failed',
-                });
-                // Only the live queue sees cost records: `output`/`newItems` feed
-                // persistence and replay, and a cost event must never become a
-                // restored history item.
-                queue.push({ type: 'cost_update', record });
-                throw error;
             }
             if (!completion) {
                 // A few application-owned model fixtures (and legacy adapters) end a
@@ -662,6 +879,8 @@ export class ApplicationRunLoop {
                 // fails closed as an incomplete model turn.
                 if (streamedToolCalls.length === 0)
                     throw new Error('Application model turn ended without completion');
+                if (criticalWrapUp)
+                    return finish(stream, state, queue);
                 await this.#dispatchToolCalls(state, stream, queue, streamedToolCalls, toolContext);
                 if (state.pendingApprovals && state.pendingApprovals.length > 0) {
                     stream.interruptions = state.pendingApprovals.map((item) => item.interruption);
@@ -670,6 +889,7 @@ export class ApplicationRunLoop {
                 }
                 continue;
             }
+            const finalCompletion = completion;
             // Commit the authoritative terminal state before handling terminal-only
             // tool calls. Approval may pause immediately after this point, and the
             // continuation must still carry the response that produced the calls.
@@ -678,7 +898,7 @@ export class ApplicationRunLoop {
             // chaining, while still exposing the completed provider response on the
             // current stream for diagnostics.
             if (state.supportsConversationChaining && state.currentProviderId !== undefined) {
-                state.responseId = completion.responseId;
+                state.responseId = finalCompletion.responseId;
                 state.responseProviderId = state.currentProviderId;
             }
             else {
@@ -686,8 +906,8 @@ export class ApplicationRunLoop {
                 state.responseProviderId = undefined;
             }
             let normalizedCompletionUsage;
-            if (completion.usage !== undefined) {
-                normalizedCompletionUsage = normalizeModelUsage(completion.usage);
+            if (finalCompletion.usage !== undefined) {
+                normalizedCompletionUsage = normalizeModelUsage(finalCompletion.usage);
                 if (normalizedCompletionUsage) {
                     const accumulated = addTokenUsage(normalizeModelUsage(state.usage), normalizedCompletionUsage);
                     state.usage = {
@@ -708,7 +928,7 @@ export class ApplicationRunLoop {
                 else {
                     // Providers may carry a future/opaque usage shape. Preserve the old
                     // pass-through behavior when normalization cannot recognize it.
-                    state.usage = completion.usage;
+                    state.usage = finalCompletion.usage;
                 }
             }
             else {
@@ -722,27 +942,33 @@ export class ApplicationRunLoop {
             // persistence and replay, and a cost event must never become a restored
             // history item.
             const record = this.#appendCostRecord(state, {
-                requestId,
+                requestId: activeRequestId,
                 provider: state.currentProviderId,
                 model: state.agent.model,
-                tier: resolveServiceTier(request),
+                tier: activeRequest ? resolveServiceTier(activeRequest) : 'standard',
                 outcome: 'completed',
                 usage: normalizedCompletionUsage,
-                providerUsd: completion.costUsd,
+                providerUsd: finalCompletion.costUsd,
             });
             queue.push({ type: 'cost_update', record });
-            stream.lastResponseId = completion.responseId;
-            stream.rawResponses?.push(completion);
+            // Cost and usage arrive in the same completion metadata, so surface both
+            // live. The footer is a per-request indicator: emit this request's own
+            // usage, never the run accumulator in `state.usage`.
+            if (normalizedCompletionUsage)
+                queue.push({ type: 'usage_update', usage: normalizedCompletionUsage });
+            this.#evaluateRunBudget(state, stream, queue);
+            stream.lastResponseId = finalCompletion.responseId;
+            stream.rawResponses?.push(finalCompletion);
             // Some provider adapters report function calls only in the terminal
             // completion rather than as separate stream events. Their reasoning may
             // likewise be terminal-only, so associate it before replaying calls.
             const toolCalls = [...streamedToolCalls];
             if (!sawToolCall) {
-                for (const item of completion.output) {
+                for (const item of finalCompletion.output) {
                     if (item.type === 'reasoning')
                         pendingNativeReasoning = appendNativeReasoning(pendingNativeReasoning, item);
                 }
-                for (const item of completion.output) {
+                for (const item of finalCompletion.output) {
                     if (item.type !== 'tool_call')
                         continue;
                     pendingNativeReasoning = commitPendingNativeReasoning(state, stream, queue, pendingNativeReasoning);
@@ -750,8 +976,6 @@ export class ApplicationRunLoop {
                     toolCalls.push(item);
                 }
             }
-            if (toolCalls.length > 0)
-                await this.#dispatchToolCalls(state, stream, queue, toolCalls, toolContext);
             // A native reasoning item belongs to the completed assistant turn even
             // when no tool call follows it. Commit it before assistant text so both
             // stateless continuation and persisted canonical history retain the
@@ -762,7 +986,7 @@ export class ApplicationRunLoop {
             // applies compaction's replacement rule; keeping the item here also
             // makes it available to an in-flight tool continuation before that
             // terminal history commit occurs.
-            for (const item of completion.output) {
+            for (const item of finalCompletion.output) {
                 if (item.type !== 'provider_opaque')
                     continue;
                 const historyItem = {
@@ -773,7 +997,7 @@ export class ApplicationRunLoop {
                 state.input.push(item);
                 outputPush(stream, queue, { type: 'item', item });
             }
-            const assistantText = completion.output
+            const assistantText = finalCompletion.output
                 .filter((item) => item.type === 'message')
                 .flatMap((item) => item.content)
                 .map((part) => part.text)
@@ -789,13 +1013,34 @@ export class ApplicationRunLoop {
                 outputPush(stream, queue, { type: 'item', item });
                 state.input.push({ type: 'message', role: 'assistant', content: [{ type: 'text', text: assistantText }] });
             }
+            // Tool calls are dispatched only after the reasoning, provider-opaque,
+            // and assistant-text items from the same completion are committed. A
+            // response that carries both prose and a tool call must serialize as
+            // text -> function_call -> function_call_result; dispatching first left
+            // the text stranded after its own tool result, where the assistant
+            // message merger glued it onto the *next* turn's tool call and every
+            // request ended with a bare assistant message. Models read that as a
+            // turn truncated mid-sentence and restart instead of progressing.
+            if (!state.criticalWrapUpPending && toolCalls.length > 0) {
+                await this.#dispatchToolCalls(state, stream, queue, toolCalls, toolContext);
+            }
+            // A critical subagent gets exactly this final tool-free model call.
+            if (criticalWrapUp)
+                return finish(stream, state, queue);
+            if (state.pendingRunBudgetInteraction && toolCalls.length > 0) {
+                return this.#pauseForRunBudgetInteraction(state, stream, queue);
+            }
             if (state.pendingApprovals.length > 0) {
                 stream.interruptions = state.pendingApprovals.map((item) => item.interruption);
                 this.#turnPaused = true;
                 return finish(stream, state, queue);
             }
-            if (!sawToolCall)
+            if (!sawToolCall) {
+                // Evidence discovered when a response has already completed needs no
+                // human boundary: there is no later request or tool to block.
+                state.pendingRunBudgetInteraction = undefined;
                 return finish(stream, state, queue);
+            }
         }
     }
     async #dispatchToolCalls(state, stream, queue, events, toolContext) {
@@ -829,6 +1074,14 @@ export class ApplicationRunLoop {
             // would apply schema defaults before execute. web_fetch relies on its
             // executor fallbacks on the strict JSON-schema path.
             entry.params = normalizeToolParameters(parseArguments(event.arguments), definition.parameters);
+            const stallEvent = state.runBudget?.observeToolCall({
+                name: event.name,
+                argumentsText: event.arguments,
+                effect: definition.effect,
+            });
+            if (stallEvent) {
+                this.#emitRunBudgetEvent(state, stallEvent, 'Tool stall evidence', stream, queue);
+            }
             // Consult this run's ledger before prompting: a decision already taken
             // (in the parent run and replayed in, or earlier in this run) must not
             // prompt again. This is what makes approval replay observable.
@@ -870,12 +1123,17 @@ export class ApplicationRunLoop {
                 approvalPending: entry.status === 'approval_pending',
             })),
         });
-        await this.#settleToolPlan(state, stream, queue, toolContext);
+        // A main-agent budget escalation is a real boundary: retain the planned
+        // calls, but do not execute one more tool while human judgement is pending.
+        if (!state.pendingRunBudgetInteraction) {
+            await this.#settleToolPlan(state, stream, queue, toolContext);
+        }
     }
     async #settleToolPlan(state, stream, queue, toolContext) {
         const plan = state.toolPlan;
         if (!plan)
             return;
+        const maxParallelToolCalls = Math.max(1, Math.floor(this.#deps.resolveMaxParallelToolCalls?.() ?? DEFAULT_MAX_PARALLEL_TOOL_CALLS));
         while (true) {
             const firstPending = plan.find((entry) => entry.status !== 'completed');
             if (!firstPending) {
@@ -890,8 +1148,7 @@ export class ApplicationRunLoop {
                     continue;
                 if (entry.status === 'approval_pending')
                     break;
-                if (group.length > 0 &&
-                    (!entry.parallelSafe || !group[0].parallelSafe || group.length >= this.#maxParallelToolCalls))
+                if (group.length > 0 && (!entry.parallelSafe || !group[0].parallelSafe || group.length >= maxParallelToolCalls))
                     break;
                 group.push(entry);
                 if (!entry.parallelSafe)
@@ -902,8 +1159,16 @@ export class ApplicationRunLoop {
                 batchId,
                 callIds: group.map((entry) => entry.event.id),
                 parallel: group.length > 1,
+                maxParallelToolCalls,
                 dispatchOrder: group.map((entry) => entry.event.id),
             });
+            for (const entry of group) {
+                outputPush(stream, queue, {
+                    type: 'tool_call_dispatched',
+                    callId: entry.event.id,
+                    toolName: entry.event.name,
+                });
+            }
             if (group.length > 1) {
                 const results = await Promise.allSettled(group.map((entry) => this.#invokePlannedTool(entry, toolContext, state)));
                 const rejected = results.find((result) => result.status === 'rejected');
@@ -940,6 +1205,7 @@ export class ApplicationRunLoop {
         state.history.push(resultItem);
         state.input.push({ type: 'tool_result', id: entry.event.id, output });
         outputPush(stream, queue, { type: 'item', item: resultItem });
+        this.#evaluateRunBudget(state, stream, queue);
     }
     /**
      * A tool that throws must not take the run down with it.
@@ -987,15 +1253,6 @@ export class ApplicationRunLoop {
                 throw error;
             }
             const message = error instanceof Error ? error.message : String(error);
-            // Feeding the same failure back forever is its own failure mode: some
-            // errors no argument can fix. Repeat the identical result once, then say
-            // so plainly rather than inviting a third identical attempt.
-            const repeated = state ? countRepeatedFailure(state, definition.name, params, message) : 1;
-            if (repeated > MAX_IDENTICAL_TOOL_FAILURES) {
-                const result = `Error: ${message}\n\nThis exact call has now failed ${repeated} times with the same error. Do not call ${definition.name} with these arguments again — either change your approach or report the problem to the user.`;
-                await this.#notifyToolLifecycle(() => this.#deps.toolLifecycle?.error(lifecycleContext, error, Date.now() - startedAt, true));
-                return result;
-            }
             const result = `Error: ${message}`;
             await this.#notifyToolLifecycle(() => this.#deps.toolLifecycle?.error(lifecycleContext, error, Date.now() - startedAt, true));
             return result;
@@ -1020,6 +1277,52 @@ export class ApplicationRunLoop {
         state.costRecords = [...(state.costRecords ?? []), record];
         return record;
     }
+    #evaluateRunBudget(state, stream, queue) {
+        if (!state.runBudget)
+            return;
+        for (const event of state.runBudget.evaluate({
+            turns: state.turnCount,
+            costRecords: state.costRecords ?? [],
+        })) {
+            this.#emitRunBudgetEvent(state, event, 'Run budget evidence', stream, queue);
+        }
+    }
+    #emitRunBudgetEvent(state, event, message, stream, queue) {
+        if (state.runBudgetEscalation === 'disabled') {
+            return;
+        }
+        if (event.type === 'budget_stage' && event.stage === 'critical' && state.wrapUpOnCriticalRunBudget) {
+            state.criticalWrapUpPending = true;
+        }
+        if (!state.wrapUpOnCriticalRunBudget &&
+            !state.pendingRunBudgetInteraction &&
+            state.runBudgetEscalation !== 'warn' &&
+            this.#requiresHumanBudgetDecision(event)) {
+            state.pendingRunBudgetInteraction = { type: 'run_budget_interaction', event };
+            state.runBudgetGrantConsumed = false;
+        }
+        if (stream && queue)
+            outputPush(stream, queue, { type: 'run_budget', evidence: event });
+        try {
+            state.onRunBudgetEvent?.(event);
+        }
+        catch {
+            // Evidence observers are delivery adapters, not budget owners.
+            this.#deps.logDiagnostic?.('Run budget event observer failed', { type: event.type });
+        }
+        this.#deps.logDiagnostic?.(message, event);
+    }
+    #requiresHumanBudgetDecision(event) {
+        return event.type === 'tool_stall' || (event.type === 'budget_stage' && event.stage !== 'soft');
+    }
+    #pauseForRunBudgetInteraction(state, stream, queue) {
+        const interaction = state.pendingRunBudgetInteraction;
+        if (!interaction)
+            return finish(stream, state, queue);
+        stream.interruptions = [interaction];
+        this.#turnPaused = true;
+        return finish(stream, state, queue);
+    }
     async #notifyToolLifecycle(operation) {
         if (!operation)
             return;
@@ -1032,27 +1335,6 @@ export class ApplicationRunLoop {
         }
     }
 }
-/**
- * How many times an identical failing call is fed back before the loop stops
- * inviting retries. One repeat is worth allowing: a transient failure resolves,
- * and a model given the error often corrects on its second attempt.
- */
-const MAX_IDENTICAL_TOOL_FAILURES = 2;
-function countRepeatedFailure(state, toolName, params, message) {
-    let key;
-    try {
-        key = JSON.stringify([toolName, params, message]);
-    }
-    catch {
-        // Unserializable params cannot be compared for identity; treat every such
-        // failure as distinct rather than collapsing unrelated calls together.
-        return 1;
-    }
-    state.toolFailureCounts ??= new Map();
-    const count = (state.toolFailureCounts.get(key) ?? 0) + 1;
-    state.toolFailureCounts.set(key, count);
-    return count;
-}
 function outputPush(stream, queue, item) {
     stream.output.push(item);
     if (stream.newItems !== stream.output)
@@ -1078,6 +1360,15 @@ function finish(stream, state, queue) {
  * Chat-Completions continuation field. Generic reasoning remains display-only
  * so providers with different native formats are not given a foreign field.
  */
+/**
+ * True when any lane namespace in the metadata carries an `encrypted_content`
+ * blob — the shape every Responses adapter produces, whichever vendor it is.
+ */
+function hasNamespacedEncryptedReasoning(metadata) {
+    if (!metadata)
+        return false;
+    return Object.values(metadata).some((value) => asRecord(value)?.encrypted_content !== undefined);
+}
 function appendNativeReasoning(current, event) {
     const nativeReasoning = event.providerMetadata?.reasoning_content;
     if (typeof nativeReasoning === 'string') {
@@ -1094,8 +1385,10 @@ function appendNativeReasoning(current, event) {
     }
     // Responses providers return encrypted reasoning only on their terminal
     // output. Their metadata is namespaced, so retain it without turning it into
-    // the Chat-Completions-only reasoning_content convention.
-    if (asRecord(event.providerMetadata?.codex) || asRecord(event.providerMetadata?.openai)) {
+    // the Chat-Completions-only reasoning_content convention. Match on the
+    // namespaced shape rather than an allowlist of lane names: an allowlist
+    // silently drops the reasoning of every Responses lane added later.
+    if (hasNamespacedEncryptedReasoning(event.providerMetadata)) {
         return {
             ...(event.id ? { id: event.id } : current?.id ? { id: current.id } : {}),
             text: event.text,