@llblab/pi-codex-usage 0.4.0 → 0.5.0

package/AGENTS.md

@@ -11,3 +11,7 @@
 - `Compact dual bar`: Encode the 5-hour and weekly quota windows in the ten-character separated-sextant bar.
   - Trigger: Changing statusline formatting.
   - Action: Keep a fixed-width `xxxxxxxxxx` bar where top sextants represent the 5-hour window and bottom sextants represent the weekly window, with 20 steps per window.
+
+- `Weekly reset countdown`: Append the weekly reset countdown only when the secondary window exposes a reset time.
+  - Trigger: Changing reset-time normalization or statusline refresh cadence.
+  - Action: Keep `d` labels rounded upward in 144-minute day-tenth steps, `h`/`m`/`s` labels floored, and hold `0s` until a successful quota refresh reports the next window.

package/BACKLOG.md

@@ -1,4 +1,4 @@
 # Backlog
 
-- [ ] `Runtime smoke test` Verify the extension inside a live Pi session against real Codex auth states: usable subscription, missing auth, missing subscription, and transient network failure.
+- [ ] `Runtime smoke test` Verify the extension inside a live Pi session against missing auth, missing subscription, and transient network failure. Usable subscription with weekly reset countdown has been checked against real Codex auth.
 - [ ] `Statusline polish` Tune the successful-refresh blink duration if the current 150ms redraw feels too visible or too subtle in the Pi footer.

package/CHANGELOG.md

@@ -1,10 +1,31 @@
 # Changelog
 
-- `0.4.0` Expanded the dual statusline bar to ten glyphs with 20 steps per quota window, moved its status key near the start of the footer status order, and draws the bar on the themed selected background. Impact: 5-hour and weekly limits now move in 5% increments for 40 total discrete points while empty cells no longer blend into the terminal background.
-- `0.3.5` Refined the compact statusline bar with quadrant glyphs, darker bar coloring, and blink-on-segment-change behavior. Impact: Codex quota changes are easier to notice while routine refreshes stay visually stable.
-- `0.3.4` Added package banner metadata and README hero image. Impact: Pi/package listings can show the Codex Usage banner while npm packages include the image asset.
-- `Fork baseline` Imported `extensions/pi-codex-usage` from `narumiruna/pi-extensions` as a standalone `@llblab/pi-codex-usage` package. Impact: the extension can be installed and maintained independently.
-- `Minimal statusline` Removed command-driven report output and narrowed the extension to a zero-configuration statusline widget. Impact: runtime behavior is automatic while `openai-codex` is active.
-- `Primary quota focus` Ignored additional returned buckets such as Spark-specific limits. Impact: the statusline only represents primary Codex 5-hour and weekly quota windows.
-- `Dual quota bar` Replaced textual percentages with a fixed-width separated-sextant bar. Impact: both 5-hour and weekly remaining quota are encoded in five statusline characters.
-- `Optimistic refresh` Kept the last good bar during refresh and transient failures, with a short successful-redraw blink. Impact: the footer no longer shifts or collapses during polling.
+## 0.5.0: Weekly Reset Countdown
+
+- Added refresh request coalescing so repeated statusline events share one quota lookup instead of spawning parallel provider/fallback requests. Impact: transient failures and busy session-tree updates no longer amplify Codex usage polling work.
+- Hardened quota parsing and failure classification by accepting array-shaped app-server rate limits, treating `n/a` as valid only when every failed source reports an unavailable auth/plan/quota state, and adding `node:test` coverage for normalization, bar formatting, and failure classification. Impact: real fallback/runtime failures are surfaced as `error` while expected unavailable states still show `n/a`.
+- Added a weekly reset countdown after the quota bar when the secondary Codex window exposes a reset timestamp, including 144-minute day-tenth steps, exact boundary redraw scheduling, hour/minute/second bucket formatting, and `0s` holdover until the next successful quota refresh. Impact: the statusline now shows both remaining quota and time until the weekly bucket cycles.
+
+## 0.4.1: Stable Startup Bar
+
+- Fixed the initial empty statusline bar to use ten non-trimmed blank glyph cells through the same formatting path as the populated quota bar. Impact: the footer background stays at ten cells during startup before the first quota values arrive.
+
+## 0.4.0
+
+- Expanded the dual statusline bar to ten glyphs with 20 steps per quota window, moved its status key near the start of the footer status order, and draws the bar on the themed selected background. Impact: 5-hour and weekly limits now move in 5% increments for 40 total discrete points while empty cells no longer blend into the terminal background.
+
+## 0.3.5
+
+- Refined the compact statusline bar with quadrant glyphs, darker bar coloring, and blink-on-segment-change behavior. Impact: Codex quota changes are easier to notice while routine refreshes stay visually stable.
+
+## 0.3.4
+
+- Added package banner metadata and README hero image. Impact: Pi/package listings can show the Codex Usage banner while npm packages include the image asset.
+
+## Fork baseline
+
+- Imported `extensions/pi-codex-usage` from `narumiruna/pi-extensions` as a standalone `@llblab/pi-codex-usage` package. Impact: the extension can be installed and maintained independently.
+- Removed command-driven report output and narrowed the extension to a zero-configuration statusline widget. Impact: runtime behavior is automatic while `openai-codex` is active.
+- Ignored additional returned buckets such as Spark-specific limits. Impact: the statusline only represents primary Codex 5-hour and weekly quota windows.
+- Replaced textual percentages with a fixed-width separated-sextant bar. Impact: both 5-hour and weekly remaining quota are encoded in five statusline characters.
+- Kept the last good bar during refresh and transient failures, with a short successful-redraw blink. Impact: the footer no longer shifts or collapses during polling.

package/README.md

@@ -15,7 +15,7 @@ This repository is a minimal fork of [`narumiruna/pi-extensions/extensions/pi-co
 ## Features
 
 - Shows an empty statusline bar immediately, then refreshes every 30 seconds while the active Pi model uses `openai-codex`
-- Statusline output stays compact, with the `codex` label accented and the quota bar drawn on a themed background
+- Statusline output stays compact, with the `codex` label accented and the quota bar plus weekly reset countdown drawn on a themed background
 - Additional returned buckets, including Spark-specific limits, are ignored
 - Pi OpenAI Codex provider auth is used first
 - Codex CLI app-server remains available as a fallback
@@ -43,11 +43,13 @@ pi install git:github.com/llblab/pi-codex-usage
 Normal usage:
 
 ```text
-codex ██████▀▀▀▀
+codex ██████▀▀▀▀ 6d
 ```
 
 The ten-character bar encodes two twenty-step limits at once: 40 total bits of quota state in 10 terminal cells. Each step is 5%: the top quadrants are the 5-hour limit, and the bottom quadrants are the weekly limit.
 
+When the weekly reset time is available, the bar is followed by a countdown. More than a day remains is shown in 144-minute day-tenth steps such as `7d`, `6.9d`, `6.6d`, `5.1d`, `5d`, `3.7d`, `3d`, `2d`, `1.9d`, `1.5d`, `1.1d`, and `1d`, rounded upward to the next tenth. Under a day it switches to floored hours, under an hour to floored minutes, and under a minute to seconds. After the reset timestamp passes, `0s` is held until the next successful quota refresh reports the new weekly window.
+
 Unavailable because Codex auth or subscription quota is not available:
 
 ```text

package/index.ts

@@ -9,13 +9,19 @@ import type {
 const CODEX_PROVIDER_ID = "openai-codex";
 const CODEX_USAGE_URL = "https://chatgpt.com/backend-api/wham/usage";
 const DEFAULT_TIMEOUT_MS = 15_000;
-const REFRESH_INTERVAL_MS = 30 * 1000;
+const SECOND_MS = 1000;
+const MINUTE_MS = 60 * SECOND_MS;
+const HOUR_MS = 60 * MINUTE_MS;
+const DAY_MS = 24 * HOUR_MS;
+const DAY_TENTH_MS = 144 * MINUTE_MS;
+const REFRESH_INTERVAL_MS = 30 * SECOND_MS;
 const REDRAW_BLINK_MS = 150;
 const STATUS_KEY = "aa-codex-usage";
 const MAX_ERROR_BODY_CHARS = 600;
 const STATUS_LABEL_TEXT = "codex";
+const DUAL_BAR_WIDTH = 10;
 const DUAL_BAR_CHARS = [
-  " ",
+  "⠀",
   "▘",
   "▝",
   "▀",
@@ -51,7 +57,7 @@ type QueryUsageResult =
   | { ok: true; report: CodexUsageReport }
   | { ok: false; errors: UsageQueryError[] };
 
-type UsageQueryError = {
+export type UsageQueryError = {
   source: UsageSource;
   message: string;
   cause?: unknown;
@@ -69,6 +75,7 @@ export type NormalizedRateLimitSnapshot = {
 
 export type NormalizedRateLimitWindow = {
   usedPercent: number;
+  resetAt?: number;
 };
 
 type RateLimitStatusPayload = {
@@ -82,6 +89,13 @@ type BackendRateLimitDetails = {
 
 type BackendWindowSnapshot = {
   used_percent?: unknown;
+  reset_at?: unknown;
+  resets_at?: unknown;
+  reset_time?: unknown;
+  end_time?: unknown;
+  ends_at?: unknown;
+  expires_at?: unknown;
+  reset_after_seconds?: unknown;
 };
 
 type AppServerRateLimitResponse = {
@@ -96,6 +110,13 @@ type AppServerRateLimitSnapshot = {
 
 type AppServerWindowSnapshot = {
   usedPercent?: unknown;
+  resetAt?: unknown;
+  resetsAt?: unknown;
+  resetTime?: unknown;
+  endTime?: unknown;
+  endsAt?: unknown;
+  expiresAt?: unknown;
+  resetAfterSeconds?: unknown;
 };
 
 type RpcResponse = {
@@ -112,17 +133,21 @@ type PendingRpc = {
 export default function codexUsage(pi: ExtensionAPI) {
   let cache: CachedReport | undefined;
   let failedRefreshes = 0;
+  let inFlightUsageQuery: Promise<QueryUsageResult> | undefined;
   let statuslineBlinkTimer: TimeoutHandle | undefined;
   let statuslineClearTimer: TimeoutHandle | undefined;
+  let statuslineCountdownTimer: TimeoutHandle | undefined;
   let statuslineRefreshTimer: TimeoutHandle | undefined;
   let statuslineRequestId = 0;
 
   const clearStatuslineTimers = () => {
     if (statuslineBlinkTimer) clearTimeout(statuslineBlinkTimer);
     if (statuslineClearTimer) clearTimeout(statuslineClearTimer);
+    if (statuslineCountdownTimer) clearTimeout(statuslineCountdownTimer);
     if (statuslineRefreshTimer) clearTimeout(statuslineRefreshTimer);
     statuslineBlinkTimer = undefined;
     statuslineClearTimer = undefined;
+    statuslineCountdownTimer = undefined;
     statuslineRefreshTimer = undefined;
   };
 
@@ -149,6 +174,29 @@ export default function codexUsage(pi: ExtensionAPI) {
     statuslineRefreshTimer.unref?.();
   };
 
+  const scheduleStatuslineCountdown = (
+    ctx: ExtensionContext,
+    report: CodexUsageReport,
+    model: CodexUsageModel | undefined,
+  ) => {
+    if (statuslineCountdownTimer) clearTimeout(statuslineCountdownTimer);
+    const delayMs = nextResetCountdownDelayMs(report);
+    if (delayMs === undefined) {
+      statuslineCountdownTimer = undefined;
+      return;
+    }
+    statuslineCountdownTimer = setTimeout(() => {
+      if (isOpenAICodexModel(ctx.model)) {
+        ctx.ui.setStatus(
+          STATUS_KEY,
+          formatCodexUsageStatusline(report, ctx, model),
+        );
+        scheduleStatuslineCountdown(ctx, report, model);
+      }
+    }, delayMs) as TimeoutHandle;
+    statuslineCountdownTimer.unref?.();
+  };
+
   const setUsageStatusline = (
     ctx: ExtensionContext,
     report: CodexUsageReport,
@@ -160,23 +208,38 @@ export default function codexUsage(pi: ExtensionAPI) {
   ) => {
     if (statuslineBlinkTimer) clearTimeout(statuslineBlinkTimer);
     if (statuslineClearTimer) clearTimeout(statuslineClearTimer);
+    if (statuslineCountdownTimer) clearTimeout(statuslineCountdownTimer);
     statuslineBlinkTimer = undefined;
     statuslineClearTimer = undefined;
+    statuslineCountdownTimer = undefined;
     const text = formatCodexUsageStatusline(report, ctx, options.model);
     if (options.blink) {
       ctx.ui.setStatus(STATUS_KEY, formatEmptyStatuslineBar(ctx));
       statuslineBlinkTimer = setTimeout(() => {
         ctx.ui.setStatus(STATUS_KEY, text);
+        scheduleStatuslineCountdown(ctx, report, options.model);
         statuslineBlinkTimer = undefined;
       }, REDRAW_BLINK_MS) as TimeoutHandle;
       statuslineBlinkTimer.unref?.();
     } else {
       ctx.ui.setStatus(STATUS_KEY, text);
+      scheduleStatuslineCountdown(ctx, report, options.model);
     }
     if (options.autoRefresh) scheduleStatuslineRefresh(ctx);
     else scheduleTemporaryStatuslineClear(ctx);
   };
 
+  const queryCurrentUsage = (ctx: ExtensionContext) => {
+    if (!inFlightUsageQuery) {
+      inFlightUsageQuery = queryUsage(ctx, {
+        timeoutMs: DEFAULT_TIMEOUT_MS,
+      }).finally(() => {
+        inFlightUsageQuery = undefined;
+      });
+    }
+    return inFlightUsageQuery;
+  };
+
   const refreshCurrentCodexUsageStatusline = async (
     ctx: ExtensionContext,
     force: boolean,
@@ -203,7 +266,7 @@ export default function codexUsage(pi: ExtensionAPI) {
       return;
     }
 
-    const result = await queryUsage(ctx, { timeoutMs: DEFAULT_TIMEOUT_MS });
+    const result = await queryCurrentUsage(ctx);
     if (requestId !== statuslineRequestId) return;
     if (!isOpenAICodexModel(ctx.model)) {
       clearUsageStatusline(ctx);
@@ -577,7 +640,11 @@ export function normalizeBackendPayload(
   _capturedAt: number,
   _source: UsageSource,
 ): CodexUsageReport {
-  const snapshot = normalizeBackendSnapshot("codex", payload.rate_limit);
+  const snapshot = normalizeBackendSnapshot(
+    "codex",
+    payload.rate_limit,
+    _capturedAt,
+  );
   if (!snapshot) {
     throw new Error(
       "Codex usage endpoint returned no displayable rate-limit windows.",
@@ -589,20 +656,25 @@ export function normalizeBackendPayload(
 function normalizeBackendSnapshot(
   limitId: string,
   rateLimit: unknown,
+  capturedAt: number,
 ): NormalizedRateLimitSnapshot | undefined {
   if (rateLimit === null || rateLimit === undefined) return undefined;
   const details = assertObject(
     rateLimit,
     "rate limit",
   ) as BackendRateLimitDetails;
-  const primary = normalizeBackendWindow(details.primary_window);
-  const secondary = normalizeBackendWindow(details.secondary_window);
+  const primary = normalizeBackendWindow(details.primary_window, capturedAt);
+  const secondary = normalizeBackendWindow(
+    details.secondary_window,
+    capturedAt,
+  );
   if (!primary && !secondary) return undefined;
   return { limitId, primary, secondary };
 }
 
 function normalizeBackendWindow(
   value: unknown,
+  capturedAt: number,
 ): NormalizedRateLimitWindow | undefined {
   if (value === null || value === undefined) return undefined;
   const window = assertObject(
@@ -611,7 +683,19 @@ function normalizeBackendWindow(
   ) as BackendWindowSnapshot;
   const usedPercent = asNumber(window.used_percent);
   if (usedPercent === undefined) return undefined;
-  return { usedPercent };
+  const resetAt = asResetTime(
+    [
+      window.reset_at,
+      window.resets_at,
+      window.reset_time,
+      window.end_time,
+      window.ends_at,
+      window.expires_at,
+    ],
+    window.reset_after_seconds,
+    capturedAt,
+  );
+  return resetAt === undefined ? { usedPercent } : { usedPercent, resetAt };
 }
 
 export function normalizeAppServerResponse(
@@ -620,7 +704,7 @@ export function normalizeAppServerResponse(
 ): CodexUsageReport {
   const snapshots: NormalizedRateLimitSnapshot[] = [];
   const addSnapshot = (raw: unknown, fallbackId: string) => {
-    const snapshot = normalizeAppServerSnapshot(raw, fallbackId);
+    const snapshot = normalizeAppServerSnapshot(raw, fallbackId, _capturedAt);
     if (!snapshot) return;
     const existingIndex = snapshots.findIndex(
       (item) => item.limitId === snapshot.limitId,
@@ -633,7 +717,11 @@ export function normalizeAppServerResponse(
     else snapshots.push(snapshot);
   };
 
-  addSnapshot(response.rateLimits, "codex");
+  if (Array.isArray(response.rateLimits)) {
+    for (const item of response.rateLimits) addSnapshot(item, "codex");
+  } else {
+    addSnapshot(response.rateLimits, "codex");
+  }
   if (snapshots.length === 0) {
     throw new Error(
       "codex app-server returned no displayable rate-limit windows.",
@@ -646,6 +734,7 @@ export function normalizeAppServerResponse(
 function normalizeAppServerSnapshot(
   raw: unknown,
   fallbackId: string,
+  capturedAt: number,
 ): NormalizedRateLimitSnapshot | undefined {
   if (raw === null || raw === undefined) return undefined;
   const snapshot = assertObject(
@@ -653,14 +742,15 @@ function normalizeAppServerSnapshot(
     "app-server rate-limit snapshot",
   ) as AppServerRateLimitSnapshot;
   const limitId = asString(snapshot.limitId) ?? fallbackId;
-  const primary = normalizeAppServerWindow(snapshot.primary);
-  const secondary = normalizeAppServerWindow(snapshot.secondary);
+  const primary = normalizeAppServerWindow(snapshot.primary, capturedAt);
+  const secondary = normalizeAppServerWindow(snapshot.secondary, capturedAt);
   if (!primary && !secondary) return undefined;
   return { limitId, primary, secondary };
 }
 
 function normalizeAppServerWindow(
   value: unknown,
+  capturedAt: number,
 ): NormalizedRateLimitWindow | undefined {
   if (value === null || value === undefined) return undefined;
   const window = assertObject(
@@ -669,7 +759,19 @@ function normalizeAppServerWindow(
   ) as AppServerWindowSnapshot;
   const usedPercent = asNumber(window.usedPercent);
   if (usedPercent === undefined) return undefined;
-  return { usedPercent };
+  const resetAt = asResetTime(
+    [
+      window.resetAt,
+      window.resetsAt,
+      window.resetTime,
+      window.endTime,
+      window.endsAt,
+      window.expiresAt,
+    ],
+    window.resetAfterSeconds,
+    capturedAt,
+  );
+  return resetAt === undefined ? { usedPercent } : { usedPercent, resetAt };
 }
 
 function mergeSnapshot(
@@ -689,7 +791,81 @@ export function formatCodexUsageStatusline(
   _model?: CodexUsageModel,
 ): string {
   const bar = formatReportBar(report);
-  return bar ? formatStatuslineBarText(ctx, bar) : formatStatuslineText(ctx, "n/a");
+  if (!bar) return formatStatuslineText(ctx, "n/a");
+  const countdown = formatWeeklyResetCountdown(report);
+  const barText = formatStatuslineBarText(ctx, bar);
+  return countdown
+    ? `${barText} ${ctx.ui.theme.fg("dim", countdown)}`
+    : barText;
+}
+
+export function formatCodexUsageBar(
+  report: CodexUsageReport,
+): string | undefined {
+  return formatReportBar(report);
+}
+
+export function formatWeeklyResetCountdown(
+  report: CodexUsageReport,
+  now = Date.now(),
+): string | undefined {
+  const resetAt = selectPrimaryCodexSnapshot(report)?.secondary?.resetAt;
+  if (resetAt === undefined) return undefined;
+  return formatResetCountdown(resetAt, now);
+}
+
+export function formatResetCountdown(
+  resetAt: number,
+  now = Date.now(),
+): string {
+  const remainingMs = Math.max(0, resetAt - now);
+  if (remainingMs >= DAY_MS) {
+    const dayTenths = Math.max(10, Math.ceil(remainingMs / DAY_TENTH_MS));
+    return `${formatTenths(dayTenths)}d`;
+  }
+  if (remainingMs >= HOUR_MS) return `${Math.floor(remainingMs / HOUR_MS)}h`;
+  if (remainingMs >= MINUTE_MS)
+    return `${Math.floor(remainingMs / MINUTE_MS)}m`;
+  return `${Math.floor(remainingMs / SECOND_MS)}s`;
+}
+
+export function nextResetCountdownDelayMs(
+  report: CodexUsageReport,
+  now = Date.now(),
+): number | undefined {
+  const resetAt = selectPrimaryCodexSnapshot(report)?.secondary?.resetAt;
+  if (resetAt === undefined) return undefined;
+  return nextResetCountdownDelayForRemainingMs(resetAt - now);
+}
+
+export function nextResetCountdownDelayForRemainingMs(
+  remainingMs: number,
+): number | undefined {
+  if (remainingMs <= 0) return undefined;
+  if (remainingMs >= DAY_MS) {
+    const dayTenths = Math.max(10, Math.ceil(remainingMs / DAY_TENTH_MS));
+    return Math.max(1, remainingMs - (dayTenths - 1) * DAY_TENTH_MS);
+  }
+  if (remainingMs >= HOUR_MS) {
+    return Math.max(
+      1,
+      remainingMs - Math.floor(remainingMs / HOUR_MS) * HOUR_MS + 1,
+    );
+  }
+  if (remainingMs >= MINUTE_MS) {
+    return Math.max(
+      1,
+      remainingMs - Math.floor(remainingMs / MINUTE_MS) * MINUTE_MS + 1,
+    );
+  }
+  return Math.max(
+    1,
+    remainingMs - Math.floor(remainingMs / SECOND_MS) * SECOND_MS + 1,
+  );
+}
+
+function formatTenths(value: number): string {
+  return value % 10 === 0 ? String(value / 10) : (value / 10).toFixed(1);
 }
 
 function formatReportBar(report: CodexUsageReport): string | undefined {
@@ -705,18 +881,12 @@ function formatStatuslineText(ctx: ExtensionContext, value: string): string {
 
 function formatStatuslineBarText(ctx: ExtensionContext, bar: string): string {
   const label = ctx.ui.theme.fg("accent", STATUS_LABEL_TEXT);
-  const value = ctx.ui.theme.bg(
-    "selectedBg",
-    ctx.ui.theme.fg("dim", bar),
-  );
+  const value = ctx.ui.theme.bg("selectedBg", ctx.ui.theme.fg("dim", bar));
   return `${label} ${value}`;
 }
 
 function formatEmptyStatuslineBar(ctx: ExtensionContext): string {
-  return formatStatuslineBarText(
-    ctx,
-    "\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0",
-  );
+  return formatStatuslineBarText(ctx, DUAL_BAR_CHARS[0].repeat(DUAL_BAR_WIDTH));
 }
 
 function formatStatuslineProblem(
@@ -724,30 +894,32 @@ function formatStatuslineProblem(
   errors: UsageQueryError[],
 ): string {
   const label = ctx.ui.theme.fg("accent", STATUS_LABEL_TEXT);
-  const value = isUnavailable(errors)
+  const value = isUsageUnavailable(errors)
     ? ctx.ui.theme.fg("muted", "n/a")
     : ctx.ui.theme.fg("error", "error");
   return `${label} ${value}`;
 }
 
-function isUnavailable(errors: UsageQueryError[]): boolean {
-  return errors.some((error) => {
-    const message = error.message.toLowerCase();
-    return (
-      message.includes("no pi openai codex subscription auth") ||
-      message.includes("no displayable rate-limit windows") ||
-      message.includes("returned no displayable rate-limit windows") ||
-      message.includes("returned 401") ||
-      message.includes("returned 403") ||
-      message.includes("unauthorized") ||
-      message.includes("forbidden") ||
-      message.includes("subscription") ||
-      message.includes("no active plan") ||
-      message.includes("plan unavailable") ||
-      message.includes("quota unavailable") ||
-      message.includes("rate limits unavailable")
-    );
-  });
+export function isUsageUnavailable(errors: UsageQueryError[]): boolean {
+  return errors.length > 0 && errors.every(isUnavailableError);
+}
+
+function isUnavailableError(error: UsageQueryError): boolean {
+  const message = error.message.toLowerCase();
+  return (
+    message.includes("no pi openai codex subscription auth") ||
+    message.includes("no displayable rate-limit windows") ||
+    message.includes("returned no displayable rate-limit windows") ||
+    message.includes("returned 401") ||
+    message.includes("returned 403") ||
+    message.includes("unauthorized") ||
+    message.includes("forbidden") ||
+    message.includes("subscription") ||
+    message.includes("no active plan") ||
+    message.includes("plan unavailable") ||
+    message.includes("quota unavailable") ||
+    message.includes("rate limits unavailable")
+  );
 }
 
 function selectPrimaryCodexSnapshot(
@@ -771,7 +943,7 @@ function formatDualLimitBar(
   const primaryParts = filledTwentieths(primary);
   const secondaryParts = filledTwentieths(secondary);
   let value = "";
-  for (let index = 0; index < 10; index++) {
+  for (let index = 0; index < DUAL_BAR_WIDTH; index++) {
     const leftPart = index * 2 + 1;
     const rightPart = leftPart + 1;
     let mask = 0;
@@ -784,7 +956,9 @@ function formatDualLimitBar(
   return value;
 }
 
-function filledTwentieths(window: NormalizedRateLimitWindow | undefined): number {
+function filledTwentieths(
+  window: NormalizedRateLimitWindow | undefined,
+): number {
   if (!window) return 0;
   return Math.round(remainingPercent(window) / 5);
 }
@@ -842,6 +1016,34 @@ function asNumber(value: unknown): number | undefined {
   return undefined;
 }
 
+function asResetTime(
+  absoluteValues: unknown[],
+  relativeSeconds: unknown,
+  capturedAt: number,
+): number | undefined {
+  for (const value of absoluteValues) {
+    const timestamp = asTimestampMs(value);
+    if (timestamp !== undefined) return timestamp;
+  }
+  const seconds = asNumber(relativeSeconds);
+  if (seconds === undefined || seconds < 0) return undefined;
+  return capturedAt + seconds * SECOND_MS;
+}
+
+function asTimestampMs(value: unknown): number | undefined {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    if (value <= 0) return undefined;
+    return value < 10_000_000_000 ? value * SECOND_MS : value;
+  }
+  if (typeof value === "string" && value.trim()) {
+    const numeric = Number(value);
+    if (Number.isFinite(numeric)) return asTimestampMs(numeric);
+    const parsed = Date.parse(value);
+    return Number.isFinite(parsed) ? parsed : undefined;
+  }
+  return undefined;
+}
+
 function hasHeader(headers: Record<string, string>, name: string): boolean {
   return Object.keys(headers).some(
     (key) => key.toLowerCase() === name.toLowerCase(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@llblab/pi-codex-usage",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "private": false,
   "description": "Minimal Pi extension that shows primary Codex ChatGPT subscription usage limits.",
   "keywords": [
@@ -26,9 +26,10 @@
   },
   "scripts": {
     "check": "node --experimental-strip-types -e \"await import('./index.ts'); console.log('pi-codex-usage: extension import ok')\"",
+    "test": "node --experimental-strip-types --test test/*.test.ts",
     "typecheck": "tsc --noEmit",
     "pack:dry": "npm pack --dry-run",
-    "validate": "npm run typecheck && npm run check && npm run pack:dry"
+    "validate": "npm run typecheck && npm run test && npm run check && npm run pack:dry"
   },
   "files": [
     "index.ts",