@coseung2/opencodex 2.8.0-cs.13 → 2.8.0-cs.14

package/src/codex/catalog/provider-fetch.ts

@@ -58,7 +58,7 @@ import { createAdmissionGate, ResourceAdmissionError, type AdmissionMetrics } fr
 
 import { JAWCODE_CATALOG_AUGMENT_PROVIDERS, catalogModelSlug, shouldExposeRoutedModel } from "./parsing";
 import type { CatalogModel } from "./parsing";
-import { disabledNativeSlugs, hasComboTargets, nativeInputModalities, nativeOpenAiContextWindow, nativeOpenAiSlugs, nativeParallelToolCalls, nativeReasoningEfforts } from "./metadata";
+import { disabledNativeSlugs, hasComboTargets, nativeInputModalities, nativeOpenAiContextWindow, nativeOpenAiMaxInputTokens, nativeOpenAiSlugs, nativeParallelToolCalls, nativeReasoningEfforts } from "./metadata";
 import { deriveComboCatalogModel, normalizedOpenAiApiSignature, openAiApiCollisionWarnings, replaceLastComboCatalogOmissions, warnUncataloguedComboOnce } from "./aggregation";
 import type { ComboCatalogOmission } from "./aggregation";
 
@@ -274,10 +274,15 @@ export function warnDroppedConfiguredIdsOnce(name: string, droppedConfiguredIds:
 }
 
 export function isGlm52ModelId(id: string): boolean {
-  const normalized = id.toLowerCase();
+  const normalized = id.trim().toLowerCase();
   return normalized === "glm-5.2" || normalized === "glm-5.2[1m]";
 }
 
+export function isGlm53ModelId(id: string): boolean {
+  const normalized = id.trim().toLowerCase();
+  return normalized === "glm-5.3" || normalized === "glm-5.3[1m]";
+}
+
 function plainRecord(value: unknown): Record<string, unknown> | undefined {
   return value !== null && typeof value === "object" && !Array.isArray(value)
     ? value as Record<string, unknown>
@@ -358,6 +363,17 @@ function modelInputModalities(
     value === "text" || value === "image" || value === "audio"
   ));
   if (explicit && explicit.length > 0) return explicit;
+  const architecture = plainRecord(item.architecture);
+  const architectureModality = typeof architecture?.modality === "string"
+    ? normalizedMetadataString(architecture.modality, 64)
+    : undefined;
+  if (architectureModality?.includes("->")) {
+    const [rawInput = ""] = architectureModality.split("->");
+    const inferred = rawInput
+      .split("+")
+      .filter(value => value === "text" || value === "image" || value === "audio");
+    if (inferred.length > 0) return [...new Set(inferred)];
+  }
   if (capabilityRecord?.vision === false) return ["text"];
   if (capabilityRecord?.vision === true || capabilities?.some(value => value === "vision" || value === "image-input")) {
     return ["text", "image"];
@@ -385,9 +401,11 @@ export function catalogHintsFromModelsApiItem(providerName: string, item: Provid
     ? sanitizeCodexReasoningEfforts(listedReasoningEfforts)
     : typeof rawReasoningEfforts === "boolean"
       ? (rawReasoningEfforts
-        ? ((providerName === "neuralwatt" || providerName === "zai") && isGlm52ModelId(item.id)
-          ? ["low", "medium", "high", "xhigh", "max"]
-          : ["low", "medium", "high", "xhigh"])
+        ? ((providerName === "neuralwatt" || providerName === "zai") && isGlm53ModelId(item.id)
+          ? ["low", "high", "max"]
+          : (providerName === "neuralwatt" || providerName === "zai") && isGlm52ModelId(item.id)
+            ? ["low", "medium", "high", "xhigh", "max"]
+            : ["low", "medium", "high", "xhigh"])
         : [])
       : undefined;
   const capabilities = modelCapabilities(item);
@@ -756,7 +774,7 @@ async function gatherRoutedModelsUncached(
         id: slug,
         owned_by: "openai",
         contextWindow,
-        maxInputTokens: contextWindow,
+        maxInputTokens: nativeOpenAiMaxInputTokens(slug) ?? contextWindow,
         inputModalities: nativeInputModalities(slug),
         reasoningEfforts: nativeReasoningEfforts(slug),
         ...(nativeParallelToolCalls(slug) ? { parallelToolCalls: true } : {}),

package/src/codex/catalog.ts

@@ -2,7 +2,7 @@
 // Public surface preserved exactly; importers keep using "src/codex/catalog".
 export { isMediaGenerationModelId, shouldExposeRoutedModel, readCodexCatalogPath, readCatalog, normalizeRoutedCatalogEntry, catalogModelSlug, filterSupportedNativeSlugs, catalogModelSupportsReasoningSummaries } from "./catalog/parsing";
 export type { CatalogModel, MultiAgentMode } from "./catalog/parsing";
-export { NATIVE_OPENAI_MODELS, nativeOpenAiContextWindow, disabledNativeSlugs, visibleNativeSlugs, desktopVisibleNativeSlugs, nativeModelRows, applyNativeVisibility, upstreamNativeEntry, nativeOpenAiSlugs, listCatalogNativeSlugs, nativeReasoningEfforts, nativeDefaultReasoningEffort } from "./catalog/metadata";
+export { NATIVE_DAYBREAK_BLUE_MODEL, NATIVE_GPT56_CONTEXT_WINDOW, NATIVE_GPT56_MAX_INPUT_TOKENS, NATIVE_OPENAI_MODELS, nativeOpenAiContextWindow, nativeOpenAiMaxInputTokens, disabledNativeSlugs, visibleNativeSlugs, desktopVisibleNativeSlugs, nativeModelRows, applyNativeVisibility, upstreamNativeEntry, nativeOpenAiSlugs, listCatalogNativeSlugs, nativeReasoningEfforts, nativeDefaultReasoningEffort } from "./catalog/metadata";
 export { isSpawnableCodexCandidate, codexExecInvocation, loadBundledCodexCatalog, materializeBundledCodexCatalog, loadCatalogTemplate } from "./catalog/bundled";
 export { nativeEffortClamp, shouldApplyNativeEffortClamp, catalogModelEfforts, codexSupportedReasoningEfforts, clampedDefaultEffort, clampEntryToCodexSupportedEfforts, clampCatalogModelsToCodexSupport } from "./catalog/effort";
 export { applyProviderConfigHints, isDatedVariantId, filterCatalogVisibleModels, gatherRoutedModels, clearGatherRoutedModelsInflight, augmentRoutedModelsWithRegistryOpenAiApiRows, augmentRoutedModelsWithJawcodeMetadata } from "./catalog/provider-fetch";

package/src/codex/pool-rotation.ts

@@ -19,6 +19,10 @@ const MAX_STICKY_LIMIT = 100;
 const DEFAULT_STRATEGY: OcxAccountPoolRotationStrategy = "quota";
 const VALID_STRATEGIES = new Set<OcxAccountPoolRotationStrategy>(["quota", "round-robin", "fill-first"]);
 
+export const DEFAULT_ACCOUNT_PRIORITY = 0;
+export const MIN_ACCOUNT_PRIORITY = -100;
+export const MAX_ACCOUNT_PRIORITY = 100;
+
 /** Strict parse for management APIs — returns null instead of defaulting. */
 export function parseAccountPoolStrategy(raw: unknown): OcxAccountPoolRotationStrategy | null {
   if (typeof raw === "string" && VALID_STRATEGIES.has(raw as OcxAccountPoolRotationStrategy)) {
@@ -43,6 +47,49 @@ export function normalizeAccountPoolStickyLimit(raw: unknown): number {
   return parseAccountPoolStickyLimit(raw) ?? DEFAULT_STICKY_LIMIT;
 }
 
+export function parseAccountPriority(raw: unknown): number | null {
+  return typeof raw === "number"
+    && Number.isInteger(raw)
+    && raw >= MIN_ACCOUNT_PRIORITY
+    && raw <= MAX_ACCOUNT_PRIORITY
+    ? raw
+    : null;
+}
+
+export function normalizeAccountPriority(raw: unknown): number {
+  return parseAccountPriority(raw) ?? DEFAULT_ACCOUNT_PRIORITY;
+}
+
+/**
+ * Narrow eligible ids to the highest configured tier that still has quota headroom.
+ * Equal-priority pools and fully drained pools preserve the caller's exact list/order.
+ */
+export function selectPriorityTier(
+  ids: readonly string[],
+  priorityOf: (id: string) => number,
+  hasHeadroom: (id: string) => boolean,
+  pinnedId?: string,
+): readonly string[] {
+  if (ids.length <= 1) return ids;
+  const priorities = ids.map(priorityOf);
+  const firstPriority = priorities[0]!;
+  if (priorities.every(priority => priority === firstPriority)) return ids;
+
+  let ceiling = Number.POSITIVE_INFINITY;
+  if (pinnedId !== undefined) {
+    const pinnedIndex = ids.indexOf(pinnedId);
+    if (pinnedIndex >= 0 && hasHeadroom(pinnedId)) ceiling = priorities[pinnedIndex]!;
+  }
+
+  const tiers = [...new Set(priorities)].sort((a, b) => b - a);
+  for (const tier of tiers) {
+    if (tier > ceiling) continue;
+    const members = ids.filter((_, index) => priorities[index] === tier);
+    if (members.some(hasHeadroom)) return members;
+  }
+  return ids;
+}
+
 function getOrCreateState(poolKey: string): SelectionState {
   let state = selectionState.get(poolKey);
   if (!state) {
@@ -60,7 +107,7 @@ function cloneSelectionState(state: SelectionState): SelectionState {
   };
 }
 
-function smoothWeightedIndex(ids: string[], state: SelectionState): number {
+function smoothWeightedIndex(ids: readonly string[], state: SelectionState): number {
   let best = -1;
   let bestScore = Number.NEGATIVE_INFINITY;
   let total = 0;
@@ -87,7 +134,7 @@ function smoothWeightedIndex(ids: string[], state: SelectionState): number {
  * either the live map entry or a scratch/clone for dry-run peek.
  */
 function pickRoundRobinFromState(
-  eligibleIds: string[],
+  eligibleIds: readonly string[],
   stickyLimit: number,
   state: SelectionState,
   commitSticky: boolean,
@@ -118,7 +165,7 @@ function pickRoundRobinFromState(
 
 export function pickRoundRobinAccount(
   poolKey: string,
-  eligibleIds: string[],
+  eligibleIds: readonly string[],
   stickyLimit: number,
 ): string | null {
   return pickRoundRobinFromState(eligibleIds, stickyLimit, getOrCreateState(poolKey), true);
@@ -130,7 +177,7 @@ export function pickRoundRobinAccount(
  */
 export function peekRoundRobinAccount(
   poolKey: string,
-  eligibleIds: string[],
+  eligibleIds: readonly string[],
   stickyLimit: number,
 ): string | null {
   const live = selectionState.get(poolKey);

package/src/codex/quota.ts

@@ -4,7 +4,9 @@ import { atomicWriteFile, getConfigDir } from "../config";
 import { captureConfigGeneration, type GenerationContext } from "../lib/state-store-sweeper";
 
 export type StoredAccountQuota = {
+  fiveHourPercent?: number;
   weeklyPercent?: number;
+  fiveHourResetAt?: number;
   monthlyPercent?: number;
   weeklyResetAt?: number;
   monthlyResetAt?: number;
@@ -41,13 +43,15 @@ export type WhamUsageResponse = {
 };
 
 type WhamUsageWindow = {
-  used_percent?: number;
-  reset_at?: number;
-  limit_window_seconds?: number;
+  used_percent?: number | string | null;
+  reset_at?: number | string | null;
+  limit_window_seconds?: number | string | null;
 };
 
 const MONTHLY_WINDOW_MIN_SECONDS = 28 * 24 * 60 * 60;
 const MONTHLY_WINDOW_MIN_MINUTES = MONTHLY_WINDOW_MIN_SECONDS / 60;
+const FIVE_HOUR_WINDOW_MIN_SECONDS = 2 * 60 * 60;
+const FIVE_HOUR_WINDOW_MAX_SECONDS = 12 * 60 * 60;
 
 const accountQuota = new Map<string, StoredAccountQuota>();
 let lastReconciledGeneration = 0;
@@ -62,15 +66,26 @@ function mayCommitAccountQuota(accountId: string, writerGeneration: number): boo
 export const CODEX_UNKNOWN_USAGE_SCORE = 101;
 export const CODEX_EXHAUSTED_USAGE_PERCENT = 100;
 
+/** Plans whose WHAM payloads expose a separate rolling five-hour window. */
+export function isCodexFiveHourQuotaPlan(plan: string | null | undefined): boolean {
+  const normalized = plan?.trim().toLowerCase();
+  // Business is the current name for the older Team workspace plan.
+  return normalized === "plus" || normalized === "team" || normalized === "business";
+}
+
 export function isCodexQuotaExhausted(
-  quota: Pick<StoredAccountQuota, "weeklyPercent" | "monthlyPercent"> | null,
+  quota: Pick<StoredAccountQuota, "fiveHourPercent" | "weeklyPercent" | "monthlyPercent"> | null,
   plan?: string | null,
 ): boolean {
   if (!quota) return false;
   const normalizedPlan = plan?.trim().toLowerCase();
   const values = normalizedPlan === "go" || normalizedPlan === "free"
     ? [quota.monthlyPercent]
-    : [quota.weeklyPercent, quota.monthlyPercent];
+    : [
+        ...(isCodexFiveHourQuotaPlan(plan) ? [quota.fiveHourPercent] : []),
+        quota.weeklyPercent,
+        quota.monthlyPercent,
+      ];
   return values.some(value => typeof value === "number"
     && Number.isFinite(value)
     && value >= CODEX_EXHAUSTED_USAGE_PERCENT);
@@ -97,15 +112,23 @@ function normalizeResetAt(value: unknown): number | undefined {
 }
 
 function hasKnownQuotaValue(quota: Omit<StoredAccountQuota, "updatedAt">): boolean {
-  return [quota.weeklyPercent, quota.monthlyPercent]
+  return [quota.fiveHourPercent, quota.weeklyPercent, quota.monthlyPercent]
     .some(value => typeof value === "number" && Number.isFinite(value));
 }
 
+function windowDurationSeconds(window: WhamUsageWindow | null | undefined): number | undefined {
+  const raw: unknown = window?.limit_window_seconds;
+  const seconds = typeof raw === "number"
+    ? raw
+    : typeof raw === "string" && raw.trim() !== ""
+      ? Number(raw)
+      : undefined;
+  return typeof seconds === "number" && Number.isFinite(seconds) && seconds > 0 ? seconds : undefined;
+}
+
 function isExplicitMonthlyWindow(window: WhamUsageWindow | null | undefined): boolean {
-  const seconds = window?.limit_window_seconds;
-  return typeof seconds === "number"
-    && Number.isFinite(seconds)
-    && seconds >= MONTHLY_WINDOW_MIN_SECONDS;
+  const seconds = windowDurationSeconds(window);
+  return seconds !== undefined && seconds >= MONTHLY_WINDOW_MIN_SECONDS;
 }
 
 function isExplicitMonthlyWindowMinutes(windowMinutes: unknown): boolean {
@@ -119,17 +142,39 @@ function isExplicitMonthlyWindowMinutes(windowMinutes: unknown): boolean {
     && minutes >= MONTHLY_WINDOW_MIN_MINUTES;
 }
 
+function isExplicitFiveHourWindow(window: WhamUsageWindow | null | undefined): boolean {
+  const seconds = windowDurationSeconds(window);
+  return seconds !== undefined
+    && seconds >= FIVE_HOUR_WINDOW_MIN_SECONDS
+    && seconds <= FIVE_HOUR_WINDOW_MAX_SECONDS;
+}
+
+function isExplicitFiveHourWindowMinutes(windowMinutes: unknown): boolean {
+  const minutes = typeof windowMinutes === "number"
+    ? windowMinutes
+    : typeof windowMinutes === "string" && windowMinutes.trim() !== ""
+      ? Number(windowMinutes)
+      : undefined;
+  return typeof minutes === "number"
+    && Number.isFinite(minutes)
+    && minutes >= FIVE_HOUR_WINDOW_MIN_SECONDS / 60
+    && minutes <= FIVE_HOUR_WINDOW_MAX_SECONDS / 60;
+}
 
 function snapshotHasWeekly(quota: Omit<StoredAccountQuota, "updatedAt">): boolean {
   return quota.weeklyPercent !== undefined || quota.weeklyResetAt !== undefined;
 }
 
+function snapshotHasFiveHour(quota: Omit<StoredAccountQuota, "updatedAt">): boolean {
+  return quota.fiveHourPercent !== undefined || quota.fiveHourResetAt !== undefined;
+}
+
 function snapshotHasMonthly(quota: Omit<StoredAccountQuota, "updatedAt">): boolean {
   return quota.monthlyPercent !== undefined || quota.monthlyResetAt !== undefined;
 }
 
 function snapshotHasUsage(quota: Omit<StoredAccountQuota, "updatedAt">): boolean {
-  return snapshotHasWeekly(quota) || snapshotHasMonthly(quota);
+  return snapshotHasFiveHour(quota) || snapshotHasWeekly(quota) || snapshotHasMonthly(quota);
 }
 export function setAccountQuotaFromParsed(
   accountId: string,
@@ -143,6 +188,8 @@ export function setAccountQuotaFromParsed(
   const creditsOnly = quota.resetCredits !== undefined && !snapshotHasUsage(quota);
 
   if (creditsOnly) {
+    if (existing?.fiveHourPercent !== undefined) next.fiveHourPercent = existing.fiveHourPercent;
+    if (existing?.fiveHourResetAt !== undefined) next.fiveHourResetAt = existing.fiveHourResetAt;
     if (existing?.weeklyPercent !== undefined) next.weeklyPercent = existing.weeklyPercent;
     if (existing?.weeklyResetAt !== undefined) next.weeklyResetAt = existing.weeklyResetAt;
     if (existing?.monthlyPercent !== undefined) next.monthlyPercent = existing.monthlyPercent;
@@ -153,20 +200,32 @@ export function setAccountQuotaFromParsed(
     return;
   }
 
-  if (snapshotHasWeekly(quota)) {
+  const hasFiveHour = snapshotHasFiveHour(quota);
+  const hasWeekly = snapshotHasWeekly(quota);
+  const hasMonthly = snapshotHasMonthly(quota);
+
+  if (hasFiveHour) {
+    if (quota.fiveHourPercent !== undefined) next.fiveHourPercent = quota.fiveHourPercent;
+    if (quota.fiveHourResetAt !== undefined) next.fiveHourResetAt = quota.fiveHourResetAt;
+    // A five-hour-only response can be a partial snapshot; retain a known
+    // weekly value until a later response supplies that window.
+    if (!hasWeekly && existing?.weeklyPercent !== undefined) {
+      next.weeklyPercent = existing.weeklyPercent;
+      if (existing.weeklyResetAt !== undefined) next.weeklyResetAt = existing.weeklyResetAt;
+    }
+  }
+
+  if (hasWeekly) {
     if (quota.weeklyPercent !== undefined) next.weeklyPercent = quota.weeklyPercent;
     if (quota.weeklyResetAt !== undefined) next.weeklyResetAt = quota.weeklyResetAt;
-  } else if (snapshotHasMonthly(quota) && !snapshotHasWeekly(quota)) {
+  } else if (hasMonthly && !hasFiveHour) {
     // Monthly-only snapshots intentionally clear stale weekly values (issue #382).
-  } else if (existing?.weeklyPercent !== undefined) {
-    next.weeklyPercent = existing.weeklyPercent;
-    if (existing.weeklyResetAt !== undefined) next.weeklyResetAt = existing.weeklyResetAt;
   }
 
-  if (snapshotHasMonthly(quota)) {
+  if (hasMonthly) {
     if (quota.monthlyPercent !== undefined) next.monthlyPercent = quota.monthlyPercent;
     if (quota.monthlyResetAt !== undefined) next.monthlyResetAt = quota.monthlyResetAt;
-  } else if (snapshotHasWeekly(quota) && existing?.monthlyPercent !== undefined) {
+  } else if ((hasWeekly || hasFiveHour) && existing?.monthlyPercent !== undefined) {
     next.monthlyPercent = existing.monthlyPercent;
     if (existing.monthlyResetAt !== undefined) next.monthlyResetAt = existing.monthlyResetAt;
   }
@@ -178,7 +237,10 @@ export function setAccountQuotaFromParsed(
   schedulePersistAccountQuotas();
 }
 
-export function parseUpstreamQuotaHeaders(headers: Headers): Omit<StoredAccountQuota, "updatedAt"> | null {
+export function parseUpstreamQuotaHeaders(
+  headers: Headers,
+  plan?: string | null,
+): Omit<StoredAccountQuota, "updatedAt"> | null {
   const primaryRaw = headers.get("x-codex-primary-used-percent");
   const secondaryRaw = headers.get("x-codex-secondary-used-percent");
   const tertiaryRaw = headers.get("x-codex-tertiary-used-percent");
@@ -196,25 +258,52 @@ export function parseUpstreamQuotaHeaders(headers: Headers): Omit<StoredAccountQ
   const secondaryResetAt = normalizeResetAt(secondaryResetRaw);
   const tertiaryResetAt = normalizeResetAt(tertiaryResetRaw);
   const primaryIsMonthly = primaryRaw !== null && isExplicitMonthlyWindowMinutes(primaryWindowMinutes);
+  const trackFiveHour = plan == null || isCodexFiveHourQuotaPlan(plan);
+  const primaryIsFiveHour = trackFiveHour && primaryRaw !== null && isExplicitFiveHourWindowMinutes(primaryWindowMinutes);
+  const secondaryIsFiveHour = trackFiveHour && secondaryRaw !== null && isExplicitFiveHourWindowMinutes(secondaryWindowMinutes);
 
   if (primaryIsMonthly) {
     if (primaryPercent !== undefined) {
       quota.monthlyPercent = primaryPercent;
       if (primaryResetAt !== undefined) quota.monthlyResetAt = primaryResetAt;
     }
-    if (secondaryPercent !== undefined) {
+    if (secondaryIsFiveHour && secondaryPercent !== undefined) {
+      quota.fiveHourPercent = secondaryPercent;
+      if (secondaryResetAt !== undefined) quota.fiveHourResetAt = secondaryResetAt;
+    } else if (secondaryPercent !== undefined) {
       quota.weeklyPercent = secondaryPercent;
       if (secondaryResetAt !== undefined) quota.weeklyResetAt = secondaryResetAt;
     }
   } else {
-    const weeklyPercent = primaryPercent ?? secondaryPercent;
-    const weeklyResetAt = primaryPercent !== undefined
-      ? primaryResetAt
-      : secondaryResetAt;
+    if (primaryIsFiveHour && primaryPercent !== undefined) {
+      quota.fiveHourPercent = primaryPercent;
+      if (primaryResetAt !== undefined) quota.fiveHourResetAt = primaryResetAt;
+    }
+    if (secondaryIsFiveHour && secondaryPercent !== undefined) {
+      quota.fiveHourPercent ??= secondaryPercent;
+      if (quota.fiveHourResetAt === undefined && secondaryResetAt !== undefined) {
+        quota.fiveHourResetAt = secondaryResetAt;
+      }
+    }
+    const weeklyPercent = primaryIsFiveHour ? secondaryPercent : primaryPercent ?? secondaryPercent;
+    const weeklyResetAt = primaryIsFiveHour
+      ? secondaryResetAt
+      : primaryPercent !== undefined ? primaryResetAt : secondaryResetAt;
     if (weeklyPercent !== undefined) {
       quota.weeklyPercent = weeklyPercent;
       if (weeklyResetAt !== undefined) quota.weeklyResetAt = weeklyResetAt;
     }
+    if (trackFiveHour
+      && !primaryIsFiveHour
+      && primaryPercent !== undefined
+      && secondaryPercent !== undefined
+      && primaryWindowMinutes === null
+      && secondaryWindowMinutes === null) {
+      quota.fiveHourPercent = primaryPercent;
+      if (primaryResetAt !== undefined) quota.fiveHourResetAt = primaryResetAt;
+      quota.weeklyPercent = secondaryPercent;
+      if (secondaryResetAt !== undefined) quota.weeklyResetAt = secondaryResetAt;
+    }
   }
 
   if (tertiaryPercent !== undefined && quota.monthlyPercent === undefined) {
@@ -229,8 +318,9 @@ export function applyAccountQuotaFromUpstreamHeaders(
   accountId: string,
   headers: Headers,
   writerGeneration = captureConfigGeneration(),
+  plan?: string | null,
 ): void {
-  const quota = parseUpstreamQuotaHeaders(headers);
+  const quota = parseUpstreamQuotaHeaders(headers, plan);
   if (!quota) return;
   setAccountQuotaFromParsed(accountId, quota, writerGeneration);
 }
@@ -251,7 +341,9 @@ export function updateAccountQuota(
   if (nextWeekly === undefined && nextMonthly === undefined && resetCredits === undefined) return;
 
   const quota: StoredAccountQuota = {
+    ...(existing?.fiveHourPercent !== undefined ? { fiveHourPercent: existing.fiveHourPercent } : {}),
     ...(existing?.weeklyPercent !== undefined ? { weeklyPercent: existing.weeklyPercent } : {}),
+    ...(existing?.fiveHourResetAt !== undefined ? { fiveHourResetAt: existing.fiveHourResetAt } : {}),
     ...(existing?.monthlyPercent !== undefined ? { monthlyPercent: existing.monthlyPercent } : {}),
     ...(existing?.weeklyResetAt !== undefined ? { weeklyResetAt: existing.weeklyResetAt } : {}),
     ...(existing?.monthlyResetAt !== undefined ? { monthlyResetAt: existing.monthlyResetAt } : {}),
@@ -378,20 +470,43 @@ export function parseUsageQuota(data: WhamUsageResponse): Omit<StoredAccountQuot
   const secondaryResetAt = normalizeResetAt(secondaryWindow?.reset_at);
   const tertiaryResetAt = normalizeResetAt(tertiaryWindow?.reset_at);
   const primaryIsMonthly = isExplicitMonthlyWindow(primaryWindow);
-
-  // [Decision Log]
-  // - 목적과 의도: distinguish weekly and roughly monthly WHAM primary windows without plan-name guesses.
-  // - 기존 구현 및 제약 조건: primary meant weekly, and older responses omit limit_window_seconds.
-  // - 검토한 주요 대안: exact-duration matching, plan-specific mapping, and a duration lower bound.
-  // - 선택한 방식: only an explicit primary duration of at least 28 days changes it to monthly.
-  // - 다른 대안 대신 이 방식을 선택한 이유: it accepts calendar-month variance and preserves legacy payloads.
-  // - 장점, 단점 및 영향: Team monthly quotas classify correctly; unknown durations remain weekly by design.
-  const weeklyPercent = primaryIsMonthly ? secondaryPercent : primaryPercent ?? secondaryPercent;
-  const weeklyResetAt = primaryIsMonthly
+  const primaryIsFiveHour = isExplicitFiveHourWindow(primaryWindow);
+  const secondaryIsFiveHour = isExplicitFiveHourWindow(secondaryWindow);
+
+  // Explicit durations win over positional assumptions. This matters because
+  // WHAM has shipped both a legacy primary=weekly shape and a dual-window
+  // primary=5h, secondary=weekly shape over time.
+  let weeklyPercent = primaryIsMonthly ? secondaryPercent : primaryPercent ?? secondaryPercent;
+  let weeklyResetAt = primaryIsMonthly
     ? secondaryResetAt
     : primaryPercent !== undefined ? primaryResetAt : secondaryResetAt;
   const monthlyPercent = primaryIsMonthly ? primaryPercent ?? tertiaryPercent : tertiaryPercent;
   const monthlyResetAt = primaryIsMonthly && primaryPercent !== undefined ? primaryResetAt : tertiaryResetAt;
+  const trackFiveHour = !thirtyDayOnly
+    && (isCodexFiveHourQuotaPlan(data.plan_type)
+      // If WHAM omitted plan_type, an explicit 5h duration is still
+      // unambiguous and should not be discarded from the display contract.
+      || (data.plan_type == null && (primaryIsFiveHour || secondaryIsFiveHour)));
+  let fiveHourPercent = trackFiveHour && primaryIsFiveHour ? primaryPercent : undefined;
+  let fiveHourResetAt = trackFiveHour && primaryIsFiveHour ? primaryResetAt : undefined;
+  if (trackFiveHour && secondaryIsFiveHour && fiveHourPercent === undefined) {
+    fiveHourPercent = secondaryPercent;
+    fiveHourResetAt = secondaryResetAt;
+  }
+  // Older dual-window payloads omitted durations. For Plus/Team/Business,
+  // the primary+secondary pair is the legacy positional 5h+weekly shape.
+  if (trackFiveHour && !primaryIsMonthly && !primaryIsFiveHour
+    && primaryPercent !== undefined && secondaryPercent !== undefined
+    && windowDurationSeconds(primaryWindow) === undefined
+    && windowDurationSeconds(secondaryWindow) === undefined) {
+    fiveHourPercent = primaryPercent;
+    fiveHourResetAt = primaryResetAt;
+    weeklyPercent = secondaryPercent;
+    weeklyResetAt = secondaryResetAt;
+  } else if (trackFiveHour && primaryIsFiveHour) {
+    weeklyPercent = secondaryPercent;
+    weeklyResetAt = secondaryResetAt;
+  }
   if (thirtyDayOnly) {
     if (monthlyPercent !== undefined) {
       quota.monthlyPercent = monthlyPercent;
@@ -401,6 +516,10 @@ export function parseUsageQuota(data: WhamUsageResponse): Omit<StoredAccountQuot
     quota.weeklyPercent = weeklyPercent;
     if (weeklyResetAt !== undefined) quota.weeklyResetAt = weeklyResetAt;
   }
+  if (trackFiveHour && fiveHourPercent !== undefined) {
+    quota.fiveHourPercent = fiveHourPercent;
+    if (fiveHourResetAt !== undefined) quota.fiveHourResetAt = fiveHourResetAt;
+  }
   if (!thirtyDayOnly && monthlyPercent !== undefined) {
     quota.monthlyPercent = monthlyPercent;
     if (monthlyResetAt !== undefined) quota.monthlyResetAt = monthlyResetAt;