feat(codex): auto-resend on usage-quota exhaustion with countdown banner

Detect Codex 5-hour/weekly quota exhaustion from the app-server's structured
signals (error.codexErrorInfo == usageLimitExceeded plus the
account/rateLimits/updated snapshot's reset time), surface a countdown banner in
the Mac and iOS apps, and automatically resend the original user message the
moment the quota window recovers.

- bridge: consume the rate-limit snapshot + usage-limit error in codex_provider;
  stage ProviderRateLimit via take_rate_limit; promote the terminal run_complete
  control to status=rate_limited with a rate_limit payload. Classify only on an
  explicit quota signal, never on bare window saturation.
- models: derive RenderSnapshot.rateLimit from the committed ledger
  (write-then-derive), cleared on run_start/run_interrupted.
- gateway: quota_resend reactor schedules a one-shot, per-thread, restart-safe
  cron resend at reset time; serial in-order scheduling, replays history on
  broadcast lag, and strips followup metadata so resends never nest.
- desktop + mobile: dumb-render a rate-limit banner with a local countdown.

Cross-reviewed by Codex and Claude; addressed prefix-compounding, false-positive
classification, reactor ordering/lag, and stale-stash issues.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: Pyiner

desktop/garyx-desktop/src/renderer/src/app-shell/AppShell.tsx

@@ -2865,6 +2865,7 @@ export function AppShell() {
   // window); the tool shimmer keys off `activeToolGroupId`. assistant_streaming
   // / tool_active are carried by the rows themselves, not a separate bubble.
   const activeToolGroupId = activeRenderState?.activeToolGroupId ?? null;
+  const activeRateLimit = activeRenderState?.rateLimit ?? null;
   const showTailThinking = Boolean(
     activeRenderState?.tailActivity === "thinking" || showPendingAckLoading,
   );
@@ -9822,6 +9823,7 @@ export function AppShell() {
         showDreams={showDreamsFeature}
         showHistoryLoadingPlaceholder={showHistoryLoadingPlaceholder}
         showTailThinking={showTailThinking}
+        rateLimit={activeRateLimit}
         threadLayoutRef={threadLayoutRef}
         threadLayoutStyle={
           !embedded && threadLogsOpen

desktop/garyx-desktop/src/renderer/src/app-shell/components/RateLimitBanner.tsx

@@ -0,0 +1,157 @@
+import { useEffect, useState, type CSSProperties } from "react";
+
+import type { RenderRateLimit } from "@shared/contracts";
+
+import { useI18n } from "../../i18n";
+
+/**
+ * Quota / rate-limit banner rendered at the tail of a thread when its most
+ * recent run terminated because the provider's rolling usage quota was
+ * exhausted. The countdown ticks locally off the server-provided `resetAt`, so
+ * no streaming updates are required. When `willAutoResend` is set the gateway
+ * has scheduled an automatic resend of the original message at reset time.
+ */
+export function RateLimitBanner({
+  rateLimit,
+}: {
+  rateLimit?: RenderRateLimit | null;
+}) {
+  const { t } = useI18n();
+  const [now, setNow] = useState(() => Date.now());
+
+  const resetMs = rateLimit?.resetAt ? Date.parse(rateLimit.resetAt) : Number.NaN;
+  const hasReset = Number.isFinite(resetMs);
+
+  useEffect(() => {
+    if (!rateLimit || !hasReset) {
+      return;
+    }
+    const id = window.setInterval(() => setNow(Date.now()), 1000);
+    return () => window.clearInterval(id);
+  }, [rateLimit, hasReset]);
+
+  if (!rateLimit) {
+    return null;
+  }
+
+  const provider = providerLabel(rateLimit.provider);
+  const windowText = windowLabel(rateLimit.window, t);
+  const remaining = hasReset ? resetMs - now : Number.NaN;
+  const recovered = hasReset && remaining <= 0;
+
+  const title = windowText
+    ? t("{provider} {window} reached")
+        .replace("{provider}", provider)
+        .replace("{window}", windowText)
+    : t("{provider} usage limit reached").replace("{provider}", provider);
+
+  let detail: string;
+  if (rateLimit.willAutoResend) {
+    if (!hasReset) {
+      detail = t("Will auto-resend when the quota recovers.");
+    } else if (recovered) {
+      detail = t("Quota recovered — resending…");
+    } else {
+      detail = t("Auto-resend in {time}").replace(
+        "{time}",
+        formatRemaining(remaining),
+      );
+    }
+  } else if (hasReset && !recovered) {
+    detail = t("Resets in {time}").replace("{time}", formatRemaining(remaining));
+  } else {
+    detail = t("Try again shortly.");
+  }
+
+  return (
+    <article
+      aria-live="polite"
+      className="rate-limit-banner"
+      role="status"
+      style={bannerStyle}
+    >
+      <span style={dotStyle} aria-hidden="true" />
+      <span style={textColumnStyle}>
+        <span style={titleStyle}>{title}</span>
+        <span style={detailStyle}>{detail}</span>
+      </span>
+    </article>
+  );
+}
+
+function providerLabel(provider?: string | null): string {
+  const slug = (provider ?? "").trim().toLowerCase();
+  if (slug.startsWith("codex")) {
+    return "Codex";
+  }
+  if (slug.startsWith("trae")) {
+    return "TRAE";
+  }
+  return provider && provider.trim() ? provider.trim() : "Provider";
+}
+
+function windowLabel(
+  window: string | null | undefined,
+  t: (key: string) => string,
+): string | null {
+  switch (window) {
+    case "primary":
+      return t("5-hour limit");
+    case "secondary":
+      return t("weekly limit");
+    default:
+      return null;
+  }
+}
+
+function formatRemaining(ms: number): string {
+  const total = Math.max(0, Math.floor(ms / 1000));
+  const hours = Math.floor(total / 3600);
+  const minutes = Math.floor((total % 3600) / 60);
+  const seconds = total % 60;
+  const pad = (value: number): string => String(value).padStart(2, "0");
+  return hours > 0
+    ? `${hours}:${pad(minutes)}:${pad(seconds)}`
+    : `${pad(minutes)}:${pad(seconds)}`;
+}
+
+const bannerStyle: CSSProperties = {
+  display: "flex",
+  alignItems: "flex-start",
+  gap: 10,
+  margin: "8px 0",
+  padding: "10px 14px",
+  borderRadius: 10,
+  border: "1px solid #f0e2c4",
+  background: "#fdf6e9",
+  color: "#7a5d1f",
+};
+
+const dotStyle: CSSProperties = {
+  flex: "0 0 auto",
+  width: 8,
+  height: 8,
+  marginTop: 5,
+  borderRadius: "50%",
+  background: "#d99a2b",
+};
+
+const textColumnStyle: CSSProperties = {
+  display: "flex",
+  flexDirection: "column",
+  gap: 2,
+  minWidth: 0,
+};
+
+const titleStyle: CSSProperties = {
+  fontSize: 13,
+  fontWeight: 600,
+  lineHeight: 1.4,
+};
+
+const detailStyle: CSSProperties = {
+  fontSize: 12.5,
+  lineHeight: 1.4,
+  fontVariantNumeric: "tabular-nums",
+  opacity: 0.9,
+};

desktop/garyx-desktop/src/renderer/src/app-shell/components/ThreadPage.tsx

@@ -22,6 +22,7 @@ import type {
   DesktopWorkspace,
   DesktopWorkspaceMode,
   PendingThreadInput,
+  RenderRateLimit,
   RenderState,
   SlashCommand,
   TranscriptMessage,
@@ -34,6 +35,7 @@ import {
   type ComposerWorkflowOption,
 } from "../../ComposerForm";
 import { ComposerQueue } from "../../ComposerQueue";
+import { RateLimitBanner } from "./RateLimitBanner";
 import { NewThreadEmptyState } from "../../NewThreadEmptyState";
 import {
   RichMessageContent,
@@ -308,6 +310,7 @@ type ThreadPageProps = {
   showDreams: boolean;
   showHistoryLoadingPlaceholder: boolean;
   showTailThinking: boolean;
+  rateLimit?: RenderRateLimit | null;
   threadLayoutRef: RefObject<HTMLDivElement | null>;
   threadLayoutStyle?: CSSProperties;
   threadLogsActiveTab: ThreadLogTab;
@@ -491,6 +494,7 @@ export function ThreadPage({
   showDreams,
   showHistoryLoadingPlaceholder,
   showTailThinking,
+  rateLimit,
   threadLayoutRef,
   threadLayoutStyle,
   threadLogsActiveTab,
@@ -955,6 +959,8 @@ export function ThreadPage({
               </div>
             </article>
           ) : null}
+
+          <RateLimitBanner rateLimit={rateLimit} />
           </div>
         ) : null}
 

desktop/garyx-desktop/src/shared/contracts.ts

@@ -1414,6 +1414,14 @@ export interface RenderFilteredPlaceholder {
   reason: RenderPlaceholderFilterReason;
 }
 
+export interface RenderRateLimit {
+  provider?: string | null;
+  resetAt?: string | null;
+  window?: string | null;
+  message?: string | null;
+  willAutoResend: boolean;
+}
+
 export interface RenderState {
   based_on_seq: number;
   rows: RenderRow[];
@@ -1422,6 +1430,7 @@ export interface RenderState {
   progress_locus: RenderProgressLocus;
   visibleMessageIds: string[];
   filtered_placeholders: RenderFilteredPlaceholder[];
+  rateLimit?: RenderRateLimit | null;
 }
 
 export interface CommittedMessageEvent {