@llblab/pi-codex-usage 0.8.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,13 @@
 
 ## 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.

package/index.ts

@@ -163,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;
@@ -210,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?.();
   };
@@ -219,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?.();
   };
@@ -236,12 +242,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?.();
@@ -266,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 {
@@ -283,74 +297,87 @@ export default function codexUsage(pi: ExtensionAPI) {
     ctx: ExtensionContext,
     model: CodexUsageModel | undefined,
   ) => {
-    if (!inFlightUsageQuery) {
-      inFlightUsageQuery = queryUsage(
-        ctx,
-        { timeoutMs: DEFAULT_TIMEOUT_MS },
-        model,
-      ).finally(() => {
-        inFlightUsageQuery = undefined;
-      });
-    }
-    return inFlightUsageQuery;
+    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, 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;
+        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();
@@ -358,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);
     }
@@ -383,6 +410,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 {
@@ -1084,8 +1124,9 @@ function formatEmptyStatuslineBar(ctx: ExtensionContext): string {
 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 +1220,13 @@ function hasExhaustedQuotaWindow(
   );
 }
 
+export function canReuseCachedReport(
+  report: CodexUsageReport,
+  model: CodexUsageModel | undefined,
+): boolean {
+  return selectActiveUsageSnapshot(report, model) !== undefined;
+}
+
 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.1",
   "private": false,
   "description": "Minimal Pi extension that shows primary Codex ChatGPT subscription usage limits.",
   "keywords": [