@openclaw/codex 2026.9.5 → 2026.9.7

package/dist/.setup/protocol-CANUwXJ3.mjs

@@ -0,0 +1,17 @@
+import { isRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
+//#region extensions/codex/src/app-server/protocol.ts
+/** Namespace Codex keeps directly model-visible without exposing it to Code Mode guests. */
+const CODEX_OPENCLAW_DIRECT_DYNAMIC_TOOL_NAMESPACE = "openclaw_direct";
+function flattenCodexDynamicToolFunctions(tools) {
+	return (tools ?? []).flatMap((tool) => tool.type === "namespace" ? tool.tools : [tool]);
+}
+/** Asserts the experimental beforeTurnId request field before it crosses the app-server boundary. */
+function assertCodexThreadForkParams(value) {
+	if (!isRecord(value) || typeof value.threadId !== "string" || !value.threadId.trim() || value.beforeTurnId !== void 0 && value.beforeTurnId !== null && typeof value.beforeTurnId !== "string") throw new Error("Invalid Codex app-server thread/fork params");
+	return value;
+}
+function isJsonObject(value) {
+	return isRecord(value);
+}
+//#endregion
+export { isJsonObject as i, assertCodexThreadForkParams as n, flattenCodexDynamicToolFunctions as r, CODEX_OPENCLAW_DIRECT_DYNAMIC_TOOL_NAMESPACE as t };

package/dist/.setup/provider-DH8NSzGt.mjs

@@ -0,0 +1,51 @@
+import { t as isOnlyMigrationKind } from "./scope-DOC1Xjc8.mjs";
+//#region extensions/codex/src/migration/provider.ts
+function buildCodexMigrationProvider(params = {}) {
+	return {
+		id: "codex",
+		label: "Codex",
+		description: [
+			"Import consolidated memories, selected Codex and personal AgentSkills, and selected eligible openai-curated plugins.",
+			"Auth credentials require separate consent. Sessions and chat history are not imported.",
+			"Codex config and hooks are saved for manual review, not activated. Source files are not moved or deleted."
+		].join(" "),
+		supportedItemKinds: ["memory", "auth"],
+		async detect(ctx) {
+			const { discoverCodexSource, hasCodexSource } = await import("./source-CS_7GFJZ.mjs").then((n) => n.a);
+			const memoryOnly = isOnlyMigrationKind(ctx, "memory");
+			const authOnly = isOnlyMigrationKind(ctx, "auth");
+			const source = await discoverCodexSource({
+				input: ctx.source,
+				memoryOnly,
+				authOnly
+			});
+			const found = memoryOnly ? source.memoryFiles.length > 0 : authOnly ? Boolean(source.authPath) : hasCodexSource(source);
+			return {
+				found,
+				source: source.root,
+				label: "Codex",
+				confidence: found ? source.confidence : "low",
+				message: found ? "Codex state found." : "Codex state not found."
+			};
+		},
+		async plan(ctx) {
+			const { buildCodexMigrationPlan } = await import("./plan-Y-QIvrKB.mjs");
+			return buildCodexMigrationPlan(ctx);
+		},
+		deferredApply: { retrySafe: true },
+		prepareApply(ctx) {
+			if (isOnlyMigrationKind(ctx, "memory") || isOnlyMigrationKind(ctx, "auth")) return;
+			return import("./apply-D3GcSoSa.mjs").then(({ prepareTargetCodexAppServer }) => prepareTargetCodexAppServer(ctx));
+		},
+		async apply(ctx, plan) {
+			const { applyCodexMigrationPlan } = await import("./apply-D3GcSoSa.mjs");
+			return await applyCodexMigrationPlan({
+				ctx,
+				plan,
+				runtime: params.runtime
+			});
+		}
+	};
+}
+//#endregion
+export { buildCodexMigrationProvider as t };

package/dist/.setup/{provider-capabilities-B8J4Dy-O.mjs → provider-capabilities-CAxoF-X1.mjs}

@@ -1,5 +1,5 @@
-import { h as releaseLeasedSharedCodexAppServerClient } from "./shared-client-BpTtuLQ5.mjs";
-import { lt as normalizeCodexDynamicToolName } from "./thread-lifecycle-Cik28qWn.mjs";
+import { h as releaseLeasedSharedCodexAppServerClient } from "./shared-client-DqyTMYug.mjs";
+import { dt as normalizeCodexDynamicToolName } from "./thread-requests-B_bRnMGN.mjs";
 import { pinExecToolTarget } from "openclaw/plugin-sdk/codex-mcp-projection";
 import { loadNodeExecAvailability } from "openclaw/plugin-sdk/node-selection-runtime";
 //#region extensions/codex/src/app-server/shell-dynamic-tools.ts
@@ -7,7 +7,6 @@ const CODEX_NODE_EXEC_DYNAMIC_TOOL_NAME = "node_exec";
 const CODEX_GATEWAY_EXEC_DYNAMIC_TOOL_NAME = "gateway_exec";
 const CODEX_GATEWAY_PROCESS_DYNAMIC_TOOL_NAME = "gateway_process";
 const PROCESS_FOLLOWUP_TEXT = "Use process (list/poll/log/write/send-keys/submit/paste/kill/clear/remove) for follow-up.";
-/** Returns true when plugin config explicitly removes any named dynamic tool. */
 function isCodexDynamicToolExcluded(config, names) {
 	const normalizedNames = new Set(names.map((name) => normalizeCodexDynamicToolName(name)));
 	return (config.codexDynamicToolsExclude ?? []).some((name) => normalizedNames.has(normalizeCodexDynamicToolName(name)));
@@ -21,18 +20,11 @@ async function createNodeExecAliasDynamicTool(execTool, node, discoverySignal, a
 		host: "node",
 		...pinnedNode ? { node: pinnedNode } : {}
 	});
-	const execute = async (toolCallId, args, signal, onUpdate) => {
-		const result = await pinnedTool.execute(toolCallId, args, signal, onUpdate);
-		return {
-			...result,
-			content: result.content.map((item) => item.type === "text" ? Object.assign({}, item, { text: item.text.replace(PROCESS_FOLLOWUP_TEXT, "Remote-node background follow-up is unavailable. Wait for the command to complete.") }) : item)
-		};
-	};
 	return {
 		...pinnedTool,
 		name: CODEX_NODE_EXEC_DYNAMIC_TOOL_NAME,
 		description: pinnedNode ? "Run a shell command to completion on the OpenClaw configured remote node for this session. This tool always uses OpenClaw host=node internally and follows the existing node exec approval and allowlist policy. Remote-node background follow-up is unavailable. Use Codex's native shell for local app-server work when it is available." : "Run a shell command to completion on an OpenClaw remote node. The sole connected node that can execute commands is selected automatically; select by name or id when several can. This tool always uses OpenClaw host=node internally and follows the existing node exec approval and allowlist policy. Remote-node background follow-up is unavailable. Use Codex's native shell for local app-server work when it is available.",
-		execute
+		execute: withProcessFollowupText(pinnedTool, "Remote-node background follow-up is unavailable. Wait for the command to complete.")
 	};
 }
 function createGatewayExecProjection(createProjection, execTool, params) {
@@ -51,6 +43,30 @@ function createGatewayProcessProjection(createProjection, processTool) {
 		description: "Manage background shell sessions in the existing per-session OpenClaw process scope: list, poll, log, write, send-keys, submit, paste, kill, clear, or remove. Use for gateway_exec follow-up; use native Codex shell session handling for ordinary local work."
 	});
 }
+function createSandboxExecProjection(execTool) {
+	return {
+		...execTool,
+		name: "sandbox_exec",
+		description: "Run a shell command through OpenClaw's configured sandbox backend for this session. Use when OpenClaw sandboxing is active or when a command must execute in the sandbox backend, such as an SSH-backed sandbox or Docker container-path bind layout. Use Codex's native shell only when no OpenClaw sandbox is active and native Code Mode is available.",
+		execute: withProcessFollowupText(execTool, "Use sandbox_process (list/poll/log/write/send-keys/submit/paste/kill/clear/remove) for follow-up.")
+	};
+}
+function withProcessFollowupText(tool, followupText) {
+	return async (toolCallId, args, signal, onUpdate) => {
+		const result = await tool.execute(toolCallId, args, signal, onUpdate);
+		return {
+			...result,
+			content: result.content.map((item) => item.type === "text" ? Object.assign({}, item, { text: item.text.replace(PROCESS_FOLLOWUP_TEXT, followupText) }) : item)
+		};
+	};
+}
+function createSandboxProcessProjection(processTool) {
+	return {
+		...processTool,
+		name: "sandbox_process",
+		description: "Manage background shell sessions through OpenClaw's configured sandbox backend for this session: list, poll, log, write, send-keys, submit, paste, kill, clear, or remove. Use only for sandbox follow-up; use Codex's native shell session handling only when no OpenClaw sandbox is active and native Code Mode is available."
+	};
+}
 //#endregion
 //#region extensions/codex/src/app-server/provider-capabilities.ts
 function resolveOverriddenProviderWebSearchSupport(modelProviderOverride) {
@@ -59,6 +75,12 @@ function resolveOverriddenProviderWebSearchSupport(modelProviderOverride) {
 	return provider === "openai" ? "supported" : "unsupported";
 }
 async function readConfiguredProviderWebSearchSupport(params) {
+	if (params.expectedNativeModelProvider) {
+		if (((await params.client.request("config/read", { includeLayers: false }, {
+			timeoutMs: params.timeoutMs,
+			signal: params.signal
+		})).config.model_provider ?? "openai") !== params.expectedNativeModelProvider) return "unknown";
+	}
 	return (await params.client.request("modelProvider/capabilities/read", {}, {
 		timeoutMs: params.timeoutMs,
 		signal: params.signal
@@ -89,6 +111,7 @@ async function resolveCodexProviderWebSearchSupport(params) {
 			client,
 			timeoutMs: params.appServer.requestTimeoutMs,
 			modelProviderOverride: params.modelProviderOverride,
+			expectedNativeModelProvider: params.expectedNativeModelProvider,
 			signal: params.signal
 		});
 	} catch {
@@ -98,4 +121,4 @@ async function resolveCodexProviderWebSearchSupport(params) {
 	}
 }
 //#endregion
-export { CODEX_NODE_EXEC_DYNAMIC_TOOL_NAME as a, createNodeExecAliasDynamicTool as c, CODEX_GATEWAY_PROCESS_DYNAMIC_TOOL_NAME as i, isCodexDynamicToolExcluded as l, resolveCodexProviderWebSearchSupportForClient as n, createGatewayExecProjection as o, CODEX_GATEWAY_EXEC_DYNAMIC_TOOL_NAME as r, createGatewayProcessProjection as s, resolveCodexProviderWebSearchSupport as t };
+export { CODEX_NODE_EXEC_DYNAMIC_TOOL_NAME as a, createNodeExecAliasDynamicTool as c, isCodexDynamicToolExcluded as d, CODEX_GATEWAY_PROCESS_DYNAMIC_TOOL_NAME as i, createSandboxExecProjection as l, resolveCodexProviderWebSearchSupportForClient as n, createGatewayExecProjection as o, CODEX_GATEWAY_EXEC_DYNAMIC_TOOL_NAME as r, createGatewayProcessProjection as s, resolveCodexProviderWebSearchSupport as t, createSandboxProcessProjection as u };

package/dist/.setup/{rate-limits-DOEGYRNs.mjs → rate-limits-B7-X2TgG.mjs}

@@ -1,20 +1,72 @@
-import { m as isJsonObject } from "./config-security-BRQ2mgW9.mjs";
+import { i as isJsonObject } from "./protocol-CANUwXJ3.mjs";
 import { normalizeOptionalString, parseStrictFiniteNumber } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { z } from "zod";
 import { MAX_DATE_TIMESTAMP_MS, resolveExpiresAtMsFromEpochSeconds } from "openclaw/plugin-sdk/number-runtime";
-import { expectDefined } from "openclaw/plugin-sdk/expect-runtime";
 import { PROVIDER_LABELS, clampPercent } from "openclaw/plugin-sdk/provider-usage";
-//#region extensions/codex/src/app-server/rate-limits.ts
-/**
-* Parses Codex account rate-limit payloads into user-facing usage summaries,
-* reset hints, and enriched usage-limit error messages.
-*/
-const CODEX_LIMIT_ID = "codex";
-const LIMIT_WINDOW_KEYS = ["primary", "secondary"];
+//#region extensions/codex/src/app-server/rate-limit-time.ts
+/** Human-readable Codex quota reset times; no account or routing decisions. */
 const ONE_SECOND_MS = 1e3;
 const ONE_MINUTE_MS = 6e4;
 const ONE_HOUR_MS = 60 * ONE_MINUTE_MS;
-const ONE_DAY_MS = 24 * ONE_HOUR_MS;
+const ONE_DAY_MS$1 = 24 * ONE_HOUR_MS;
+function formatCalendarResetTime(resetsAtMs, nowMs) {
+	const resetDate = new Date(resetsAtMs);
+	const resetParts = new Intl.DateTimeFormat("en-US", {
+		month: "short",
+		day: "numeric",
+		...resetDate.getFullYear() === new Date(nowMs).getFullYear() ? {} : { year: "numeric" },
+		hour: "numeric",
+		minute: "2-digit",
+		timeZoneName: "short"
+	}).formatToParts(resetDate);
+	const part = (type) => resetParts.find((entry) => entry.type === type)?.value;
+	const dateParts = [
+		part("month"),
+		part("day"),
+		part("year")
+	].filter(Boolean);
+	return [
+		dateParts.length > 1 ? `${dateParts[0]} ${dateParts.slice(1).join(", ")}` : dateParts[0],
+		"at",
+		[
+			[part("hour"), part("minute")].filter(Boolean).join(":"),
+			part("dayPeriod"),
+			part("timeZoneName")
+		].filter(Boolean).join(" ")
+	].filter(Boolean).join(" ");
+}
+function formatRelativeDuration(durationMs) {
+	const safeMs = Math.max(1e3, durationMs);
+	if (safeMs < ONE_MINUTE_MS) return `${Math.ceil(safeMs / 1e3)} seconds`;
+	if (safeMs < ONE_HOUR_MS) {
+		const minutes = Math.ceil(safeMs / ONE_MINUTE_MS);
+		return `${minutes} ${minutes === 1 ? "minute" : "minutes"}`;
+	}
+	if (safeMs < ONE_DAY_MS$1) {
+		const hours = Math.ceil(safeMs / ONE_HOUR_MS);
+		return `${hours} ${hours === 1 ? "hour" : "hours"}`;
+	}
+	const days = Math.ceil(safeMs / ONE_DAY_MS$1);
+	return `${days} ${days === 1 ? "day" : "days"}`;
+}
+function formatResetDuration(resetsAtMs, nowMs) {
+	const durationMs = Math.round(Math.max(ONE_SECOND_MS, resetsAtMs - nowMs) / ONE_SECOND_MS) * ONE_SECOND_MS;
+	const days = Math.floor(durationMs / ONE_DAY_MS$1);
+	const hours = Math.floor(durationMs % ONE_DAY_MS$1 / ONE_HOUR_MS);
+	const minutes = Math.floor(durationMs % ONE_HOUR_MS / ONE_MINUTE_MS);
+	const seconds = Math.floor(durationMs % ONE_MINUTE_MS / ONE_SECOND_MS);
+	if (days > 0) return hours > 0 ? `${days}d ${hours}h` : `${days}d`;
+	if (hours > 0) return minutes > 0 ? `${hours}h ${minutes}m` : `${hours}h`;
+	if (minutes > 0) return seconds > 0 ? `${minutes}m ${seconds}s` : `${minutes}m`;
+	return `${seconds}s`;
+}
+//#endregion
+//#region extensions/codex/src/app-server/rate-limits.ts
+const CODEX_LIMIT_ID = "codex";
+const CODEX_RESERVE_ROUTE = "gpt-reserve";
+const CODEX_RESERVE_USAGE_NOTICE = "Luna Reserve is a separate, backend-authorized route. Ordinary Luna does not use this reserve, even with Fast off. An unused reserve does not establish eligibility or per-request billing. Ordinary usage may consume credits after included limits are reached.";
+const LIMIT_WINDOW_KEYS = ["primary", "secondary"];
+const ONE_DAY_MS = 864e5;
 const DAY_WINDOW_MINUTES = 1440;
 const WEEKLY_WINDOW_MINUTES = 7 * DAY_WINDOW_MINUTES;
 const WEEKLY_RESET_GAP_MS = 3 * ONE_DAY_MS;
@@ -24,32 +76,18 @@ const optionalNumber = z.number().optional().catch(void 0);
 const optionalBoolean = z.boolean().optional().catch(void 0);
 const rateLimitWindowSchema = z.object({
 	usedPercent: optionalNumber,
-	used_percent: optionalNumber,
 	resetsAt: optionalNumber,
-	resets_at: optionalNumber,
-	windowDurationMins: optionalNumber,
-	window_duration_mins: optionalNumber,
-	windowMinutes: optionalNumber,
-	window_minutes: optionalNumber
-}).transform((window) => {
-	const resetsAt = window.resetsAt ?? window.resets_at;
-	return {
-		usedPercent: window.usedPercent ?? window.used_percent,
-		resetsAt,
-		resetsAtMs: resolveExpiresAtMsFromEpochSeconds(resetsAt, { maxMs: MAX_DATE_TIMESTAMP_MS }) ?? 0,
-		windowDurationMins: window.windowDurationMins ?? window.window_duration_mins ?? window.windowMinutes ?? window.window_minutes
-	};
-}).optional().catch(void 0);
+	windowDurationMins: optionalNumber
+}).transform((window) => ({
+	usedPercent: window.usedPercent,
+	resetsAtMs: resolveExpiresAtMsFromEpochSeconds(window.resetsAt, { maxMs: MAX_DATE_TIMESTAMP_MS }) ?? 0,
+	windowDurationMins: window.windowDurationMins
+})).optional().catch(void 0);
 const creditsSchema = z.object({
 	hasCredits: optionalBoolean,
-	has_credits: optionalBoolean,
 	unlimited: optionalBoolean,
 	balance: z.preprocess(parseStrictFiniteNumber, optionalNumber)
-}).transform((credits) => ({
-	hasCredits: credits.hasCredits ?? credits.has_credits,
-	unlimited: credits.unlimited,
-	balance: credits.balance
-})).optional().catch(void 0);
+}).optional().catch(void 0);
 const rateLimitSnapshotSchema = z.looseObject({
 	primary: rateLimitWindowSchema,
 	secondary: rateLimitWindowSchema,
@@ -58,19 +96,22 @@ const rateLimitSnapshotSchema = z.looseObject({
 	primary: snapshot.primary,
 	secondary: snapshot.secondary,
 	credits: snapshot.credits,
-	limitId: normalizeOptionalString(snapshot.limitId) ?? normalizeOptionalString(snapshot.limit_id),
-	limitName: normalizeOptionalString(snapshot.limitName) ?? normalizeOptionalString(snapshot.limit_name),
-	planType: normalizeOptionalString(snapshot.planType) ?? normalizeOptionalString(snapshot.plan_type),
-	rateLimitReachedType: normalizeOptionalString(snapshot.rateLimitReachedType) ?? normalizeOptionalString(snapshot.rate_limit_reached_type)
+	limitId: normalizeOptionalString(snapshot.limitId),
+	limitName: normalizeOptionalString(snapshot.limitName),
+	planType: normalizeOptionalString(snapshot.planType),
+	rateLimitReachedType: normalizeOptionalString(snapshot.rateLimitReachedType)
 }));
-/** Enriches Codex usage-limit failures with reset timing and recovery guidance. */
 function formatCodexUsageLimitErrorMessage(params) {
 	const message = normalizeOptionalString(params.message);
-	if (!isCodexUsageLimitError(params.codexErrorInfo)) return;
+	if (params.codexErrorInfo !== "usageLimitExceeded") return;
 	const nowMs = params.nowMs ?? Date.now();
-	const usageSummary = summarizeCodexAccountUsage(params.rateLimits, nowMs);
-	if (params.rateLimitsAuthoritative && hasCodexRateLimitSnapshots(params.rateLimits) && !usageSummary?.blocked) return [CODEX_USAGE_LIMIT_STATE_MISMATCH_MESSAGE, "Retry the request, use another Codex account if available, or switch to another configured model/provider."].join(" ");
-	const nextReset = selectBlockingRateLimitReset(params.rateLimits, nowMs) ?? (usageSummary?.blocked ? void 0 : selectNextRateLimitReset(params.rateLimits, nowMs));
+	const ordinaryUsageAllowed = readOrdinaryUsageAllowed(params.rateLimits);
+	const snapshots = collectCodexRateLimitSnapshots(params.rateLimits).filter(snapshotHasDisplayableData);
+	const usageSnapshot = snapshots.find(isCodexLimitSnapshot) ?? snapshots[0];
+	const blockingSnapshot = selectBlockingRateLimitSnapshot(snapshots, ordinaryUsageAllowed);
+	const usageSummary = usageSnapshot ? summarizeRateLimitUsage(usageSnapshot, blockingSnapshot, nowMs) : void 0;
+	if (params.rateLimitsAuthoritative && (ordinaryUsageAllowed === true && !blockingSnapshot || ordinaryUsageAllowed === void 0 && usageSummary?.blocked === false)) return [CODEX_USAGE_LIMIT_STATE_MISMATCH_MESSAGE, "Retry the request, use another Codex account if available, or switch to another configured model/provider."].join(" ");
+	const nextReset = (blockingSnapshot ? selectSnapshotBlockingReset(blockingSnapshot, nowMs) : void 0) ?? (ordinaryUsageAllowed === void 0 && !usageSummary?.blocked ? selectNextRateLimitReset(params.rateLimits, nowMs) : void 0);
 	const parts = [CODEX_USAGE_LIMIT_MESSAGE_PREFIX];
 	let recoveryAction = "Wait until Codex becomes available";
 	if (nextReset) {
@@ -89,40 +130,42 @@ function formatCodexUsageLimitErrorMessage(params) {
 	parts.push(`${recoveryAction}, use another Codex account if available, or switch to another configured model/provider.`);
 	return parts.join(" ");
 }
-/** Detects usage-limit messages that need a fresh rate-limit query before display. */
 function shouldRefreshCodexRateLimitsForUsageLimitMessage(message) {
 	const text = normalizeOptionalString(message);
 	return Boolean(text?.startsWith(CODEX_USAGE_LIMIT_MESSAGE_PREFIX) && !text.includes("Next reset "));
 }
-/** Formats compact summaries for raw Codex rate-limit snapshot payloads. */
 function summarizeCodexRateLimits(value, nowMs = Date.now()) {
 	const snapshots = collectCodexRateLimitSnapshots(value).filter(snapshotHasDisplayableData);
 	if (snapshots.length === 0) return;
 	const summaries = snapshots.slice(0, 4).map((snapshot) => summarizeRateLimitSnapshot(snapshot, nowMs)).filter((summary) => summary !== void 0);
-	return summaries.length > 0 ? summaries.join("; ") : void 0;
+	if (summaries.length === 0) return;
+	return [summaries.join("; "), reserveUsageNotice(snapshots)].filter(Boolean).join(". ");
 }
-/** Returns true when a value contains any recognizable Codex rate-limit snapshots. */
 function hasCodexRateLimitSnapshots(value) {
 	return collectCodexRateLimitSnapshots(value).length > 0;
 }
-/** Builds short account availability lines suitable for status surfaces. */
 function summarizeCodexAccountRateLimits(value, nowMs = Date.now()) {
 	const summary = summarizeCodexAccountUsage(value, nowMs);
 	if (!summary) return;
 	if (!summary.blocked) return ["Codex is available."];
 	return [summary.blockedUntilText ? `Codex is paused until ${summary.blockedUntilText}.` : "Codex is paused by a usage limit.", summary.blockingReason ? `Your ${summary.blockingReason}.` : "Your Codex usage limit is reached."];
 }
-/** Returns the reset timestamp for the currently blocking Codex usage limit. */
 function resolveCodexUsageLimitResetAtMs(value, nowMs = Date.now()) {
-	return selectBlockingRateLimitReset(value, nowMs)?.resetsAtMs;
+	const blockingSnapshot = selectBlockingRateLimitSnapshot(collectCodexRateLimitSnapshots(value), readOrdinaryUsageAllowed(value));
+	return blockingSnapshot ? selectSnapshotBlockingReset(blockingSnapshot, nowMs)?.resetsAtMs : void 0;
 }
-/** Summarizes account availability, blocking reason, and reset time from rate-limit data. */
 function summarizeCodexAccountUsage(value, nowMs = Date.now()) {
-	const snapshots = collectCodexRateLimitSnapshots(value).filter(snapshotHasDisplayableData);
-	if (snapshots.length === 0) return;
-	const usageSnapshot = snapshots.find(isCodexLimitSnapshot) ?? expectDefined(snapshots[0], "displayable Codex rate-limit snapshot");
-	const blockedSnapshots = snapshots.filter(snapshotHasLimitBlock);
-	const blockingSnapshot = blockedSnapshots.find(isCodexLimitSnapshot) ?? blockedSnapshots[0] ?? void 0;
+	const ordinaryUsageAllowed = readOrdinaryUsageAllowed(value);
+	if (ordinaryUsageAllowed === null) return;
+	const snapshot = collectCodexRateLimitSnapshots(value).find(isCodexLimitSnapshot);
+	if (ordinaryUsageAllowed !== void 0) return {
+		usageLine: snapshot ? formatUsageLine(snapshot) : void 0,
+		blocked: !ordinaryUsageAllowed,
+		...!ordinaryUsageAllowed ? { blockingReason: "Codex usage limit is reached" } : {}
+	};
+	return snapshot && snapshotHasDisplayableData(snapshot) ? summarizeRateLimitUsage(snapshot, snapshotHasLimitBlock(snapshot) ? snapshot : void 0, nowMs) : void 0;
+}
+function summarizeRateLimitUsage(usageSnapshot, blockingSnapshot, nowMs) {
 	const blockingEntries = blockingSnapshot ? readWindowEntries(blockingSnapshot) : [];
 	const blockingWindowEntry = selectBlockingWindowEntry(blockingEntries, nowMs);
 	const blockingWindow = blockingWindowEntry?.window;
@@ -141,13 +184,14 @@ function summarizeCodexAccountUsage(value, nowMs = Date.now()) {
 		...blockingReason ? { blockingReason } : {}
 	};
 }
-/** Converts Codex app-server rate-limit payloads into OpenAI/Codex usage windows. */
 function buildCodexAppServerUsageSnapshot(value, options = {}) {
 	const snapshots = collectCodexRateLimitSnapshots(value);
 	const snapshot = snapshots.find(isCodexLimitSnapshot) ?? snapshots[0];
 	const entries = snapshot ? readWindowEntries(snapshot) : [];
 	const windows = entries.map((entry) => readProviderUsageWindow(entry, entries)).filter((window) => Boolean(window));
+	const summary = reserveUsageNotice(snapshots);
 	const result = {
+		...summary ? { summary } : {},
 		provider: "openai",
 		displayName: PROVIDER_LABELS.openai,
 		windows,
@@ -176,29 +220,21 @@ function buildCodexAppServerUsageSnapshot(value, options = {}) {
 	}
 	return result;
 }
-function isCodexUsageLimitError(codexErrorInfo) {
-	if (codexErrorInfo === "usageLimitExceeded") return true;
-	if (typeof codexErrorInfo === "string") {
-		if (codexErrorInfo.replace(/[_\s-]/gu, "").toLowerCase() === "usagelimitexceeded") return true;
-	}
-	return false;
-}
 function selectNextRateLimitReset(value, nowMs) {
 	const futureWindows = collectCodexRateLimitSnapshots(value).flatMap((snapshot) => LIMIT_WINDOW_KEYS.flatMap((key) => snapshot[key] ?? [])).filter((window) => window.resetsAtMs > nowMs);
 	if (futureWindows.length === 0) return;
 	const exhaustedWindows = futureWindows.filter((window) => window.usedPercent !== void 0 && window.usedPercent >= 100);
 	return (exhaustedWindows.length > 0 ? exhaustedWindows : futureWindows).toSorted((left, right) => left.resetsAtMs - right.resetsAtMs)[0];
 }
-function selectBlockingRateLimitReset(value, nowMs) {
-	const blockedSnapshots = collectCodexRateLimitSnapshots(value).filter(snapshotHasLimitBlock);
-	const blockingSnapshot = blockedSnapshots.find(isCodexLimitSnapshot) ?? blockedSnapshots[0] ?? void 0;
-	return blockingSnapshot ? selectSnapshotBlockingReset(blockingSnapshot, nowMs) : void 0;
+function selectBlockingRateLimitSnapshot(snapshots, ordinaryUsageAllowed) {
+	const blockedSnapshots = snapshots.filter((snapshot) => snapshotHasLimitBlock(snapshot) && (ordinaryUsageAllowed !== true && ordinaryUsageAllowed !== null || !isCodexLimitSnapshot(snapshot)));
+	return blockedSnapshots.find(isCodexLimitSnapshot) ?? blockedSnapshots[0];
 }
 function summarizeRateLimitSnapshot(snapshot, nowMs) {
 	const label = formatLimitLabel(snapshot);
 	const windows = LIMIT_WINDOW_KEYS.flatMap((key) => {
 		const window = snapshot[key];
-		return window ? [formatRateLimitWindow(key, window, nowMs)] : [];
+		return window ? [`${key} ${formatRateLimitWindowDetails(window, nowMs)}`] : [];
 	});
 	const reachedType = snapshot.rateLimitReachedType;
 	const suffix = reachedType ? ` (${formatReachedType(reachedType)})` : "";
@@ -206,28 +242,14 @@ function summarizeRateLimitSnapshot(snapshot, nowMs) {
 	if (reachedType) return `${label}: ${formatReachedType(reachedType)}`;
 }
 function collectCodexRateLimitSnapshots(value) {
-	const snapshots = [];
-	collectRateLimitSnapshots(value, snapshots, /* @__PURE__ */ new Set());
-	return snapshots;
-}
-function collectRateLimitSnapshots(value, snapshots, seen) {
-	if (Array.isArray(value)) {
-		for (const entry of value) collectRateLimitSnapshots(entry, snapshots, seen);
-		return;
-	}
-	if (!isJsonObject(value)) return;
-	if (isRateLimitSnapshot(value)) {
-		addRateLimitSnapshot(rateLimitSnapshotSchema.parse(value), snapshots, seen);
-		return;
-	}
+	if (!isJsonObject(value)) return [];
+	if (isRateLimitSnapshot(value)) return [rateLimitSnapshotSchema.parse(value)];
 	const byLimitId = value.rateLimitsByLimitId;
-	if (isJsonObject(byLimitId)) for (const key of sortedRateLimitKeys(Object.keys(byLimitId))) collectRateLimitSnapshots(byLimitId[key], snapshots, seen);
-	const snakeByLimitId = value.rate_limits_by_limit_id;
-	if (isJsonObject(snakeByLimitId)) for (const key of sortedRateLimitKeys(Object.keys(snakeByLimitId))) collectRateLimitSnapshots(snakeByLimitId[key], snapshots, seen);
-	collectRateLimitSnapshots(value.rateLimits, snapshots, seen);
-	collectRateLimitSnapshots(value.rate_limits, snapshots, seen);
-	collectRateLimitSnapshots(value.data, snapshots, seen);
-	collectRateLimitSnapshots(value.items, snapshots, seen);
+	return (isJsonObject(byLimitId) ? sortedRateLimitKeys(Object.keys(byLimitId)).map((key) => byLimitId[key]) : [value.rateLimits]).filter(isJsonObject).filter(isRateLimitSnapshot).map((snapshot) => rateLimitSnapshotSchema.parse(snapshot));
+}
+function readOrdinaryUsageAllowed(value) {
+	const allowed = isJsonObject(value) ? value.ordinaryUsageAllowed : void 0;
+	return allowed === null || typeof allowed === "boolean" ? allowed : void 0;
 }
 function sortedRateLimitKeys(keys) {
 	return keys.toSorted((left, right) => {
@@ -236,33 +258,26 @@ function sortedRateLimitKeys(keys) {
 		return left.localeCompare(right);
 	});
 }
-function addRateLimitSnapshot(snapshot, snapshots, seen) {
-	const signature = [
-		snapshot.limitId ?? "",
-		snapshot.limitName ?? "",
-		formatWindowSignature(snapshot.primary),
-		formatWindowSignature(snapshot.secondary)
-	].join("|");
-	if (seen.has(signature)) return;
-	seen.add(signature);
-	snapshots.push(snapshot);
-}
 function isRateLimitSnapshot(value) {
-	return isJsonObject(value.primary) || isJsonObject(value.secondary) || value.rateLimitReachedType !== void 0 || value.rate_limit_reached_type !== void 0 || value.limitId !== void 0 || value.limit_id !== void 0 || value.limitName !== void 0 || value.limit_name !== void 0;
+	return isJsonObject(value.primary) || isJsonObject(value.secondary) || value.rateLimitReachedType !== void 0 || value.limitId !== void 0 || value.limitName !== void 0;
 }
 function snapshotHasDisplayableData(snapshot) {
 	return Boolean(snapshot.rateLimitReachedType) || readWindowEntries(snapshot).some((entry) => entry.window.usedPercent !== void 0 || entry.window.resetsAtMs > 0);
 }
-function formatRateLimitWindow(key, window, nowMs) {
-	return `${key} ${formatRateLimitWindowDetails(window, nowMs)}`;
-}
 function formatRateLimitWindowDetails(window, nowMs) {
 	return `${window.usedPercent === void 0 ? "usage unknown" : `${Math.max(0, 100 - Math.round(window.usedPercent))}% left`}${window.resetsAtMs > nowMs ? ` ⏱${formatResetDuration(window.resetsAtMs, nowMs)}` : ""}`;
 }
+function reserveUsageNotice(snapshots) {
+	return snapshots.some(isReserveSnapshot) ? CODEX_RESERVE_USAGE_NOTICE : void 0;
+}
+function isReserveSnapshot(snapshot) {
+	return snapshot.limitName === CODEX_RESERVE_ROUTE || snapshot.limitId === CODEX_RESERVE_ROUTE;
+}
 function formatLimitLabel(snapshot) {
+	if (isReserveSnapshot(snapshot)) return "Luna Reserve (separate route)";
 	const label = snapshot.limitName ?? snapshot.limitId;
 	if (!label || label === CODEX_LIMIT_ID) return "Codex";
-	return label.replace(/[_-]+/gu, " ").replace(/\s+/gu, " ").trim();
+	return formatReachedType(label);
 }
 function formatReachedType(value) {
 	return value.replace(/[_-]+/gu, " ").replace(/\s+/gu, " ").trim();
@@ -312,11 +327,8 @@ function formatCodexCreditSummary(credits) {
 	return roundedBalance > 0 ? `${roundedBalance} credits` : void 0;
 }
 function selectSnapshotBlockingReset(snapshot, nowMs) {
-	const futureWindows = readWindowEntries(snapshot).map((entry) => entry.window).filter((window) => window.resetsAtMs > nowMs);
-	const exhaustedWindows = futureWindows.filter((window) => window.usedPercent !== void 0 && window.usedPercent >= 100);
-	const candidates = exhaustedWindows.length > 0 ? exhaustedWindows : futureWindows;
-	const resetSort = exhaustedWindows.length > 0 ? (left, right) => right.resetsAtMs - left.resetsAtMs : (left, right) => left.resetsAtMs - right.resetsAtMs;
-	return candidates.toSorted(resetSort)[0];
+	const window = selectBlockingWindowEntry(readWindowEntries(snapshot), nowMs)?.window;
+	return window && window.resetsAtMs > nowMs ? window : void 0;
 }
 function selectBlockingWindowEntry(entries, nowMs) {
 	const futureEntries = entries.filter((entry) => entry.window.resetsAtMs > nowMs);
@@ -351,10 +363,9 @@ function formatUsageLine(snapshot) {
 	return windows.length > 0 ? windows.join(" · ") : void 0;
 }
 function formatUsageWindowLabel(entry, entries) {
+	const period = formatBlockingLimitPeriod(entry, entries);
+	if (period) return period;
 	const minutes = entry.window.windowDurationMins;
-	if (minutes === WEEKLY_WINDOW_MINUTES || hasWeeklySecondaryResetCadence(entry, entries)) return "weekly";
-	if (minutes === DAY_WINDOW_MINUTES) return "daily";
-	if (minutes !== void 0 && minutes > 0 && minutes < DAY_WINDOW_MINUTES) return "short-term";
 	if (minutes !== void 0 && minutes > 0 && minutes % DAY_WINDOW_MINUTES === 0) return `${minutes / DAY_WINDOW_MINUTES}-day`;
 	if (minutes !== void 0 && minutes > 0 && minutes % 60 === 0) return `${minutes / 60}-hour`;
 	return "usage";
@@ -364,60 +375,6 @@ function hasWeeklySecondaryResetCadence(entry, entries) {
 	const primaryResetMs = entries.find((candidate) => candidate.key === "primary")?.window.resetsAtMs;
 	return typeof primaryResetMs === "number" && primaryResetMs > 0 && entry.window.resetsAtMs > 0 && entry.window.resetsAtMs - primaryResetMs >= WEEKLY_RESET_GAP_MS;
 }
-function formatCalendarResetTime(resetsAtMs, nowMs) {
-	const resetDate = new Date(resetsAtMs);
-	const resetParts = new Intl.DateTimeFormat("en-US", {
-		month: "short",
-		day: "numeric",
-		...resetDate.getFullYear() === new Date(nowMs).getFullYear() ? {} : { year: "numeric" },
-		hour: "numeric",
-		minute: "2-digit",
-		timeZoneName: "short"
-	}).formatToParts(resetDate);
-	const part = (type) => resetParts.find((entry) => entry.type === type)?.value;
-	const dateParts = [
-		part("month"),
-		part("day"),
-		part("year")
-	].filter(Boolean);
-	return [
-		dateParts.length > 1 ? `${dateParts[0]} ${dateParts.slice(1).join(", ")}` : dateParts[0],
-		"at",
-		[
-			[part("hour"), part("minute")].filter(Boolean).join(":"),
-			part("dayPeriod"),
-			part("timeZoneName")
-		].filter(Boolean).join(" ")
-	].filter(Boolean).join(" ");
-}
-function formatRelativeDuration(durationMs) {
-	const safeMs = Math.max(1e3, durationMs);
-	if (safeMs < ONE_MINUTE_MS) return `${Math.ceil(safeMs / 1e3)} seconds`;
-	if (safeMs < ONE_HOUR_MS) {
-		const minutes = Math.ceil(safeMs / ONE_MINUTE_MS);
-		return `${minutes} ${minutes === 1 ? "minute" : "minutes"}`;
-	}
-	if (safeMs < ONE_DAY_MS) {
-		const hours = Math.ceil(safeMs / ONE_HOUR_MS);
-		return `${hours} ${hours === 1 ? "hour" : "hours"}`;
-	}
-	const days = Math.ceil(safeMs / ONE_DAY_MS);
-	return `${days} ${days === 1 ? "day" : "days"}`;
-}
-function formatResetDuration(resetsAtMs, nowMs) {
-	const durationMs = Math.round(Math.max(ONE_SECOND_MS, resetsAtMs - nowMs) / ONE_SECOND_MS) * ONE_SECOND_MS;
-	const days = Math.floor(durationMs / ONE_DAY_MS);
-	const hours = Math.floor(durationMs % ONE_DAY_MS / ONE_HOUR_MS);
-	const minutes = Math.floor(durationMs % ONE_HOUR_MS / ONE_MINUTE_MS);
-	const seconds = Math.floor(durationMs % ONE_MINUTE_MS / ONE_SECOND_MS);
-	if (days > 0) return hours > 0 ? `${days}d ${hours}h` : `${days}d`;
-	if (hours > 0) return minutes > 0 ? `${hours}h ${minutes}m` : `${hours}h`;
-	if (minutes > 0) return seconds > 0 ? `${minutes}m ${seconds}s` : `${minutes}m`;
-	return `${seconds}s`;
-}
-function formatWindowSignature(window) {
-	return window ? `${window.usedPercent ?? ""}:${window.resetsAt ?? ""}` : "";
-}
 function extractCodexRetryHint(message) {
 	if (!message) return;
 	const tryAgainAt = /\btry again\s+(at\s+[^.!?\n]+)(?:[.!?]|$)/iu.exec(message);
@@ -425,4 +382,4 @@ function extractCodexRetryHint(message) {
 	return /\btry again\s+((?:tomorrow|in\s+[^.!?\n]+)[^.!?\n]*)(?:[.!?]|$)/iu.exec(message)?.[1]?.trim();
 }
 //#endregion
-export { shouldRefreshCodexRateLimitsForUsageLimitMessage as a, summarizeCodexRateLimits as c, resolveCodexUsageLimitResetAtMs as i, formatCodexUsageLimitErrorMessage as n, summarizeCodexAccountRateLimits as o, hasCodexRateLimitSnapshots as r, summarizeCodexAccountUsage as s, buildCodexAppServerUsageSnapshot as t };
+export { shouldRefreshCodexRateLimitsForUsageLimitMessage as a, summarizeCodexRateLimits as c, resolveCodexUsageLimitResetAtMs as i, formatRelativeDuration as l, formatCodexUsageLimitErrorMessage as n, summarizeCodexAccountRateLimits as o, hasCodexRateLimitSnapshots as r, summarizeCodexAccountUsage as s, buildCodexAppServerUsageSnapshot as t };