@cortexkit/opencode-magic-context 0.49.18 → 0.49.19

package/dist/{wrapup-orchestrator-s9zc5b00.js → wrapup-orchestrator-whhbjmaz.js}

@@ -1,11 +1,11 @@
 import {
   runManagedWrapup2
-} from "./index-24jbw52d.js";
-import"./index-r4nkrs05.js";
-import"./index-s1ex9y6p.js";
+} from "./index-4911rn0b.js";
+import"./index-c1p88z1y.js";
+import"./index-rpxdjkm0.js";
 import"./index-4s3t0nd0.js";
-import"./index-v8awdgvd.js";
-import"./index-x4njr8df.js";
+import"./index-3h4dp9wb.js";
+import"./index-se4m2g6w.js";
 import"./index-sd3egckz.js";
 import"./index-24fezq97.js";
 import"./index-ze7mvk54.js";
@@ -14,7 +14,7 @@ import"./index-4dhv7mqz.js";
 import"./index-v10f1rjv.js";
 import"./index-s74zqahq.js";
 import"./index-qt1qqasc.js";
-import"./index-rmwykbbb.js";
+import"./index-9zcsy3hh.js";
 import"./index-cf74k5ak.js";
 import"./index-1zx87sdm.js";
 import"./index-kq82mtg0.js";
@@ -25,9 +25,9 @@ import"./index-wgypt3cs.js";
 import"./index-rr2bb45z.js";
 import"./index-b5vqckbw.js";
 import"./index-6x57ar45.js";
-import"./index-fgncb0ng.js";
+import"./index-jrr131e0.js";
 import"./index-fb3zxn06.js";
-import"./index-qn7xstt2.js";
+import"./index-63k48rv9.js";
 import"./index-2vxtcb95.js";
 import"./index-a6mc0v4d.js";
 import"./index-fr0wbhdn.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cortexkit/opencode-magic-context",
-  "version": "0.49.18",
+  "version": "0.49.19",
   "type": "module",
   "description": "OpenCode plugin for Magic Context — cross-session memory and context management",
   "main": "dist/index.js",

package/src/shared/model-suggestion-retry.test.ts

@@ -5,6 +5,8 @@ import { recordedGeminiQuotaMessages } from "../features/magic-context/dreamer/p
 import { HiddenAgentStepLimit } from "../v2/hooks/hidden-child";
 import {
     getPromptFailureDetail,
+    noteModelActivityMonitored,
+    noteModelOutputReceived,
     promptSyncWithModelSuggestionRetry,
     promptSyncWithValidatedOutputRetry,
 } from "./model-suggestion-retry";
@@ -833,3 +835,167 @@ test("timeout rejects an uncooperative carrier and aborts its child", async () =
         clearTimeout(timer);
     }
 });
+
+describe("first-output deadline", () => {
+    const primary = { providerID: "opencode", modelID: "free-model" };
+    type Behaviour = "silent" | "partial" | "answer" | "unmonitored";
+
+    /**
+     * A transport double that behaves per model. "silent" watches the child but the
+     * model never answers; "partial" streams something and then hangs; "unmonitored"
+     * hangs without ever reporting whether the model answered (the Pi and OpenCode 2
+     * carriers); "answer" completes at once.
+     */
+    function modelTransport(behaviours: Record<string, Behaviour>) {
+        const calls: Array<{ model: string; startedAt: number }> = [];
+        const transport = Object.assign(
+            async (request: PromptCall & { signal?: AbortSignal }) => {
+                const model = request.body.model
+                    ? `${request.body.model.providerID}/${request.body.model.modelID}`
+                    : "primary";
+                calls.push({ model, startedAt: Date.now() });
+                const behaviour = behaviours[model] ?? "answer";
+                if (behaviour === "answer") return;
+                if (behaviour === "silent") noteModelActivityMonitored(request.signal);
+                if (behaviour === "partial") noteModelOutputReceived(request.signal);
+                await new Promise<void>((_resolve, reject) =>
+                    request.signal?.addEventListener("abort", () => reject(new Error("aborted"))),
+                );
+            },
+            { childSessionId: "child-first-output" },
+        );
+        return { transport, calls };
+    }
+
+    async function run(
+        behaviours: Record<string, Behaviour>,
+        options: { timeoutMs: number; firstOutputTimeoutMs?: number; fallbackModels?: string[] },
+    ) {
+        const { transport, calls } = modelTransport(behaviours);
+        const startedAt = Date.now();
+        let caught: unknown;
+        let result: Awaited<ReturnType<typeof promptSyncWithValidatedOutputRetry>> | undefined;
+        try {
+            result = await promptSyncWithValidatedOutputRetry(
+                createClient(mock(async () => ({}))),
+                createArgs(primary),
+                {
+                    transport: transport as never,
+                    timeoutMs: options.timeoutMs,
+                    ...(options.firstOutputTimeoutMs !== undefined
+                        ? { firstOutputTimeoutMs: options.firstOutputTimeoutMs }
+                        : {}),
+                    fallbackModels: options.fallbackModels ?? ["anthropic/claude-sonnet-5-5"],
+                    fetchOutput: async () => "<classify></classify>",
+                    validateOutput: (output: string) => output,
+                },
+            );
+        } catch (error) {
+            caught = error;
+        }
+        return { result, caught, calls, elapsedMs: Date.now() - startedAt };
+    }
+
+    test("a primary that streams nothing by the deadline moves on to the fallback", async () => {
+        const outcome = await run(
+            { "opencode/free-model": "silent" },
+            { timeoutMs: 2_000, firstOutputTimeoutMs: 40 },
+        );
+        expect(outcome.caught).toBeUndefined();
+        expect(outcome.result?.attempt.label).toBe("anthropic/claude-sonnet-5-5");
+        expect(outcome.calls.map((call) => call.model)).toEqual([
+            "opencode/free-model",
+            "anthropic/claude-sonnet-5-5",
+        ]);
+        // The silent primary was cut at its first-output deadline, not its timeout.
+        expect(outcome.elapsedMs).toBeLessThan(1_000);
+    });
+
+    test("the unvalidated chain also moves on from a silent primary", async () => {
+        const { transport, calls } = modelTransport({ "opencode/free-model": "silent" });
+        await promptSyncWithModelSuggestionRetry(
+            createClient(mock(async () => ({}))),
+            createArgs(primary),
+            {
+                transport: transport as never,
+                timeoutMs: 2_000,
+                firstOutputTimeoutMs: 40,
+                fallbackModels: ["anthropic/claude-sonnet-5-5"],
+            },
+        );
+        expect(calls.map((call) => call.model)).toEqual([
+            "opencode/free-model",
+            "anthropic/claude-sonnet-5-5",
+        ]);
+    });
+
+    test("a primary that produced output before timing out does not fall back", async () => {
+        const outcome = await run(
+            { "opencode/free-model": "partial" },
+            { timeoutMs: 120, firstOutputTimeoutMs: 20 },
+        );
+        expect((outcome.caught as Error).message).toBe("prompt timed out after 120ms");
+        expect(outcome.calls).toHaveLength(1);
+        expect(getPromptFailureDetail(outcome.caught)?.failureClass).toBe("provider_timeout");
+    });
+
+    test("a silent primary's time comes out of the fallback's timeout", async () => {
+        // The fallback is the last model, so it gets no first-output cut of its own;
+        // its timeout is what the silent primary left of the overall 300 ms.
+        const outcome = await run(
+            { "opencode/free-model": "silent", "anthropic/claude-sonnet-5-5": "silent" },
+            { timeoutMs: 300, firstOutputTimeoutMs: 100 },
+        );
+        const message = (outcome.caught as Error).message;
+        const fallbackTimeoutMs = Number(/prompt timed out after (\d+)ms$/.exec(message)?.[1]);
+        expect(outcome.calls).toHaveLength(2);
+        expect(fallbackTimeoutMs).toBeLessThanOrEqual(200);
+        expect(fallbackTimeoutMs).toBeGreaterThan(100);
+        expect(outcome.elapsedMs).toBeLessThan(300 + 150);
+    });
+
+    test("the last model in the chain is never cut for silence", async () => {
+        const outcome = await run(
+            { "opencode/free-model": "silent" },
+            { timeoutMs: 120, firstOutputTimeoutMs: 20, fallbackModels: [] },
+        );
+        expect((outcome.caught as Error).message).toBe("prompt timed out after 120ms");
+        expect(outcome.calls).toHaveLength(1);
+    });
+
+    test("a transport that cannot see model output keeps the plain timeout", async () => {
+        const outcome = await run(
+            { "opencode/free-model": "unmonitored" },
+            { timeoutMs: 120, firstOutputTimeoutMs: 20 },
+        );
+        expect((outcome.caught as Error).message).toBe("prompt timed out after 120ms");
+        expect(outcome.calls).toHaveLength(1);
+    });
+
+    test("a caller without a first-output deadline keeps timeouts final", async () => {
+        // The historian passes no first-output deadline: a silent model still ends
+        // its chain at the timeout, exactly as before.
+        const outcome = await run({ "opencode/free-model": "silent" }, { timeoutMs: 120 });
+        expect((outcome.caught as Error).message).toBe("prompt timed out after 120ms");
+        expect(outcome.calls).toHaveLength(1);
+    });
+
+    test("a caller without a first-output deadline still falls back on a provider failure", async () => {
+        const prompt = mock(async (args: PromptCall) => {
+            if (args.body.model?.providerID === "opencode")
+                throw new Error("429 Too Many Requests: quota exceeded");
+            return {};
+        });
+        const result = await promptSyncWithValidatedOutputRetry(
+            createClient(prompt),
+            createArgs(primary),
+            {
+                fallbackModels: ["anthropic/claude-sonnet-5-5"],
+                fetchOutput: async () => "summary",
+                validateOutput: (output: string) => output,
+            },
+        );
+        expect(result.attempt.label).toBe("anthropic/claude-sonnet-5-5");
+        expect(prompt).toHaveBeenCalledTimes(2);
+    });
+});

package/src/shared/model-suggestion-retry.ts

@@ -89,11 +89,26 @@ export interface PromptRetryOptions {
      *     still self-heal at the primary AND at each fallback).
      *   - Iteration stops immediately on abort/timeout/context-overflow errors —
      *     fallbacks won't help and the caller's emergency-recovery path needs
-     *     to handle these.
+     *     to handle these. The exception is an attempt cut by
+     *     `firstOutputTimeoutMs` (see there), which moves on to the next model.
      *   - On all-failed, the LAST error is thrown (matches legacy behavior when
      *     `fallbackModels` is empty).
      */
     fallbackModels?: readonly ModelInput[];
+    /**
+     * How long an attempt may go without the model producing anything (no
+     * streamed text, reasoning, tool call, or token usage) before the model is
+     * treated as hung. The attempt is then stopped and the next configured model
+     * runs with whatever is left of `timeoutMs`, so a dead model costs this
+     * bound instead of the whole timeout. An attempt that has produced output
+     * keeps its full timeout and, if that expires, still ends the chain.
+     *
+     * Applies only to an attempt that has a later model to move to, is capped at
+     * half that attempt's timeout so the next model keeps a usable share, and
+     * only works with transports that watch the child for output (OpenCode's
+     * `prompt_async` wait). Undefined = no first-output deadline.
+     */
+    firstOutputTimeoutMs?: number;
     /**
      * Identifier for structured logging (e.g. "dreamer:consolidate",
      * "historian", "compressor", "dreamer"). Helps correlate fallback
@@ -168,9 +183,53 @@ export function isHostTimeoutError(error: unknown): boolean {
     );
 }
 
+/**
+ * The model chain cut this attempt short because the model had produced nothing
+ * (no streamed text, reasoning, tool call, or token usage) by the first-output
+ * deadline. A model that has not answered at all is treated like a provider
+ * failure, so the next configured model gets the rest of the time.
+ */
+export class ModelProducedNoOutputError extends Error {
+    constructor(readonly waitedMs: number) {
+        // Keeps "timed out after Nms" so ledgers record the attempt as timed out.
+        super(`prompt timed out after ${waitedMs}ms with no model output`);
+        this.name = "ModelProducedNoOutputError";
+    }
+}
+
+/**
+ * What a transport has seen of the model during one attempt. `monitored` means
+ * the transport watches the child's messages and will set `received` as soon as
+ * the model streams anything. Transports that cannot see progress never set
+ * `monitored`, and the first-output deadline then never fires for them.
+ */
+interface ModelActivity {
+    monitored: boolean;
+    received: boolean;
+}
+
+/** Keyed by the per-attempt abort signal that `promptWithTimeout` hands the transport. */
+const modelActivityBySignal = new WeakMap<AbortSignal, ModelActivity>();
+
+/** A transport calls this once it is watching the child for model output. */
+export function noteModelActivityMonitored(signal: AbortSignal | undefined): void {
+    const activity = signal ? modelActivityBySignal.get(signal) : undefined;
+    if (activity) activity.monitored = true;
+}
+
+/** A transport calls this when it sees the model produce anything for this attempt. */
+export function noteModelOutputReceived(signal: AbortSignal | undefined): void {
+    const activity = signal ? modelActivityBySignal.get(signal) : undefined;
+    if (activity) {
+        activity.monitored = true;
+        activity.received = true;
+    }
+}
+
 /** Our own slice expiry (see `promptWithTimeout`) or a host request timer. */
 export function isPromptTimeoutError(error: unknown): boolean {
     if (isHostTimeoutError(error)) return true;
+    if (error instanceof ModelProducedNoOutputError) return true;
     return error instanceof Error && /^prompt timed out after \d+ms$/.test(error.message);
 }
 
@@ -275,6 +334,7 @@ async function promptWithTimeout(
     timeoutMs: number,
     signal?: AbortSignal,
     transport?: PromptTransport,
+    firstOutputTimeoutMs?: number,
 ): Promise<void> {
     // Bail immediately if the caller's signal is already aborted (e.g.
     // lease loss before this attempt was scheduled). Per spec
@@ -287,6 +347,23 @@ async function promptWithTimeout(
     }
     const controller = new AbortController();
     const timeout = setTimeout(() => controller.abort(), timeoutMs);
+    const activity: ModelActivity = { monitored: false, received: false };
+    modelActivityBySignal.set(controller.signal, activity);
+    // Set when the first-output deadline, not the attempt timeout, ended the attempt.
+    let silent = false;
+    const firstOutputTimer =
+        firstOutputTimeoutMs !== undefined && firstOutputTimeoutMs < timeoutMs
+            ? setTimeout(() => {
+                  // Only a transport that watches the child can say the model is silent.
+                  if (!activity.monitored || activity.received) return;
+                  silent = true;
+                  controller.abort();
+              }, firstOutputTimeoutMs)
+            : undefined;
+    const timeoutError = () =>
+        silent && firstOutputTimeoutMs !== undefined
+            ? new ModelProducedNoOutputError(firstOutputTimeoutMs)
+            : new Error(`prompt timed out after ${timeoutMs}ms`);
 
     // Link external signal to internal controller so external abort cancels the fetch
     const onExternalAbort = () => controller.abort();
@@ -319,7 +396,7 @@ async function promptWithTimeout(
             if (!transport || transport.childSessionId) {
                 await abortChildRun(client, transport?.childSessionId ?? args.path.id);
             }
-            throw new Error(`prompt timed out after ${timeoutMs}ms`);
+            throw timeoutError();
         }
         if (isHostTimeoutError(error)) {
             // The host client's own request timer fired. Only our side of the
@@ -333,6 +410,7 @@ async function promptWithTimeout(
         throw error;
     } finally {
         clearTimeout(timeout);
+        if (firstOutputTimer) clearTimeout(firstOutputTimer);
         signal?.removeEventListener("abort", onExternalAbort);
     }
     // Some transports resolve with an error result when their fetch is aborted.
@@ -341,11 +419,7 @@ async function promptWithTimeout(
         if (!transport || transport.childSessionId) {
             await abortChildRun(client, transport?.childSessionId ?? args.path.id);
         }
-        throw new Error(
-            signal?.aborted
-                ? externalAbortMessage(signal)
-                : `prompt timed out after ${timeoutMs}ms`,
-        );
+        throw signal?.aborted ? new Error(externalAbortMessage(signal)) : timeoutError();
     }
 }
 
@@ -382,7 +456,12 @@ async function abortChildRun(client: Client, sessionId: string): Promise<void> {
  *     model. Caller has its own emergency-recovery path for this.
  *   - Timeout — same wall-clock budget on the same prompt is unlikely to
  *     succeed on another model. Caller decides whether to retry at a higher
- *     level (e.g. historian's MAX_HISTORIAN_RETRIES loop).
+ *     level (e.g. historian's MAX_HISTORIAN_RETRIES loop). This covers an
+ *     attempt that ran out its whole time, whether or not the model answered.
+ *
+ * A `ModelProducedNoOutputError` is the exception: no output was observed
+ * before the first-output deadline, which points at the model rather than the
+ * prompt, so the chain gives the next model the time that is left.
  *
  * Everything else (auth errors, ProviderModelNotFoundError without suggestion,
  * rate limits, transient network failures, etc.) is considered retryable on a
@@ -397,6 +476,8 @@ function isNonRetryable(error: unknown, externalSignal?: AbortSignal): boolean {
     )
         return true;
 
+    if (error instanceof ModelProducedNoOutputError) return false;
+
     if (error instanceof Error) {
         if (error.name === "AbortError") return true;
         // promptWithTimeout wraps both abort cases in plain `Error` with a
@@ -442,7 +523,11 @@ function classifyPromptFailure(
     if (externalSignal?.aborted || message === "prompt aborted by external signal") {
         return "child_aborted";
     }
-    if (/^prompt timed out after \d+ms$/.test(message) || isHostTimeoutError(error)) {
+    if (
+        error instanceof ModelProducedNoOutputError ||
+        /^prompt timed out after \d+ms$/.test(message) ||
+        isHostTimeoutError(error)
+    ) {
         return "provider_timeout";
     }
     if (phase === "validation") {
@@ -513,6 +598,7 @@ async function attemptOnce(
     label: string,
     transport?: PromptTransport,
     allowModelSuggestions = true,
+    firstOutputTimeoutMs?: number,
 ): Promise<void> {
     // Keep this snapshot separate from the object passed to the client. A
     // failed prompt facade may rewrite its request body before rejecting; the
@@ -520,7 +606,14 @@ async function attemptOnce(
     const originalBody = { ...args.body };
     const attemptArgs = copyPromptArgs(args, originalBody);
     try {
-        await promptWithTimeout(client, attemptArgs, timeoutMs, signal, transport);
+        await promptWithTimeout(
+            client,
+            attemptArgs,
+            timeoutMs,
+            signal,
+            transport,
+            firstOutputTimeoutMs,
+        );
         return;
     } catch (error) {
         // Non-retryable failures and callers with model suggestions disabled
@@ -551,10 +644,48 @@ async function attemptOnce(
             timeoutMs,
             signal,
             transport,
+            firstOutputTimeoutMs,
         );
     }
 }
 
+/**
+ * Per-attempt timing across one model chain. An attempt cut by the first-output
+ * deadline has the time it used taken out of every later attempt's timeout, so
+ * a silent model never stretches the caller's overall wait past `timeoutMs`.
+ * Attempts that fail for other reasons keep the existing full per-attempt budget.
+ */
+function createChainClock(options: PromptRetryOptions, timeoutMs: number) {
+    const fallbacks = options.fallbackModels ?? [];
+    const hasValidFallbackFrom = (index: number) =>
+        fallbacks.slice(index).some((fallback) => {
+            const entry = toModelEntry(fallback);
+            return entry ? parseProviderModel(entry.model) !== null : false;
+        });
+    let silentSpentMs = 0;
+    return {
+        /** Budget for an attempt whose next candidate is `fallbacks[nextFallbackIndex]`. */
+        budget(nextFallbackIndex: number): { timeoutMs: number; firstOutputTimeoutMs?: number } {
+            const attemptTimeoutMs = Math.max(1, timeoutMs - silentSpentMs);
+            // The last model in the chain has nothing to move to, so it keeps the
+            // plain timeout rather than being cut short for no benefit.
+            if (
+                options.firstOutputTimeoutMs === undefined ||
+                !hasValidFallbackFrom(nextFallbackIndex)
+            )
+                return { timeoutMs: attemptTimeoutMs };
+            const bound = Math.min(options.firstOutputTimeoutMs, Math.floor(attemptTimeoutMs / 2));
+            return bound > 0
+                ? { timeoutMs: attemptTimeoutMs, firstOutputTimeoutMs: bound }
+                : { timeoutMs: attemptTimeoutMs };
+        },
+        settle(error: unknown, startedAt: number): void {
+            if (error instanceof ModelProducedNoOutputError)
+                silentSpentMs += Date.now() - startedAt;
+        },
+    };
+}
+
 /**
  * Run an OpenCode subagent prompt with model fallback support.
  *
@@ -591,21 +722,26 @@ export async function promptSyncWithModelSuggestionRetry(
             : "primary";
 
     let lastError: unknown = null;
+    const clock = createChainClock(options, timeoutMs);
 
+    const primaryStartedAt = Date.now();
     try {
+        const budget = clock.budget(0);
         await attemptOnce(
             client,
             baseArgs,
-            timeoutMs,
+            budget.timeoutMs,
             options.signal,
             callContext,
             explicitPrimaryLabel,
             options.transport,
             options.allowModelSuggestions,
+            budget.firstOutputTimeoutMs,
         );
         return;
     } catch (error) {
         lastError = error;
+        clock.settle(error, primaryStartedAt);
         if (isNonRetryable(error, options.signal)) throw error;
 
         if (fallbacks.length === 0) {
@@ -637,16 +773,19 @@ export async function promptSyncWithModelSuggestionRetry(
             ...(fallback?.qualifier ? { variant: fallback.qualifier } : {}),
         });
 
+        const attemptStartedAt = Date.now();
         try {
+            const budget = clock.budget(i + 1);
             await attemptOnce(
                 client,
                 attemptArgs,
-                timeoutMs,
+                budget.timeoutMs,
                 options.signal,
                 callContext,
                 label,
                 options.transport,
                 options.allowModelSuggestions,
+                budget.firstOutputTimeoutMs,
             );
             log(
                 `[${callContext}] fallback succeeded with ${label} (attempt ${i + 2}/${fallbacks.length + 1})`,
@@ -654,6 +793,7 @@ export async function promptSyncWithModelSuggestionRetry(
             return;
         } catch (error) {
             lastError = error;
+            clock.settle(error, attemptStartedAt);
             if (isNonRetryable(error, options.signal)) throw error;
 
             const remaining = fallbacks.length - i - 1;
@@ -682,6 +822,7 @@ async function attemptAndValidate<TOutput, TValidated>(
     callContext: string,
     attempt: PromptAttemptInfo,
     options: ValidatedPromptRetryOptions<TOutput, TValidated>,
+    firstOutputTimeoutMs?: number,
 ): Promise<ValidatedPromptRetryResult<TOutput, TValidated>> {
     try {
         await attemptOnce(
@@ -693,6 +834,7 @@ async function attemptAndValidate<TOutput, TValidated>(
             attempt.label,
             options.transport,
             options.allowModelSuggestions,
+            firstOutputTimeoutMs,
         );
     } catch (error) {
         throw {
@@ -779,7 +921,9 @@ export async function promptSyncWithValidatedOutputRetry<TOutput, TValidated = T
     let firstError: unknown = null;
     let lastError: unknown = null;
     const cooledPrimary = primaryQuotaFailure(explicitPrimaryLabel);
+    const clock = createChainClock(options, timeoutMs);
 
+    const primaryStartedAt = Date.now();
     try {
         if (cooledPrimary)
             throw {
@@ -794,10 +938,11 @@ export async function promptSyncWithValidatedOutputRetry<TOutput, TValidated = T
                     skipped: true,
                 },
             } satisfies FailedAttempt;
+        const budget = clock.budget(0);
         return await attemptAndValidate(
             client,
             baseArgs,
-            timeoutMs,
+            budget.timeoutMs,
             options.signal,
             callContext,
             {
@@ -808,10 +953,12 @@ export async function promptSyncWithValidatedOutputRetry<TOutput, TValidated = T
                 model: baseBody.model,
             },
             options,
+            budget.firstOutputTimeoutMs,
         );
     } catch (caught) {
         const failure = caught as FailedAttempt;
         failedAttempts.push(failure);
+        clock.settle(failure.error, primaryStartedAt);
         firstError = failure.error;
         lastError = failure.error;
         if (
@@ -876,15 +1023,18 @@ export async function promptSyncWithValidatedOutputRetry<TOutput, TValidated = T
             model: parsed,
         };
 
+        const attemptStartedAt = Date.now();
         try {
+            const budget = clock.budget(i + 1);
             const result = await attemptAndValidate(
                 client,
                 attemptArgs,
-                timeoutMs,
+                budget.timeoutMs,
                 options.signal,
                 callContext,
                 attempt,
                 options,
+                budget.firstOutputTimeoutMs,
             );
             log(
                 `[${callContext}] fallback succeeded with ${label} (attempt ${i + 2}/${fallbacks.length + 1})`,
@@ -893,6 +1043,7 @@ export async function promptSyncWithValidatedOutputRetry<TOutput, TValidated = T
         } catch (caught) {
             const failure = caught as FailedAttempt;
             failedAttempts.push(failure);
+            clock.settle(failure.error, attemptStartedAt);
             lastError = failure.error;
             if (isNonRetryable(failure.error, options.signal)) {
                 throwWithPromptFailure(