@llblab/pi-codex-usage 0.8.0 → 0.8.2

package/BACKLOG.md

@@ -1,3 +1,8 @@
 # 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 ...`.
+- [x] Replace the visually full startup/request placeholder with counter-moving upper/lower in-bar loading markers. Keep the last usable active-bucket bar visible during ordinary refreshes, and hold provisional zero-usage reports behind the loader until confirmed stable.

package/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 ## Unreleased
 
+## 0.8.2: Quota Loading Hotfix
+
+- Replaced the static empty request placeholder with fixed-width upper and lower markers that move in opposite directions through their respective quota bars, reverse at the ends, and randomly start from either mirrored endpoint phase, using the normal themed bar background. Impact: motion distinguishes startup and model-bucket loading from 100% available quota while preserving the dual-window visual language.
+- Kept the last usable active-bucket report visible while refreshing, including when returning from another model bucket, and stabilized first reports claiming both windows are completely unused for 15 seconds with one-second retries. Impact: routine polling remains visually stable while transient provider initialization values stay behind the loader instead of appearing as false 100% availability.
+
+## 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.

package/README.md

@@ -14,7 +14,8 @@ 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`
+- Shows two counter-moving half-height markers in the statusline bar while the active Codex/Spark quota bucket is loading, then refreshes every 30 seconds
+- Keeps the last usable active-bucket bar visible during ordinary refreshes instead of replacing known quota with a loading state
 - 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
@@ -57,6 +58,8 @@ 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.
 
+Before the first usable report for the active quota bucket arrives, two half-height markers move through the same fixed-width themed bar. The upper 5-hour marker travels opposite the lower weekly marker; both reverse smoothly at the ends, and each loader run randomly starts from one of the two mirrored endpoint phases. Their motion distinguishes loading from 100% remaining quota while preserving the normal bar background. A first report claiming both windows are completely unused is treated as provisional for 15 seconds and retried every second, because providers can briefly emit zeroed windows while initializing. Once a usable report exists, refresh requests preserve that last good bar.
+
 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.
 
 When the 5-hour window is exhausted and exposes its own reset time, the statusline adds the 5-hour reset before the weekly reset:

package/index.ts

@@ -17,6 +17,9 @@ const HOUR_TENTH_MS = 6 * MINUTE_MS;
 const DAY_MS = 24 * HOUR_MS;
 const DAY_TENTH_MS = 144 * MINUTE_MS;
 const REFRESH_INTERVAL_MS = 30 * SECOND_MS;
+const PROVISIONAL_RETRY_MS = SECOND_MS;
+const FULL_AVAILABILITY_CONFIRMATION_MS = 15 * SECOND_MS;
+const LOADING_FRAME_MS = 30;
 const REDRAW_BLINK_MS = 150;
 const STATUS_KEY = "aa-codex-usage";
 const MAX_ERROR_BODY_CHARS = 600;
@@ -55,8 +58,7 @@ type PiModel = NonNullable<ExtensionContext["model"]>;
 export type CodexUsageModel = Pick<PiModel, "id" | "name" | "provider">;
 type CodexUsageTelegramStatusModel = Pick<PiModel, "id" | "name" | "provider">;
 type TelegramStatusLineProviderResult =
-  | { label: string; value: string }
-  | undefined;
+  { label: string; value: string } | undefined;
 type TelegramStatusLineProvider = (ctx: {
   activeModel?: CodexUsageTelegramStatusModel;
 }) => TelegramStatusLineProviderResult;
@@ -163,12 +165,18 @@ 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;
+  let statuslineLoadingTimer: TimeoutHandle | undefined;
   let statuslineRefreshTimer: TimeoutHandle | undefined;
+  let statuslineLoadingFrame = 0;
+  let statuslineLoadingLimitId: string | undefined;
   let statuslineRequestId = 0;
+  let provisionalFullReport:
+    { limitId: string; firstSeenAt: number } | undefined;
   let unregisterTelegramStatusLine: (() => void) | undefined;
   let telegramStatusLineRegistration: Promise<void> | undefined;
 
@@ -179,7 +187,9 @@ export default function codexUsage(pi: ExtensionAPI) {
         if (!isOpenAICodexModel(activeModel)) return undefined;
         if (!cache) return undefined;
         const value = formatCodexUsageStatusValue(cache.report, activeModel);
-        return value ? { label: activeUsageLabel(activeModel), value } : undefined;
+        return value
+          ? { label: activeUsageLabel(activeModel), value }
+          : undefined;
       },
     )
       .then((unregister) => {
@@ -194,13 +204,51 @@ export default function codexUsage(pi: ExtensionAPI) {
     if (statuslineBlinkTimer) clearTimeout(statuslineBlinkTimer);
     if (statuslineClearTimer) clearTimeout(statuslineClearTimer);
     if (statuslineCountdownTimer) clearTimeout(statuslineCountdownTimer);
+    if (statuslineLoadingTimer) clearTimeout(statuslineLoadingTimer);
     if (statuslineRefreshTimer) clearTimeout(statuslineRefreshTimer);
     statuslineBlinkTimer = undefined;
     statuslineClearTimer = undefined;
     statuslineCountdownTimer = undefined;
+    statuslineLoadingTimer = undefined;
+    statuslineLoadingLimitId = undefined;
     statuslineRefreshTimer = undefined;
   };
 
+  const stopStatuslineLoading = () => {
+    if (statuslineLoadingTimer) clearTimeout(statuslineLoadingTimer);
+    statuslineLoadingTimer = undefined;
+    statuslineLoadingLimitId = undefined;
+  };
+
+  const startStatuslineLoading = (
+    ctx: ExtensionContext,
+    model: CodexUsageModel | undefined,
+  ) => {
+    const limitId = activeUsageLimitId(model);
+    if (statuslineLoadingTimer && statuslineLoadingLimitId === limitId) return;
+    stopStatuslineLoading();
+    statuslineLoadingFrame = Math.random() < 0.5 ? 0 : DUAL_BAR_WIDTH * 2 - 1;
+    statuslineLoadingLimitId = limitId;
+    const drawNextFrame = () => {
+      try {
+        ctx.ui.setStatus(
+          STATUS_KEY,
+          formatStatuslineLoading(ctx, statuslineLoadingFrame, model),
+        );
+        statuslineLoadingFrame += 1;
+        statuslineLoadingTimer = setTimeout(
+          drawNextFrame,
+          LOADING_FRAME_MS,
+        ) as TimeoutHandle;
+        statuslineLoadingTimer.unref?.();
+      } catch (error) {
+        statuslineLoadingTimer = undefined;
+        handleTimerError(error);
+      }
+    };
+    drawNextFrame();
+  };
+
   const clearUsageStatusline = (ctx: ExtensionContext) => {
     statuslineRequestId += 1;
     clearStatuslineTimers();
@@ -210,17 +258,26 @@ 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?.();
   };
 
-  const scheduleStatuslineRefresh = (ctx: ExtensionContext) => {
+  const scheduleStatuslineRefresh = (
+    ctx: ExtensionContext,
+    delayMs = REFRESH_INTERVAL_MS,
+  ) => {
     if (statuslineRefreshTimer) clearTimeout(statuslineRefreshTimer);
     statuslineRefreshTimer = setTimeout(() => {
-      void refreshCurrentCodexUsageStatusline(ctx, true);
-    }, REFRESH_INTERVAL_MS) as TimeoutHandle;
+      void refreshCurrentCodexUsageStatusline(ctx, true).catch(
+        handleAsyncTimerError,
+      );
+    }, delayMs) as TimeoutHandle;
     statuslineRefreshTimer.unref?.();
   };
 
@@ -236,12 +293,16 @@ export default function codexUsage(pi: ExtensionAPI) {
       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?.();
@@ -259,16 +320,24 @@ export default function codexUsage(pi: ExtensionAPI) {
     if (statuslineBlinkTimer) clearTimeout(statuslineBlinkTimer);
     if (statuslineClearTimer) clearTimeout(statuslineClearTimer);
     if (statuslineCountdownTimer) clearTimeout(statuslineCountdownTimer);
+    stopStatuslineLoading();
     statuslineBlinkTimer = undefined;
     statuslineClearTimer = undefined;
     statuslineCountdownTimer = undefined;
     const text = formatCodexUsageStatusline(report, ctx, options.model);
     if (options.blink) {
-      ctx.ui.setStatus(STATUS_KEY, formatEmptyStatuslineBar(ctx));
+      ctx.ui.setStatus(
+        STATUS_KEY,
+        formatStatuslineLoading(ctx, statuslineLoadingFrame, options.model),
+      );
       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 {
@@ -283,74 +352,127 @@ export default function codexUsage(pi: ExtensionAPI) {
     ctx: ExtensionContext,
     model: CodexUsageModel | undefined,
   ) => {
-    if (!inFlightUsageQuery) {
-      inFlightUsageQuery = queryUsage(
-        ctx,
-        { timeoutMs: DEFAULT_TIMEOUT_MS },
-        model,
-      ).finally(() => {
+    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;
-      });
-    }
-    return inFlightUsageQuery;
+    });
+    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;
-    }
+      const usableCache =
+        cache && canReuseCachedReport(cache.report, activeModel)
+          ? cache
+          : undefined;
+      if (usableCache) {
+        setUsageStatusline(ctx, usableCache.report, {
+          autoRefresh: true,
+          blink: false,
+          model: activeModel,
+        });
+      } else {
+        startStatuslineLoading(ctx, activeModel);
+      }
+      const requestId = statuslineRequestId + 1;
+      statuslineRequestId = requestId;
+      const freshCache =
+        usableCache && Date.now() - usableCache.createdAt < REFRESH_INTERVAL_MS
+          ? usableCache
+          : undefined;
+      if (freshCache && !force) {
+        setUsageStatusline(ctx, freshCache.report, {
+          autoRefresh: true,
+          blink: false,
+          model: activeModel,
+        });
+        return;
+      }
 
-    const result = await queryCurrentUsage(ctx, model);
-    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;
+        const activeCache =
+          cache && canReuseCachedReport(cache.report, activeModel)
+            ? cache
+            : undefined;
+        if (!activeCache || failedRefreshes >= 5) {
+          stopStatuslineLoading();
+          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 previousWasFullyAvailable = previousReport
+        ? isFullyAvailableReport(previousReport, activeModel)
+        : false;
+      if (
+        isFullyAvailableReport(result.report, activeModel) &&
+        !previousWasFullyAvailable
+      ) {
+        const now = Date.now();
+        const limitId = activeUsageLimitId(activeModel);
+        if (provisionalFullReport?.limitId !== limitId) {
+          provisionalFullReport = { limitId, firstSeenAt: now };
+        }
+        if (
+          now - provisionalFullReport.firstSeenAt <
+          FULL_AVAILABILITY_CONFIRMATION_MS
+        ) {
+          scheduleStatuslineRefresh(ctx, PROVISIONAL_RETRY_MS);
+          return;
+        }
+      } else {
+        provisionalFullReport = undefined;
+      }
+      const blink = previousReport
+        ? formatReportBar(previousReport, activeModel) !==
+          formatReportBar(result.report, activeModel)
+        : false;
+      failedRefreshes = 0;
+      provisionalFullReport = undefined;
+      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();
@@ -358,19 +480,25 @@ 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);
     }
@@ -383,6 +511,19 @@ 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 {
@@ -406,7 +547,9 @@ function activeUsageLimitId(
 function activeUsageLabel(
   model: Pick<PiModel, "id" | "name" | "provider"> | undefined,
 ): string {
-  return isSparkCodexModel(model) ? SPARK_STATUS_LABEL_TEXT : DEFAULT_STATUS_LABEL_TEXT;
+  return isSparkCodexModel(model)
+    ? SPARK_STATUS_LABEL_TEXT
+    : DEFAULT_STATUS_LABEL_TEXT;
 }
 
 async function importTelegramStatusLineModule(): Promise<
@@ -786,7 +929,7 @@ 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;
+    : (normalizedUsageKey(raw) ?? CODEX_USAGE_LIMIT_ID);
 }
 
 function normalizeBackendSnapshot(
@@ -1077,15 +1220,41 @@ function formatStatuslineBarText(
   return `${label} ${value}`;
 }
 
-function formatEmptyStatuslineBar(ctx: ExtensionContext): string {
-  return formatStatuslineBarText(ctx, DUAL_BAR_CHARS[0].repeat(DUAL_BAR_WIDTH));
+export function formatCodexUsageLoadingBar(frame: number): string {
+  const totalParts = DUAL_BAR_WIDTH * 2;
+  const cycleFrames = (totalParts - 1) * 2;
+  const finiteFrame = Number.isFinite(frame) ? frame : 0;
+  const cycleFrame = Math.abs(Math.trunc(finiteFrame)) % cycleFrames;
+  const primaryPart =
+    cycleFrame < totalParts ? cycleFrame : cycleFrames - cycleFrame;
+  const secondaryPart = totalParts - primaryPart - 1;
+  const masks = Array<number>(DUAL_BAR_WIDTH).fill(0);
+  const primaryCell = Math.floor(primaryPart / 2);
+  const secondaryCell = Math.floor(secondaryPart / 2);
+  masks[primaryCell] |= primaryPart % 2 === 0 ? 1 : 2;
+  masks[secondaryCell] |= secondaryPart % 2 === 0 ? 4 : 8;
+  return masks.map((mask) => DUAL_BAR_CHARS[mask]).join("");
+}
+
+function formatStatuslineLoading(
+  ctx: ExtensionContext,
+  frame: number,
+  model?: CodexUsageModel,
+): string {
+  return formatStatuslineBarText(
+    ctx,
+    formatCodexUsageLoadingBar(frame),
+    "selectedBg",
+    model,
+  );
 }
 
 function formatStatuslineProblem(
   ctx: ExtensionContext,
   errors: UsageQueryError[],
+  model?: CodexUsageModel,
 ): string {
-  const label = ctx.ui.theme.fg("accent", DEFAULT_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");
@@ -1179,6 +1348,26 @@ function hasExhaustedQuotaWindow(
   );
 }
 
+export function canReuseCachedReport(
+  report: CodexUsageReport,
+  model: CodexUsageModel | undefined,
+): boolean {
+  return selectActiveUsageSnapshot(report, model) !== undefined;
+}
+
+export function isFullyAvailableReport(
+  report: CodexUsageReport,
+  model?: CodexUsageModel,
+): boolean {
+  const snapshot = selectActiveUsageSnapshot(report, model);
+  return (
+    snapshot?.primary !== undefined &&
+    snapshot.secondary !== undefined &&
+    clampPercent(snapshot.primary.usedPercent) === 0 &&
+    clampPercent(snapshot.secondary.usedPercent) === 0
+  );
+}
+
 function selectActiveUsageSnapshot(
   report: CodexUsageReport,
   model: CodexUsageModel | undefined,

package/package.json

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