fix: stop quota scheduler cooldown drift

The preemptive quota scheduler calculated deferrals from the nearest
reset window. When a later primary or secondary reset was still active,
that shortened the effective cooldown and let requests resume too early.

Use the longest relevant reset window for 429 deferrals and for
near-exhaustion quota deferrals so cooldowns stay aligned with the
latest active quota window.

Author: ndycode

lib/preemptive-quota-scheduler.ts

@@ -238,14 +238,27 @@ export class PreemptiveQuotaScheduler {
 		const snapshot = this.snapshots.get(key);
 		if (!snapshot) return { defer: false, waitMs: 0 };
 
+		const primaryWait =
+			typeof snapshot.primary.resetAtMs === "number" &&
+			Number.isFinite(snapshot.primary.resetAtMs) &&
+			snapshot.primary.resetAtMs > now
+				? snapshot.primary.resetAtMs - now
+				: 0;
+		const secondaryWait =
+			typeof snapshot.secondary.resetAtMs === "number" &&
+			Number.isFinite(snapshot.secondary.resetAtMs) &&
+			snapshot.secondary.resetAtMs > now
+				? snapshot.secondary.resetAtMs - now
+				: 0;
+
 		const waitCandidates = [snapshot.primary.resetAtMs, snapshot.secondary.resetAtMs]
 			.filter((value): value is number => typeof value === "number" && Number.isFinite(value) && value > now)
 			.map((value) => value - now)
 			.filter((value) => value > 0);
-		const nearestWait = waitCandidates.length > 0 ? Math.min(...waitCandidates) : 0;
+		const longestWait = waitCandidates.length > 0 ? Math.max(...waitCandidates) : 0;
 
-		if (snapshot.status === 429 && nearestWait > 0) {
-			const bounded = Math.min(nearestWait, this.maxDeferralMs);
+		if (snapshot.status === 429 && longestWait > 0) {
+			const bounded = Math.min(longestWait, this.maxDeferralMs);
 			if (bounded > 0) {
 				return { defer: true, waitMs: bounded, reason: "rate-limit" };
 			}
@@ -259,9 +272,12 @@ export class PreemptiveQuotaScheduler {
 			typeof snapshot.secondary.usedPercent === "number" &&
 			Number.isFinite(snapshot.secondary.usedPercent) &&
 			snapshot.secondary.usedPercent >= 100 - this.secondaryRemainingPercentThreshold;
-		const nearExhausted = primaryNearExhausted || secondaryNearExhausted;
-		if (nearExhausted && nearestWait > 0) {
-			const bounded = Math.min(nearestWait, this.maxDeferralMs);
+		const nearExhaustedWait = Math.max(
+			primaryNearExhausted ? primaryWait : 0,
+			secondaryNearExhausted ? secondaryWait : 0,
+		);
+		if (nearExhaustedWait > 0) {
+			const bounded = Math.min(nearExhaustedWait, this.maxDeferralMs);
 			if (bounded > 0) {
 				return { defer: true, waitMs: bounded, reason: "quota-near-exhaustion" };
 			}

test/preemptive-quota-scheduler.test.ts

@@ -87,6 +87,21 @@ describe("preemptive quota scheduler", () => {
 		expect(decision.waitMs).toBe(25_000);
 	});
 
+	it("uses the longest active reset window for 429 deferrals", () => {
+		const scheduler = new PreemptiveQuotaScheduler();
+		scheduler.update("acc:model", {
+			status: 429,
+			primary: { resetAtMs: 31_000 },
+			secondary: { resetAtMs: 61_000 },
+			updatedAt: 1_000,
+		});
+
+		const decision = scheduler.getDeferral("acc:model", 6_000);
+		expect(decision.defer).toBe(true);
+		expect(decision.reason).toBe("rate-limit");
+		expect(decision.waitMs).toBe(55_000);
+	});
+
 	it("preserves secondary near-exhaustion state when marking a quota key rate-limited", () => {
 		const scheduler = new PreemptiveQuotaScheduler({
 			remainingPercentThresholdSecondary: 5,
@@ -141,6 +156,24 @@ describe("preemptive quota scheduler", () => {
 		expect(decision.reason).toBe("quota-near-exhaustion");
 	});
 
+	it("uses the longest near-exhausted reset window for quota deferrals", () => {
+		const scheduler = new PreemptiveQuotaScheduler({
+			remainingPercentThresholdPrimary: 5,
+			remainingPercentThresholdSecondary: 5,
+		});
+		scheduler.update("acc:model", {
+			status: 200,
+			primary: { usedPercent: 96, resetAtMs: 70_000 },
+			secondary: { usedPercent: 97, resetAtMs: 120_000 },
+			updatedAt: 10_000,
+		});
+
+		const decision = scheduler.getDeferral("acc:model", 20_000);
+		expect(decision.defer).toBe(true);
+		expect(decision.reason).toBe("quota-near-exhaustion");
+		expect(decision.waitMs).toBe(100_000);
+	});
+
 	it("prunes expired snapshots", () => {
 		const scheduler = new PreemptiveQuotaScheduler();
 		scheduler.update("a", {