@llblab/pi-codex-usage 0.7.0 → 0.8.1

package/BACKLOG.md

@@ -1,3 +1,7 @@
 # Backlog
 
-No open work.
+## Pending Release Verification
+
+- [x] Fix stale extension context usage after session replacement or reload. Source: GitHub issue #1. Timers must not keep using captured stale `ctx` after Pi session lifecycle changes.
+- [x] Make usage refresh cache/in-flight state model-aware for Codex vs Spark. A regular Codex cache or request must not temporarily render Spark as `n/a` after model switching.
+- [x] Preserve the active `codex`/`spark` label for failure states. Spark failures should render `spark n/a` or `spark error`, not `codex ...`.

package/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 ## Unreleased
 
+## 0.8.1: Stale Context Hotfix
+
+- Fixed stale extension context crashes from delayed statusline timers after Pi session replacement or reload. Impact: timers now ignore stale `ctx` failures instead of letting issue #1 crash Pi after idle/session lifecycle changes.
+- Fixed Codex/Spark refresh state to key in-flight usage lookups by active quota bucket and only reuse cached reports that contain the active bucket. Impact: switching between regular Codex and Spark no longer temporarily renders the active bucket as unavailable because of a stale request/cache.
+- Fixed Spark failure labels. Impact: Spark unavailable/error states now render with the `spark` label instead of falling back to `codex`.
+- Added regression coverage for active-bucket cache reuse and stale extension context error detection.
+
+## 0.8.0: Spark Model Usage Status
+
+- Added active-bucket status support for `GPT-5.3-Codex-Spark`. Impact: selecting the Spark Codex subscription model now shows the parallel Spark rate-limit bucket with a `spark` label, while regular Codex models keep the existing `codex` bucket/status behavior.
+- Added parsing for backend `additional_rate_limits`, including the Spark `GPT-5.3-Codex-Spark` / `codex_bengalfox` limit. Impact: Spark quota can be shown from the same Pi-auth usage response path as normal Codex quota instead of relying only on app-server fallback.
+
 ## 0.7.0: Exhausted Quota Visibility
 
 - Added exhausted-quota warning background for the statusline quota bar. Impact: when either the 5-hour or weekly Codex window has 0% remaining, the bar keeps its shape but switches from the selected background to the error background for faster visual detection.

package/README.md

@@ -15,9 +15,11 @@ 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 plus weekly reset countdown drawn on a themed background
-- When `pi-telegram` is available, the same compact value appears as `codex: <value>` in the `/start` menu status text for active OpenAI Codex subscription models
-- Additional returned buckets, including Spark-specific limits, are ignored
+- Statusline output stays compact, with the active usage label accented and the quota bar plus weekly reset countdown drawn on a themed background
+- Regular Codex subscription models show the primary `codex` quota bucket
+- `GPT-5.3-Codex-Spark` shows the parallel Spark quota bucket with the `spark` label
+- When `pi-telegram` is available, the same compact value appears as `codex: <value>` or `spark: <value>` in the `/start` menu status text for active OpenAI Codex subscription models
+- Additional returned buckets unrelated to the active Codex/Spark model are ignored
 - Pi OpenAI Codex provider auth is used first
 - Codex CLI app-server remains available as a fallback
 - Missing auth, subscription, plan, or quota windows are shown as `n/a`, not as an error
@@ -41,12 +43,18 @@ pi install git:github.com/llblab/pi-codex-usage
 
 ## Statusline
 
-Normal usage:
+Regular Codex usage:
 
 ```text
 codex ██████▀▀▀▀ 6d
 ```
 
+Spark model usage:
+
+```text
+spark ██████████ 7d
+```
+
 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. If either quota window is exhausted, the bar keeps the same shape but switches to the error background color.
 
 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`, and `1.1d`, rounded upward to the next tenth. At 24 hours and below it switches to upward-rounded 6-minute hour-tenth steps such as `24h`, `23.7h`, `20.1h`, `20h`, `19.9h`, `1.4h`, `1.3h`, `1.2h`, `1.1h`, and `1h`. Under an hour it switches 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.
@@ -77,9 +85,10 @@ If `@llblab/pi-telegram` is loaded with the public status-line provider API, thi
 
 ```text
 codex: ██████▀▀▀▀ 6d
+spark: ██████████ 7d
 ```
 
-The value is the same compact quota bar plus weekly reset countdown used by the terminal statusline. If `pi-telegram` is absent, older, or the active model is not a Codex subscription model, no Telegram row is added.
+The value is the same compact quota bar plus weekly reset countdown used by the terminal statusline, and the label follows the active Codex/Spark model. If `pi-telegram` is absent, older, or the active model is not a Codex subscription model, no Telegram row is added.
 
 ## Auth
 

package/index.ts

@@ -20,7 +20,11 @@ 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 DEFAULT_STATUS_LABEL_TEXT = "codex";
+const SPARK_STATUS_LABEL_TEXT = "spark";
+const CODEX_USAGE_LIMIT_ID = "codex";
+const SPARK_USAGE_LIMIT_ID = "spark";
+const SPARK_MODEL_KEY = "gpt-5.3-codex-spark";
 const DUAL_BAR_WIDTH = 10;
 const TELEGRAM_STATUS_IMPORT_SPECIFIERS = [
   "@llblab/pi-telegram/status",
@@ -49,7 +53,7 @@ type UsageSource = "pi-auth" | "codex-app-server";
 type TimeoutHandle = ReturnType<typeof setTimeout> & { unref?: () => void };
 type PiModel = NonNullable<ExtensionContext["model"]>;
 export type CodexUsageModel = Pick<PiModel, "id" | "name" | "provider">;
-type CodexUsageTelegramStatusModel = Pick<PiModel, "provider">;
+type CodexUsageTelegramStatusModel = Pick<PiModel, "id" | "name" | "provider">;
 type TelegramStatusLineProviderResult =
   | { label: string; value: string }
   | undefined;
@@ -99,6 +103,13 @@ export type NormalizedRateLimitWindow = {
 
 type RateLimitStatusPayload = {
   rate_limit?: unknown;
+  additional_rate_limits?: unknown;
+};
+
+type BackendAdditionalRateLimit = {
+  limit_name?: unknown;
+  metered_feature?: unknown;
+  rate_limit?: unknown;
 };
 
 type BackendRateLimitDetails = {
@@ -152,7 +163,9 @@ type PendingRpc = {
 export default function codexUsage(pi: ExtensionAPI) {
   let cache: CachedReport | undefined;
   let failedRefreshes = 0;
-  let inFlightUsageQuery: Promise<QueryUsageResult> | undefined;
+  let inFlightUsageQuery:
+    | { limitId: string; promise: Promise<QueryUsageResult> }
+    | undefined;
   let statuslineBlinkTimer: TimeoutHandle | undefined;
   let statuslineClearTimer: TimeoutHandle | undefined;
   let statuslineCountdownTimer: TimeoutHandle | undefined;
@@ -167,8 +180,8 @@ export default function codexUsage(pi: ExtensionAPI) {
       ({ activeModel }) => {
         if (!isOpenAICodexModel(activeModel)) return undefined;
         if (!cache) return undefined;
-        const value = formatCodexUsageStatusValue(cache.report);
-        return value ? { label: "codex", value } : undefined;
+        const value = formatCodexUsageStatusValue(cache.report, activeModel);
+        return value ? { label: activeUsageLabel(activeModel), value } : undefined;
       },
     )
       .then((unregister) => {
@@ -199,8 +212,12 @@ export default function codexUsage(pi: ExtensionAPI) {
   const scheduleTemporaryStatuslineClear = (ctx: ExtensionContext) => {
     if (statuslineClearTimer) clearTimeout(statuslineClearTimer);
     statuslineClearTimer = setTimeout(() => {
-      ctx.ui.setStatus(STATUS_KEY, undefined);
-      statuslineClearTimer = undefined;
+      try {
+        ctx.ui.setStatus(STATUS_KEY, undefined);
+        statuslineClearTimer = undefined;
+      } catch (error) {
+        handleTimerError(error);
+      }
     }, REFRESH_INTERVAL_MS) as TimeoutHandle;
     statuslineClearTimer.unref?.();
   };
@@ -208,7 +225,7 @@ export default function codexUsage(pi: ExtensionAPI) {
   const scheduleStatuslineRefresh = (ctx: ExtensionContext) => {
     if (statuslineRefreshTimer) clearTimeout(statuslineRefreshTimer);
     statuslineRefreshTimer = setTimeout(() => {
-      void refreshCurrentCodexUsageStatusline(ctx, true);
+      void refreshCurrentCodexUsageStatusline(ctx, true).catch(handleAsyncTimerError);
     }, REFRESH_INTERVAL_MS) as TimeoutHandle;
     statuslineRefreshTimer.unref?.();
   };
@@ -219,18 +236,22 @@ export default function codexUsage(pi: ExtensionAPI) {
     model: CodexUsageModel | undefined,
   ) => {
     if (statuslineCountdownTimer) clearTimeout(statuslineCountdownTimer);
-    const delayMs = nextResetCountdownDelayMs(report);
+    const delayMs = nextResetCountdownDelayMs(report, Date.now(), model);
     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);
+      try {
+        if (isOpenAICodexModel(ctx.model)) {
+          ctx.ui.setStatus(
+            STATUS_KEY,
+            formatCodexUsageStatusline(report, ctx, model),
+          );
+          scheduleStatuslineCountdown(ctx, report, model);
+        }
+      } catch (error) {
+        handleTimerError(error);
       }
     }, delayMs) as TimeoutHandle;
     statuslineCountdownTimer.unref?.();
@@ -255,9 +276,13 @@ export default function codexUsage(pi: ExtensionAPI) {
     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;
+        try {
+          ctx.ui.setStatus(STATUS_KEY, text);
+          scheduleStatuslineCountdown(ctx, report, options.model);
+          statuslineBlinkTimer = undefined;
+        } catch (error) {
+          handleTimerError(error);
+        }
       }, REDRAW_BLINK_MS) as TimeoutHandle;
       statuslineBlinkTimer.unref?.();
     } else {
@@ -268,73 +293,91 @@ export default function codexUsage(pi: ExtensionAPI) {
     else scheduleTemporaryStatuslineClear(ctx);
   };
 
-  const queryCurrentUsage = (ctx: ExtensionContext) => {
-    if (!inFlightUsageQuery) {
-      inFlightUsageQuery = queryUsage(ctx, {
-        timeoutMs: DEFAULT_TIMEOUT_MS,
-      }).finally(() => {
-        inFlightUsageQuery = undefined;
-      });
-    }
-    return inFlightUsageQuery;
+  const queryCurrentUsage = (
+    ctx: ExtensionContext,
+    model: CodexUsageModel | undefined,
+  ) => {
+    const limitId = activeUsageLimitId(model);
+    if (inFlightUsageQuery?.limitId === limitId) return inFlightUsageQuery.promise;
+    const promise = queryUsage(
+      ctx,
+      { timeoutMs: DEFAULT_TIMEOUT_MS },
+      model,
+    ).finally(() => {
+      if (inFlightUsageQuery?.promise === promise) inFlightUsageQuery = undefined;
+    });
+    inFlightUsageQuery = { limitId, promise };
+    return promise;
   };
 
   const refreshCurrentCodexUsageStatusline = async (
     ctx: ExtensionContext,
     force: boolean,
-    model = ctx.model,
+    model?: CodexUsageModel,
   ) => {
-    if (!isOpenAICodexModel(model)) {
-      clearUsageStatusline(ctx);
-      return;
-    }
+    try {
+      const activeModel = model ?? ctx.model;
+      if (!isOpenAICodexModel(activeModel)) {
+        clearUsageStatusline(ctx);
+        return;
+      }
 
-    if (!cache) ctx.ui.setStatus(STATUS_KEY, formatEmptyStatuslineBar(ctx));
-    const requestId = statuslineRequestId + 1;
-    statuslineRequestId = requestId;
-    const cached =
-      cache && Date.now() - cache.createdAt < REFRESH_INTERVAL_MS
-        ? cache
-        : undefined;
-    if (cached && !force) {
-      setUsageStatusline(ctx, cached.report, {
-        autoRefresh: true,
-        blink: false,
-        model,
-      });
-      return;
-    }
+      if (!cache) ctx.ui.setStatus(STATUS_KEY, formatEmptyStatuslineBar(ctx));
+      const requestId = statuslineRequestId + 1;
+      statuslineRequestId = requestId;
+      const cached =
+        cache &&
+        Date.now() - cache.createdAt < REFRESH_INTERVAL_MS &&
+        canReuseCachedReport(cache.report, activeModel)
+          ? cache
+          : undefined;
+      if (cached && !force) {
+        setUsageStatusline(ctx, cached.report, {
+          autoRefresh: true,
+          blink: false,
+          model: activeModel,
+        });
+        return;
+      }
 
-    const result = await queryCurrentUsage(ctx);
-    if (requestId !== statuslineRequestId) return;
-    if (!isOpenAICodexModel(ctx.model)) {
-      clearUsageStatusline(ctx);
-      return;
-    }
+      const result = await queryCurrentUsage(ctx, activeModel);
+      if (requestId !== statuslineRequestId) return;
+      if (!isOpenAICodexModel(ctx.model)) {
+        clearUsageStatusline(ctx);
+        return;
+      }
 
-    if (!result.ok) {
-      failedRefreshes += 1;
-      if (!cache || failedRefreshes >= 5) {
-        ctx.ui.setStatus(
-          STATUS_KEY,
-          formatStatuslineProblem(ctx, result.errors),
-        );
+      if (!result.ok) {
+        failedRefreshes += 1;
+        if (!cache || failedRefreshes >= 5) {
+          ctx.ui.setStatus(
+            STATUS_KEY,
+            formatStatuslineProblem(ctx, result.errors, activeModel),
+          );
+        }
+        scheduleStatuslineRefresh(ctx);
+        return;
       }
-      scheduleStatuslineRefresh(ctx);
-      return;
-    }
 
-    const previousReport = cache?.report;
-    const blink = previousReport
-      ? formatReportBar(previousReport) !== formatReportBar(result.report)
-      : false;
-    failedRefreshes = 0;
-    cache = { createdAt: Date.now(), report: result.report };
-    setUsageStatusline(ctx, result.report, {
-      autoRefresh: true,
-      blink,
-      model,
-    });
+      const previousReport = cache?.report;
+      const blink = previousReport
+        ? formatReportBar(previousReport, activeModel) !==
+          formatReportBar(result.report, activeModel)
+        : false;
+      failedRefreshes = 0;
+      cache = { createdAt: Date.now(), report: result.report };
+      setUsageStatusline(ctx, result.report, {
+        autoRefresh: true,
+        blink,
+        model: activeModel,
+      });
+    } catch (error) {
+      if (isStaleExtensionContextError(error)) {
+        clearStatuslineTimers();
+        return;
+      }
+      throw error;
+    }
   };
 
   ensureTelegramStatusLineRegistered();
@@ -342,19 +385,19 @@ export default function codexUsage(pi: ExtensionAPI) {
   pi.on("session_start", (_event, ctx) => {
     ensureTelegramStatusLineRegistered();
     if (isOpenAICodexModel(ctx.model))
-      void refreshCurrentCodexUsageStatusline(ctx, false);
+      void refreshCurrentCodexUsageStatusline(ctx, false).catch(handleAsyncTimerError);
     else clearUsageStatusline(ctx);
   });
 
   pi.on("session_tree", (_event, ctx) => {
     if (isOpenAICodexModel(ctx.model))
-      void refreshCurrentCodexUsageStatusline(ctx, false);
+      void refreshCurrentCodexUsageStatusline(ctx, false).catch(handleAsyncTimerError);
     else clearUsageStatusline(ctx);
   });
 
   pi.on("model_select", (event, ctx) => {
     if (isOpenAICodexModel(event.model)) {
-      void refreshCurrentCodexUsageStatusline(ctx, false, event.model);
+      void refreshCurrentCodexUsageStatusline(ctx, false, event.model).catch(handleAsyncTimerError);
     } else {
       clearUsageStatusline(ctx);
     }
@@ -367,12 +410,45 @@ export default function codexUsage(pi: ExtensionAPI) {
   });
 }
 
+function handleAsyncTimerError(error: unknown): void {
+  handleTimerError(error);
+}
+
+function handleTimerError(error: unknown): void {
+  if (isStaleExtensionContextError(error)) return;
+  throw error;
+}
+
+export function isStaleExtensionContextError(error: unknown): boolean {
+  return error instanceof Error && error.message.includes("ctx is stale");
+}
+
 function isOpenAICodexModel(
   model: Pick<PiModel, "provider"> | undefined,
 ): boolean {
   return model?.provider === CODEX_PROVIDER_ID;
 }
 
+function isSparkCodexModel(
+  model: Pick<PiModel, "id" | "name" | "provider"> | undefined,
+): boolean {
+  if (!isOpenAICodexModel(model)) return false;
+  const key = `${model?.id ?? ""} ${model?.name ?? ""}`.toLowerCase();
+  return key.includes(SPARK_MODEL_KEY);
+}
+
+function activeUsageLimitId(
+  model: Pick<PiModel, "id" | "name" | "provider"> | undefined,
+): string {
+  return isSparkCodexModel(model) ? SPARK_USAGE_LIMIT_ID : CODEX_USAGE_LIMIT_ID;
+}
+
+function activeUsageLabel(
+  model: Pick<PiModel, "id" | "name" | "provider"> | undefined,
+): string {
+  return isSparkCodexModel(model) ? SPARK_STATUS_LABEL_TEXT : DEFAULT_STATUS_LABEL_TEXT;
+}
+
 async function importTelegramStatusLineModule(): Promise<
   TelegramStatusLineModule | undefined
 > {
@@ -401,25 +477,29 @@ async function registerCodexUsageTelegramStatusLine(
 async function queryUsage(
   ctx: ExtensionContext,
   options: Pick<QueryUsageOptions, "timeoutMs">,
+  model: CodexUsageModel | undefined,
 ): Promise<QueryUsageResult> {
   const errors: UsageQueryError[] = [];
+  const sources = isSparkCodexModel(model)
+    ? (["codex-app-server", "pi-auth"] as const)
+    : (["pi-auth", "codex-app-server"] as const);
 
-  try {
-    const report = await queryViaPiAuth(ctx, options.timeoutMs);
-    return { ok: true, report };
-  } catch (cause) {
-    errors.push({ source: "pi-auth", message: errorMessage(cause), cause });
-  }
-
-  try {
-    const report = await queryViaCodexAppServer(options.timeoutMs);
-    return { ok: true, report };
-  } catch (cause) {
-    errors.push({
-      source: "codex-app-server",
-      message: errorMessage(cause),
-      cause,
-    });
+  for (const source of sources) {
+    try {
+      const report =
+        source === "pi-auth"
+          ? await queryViaPiAuth(ctx, options.timeoutMs)
+          : await queryViaCodexAppServer(options.timeoutMs);
+      if (selectUsageSnapshot(report, activeUsageLimitId(model))) {
+        return { ok: true, report };
+      }
+      errors.push({
+        source,
+        message: `${source} returned no displayable ${activeUsageLabel(model)} rate-limit windows`,
+      });
+    } catch (cause) {
+      errors.push({ source, message: errorMessage(cause), cause });
+    }
   }
 
   return { ok: false, errors };
@@ -711,17 +791,42 @@ export function normalizeBackendPayload(
   _capturedAt: number,
   _source: UsageSource,
 ): CodexUsageReport {
-  const snapshot = normalizeBackendSnapshot(
-    "codex",
+  const snapshots: NormalizedRateLimitSnapshot[] = [];
+  const primarySnapshot = normalizeBackendSnapshot(
+    CODEX_USAGE_LIMIT_ID,
     payload.rate_limit,
     _capturedAt,
   );
-  if (!snapshot) {
+  if (primarySnapshot) snapshots.push(primarySnapshot);
+
+  if (Array.isArray(payload.additional_rate_limits)) {
+    for (const item of payload.additional_rate_limits) {
+      const additional = assertObject(
+        item,
+        "additional rate limit",
+      ) as BackendAdditionalRateLimit;
+      const snapshot = normalizeBackendSnapshot(
+        backendAdditionalLimitId(additional),
+        additional.rate_limit,
+        _capturedAt,
+      );
+      if (snapshot) snapshots.push(snapshot);
+    }
+  }
+
+  if (snapshots.length === 0) {
     throw new Error(
       "Codex usage endpoint returned no displayable rate-limit windows.",
     );
   }
-  return { snapshots: [snapshot] };
+  return { snapshots };
+}
+
+function backendAdditionalLimitId(limit: BackendAdditionalRateLimit): string {
+  const raw = `${asString(limit.limit_name) ?? ""} ${asString(limit.metered_feature) ?? ""}`;
+  return raw.toLowerCase().includes("spark")
+    ? SPARK_USAGE_LIMIT_ID
+    : normalizedUsageKey(raw) ?? CODEX_USAGE_LIMIT_ID;
 }
 
 function normalizeBackendSnapshot(
@@ -859,15 +964,16 @@ function mergeSnapshot(
 export function formatCodexUsageStatusline(
   report: CodexUsageReport,
   ctx: ExtensionContext,
-  _model?: CodexUsageModel,
+  model?: CodexUsageModel,
 ): string {
-  const value = formatCodexUsageStatusValue(report);
-  if (!value) return formatStatuslineText(ctx, "n/a");
+  const value = formatCodexUsageStatusValue(report, model);
+  if (!value) return formatStatuslineText(ctx, "n/a", model);
   const [bar, countdown] = value.split(" ", 2);
   const barText = formatStatuslineBarText(
     ctx,
     bar ?? "",
-    hasExhaustedQuotaWindow(report) ? "toolErrorBg" : "selectedBg",
+    hasExhaustedQuotaWindow(report, model) ? "toolErrorBg" : "selectedBg",
+    model,
   );
   return countdown
     ? `${barText} ${ctx.ui.theme.fg("dim", countdown)}`
@@ -882,31 +988,40 @@ export function formatCodexUsageBar(
 
 export function formatCodexUsageStatusValue(
   report: CodexUsageReport,
+  modelOrNow?: CodexUsageModel | number,
   now = Date.now(),
 ): string | undefined {
-  const snapshot = selectPrimaryCodexSnapshot(report);
+  const model = typeof modelOrNow === "number" ? undefined : modelOrNow;
+  const capturedNow = typeof modelOrNow === "number" ? modelOrNow : now;
+  const snapshot = selectActiveUsageSnapshot(report, model);
   if (!snapshot || (!snapshot.primary && !snapshot.secondary)) return undefined;
   const bar = formatDualLimitBar(snapshot.primary, snapshot.secondary);
   if (isQuotaWindowExhausted(snapshot.primary) && snapshot.primary?.resetAt) {
-    const primaryCountdown = formatResetCountdown(snapshot.primary.resetAt, now);
+    const primaryCountdown = formatResetCountdown(
+      snapshot.primary.resetAt,
+      capturedNow,
+    );
     const weeklyCountdown = snapshot.secondary?.resetAt
-      ? formatResetCountdown(snapshot.secondary.resetAt, now)
+      ? formatResetCountdown(snapshot.secondary.resetAt, capturedNow)
       : undefined;
     return weeklyCountdown
       ? `${bar} ${primaryCountdown}/${weeklyCountdown}`
       : `${bar} ${primaryCountdown}`;
   }
-  const countdown = formatWeeklyResetCountdown(report, now);
+  const countdown = formatWeeklyResetCountdown(report, model, capturedNow);
   return countdown ? `${bar} ${countdown}` : bar;
 }
 
 export function formatWeeklyResetCountdown(
   report: CodexUsageReport,
+  modelOrNow?: CodexUsageModel | number,
   now = Date.now(),
 ): string | undefined {
-  const resetAt = selectPrimaryCodexSnapshot(report)?.secondary?.resetAt;
+  const model = typeof modelOrNow === "number" ? undefined : modelOrNow;
+  const capturedNow = typeof modelOrNow === "number" ? modelOrNow : now;
+  const resetAt = selectActiveUsageSnapshot(report, model)?.secondary?.resetAt;
   if (resetAt === undefined) return undefined;
-  return formatResetCountdown(resetAt, now);
+  return formatResetCountdown(resetAt, capturedNow);
 }
 
 export function formatResetCountdown(
@@ -930,8 +1045,9 @@ export function formatResetCountdown(
 export function nextResetCountdownDelayMs(
   report: CodexUsageReport,
   now = Date.now(),
+  model?: CodexUsageModel,
 ): number | undefined {
-  const snapshot = selectPrimaryCodexSnapshot(report);
+  const snapshot = selectActiveUsageSnapshot(report, model);
   const resetTimes = [snapshot?.secondary?.resetAt];
   if (isQuotaWindowExhausted(snapshot?.primary)) {
     resetTimes.push(snapshot?.primary?.resetAt);
@@ -972,14 +1088,21 @@ function formatTenths(value: number): string {
   return value % 10 === 0 ? String(value / 10) : (value / 10).toFixed(1);
 }
 
-function formatReportBar(report: CodexUsageReport): string | undefined {
-  const snapshot = selectPrimaryCodexSnapshot(report);
+function formatReportBar(
+  report: CodexUsageReport,
+  model?: CodexUsageModel,
+): string | undefined {
+  const snapshot = selectActiveUsageSnapshot(report, model);
   if (!snapshot || (!snapshot.primary && !snapshot.secondary)) return undefined;
   return formatDualLimitBar(snapshot.primary, snapshot.secondary);
 }
 
-function formatStatuslineText(ctx: ExtensionContext, value: string): string {
-  const label = ctx.ui.theme.fg("accent", STATUS_LABEL_TEXT);
+function formatStatuslineText(
+  ctx: ExtensionContext,
+  value: string,
+  model?: CodexUsageModel,
+): string {
+  const label = ctx.ui.theme.fg("accent", activeUsageLabel(model));
   return `${label} ${ctx.ui.theme.fg("dim", value)}`;
 }
 
@@ -987,8 +1110,9 @@ function formatStatuslineBarText(
   ctx: ExtensionContext,
   bar: string,
   background: "selectedBg" | "toolErrorBg" = "selectedBg",
+  model?: CodexUsageModel,
 ): string {
-  const label = ctx.ui.theme.fg("accent", STATUS_LABEL_TEXT);
+  const label = ctx.ui.theme.fg("accent", activeUsageLabel(model));
   const value = ctx.ui.theme.bg(background, ctx.ui.theme.fg("dim", bar));
   return `${label} ${value}`;
 }
@@ -1000,8 +1124,9 @@ function formatEmptyStatuslineBar(ctx: ExtensionContext): string {
 function formatStatuslineProblem(
   ctx: ExtensionContext,
   errors: UsageQueryError[],
+  model?: CodexUsageModel,
 ): string {
-  const label = ctx.ui.theme.fg("accent", STATUS_LABEL_TEXT);
+  const label = ctx.ui.theme.fg("accent", activeUsageLabel(model));
   const value = isUsageUnavailable(errors)
     ? ctx.ui.theme.fg("muted", "n/a")
     : ctx.ui.theme.fg("error", "error");
@@ -1030,12 +1155,6 @@ function isUnavailableError(error: UsageQueryError): boolean {
   );
 }
 
-function selectPrimaryCodexSnapshot(
-  report: CodexUsageReport,
-): NormalizedRateLimitSnapshot | undefined {
-  return report.snapshots.find(isPrimaryCodexSnapshot);
-}
-
 function normalizedUsageKey(value: string | undefined): string | undefined {
   const key = value
     ?.toLowerCase()
@@ -1090,18 +1209,39 @@ function isQuotaWindowExhausted(
   return window !== undefined && remainingPercent(window) <= 0;
 }
 
-function hasExhaustedQuotaWindow(report: CodexUsageReport): boolean {
-  const snapshot = selectPrimaryCodexSnapshot(report);
+function hasExhaustedQuotaWindow(
+  report: CodexUsageReport,
+  model?: CodexUsageModel,
+): boolean {
+  const snapshot = selectActiveUsageSnapshot(report, model);
   return (
     isQuotaWindowExhausted(snapshot?.primary) ||
     isQuotaWindowExhausted(snapshot?.secondary)
   );
 }
 
-function isPrimaryCodexSnapshot(
-  snapshot: NormalizedRateLimitSnapshot,
+export function canReuseCachedReport(
+  report: CodexUsageReport,
+  model: CodexUsageModel | undefined,
 ): boolean {
-  return normalizedUsageKey(snapshot.limitId) === "codex";
+  return selectActiveUsageSnapshot(report, model) !== undefined;
+}
+
+function selectActiveUsageSnapshot(
+  report: CodexUsageReport,
+  model: CodexUsageModel | undefined,
+): NormalizedRateLimitSnapshot | undefined {
+  return selectUsageSnapshot(report, activeUsageLimitId(model));
+}
+
+function selectUsageSnapshot(
+  report: CodexUsageReport,
+  limitId: string,
+): NormalizedRateLimitSnapshot | undefined {
+  const normalizedLimitId = normalizedUsageKey(limitId);
+  return report.snapshots.find(
+    (snapshot) => normalizedUsageKey(snapshot.limitId) === normalizedLimitId,
+  );
 }
 
 function clampPercent(value: number): number {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@llblab/pi-codex-usage",
-  "version": "0.7.0",
+  "version": "0.8.1",
   "private": false,
   "description": "Minimal Pi extension that shows primary Codex ChatGPT subscription usage limits.",
   "keywords": [