fix(server): cool a Codex rate-limit burst for a minute, not fifteen

Co-Authored-By: GPT-5.6 Sol via Traex <noreply@openai.com>

Author: ScriptedAlchemy

apps/server/src/orchestration-v2/ProviderPoolFailover.test.ts

@@ -0,0 +1,46 @@
+import { assert, describe, it } from "@effect/vitest";
+import type { OrchestrationV2ProviderFailure } from "@t3tools/contracts";
+
+import { limitCooldownUntilMs } from "./ProviderPoolFailover.ts";
+
+const nowMs = Date.parse("2026-10-20T12:00:00.000Z");
+const futureResetAt = "2026-10-20T12:10:00.000Z";
+const pastResetAt = "2026-10-20T11:50:00.000Z";
+
+const failure = (code: "rateLimitExceeded" | "usageLimitExceeded" | null, resetAt?: string) =>
+  ({
+    class: "usage_limit",
+    message: "Provider limit reached",
+    code,
+    retryable: null,
+    ...(resetAt === undefined ? {} : { resetAt }),
+  }) satisfies OrchestrationV2ProviderFailure;
+
+describe("limitCooldownUntilMs", () => {
+  it.each(["rateLimitExceeded", "usageLimitExceeded"] as const)(
+    "uses a future reset for %s",
+    (code) => {
+      assert.strictEqual(
+        limitCooldownUntilMs(failure(code, futureResetAt), nowMs),
+        Date.parse(futureResetAt),
+      );
+    },
+  );
+
+  it.each([pastResetAt, undefined])(
+    "uses a one-minute cooldown for a rate-limit burst with reset %s",
+    (resetAt) => {
+      assert.strictEqual(
+        limitCooldownUntilMs(failure("rateLimitExceeded", resetAt), nowMs),
+        nowMs + 60_000,
+      );
+    },
+  );
+
+  it.each(["usageLimitExceeded", null] as const)(
+    "uses the default cooldown for code %s without a future reset",
+    (code) => {
+      assert.strictEqual(limitCooldownUntilMs(failure(code), nowMs), nowMs + 15 * 60_000);
+    },
+  );
+});

apps/server/src/orchestration-v2/ProviderPoolFailover.ts

@@ -34,6 +34,20 @@ export type UsageLimitResolution =
   | { readonly type: "finalize"; readonly resetAt: IsoDateTime | null };
 
 export const DEFAULT_LIMIT_COOLDOWN_MS = 15 * 60_000;
+// Per-minute burst limits recover quickly and should not park a healthy account.
+export const BURST_LIMIT_COOLDOWN_MS = 60_000;
+
+export function limitCooldownUntilMs(
+  failure: OrchestrationV2ProviderFailure,
+  nowMs: number,
+): number {
+  const resetMs = failure.resetAt == null ? Number.NaN : Date.parse(failure.resetAt);
+  if (resetMs > nowMs) return resetMs;
+  return (
+    nowMs +
+    (failure.code === "rateLimitExceeded" ? BURST_LIMIT_COOLDOWN_MS : DEFAULT_LIMIT_COOLDOWN_MS)
+  );
+}
 
 /**
  * Runs between a usage-limit terminal and the run going terminal. A reference
@@ -59,14 +73,11 @@ const make = Effect.gen(function* () {
     input: UsageLimitedAttempt,
   ) {
     const nowMs = DateTime.toEpochMillis(yield* DateTime.now);
-    const resetMs = input.failure.resetAt == null ? Number.NaN : Date.parse(input.failure.resetAt);
     // Every driver cools through this one site, pooled or not, so the
     // Providers page shows "Limited until" for any account.
     yield* catalog.markLimited({
       instanceId: input.providerInstanceId,
-      until: DateTime.formatIso(
-        DateTime.makeUnsafe(resetMs > nowMs ? resetMs : nowMs + DEFAULT_LIMIT_COOLDOWN_MS),
-      ),
+      until: DateTime.formatIso(DateTime.makeUnsafe(limitCooldownUntilMs(input.failure, nowMs))),
     });
     const asToday = { type: "finalize", resetAt: input.failure.resetAt ?? null } as const;
     const owner = findProviderPool(yield* catalog.getPublishedProviders, input.providerInstanceId);