fix: fold review follow-ups into rebuilt main wave

Author: ndycode

lib/codex-manager/commands/report.ts

@@ -12,8 +12,10 @@ import {
 	summarizeForecast,
 } from "../../forecast.js";
 import {
+	type AccountIdentityMatch,
 	applyRefreshedAccountPatch,
 	persistRefreshedAccountPatch,
+	type RefreshedAccountPatch,
 	serializeForecastResults,
 } from "../forecast-report-shared.js";
 import {

lib/codex-manager/forecast-report-shared.ts

@@ -96,6 +96,8 @@ export function serializeForecastResults(
 	index: number;
 	label: string;
 	isCurrent: boolean;
+	selected: boolean;
+	primaryReason?: string;
 	availability: ForecastAccountResult["availability"];
 	riskScore: number;
 	riskLevel: ForecastAccountResult["riskLevel"];
@@ -116,6 +118,8 @@ export function serializeForecastResults(
 			index: result.index,
 			label: result.label,
 			isCurrent: result.isCurrent,
+			selected: false,
+			primaryReason: result.reasons[0],
 			availability: result.availability,
 			riskScore: result.riskScore,
 			riskLevel: result.riskLevel,

lib/config.ts

@@ -1084,7 +1084,7 @@ export function getRateLimitDedupWindowMs(pluginConfig: PluginConfig): number {
 	return resolveNumberSetting(
 		"CODEX_AUTH_RATE_LIMIT_DEDUP_WINDOW_MS",
 		pluginConfig.rateLimitDedupWindowMs,
-		DEFAULT_PLUGIN_CONFIG.rateLimitDedupWindowMs,
+		DEFAULT_PLUGIN_CONFIG.rateLimitDedupWindowMs ?? 2_000,
 		{ min: 0 },
 	);
 }
@@ -1093,7 +1093,7 @@ export function getRateLimitStateResetMs(pluginConfig: PluginConfig): number {
 	return resolveNumberSetting(
 		"CODEX_AUTH_RATE_LIMIT_STATE_RESET_MS",
 		pluginConfig.rateLimitStateResetMs,
-		DEFAULT_PLUGIN_CONFIG.rateLimitStateResetMs,
+		DEFAULT_PLUGIN_CONFIG.rateLimitStateResetMs ?? 120_000,
 		{ min: 1_000 },
 	);
 }
@@ -1102,7 +1102,7 @@ export function getRateLimitMaxBackoffMs(pluginConfig: PluginConfig): number {
 	return resolveNumberSetting(
 		"CODEX_AUTH_RATE_LIMIT_MAX_BACKOFF_MS",
 		pluginConfig.rateLimitMaxBackoffMs,
-		DEFAULT_PLUGIN_CONFIG.rateLimitMaxBackoffMs,
+		DEFAULT_PLUGIN_CONFIG.rateLimitMaxBackoffMs ?? 60_000,
 		{ min: 1_000 },
 	);
 }
@@ -1113,7 +1113,7 @@ export function getRateLimitShortRetryThresholdMs(
 	return resolveNumberSetting(
 		"CODEX_AUTH_RATE_LIMIT_SHORT_RETRY_THRESHOLD_MS",
 		pluginConfig.rateLimitShortRetryThresholdMs,
-		DEFAULT_PLUGIN_CONFIG.rateLimitShortRetryThresholdMs,
+		DEFAULT_PLUGIN_CONFIG.rateLimitShortRetryThresholdMs ?? 5_000,
 		{ min: 0 },
 	);
 }
@@ -1842,11 +1842,20 @@ export function getPluginConfigExplainReport(): ConfigExplainReport {
 	const stored = resolveStoredPluginConfigRecord();
 	const storedRecord = stored.record ?? null;
 	const entries = CONFIG_EXPLAIN_ENTRIES.map((entry) => {
-		const value = entry.getValue(pluginConfig);
+		const rawValue = entry.getValue(pluginConfig);
+		const rawDefaultValue = DEFAULT_PLUGIN_CONFIG[entry.key];
+		const value =
+			entry.key === "retryAllAccountsMaxRetries" && rawValue === 0
+				? Number.POSITIVE_INFINITY
+				: rawValue;
+		const defaultValue =
+			entry.key === "retryAllAccountsMaxRetries" && rawDefaultValue === 0
+				? Number.POSITIVE_INFINITY
+				: rawDefaultValue;
 		return {
 			key: entry.key,
 			value: normalizeConfigExplainValue(value),
-			defaultValue: normalizeConfigExplainValue(DEFAULT_PLUGIN_CONFIG[entry.key]),
+			defaultValue: normalizeConfigExplainValue(defaultValue),
 			source: resolveConfigExplainSource(
 				entry,
 				pluginConfig,

lib/index.ts

@@ -8,7 +8,17 @@ export * from "./auth/auth.js";
 export * from "./request/fetch-helpers.js";
 export * from "./request/request-transformer.js";
 export * from "./request/response-handler.js";
-export * from "./request/rate-limit-backoff.js";
+export {
+	MAX_SHORT_RETRY_ATTEMPTS,
+	calculateBackoffMs,
+	clearRateLimitBackoffState,
+	configureRateLimitBackoff,
+	getRateLimitBackoff,
+	getRateLimitBackoffWithReason,
+	getRateLimitShortRetryThresholdMs as getConfiguredRateLimitShortRetryThresholdMs,
+	resetRateLimitBackoff,
+	resetRateLimitBackoffConfig,
+} from "./request/rate-limit-backoff.js";
 export * from "./prompts/codex.js";
 export * from "./shutdown.js";
 export * from "./circuit-breaker.js";

lib/request/fetch-helpers.ts

@@ -982,23 +982,31 @@ function mapUsageLimit404WithBody(response: Response, bodyText: string): Respons
 	if (!bodyText) return null;
 
 	let code = "";
+	let type = "";
 	try {
-		const parsed = JSON.parse(bodyText) as { error?: { code?: string | number; type?: string } };
-		code = (parsed?.error?.code ?? parsed?.error?.type ?? "").toString();
+		const parsed = JSON.parse(bodyText) as {
+			error?: { code?: string | number; type?: string | number };
+		};
+		code = (parsed?.error?.code ?? "").toString();
+		type = (parsed?.error?.type ?? "").toString();
 	} catch {
 		code = "";
+		type = "";
 	}
 
+	const normalizedSignals = [code, type]
+		.map((value) => value.toLowerCase())
+		.filter((value) => value.length > 0);
+
 	// Check for entitlement errors first - these should NOT be treated as rate limits
-	if (isEntitlementError(code, bodyText)) {
+	if (isEntitlementError(normalizedSignals.join(" "), bodyText)) {
 		return createEntitlementErrorResponse(bodyText);
 	}
 
 	// Only structured quota-limit codes should be remapped from 404 to 429.
 	// Free-text 404 bodies and generic rate_limit_* codes are too ambiguous and
 	// degrade downstream rate-limit reason classification to "unknown".
-	const normalizedCode = code.toLowerCase();
-	if (!normalizedCode.includes("usage_limit")) {
+	if (!normalizedSignals.some((value) => value.includes("usage_limit"))) {
 		return null;
 	}
 

lib/request/rate-limit-backoff.ts

@@ -16,12 +16,13 @@ export interface RateLimitBackoffResult {
  * - Reset backoff after a quiet period.
  */
 const DEFAULT_RATE_LIMIT_DEDUP_WINDOW_MS =
-	DEFAULT_PLUGIN_CONFIG.rateLimitDedupWindowMs;
+	DEFAULT_PLUGIN_CONFIG.rateLimitDedupWindowMs ?? 2_000;
 const DEFAULT_RATE_LIMIT_STATE_RESET_MS =
-	DEFAULT_PLUGIN_CONFIG.rateLimitStateResetMs;
-const DEFAULT_MAX_BACKOFF_MS = DEFAULT_PLUGIN_CONFIG.rateLimitMaxBackoffMs;
+	DEFAULT_PLUGIN_CONFIG.rateLimitStateResetMs ?? 120_000;
+const DEFAULT_MAX_BACKOFF_MS =
+	DEFAULT_PLUGIN_CONFIG.rateLimitMaxBackoffMs ?? 60_000;
 const DEFAULT_RATE_LIMIT_SHORT_RETRY_THRESHOLD_MS =
-	DEFAULT_PLUGIN_CONFIG.rateLimitShortRetryThresholdMs;
+	DEFAULT_PLUGIN_CONFIG.rateLimitShortRetryThresholdMs ?? 5_000;
 const RATE_LIMIT_BACKOFF_JITTER_FACTOR = 0.2;
 
 interface RateLimitBackoffConfig {
@@ -281,8 +282,11 @@ export function getRateLimitBackoffWithReason(
 		resolvedServerRetryAfterMs,
 		resolvedStableAccountKey,
 	);
+	const normalizedBaseDelay = normalizeDelayMs(resolvedServerRetryAfterMs, 1000);
 	const adjustedDelay = calculateBackoffMs(
-		result.delayMs,
+		result.attempt === 1 && !result.isDuplicate
+			? normalizedBaseDelay
+			: result.delayMs,
 		result.attempt,
 		resolvedReason,
 	);

test/auto-update-checker.test.ts

@@ -256,6 +256,7 @@ describe("auto-update-checker", () => {
 			const result = await checkForUpdates(true);
 
 			expect(result.currentVersion).toBe("0.0.0");
+			expect(globalThis.fetch).toHaveBeenCalled();
 			expect(logger.debug).toHaveBeenCalledWith(
 				"Failed to read current package version",
 				expect.objectContaining({ error: expect.any(String) }),
@@ -311,6 +312,37 @@ describe("auto-update-checker", () => {
 			expect(globalThis.fetch).toHaveBeenCalled();
 		});
 
+		it.each(["EBUSY", "EPERM"] as const)(
+			"logs debug details when cache read fails on windows-style lock (%s)",
+			async (code) => {
+				vi.mocked(fs.existsSync).mockReturnValue(true);
+				vi.mocked(fs.readFileSync).mockImplementation((path: unknown) => {
+					if (String(path).includes("package.json")) {
+						return JSON.stringify(mockPackageJson);
+					}
+					if (String(path).includes("update-check-cache.json")) {
+						const error = new Error(`${code}: locked`) as NodeJS.ErrnoException;
+						error.code = code;
+						error.name = code;
+						throw error;
+					}
+					throw new Error("File not found");
+				});
+				vi.mocked(globalThis.fetch).mockResolvedValue({
+					ok: true,
+					json: async () => ({ version: "5.0.0" }),
+				} as Response);
+
+				await checkForUpdates();
+
+				expect(logger.debug).toHaveBeenCalledWith(
+					"Failed to load update cache",
+					expect.objectContaining({ error: expect.stringContaining(code) }),
+				);
+				expect(globalThis.fetch).toHaveBeenCalled();
+			},
+		);
+
 		it("handles cached null latestVersion without update", async () => {
 			const cacheData = {
 				lastCheck: Date.now() - 1000 * 60 * 60,

test/fetch-helpers.test.ts

@@ -494,6 +494,37 @@ describe('Fetch Helpers Module', () => {
 			expect(rateLimit?.retryAfterMs).toBeGreaterThan(0);
 		});
 
+		it('maps usage-limit 404 errors to 429 when code and type disagree', async () => {
+			const body = {
+				error: {
+					code: 'rate_limit_exceeded',
+					type: 'usage_limit_reached',
+					message: 'limit reached',
+				},
+			};
+			const resp = new Response(JSON.stringify(body), { status: 404 });
+			const { response: mapped, rateLimit } = await handleErrorResponse(resp);
+			expect(mapped.status).toBe(429);
+			expect(rateLimit?.retryAfterMs).toBeGreaterThan(0);
+		});
+
+		it('maps entitlement-style 404 errors to 403 when only error.type carries the signal', async () => {
+			const body = {
+				error: {
+					code: 'not_found',
+					type: 'usage_not_included',
+					message: 'Not included in your plan',
+				},
+			};
+			const resp = new Response(JSON.stringify(body), { status: 404 });
+			const { response: mapped, rateLimit } = await handleErrorResponse(resp);
+			expect(mapped.status).toBe(403);
+			const json = await mapped.json() as { error: { code?: string; message?: string } };
+			expect(json.error.code).toBe('usage_not_included');
+			expect(json.error.message).toContain('not included');
+			expect(rateLimit).toBeUndefined();
+		});
+
 		it('leaves non-usage 404 errors unchanged', async () => {
 			const body = { error: { code: 'not_found', message: 'nope' } };
 			const resp = new Response(JSON.stringify(body), { status: 404 });