@llblab/pi-codex-usage 0.4.1 → 0.5.1

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,5 +1,17 @@
 # Changelog
 
+## Unreleased
+
+## 0.5.1: Non-Codex Bucket Hotfix
+
+- Fixed non-Codex app-server quota buckets so Spark-only or unrelated limits are ignored instead of being displayed as Codex quota.
+
+## 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.

package/README.md

@@ -4,7 +4,7 @@
 
 ![Codex Usage](./banner.png)
 
-This repository is a minimal fork of [`narumiruna/pi-extensions/extensions/pi-codex-usage`](https://github.com/narumiruna/pi-extensions/tree/main/extensions/pi-codex-usage). It keeps the auth and quota-fetching path, but intentionally narrows the interface to the primary Codex 5-hour and weekly windows.
+This repository is a minimal fork of [`narumiruna/pi-extensions/extensions/pi-codex-usage`](https://github.com/narumiruna/pi-extensions/tree/main/extensions/pi-codex-usage). It keeps the auth and quota-fetching path, but intentionally narrows the interface to the primary Codex 5-hour and weekly limits.
 
 ## Start Here
 
@@ -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,7 +9,12 @@ 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;
@@ -52,7 +57,7 @@ type QueryUsageResult =
   | { ok: true; report: CodexUsageReport }
   | { ok: false; errors: UsageQueryError[] };
 
-type UsageQueryError = {
+export type UsageQueryError = {
   source: UsageSource;
   message: string;
   cause?: unknown;
@@ -70,6 +75,7 @@ export type NormalizedRateLimitSnapshot = {
 
 export type NormalizedRateLimitWindow = {
   usedPercent: number;
+  resetAt?: number;
 };
 
 type RateLimitStatusPayload = {
@@ -83,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 = {
@@ -97,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 = {
@@ -113,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;
   };
 
@@ -150,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,
@@ -161,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,
@@ -204,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);
@@ -578,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.",
@@ -590,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(
@@ -612,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(
@@ -621,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,
@@ -634,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.",
@@ -647,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(
@@ -654,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(
@@ -670,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(
@@ -690,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 {
@@ -706,10 +881,7 @@ 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}`;
 }
 
@@ -722,36 +894,38 @@ 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(
   report: CodexUsageReport,
 ): NormalizedRateLimitSnapshot | undefined {
-  return report.snapshots.find(isPrimaryCodexSnapshot) ?? report.snapshots[0];
+  return report.snapshots.find(isPrimaryCodexSnapshot);
 }
 
 function normalizedUsageKey(value: string | undefined): string | undefined {
@@ -782,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);
 }
@@ -840,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.1",
+  "version": "0.5.1",
   "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",