@monotykamary/pi-better-openai 0.2.0 → 0.2.2

package/README.md

@@ -46,8 +46,17 @@ Usage display, image generation, and live voice require pi's `openai-codex` OAut
   - `/live` starts or stops realtime voice mode. `Ctrl+Shift+L` is the keyboard toggle.
   - `/pets [help|list|wake [slug]|tuck|select <slug>]` renders or manages custom pets from `${CODEX_HOME:-~/.codex}/pets`.
   - `/openai-usage` shows current OpenAI subscription usage.
+  - `/openai-resets` inspects and manually redeems a banked Codex reset.
   - `/openai-settings` opens settings, diagnostics, and config details.
 
+## Banked resets
+
+Unused banked Codex resets **auto-redeem by default, 5 minutes before expiry**, while an interactive pi session is running and Codex credentials are available. Starting pi within that final five-minute window also triggers the check; expired credits are skipped. This runs independently of the usage display and current model. The reset picker shows the auto-redemption note beside each eligible expiry. Disable **Auto-redeem banked resets** in `/openai-settings` or set `usage.autoRedeemBankedResets` to `false` to opt out.
+
+For safety, each attempt targets one explicit, freshly checked credit ID, with no fallback to another credit and no automatic retry after a consume request (including errors or `nothing_to_reset`). A persistent per-account guard permits at most one redemption attempt in five minutes across pi sessions sharing the same agent directory; manual redemption uses the same guard. Simultaneously expiring credits are not drained. Reservations live under `$PI_CODING_AGENT_DIR/pi-better-openai/reset-redemptions` (default `~/.pi/agent/pi-better-openai/reset-redemptions`); unreadable state or an orphaned lock blocks redemption rather than risking a duplicate. Separate machines/agent directories cannot coordinate this local guard.
+
+Pi must remain running and awake; this is not an OS-level scheduled task. No eligible usage window or unavailable credentials can prevent redemption.
+
 ## Configuration
 
 The extension reads JSON config from two locations:
@@ -84,7 +93,8 @@ Example config:
     "enabled": true,
     "refreshIntervalMs": 60000,
     "showOnlyOnSubscriptionModels": true,
-    "showResetTimes": true
+    "showResetTimes": true,
+    "autoRedeemBankedResets": true
   },
   "footer": {
     "mode": "status"

package/index.ts

@@ -72,10 +72,8 @@ import {
 } from "./src/usage.ts";
 import {
   buildBankedResetConfirmation,
-  consumeBankedReset,
   formatBankedResetChoice,
   formatConsumeOutcome,
-  newRedeemRequestId,
   selectBankedResetCredit,
 } from "./src/resets.ts";
 import { ResetController } from "./src/reset-controller.ts";
@@ -291,7 +289,12 @@ export default function betterOpenAI(pi: ExtensionAPI): void {
   let cachedSessionNameLeafId: string | null | undefined;
   let cachedSessionName: string | undefined;
   const usageController = new UsageController(config, updateFooter);
-  const resetController = new ResetController();
+  const resetController = new ResetController(
+    (ctx) => hasTerminalUI(ctx) && config(ctx).usage.autoRedeemBankedResets,
+    (ctx) => {
+      void usageController.refresh(ctx, ctx.model?.id, { force: true });
+    },
+  );
   const petController = new PetFooterController(config, updateFooter, () => footerInstalled);
   let multiproviderService: MultiproviderService | undefined;
   let unsubscribeMultiprovider: (() => void) | undefined;
@@ -444,6 +447,15 @@ export default function betterOpenAI(pi: ExtensionAPI): void {
   }
 
   async function redeemBankedReset(ctx: ExtensionContext): Promise<void> {
+    const resume = resetController.pauseAutoRedeem();
+    try {
+      await chooseBankedReset(ctx);
+    } finally {
+      resume();
+    }
+  }
+
+  async function chooseBankedReset(ctx: ExtensionContext): Promise<void> {
     if (!hasTerminalUI(ctx)) {
       ctx.ui.notify("/openai-resets requires an interactive TUI session.", "warning");
       return;
@@ -466,16 +478,26 @@ export default function betterOpenAI(pi: ExtensionAPI): void {
     const available = credits.credits.filter((credit) => credit.status === "available");
     let selected = selectBankedResetCredit(credits.credits);
     if (available.length > 1 && selected) {
-      const options = available.map((credit, index) => formatBankedResetChoice(credit, index));
+      const options = available.map((credit, index) =>
+        formatBankedResetChoice(credit, index, config(ctx).usage.autoRedeemBankedResets),
+      );
       const chosen = await ctx.ui.select("Redeem which banked reset?", options);
       if (chosen === undefined) {
         ctx.ui.notify("Banked reset redemption cancelled.", "info");
         return;
       }
-      selected = available[Math.max(0, options.indexOf(chosen))];
+      selected = available[options.indexOf(chosen)];
+    }
+    if (!selected) {
+      ctx.ui.notify(
+        "No individually identifiable banked reset is available; nothing was redeemed.",
+        "warning",
+      );
+      return;
     }
     const confirmation = buildBankedResetConfirmation({
       credit: selected,
+      autoRedeem: config(ctx).usage.autoRedeemBankedResets,
       availableCount: credits.availableCount,
       snapshot: usageController.snapshot,
     });
@@ -484,9 +506,7 @@ export default function betterOpenAI(pi: ExtensionAPI): void {
       return;
     }
     try {
-      const timeoutSignal = AbortSignal.timeout(15_000);
-      const signal = ctx.signal ? AbortSignal.any([ctx.signal, timeoutSignal]) : timeoutSignal;
-      const result = await consumeBankedReset(ctx, selected?.id, newRedeemRequestId(), signal);
+      const result = await resetController.redeem(ctx, selected.id);
       const outcome = formatConsumeOutcome(result);
       ctx.ui.notify(outcome.message, outcome.level);
       void usageController.refresh(ctx, ctx.model?.id, { force: true });
@@ -1000,6 +1020,7 @@ export default function betterOpenAI(pi: ExtensionAPI): void {
       void petController.refresh(ctx, next);
     if (id.startsWith("usage.")) {
       usageController.restartAfterSettingsChange(ctx, next);
+      resetController.start(ctx);
     }
     updateFooter(ctx);
   }
@@ -1435,7 +1456,11 @@ export default function betterOpenAI(pi: ExtensionAPI): void {
     updateFooter(ctx);
     if (hasTerminalUI(ctx) && nextConfig.pets.enabled) void petController.refresh(ctx, nextConfig);
     usageController.start(ctx);
-    if (nextConfig.usage.enabled && isOpenAISubscriptionModel(ctx, nextConfig))
+    if (
+      hasTerminalUI(ctx) &&
+      (nextConfig.usage.autoRedeemBankedResets ||
+        (nextConfig.usage.enabled && isOpenAISubscriptionModel(ctx, nextConfig)))
+    )
       resetController.start(ctx);
     if (fastController.active) ctx.ui.notify(fastController.stateText(ctx, nextConfig), "info");
   });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@monotykamary/pi-better-openai",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "Improve OpenAI in pi with fast mode, usage stats, realtime voice, image generation, and footer polish.",
   "keywords": [
     "fast",
@@ -62,9 +62,9 @@
     "ws": "8.21.2"
   },
   "devDependencies": {
-    "@earendil-works/pi-ai": "0.85.1",
-    "@earendil-works/pi-coding-agent": "0.85.1",
-    "@earendil-works/pi-tui": "0.85.1",
+    "@earendil-works/pi-ai": "0.86.0",
+    "@earendil-works/pi-coding-agent": "0.86.0",
+    "@earendil-works/pi-tui": "0.86.0",
     "@types/node": "~22.19.0",
     "@types/proxy-from-env": "1.0.4",
     "@types/ws": "8.18.1",
@@ -86,8 +86,8 @@
     "@oh-my-pi/pi-natives-win32-x64": "17.2.9"
   },
   "overrides": {
-    "@earendil-works/pi-agent-core": "0.85.1",
-    "@earendil-works/pi-ai": "0.85.1",
+    "@earendil-works/pi-agent-core": "0.86.0",
+    "@earendil-works/pi-ai": "0.86.0",
     "brace-expansion": "5.0.9",
     "nanoid": "3.3.18",
     "postcss": "8.5.25",

package/src/config.ts

@@ -59,6 +59,7 @@ export type UsageConfig = {
   showOnlyOnSubscriptionModels?: boolean;
   showResetTimes?: boolean;
   showBankedResets?: boolean;
+  autoRedeemBankedResets?: boolean;
 };
 
 export type FooterConfig = {
@@ -144,6 +145,7 @@ export const DEFAULT_USAGE_CONFIG: Required<UsageConfig> = {
   showOnlyOnSubscriptionModels: true,
   showResetTimes: true,
   showBankedResets: true,
+  autoRedeemBankedResets: true,
 };
 
 export const DEFAULT_FOOTER_CONFIG: Required<FooterConfig> = {
@@ -322,6 +324,16 @@ export const USAGE_SETTING_DESCRIPTORS: readonly SettingsOptionDescriptor[] = [
     description: "Show the available banked Codex reset count in the usage status line.",
     parse: booleanSetting,
   },
+  {
+    id: "usage.autoRedeemBankedResets",
+    section: "usage",
+    key: "autoRedeemBankedResets",
+    label: "Auto-redeem banked resets",
+    currentValue: (cfg) => String(cfg.usage.autoRedeemBankedResets),
+    values: ["true", "false"],
+    description: "Redeem one unused banked reset 5 minutes before expiry while pi is running.",
+    parse: booleanSetting,
+  },
 ];
 
 export const IMAGE_SETTING_DESCRIPTORS: readonly SettingsOptionDescriptor[] = [
@@ -659,6 +671,8 @@ export function readConfig(path: string): ConfigFile | undefined {
       config.usage.showResetTimes = parsed.usage.showResetTimes;
     if (typeof parsed.usage.showBankedResets === "boolean")
       config.usage.showBankedResets = parsed.usage.showBankedResets;
+    if (typeof parsed.usage.autoRedeemBankedResets === "boolean")
+      config.usage.autoRedeemBankedResets = parsed.usage.autoRedeemBankedResets;
   }
   if (
     isRecord(parsed.footer) &&

package/src/reset-controller.ts

@@ -1,6 +1,18 @@
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { getCodexCredentials } from "./codex-auth.ts";
 import { sanitizeDiagnosticError } from "./format.ts";
-import { type BankedResetCredits, requestBankedResetCredits } from "./resets.ts";
+import { reserveBankedResetRedemption } from "./reset-guard.ts";
+import {
+  BANKED_RESET_AUTO_REDEEM_LEAD_MS,
+  type BankedResetCredit,
+  type BankedResetCredits,
+  type ConsumeBankedResetResult,
+  consumeBankedReset,
+  formatConsumeOutcome,
+  newRedeemRequestId,
+  requestBankedResetCredits,
+  selectAutoRedeemCredit,
+} from "./resets.ts";
 
 export const BANKED_RESET_CACHE_TTL_MS = 5 * 60_000;
 const BANKED_RESET_REQUEST_TIMEOUT_MS = 10_000;
@@ -10,19 +22,34 @@ export type BankedResetCache = {
   updatedAt: number;
 };
 
-// Keeps the banked-reset credit list warm so /openai-resets opens without
-// paying the credential-resolution + wham round trip. The cache is prefetched
-// at session start, refreshed on a TTL, and served even when stale (a stale
-// open still kicks off a background refresh; the backend re-validates every
-// redemption server-side, so a stale offer can never be consumed twice).
+// Keep the picker warm, but never redeem from the cache alone. Automatic
+// redemption revalidates one exact credit and pins its account for the POST.
 export class ResetController {
   private cache: BankedResetCache | undefined;
   private error: string | undefined;
   private lastFetchAt: number | undefined;
   private inFlight: Promise<void> | undefined;
   private timer: ReturnType<typeof setInterval> | undefined;
+  private autoTimer: ReturnType<typeof setTimeout> | undefined;
   private sessionSignal: AbortSignal | undefined;
   private sessionAbortHandler: (() => void) | undefined;
+  private lifetime = new AbortController();
+  private generation = 0;
+  private activeCtx: ExtensionContext | undefined;
+  private redeeming = false;
+  private manualPickers = 0;
+  private blockedUntilMs = 0;
+
+  private readonly autoRedeemEnabled: (ctx: ExtensionContext) => boolean;
+  private readonly onAutoRedeemed: (ctx: ExtensionContext) => void;
+
+  constructor(
+    autoRedeemEnabled: (ctx: ExtensionContext) => boolean = () => false,
+    onAutoRedeemed: (ctx: ExtensionContext) => void = () => {},
+  ) {
+    this.autoRedeemEnabled = autoRedeemEnabled;
+    this.onAutoRedeemed = onAutoRedeemed;
+  }
 
   get snapshot(): BankedResetCache | undefined {
     return this.cache;
@@ -36,7 +63,16 @@ export class ResetController {
     return this.cache !== undefined && now - this.cache.updatedAt < BANKED_RESET_CACHE_TTL_MS;
   }
 
+  private requestSignal(ctx: ExtensionContext): AbortSignal {
+    return AbortSignal.any([
+      this.lifetime.signal,
+      AbortSignal.timeout(BANKED_RESET_REQUEST_TIMEOUT_MS),
+      ...(ctx.signal ? [ctx.signal] : []),
+    ]);
+  }
+
   refresh(ctx: ExtensionContext, options?: { force?: boolean }): Promise<void> {
+    if (this.lifetime.signal.aborted) return Promise.resolve();
     if (this.inFlight) return this.inFlight;
     if (
       !options?.force &&
@@ -45,11 +81,12 @@ export class ResetController {
     )
       return Promise.resolve();
     this.lastFetchAt = Date.now();
-    const timeoutSignal = AbortSignal.timeout(BANKED_RESET_REQUEST_TIMEOUT_MS);
-    const signal = ctx.signal ? AbortSignal.any([ctx.signal, timeoutSignal]) : timeoutSignal;
+    const generation = this.generation;
+    const signal = this.requestSignal(ctx);
     const task = (async () => {
       try {
         const credits = await requestBankedResetCredits(ctx, signal);
+        if (signal.aborted || generation !== this.generation) return;
         if (credits) {
           this.cache = { credits, updatedAt: Date.now() };
           this.error = undefined;
@@ -57,20 +94,169 @@ export class ResetController {
           this.error = "OpenAI Codex credentials unavailable.";
         }
       } catch (error) {
+        if (generation !== this.generation || signal.aborted) return;
         this.error = sanitizeDiagnosticError(
           error instanceof Error ? error.message : String(error),
         );
       } finally {
-        this.inFlight = undefined;
+        if (generation === this.generation) {
+          this.inFlight = undefined;
+          this.scheduleAutoRedeem();
+        }
       }
     })();
     this.inFlight = task;
     return task;
   }
 
+  // While a person is choosing/confirming, the timer must not spend a different
+  // credit behind their dialog. An already-running redemption remains locked.
+  pauseAutoRedeem(): () => void {
+    this.manualPickers++;
+    this.clearAutoTimer();
+    return () => {
+      this.manualPickers--;
+      this.scheduleAutoRedeem();
+    };
+  }
+
+  async redeem(ctx: ExtensionContext, creditId: string): Promise<ConsumeBankedResetResult> {
+    if (!creditId) throw new Error("An explicit banked reset credit is required.");
+    if (this.redeeming) throw new Error("A banked reset redemption is already in progress.");
+    this.redeeming = true;
+    const generation = this.generation;
+    this.blockedUntilMs = Date.now() + BANKED_RESET_AUTO_REDEEM_LEAD_MS;
+    try {
+      const signal = this.requestSignal(ctx);
+      const credentials = await getCodexCredentials(ctx, signal);
+      signal.throwIfAborted();
+      if (!credentials) throw new Error("OpenAI Codex credentials unavailable.");
+      if (!reserveBankedResetRedemption(credentials.accountId, creditId))
+        throw new Error(
+          "A banked reset was already attempted recently; no additional credit was spent.",
+        );
+      return await consumeBankedReset(ctx, creditId, newRedeemRequestId(), signal, credentials);
+    } finally {
+      if (generation === this.generation) {
+        this.redeeming = false;
+        this.scheduleAutoRedeem();
+      }
+    }
+  }
+
+  private clearAutoTimer(): void {
+    if (this.autoTimer) clearTimeout(this.autoTimer);
+    this.autoTimer = undefined;
+  }
+
+  private canAutoRedeem(ctx: ExtensionContext): boolean {
+    return (
+      this.activeCtx === ctx &&
+      !this.lifetime.signal.aborted &&
+      !ctx.signal?.aborted &&
+      this.manualPickers === 0 &&
+      this.autoRedeemEnabled(ctx)
+    );
+  }
+
+  private scheduleAutoRedeem(): void {
+    const ctx = this.activeCtx;
+    if (!ctx || this.redeeming) return;
+    try {
+      if (!this.canAutoRedeem(ctx)) {
+        this.clearAutoTimer();
+        return;
+      }
+      // A cache refresh must not replace a due timer with the next credit,
+      // particularly when the scheduled one was redeemed in another client.
+      if (this.autoTimer) return;
+      const credit = selectAutoRedeemCredit(this.cache?.credits.credits ?? []);
+      if (!credit || credit.expiresAtMs === null) return;
+      const dueAt = Math.max(
+        credit.expiresAtMs - BANKED_RESET_AUTO_REDEEM_LEAD_MS,
+        this.blockedUntilMs,
+      );
+      this.autoTimer = setTimeout(
+        () => {
+          this.autoTimer = undefined;
+          if (Date.now() < dueAt) this.scheduleAutoRedeem();
+          else void this.autoRedeem(ctx, credit);
+        },
+        Math.max(0, Math.min(dueAt - Date.now(), BANKED_RESET_CACHE_TTL_MS)),
+      );
+      this.autoTimer.unref?.();
+    } catch {
+      // Stale extension contexts must not leave a background timer running.
+      this.stop();
+    }
+  }
+
+  private async autoRedeem(ctx: ExtensionContext, scheduled: BankedResetCredit): Promise<void> {
+    const generation = this.generation;
+    let ownsRedemption = false;
+    try {
+      if (this.redeeming || !this.canAutoRedeem(ctx) || Date.now() < this.blockedUntilMs) return;
+      this.redeeming = true;
+      ownsRedemption = true;
+      // Even a no-op or ambiguous failure ends this window: never try the next
+      // credit. The persistent reservation below enforces this across processes.
+      this.blockedUntilMs = Date.now() + BANKED_RESET_AUTO_REDEEM_LEAD_MS;
+      const signal = this.requestSignal(ctx);
+      const credentials = await getCodexCredentials(ctx, signal);
+      if (!credentials) return;
+      const fresh = await requestBankedResetCredits(ctx, signal, credentials);
+      if (signal.aborted || generation !== this.generation || !this.canAutoRedeem(ctx)) return;
+      if (!fresh) return;
+      this.cache = { credits: fresh, updatedAt: Date.now() };
+      this.error = undefined;
+      const credit = selectAutoRedeemCredit(fresh.credits.filter((row) => row.id === scheduled.id));
+      if (
+        !credit ||
+        credit.expiresAtMs === null ||
+        fresh.availableCount <= 0 ||
+        fresh.applicableCount === 0 ||
+        credit.expiresAtMs - Date.now() > BANKED_RESET_AUTO_REDEEM_LEAD_MS
+      )
+        return;
+      if (!reserveBankedResetRedemption(credentials.accountId, credit.id)) return;
+      const result = await consumeBankedReset(
+        ctx,
+        credit.id,
+        newRedeemRequestId(),
+        signal,
+        credentials,
+      );
+      if (signal.aborted || generation !== this.generation) return;
+      const outcome = formatConsumeOutcome(result);
+      ctx.ui.notify(`Auto-redeem: ${outcome.message}`, outcome.level);
+      if (result.code === "reset") this.onAutoRedeemed(ctx);
+      void this.refresh(ctx, { force: true });
+    } catch (error) {
+      if (generation !== this.generation || this.lifetime.signal.aborted) return;
+      this.error = sanitizeDiagnosticError(error instanceof Error ? error.message : String(error));
+      try {
+        ctx.ui.notify(
+          `Banked reset auto-redemption failed; no automatic retry: ${this.error}`,
+          "warning",
+        );
+      } catch {
+        /* The context may have become stale. */
+      }
+    } finally {
+      if (ownsRedemption && generation === this.generation) {
+        this.redeeming = false;
+        this.scheduleAutoRedeem();
+      }
+    }
+  }
+
   start(ctx: ExtensionContext): void {
     this.stop();
+    this.lifetime = new AbortController();
+    this.cache = undefined;
+    this.lastFetchAt = undefined;
     if (ctx.signal?.aborted) return;
+    this.activeCtx = ctx;
     this.sessionSignal = ctx.signal;
     this.sessionAbortHandler = () => this.stop();
     ctx.signal?.addEventListener("abort", this.sessionAbortHandler, { once: true });
@@ -86,6 +272,12 @@ export class ResetController {
   }
 
   stop(): void {
+    this.generation++;
+    this.lifetime.abort();
+    this.activeCtx = undefined;
+    this.inFlight = undefined;
+    this.redeeming = false;
+    this.clearAutoTimer();
     if (this.timer) clearInterval(this.timer);
     this.timer = undefined;
     if (this.sessionSignal && this.sessionAbortHandler) {

package/src/reset-guard.ts

@@ -0,0 +1,62 @@
+import { createHash } from "node:crypto";
+import { closeSync, mkdirSync, openSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { piAgentDir } from "./paths.ts";
+import { BANKED_RESET_AUTO_REDEEM_LEAD_MS } from "./resets.ts";
+
+// Reserve before sending a POST, not after receiving its outcome. A timeout may
+// already have spent the credit. Shared by manual/automatic redemption and all
+// pi processes using this agent directory. Corrupt state or an orphaned lock
+// fails closed rather than risking another redemption.
+export function reserveBankedResetRedemption(
+  accountId: string,
+  creditId: string,
+  now = Date.now(),
+): boolean {
+  const digest = (value: string) => createHash("sha256").update(value).digest("hex");
+  const dir = join(piAgentDir(), "pi-better-openai", "reset-redemptions");
+  mkdirSync(dir, { recursive: true, mode: 0o700 });
+  const path = join(dir, `${digest(accountId)}.json`);
+  const lock = `${path}.lock`;
+  let fd: number;
+  try {
+    fd = openSync(lock, "wx", 0o600);
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === "EEXIST") return false;
+    throw new Error("Banked reset safety reservation unavailable.");
+  }
+  try {
+    let previous: { blockedUntilMs?: unknown; creditHash?: unknown } | undefined;
+    try {
+      previous = JSON.parse(readFileSync(path, "utf8"));
+      if (
+        !previous ||
+        typeof previous.blockedUntilMs !== "number" ||
+        !Number.isFinite(previous.blockedUntilMs) ||
+        typeof previous.creditHash !== "string"
+      )
+        throw new Error("Invalid reservation");
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== "ENOENT")
+        throw new Error("Banked reset safety reservation unavailable.");
+    }
+    const creditHash = digest(creditId);
+    if (
+      previous &&
+      ((previous.blockedUntilMs as number) > now || previous.creditHash === creditHash)
+    )
+      return false;
+    writeFileSync(
+      path,
+      JSON.stringify({
+        blockedUntilMs: now + BANKED_RESET_AUTO_REDEEM_LEAD_MS,
+        creditHash,
+      }),
+      { mode: 0o600 },
+    );
+    return true;
+  } finally {
+    closeSync(fd);
+    unlinkSync(lock);
+  }
+}

package/src/resets.ts

@@ -1,12 +1,14 @@
 import { randomUUID } from "node:crypto";
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { getCodexCredentials } from "./codex-auth.ts";
+import { getCodexCredentials, type CodexCredentials } from "./codex-auth.ts";
 import { formatPercent, type UsageSnapshot } from "./usage.ts";
 
 export const RESET_CREDITS_URL = "https://chatgpt.com/backend-api/wham/rate-limit-reset-credits";
 export const CONSUME_RESET_URL =
   "https://chatgpt.com/backend-api/wham/rate-limit-reset-credits/consume";
 
+export const BANKED_RESET_AUTO_REDEEM_LEAD_MS = 5 * 60_000;
+
 export type BankedResetStatus = "available" | "redeeming" | "redeemed" | "unknown";
 
 export type BankedResetCredit = {
@@ -129,6 +131,21 @@ export function selectBankedResetCredit(
   })[0];
 }
 
+export function selectAutoRedeemCredit(
+  credits: readonly BankedResetCredit[],
+  now = Date.now(),
+): BankedResetCredit | undefined {
+  return selectBankedResetCredit(
+    credits.filter(
+      (credit) =>
+        credit.resetType === "codex_rate_limits" &&
+        credit.expiresAtMs !== null &&
+        Number.isFinite(credit.expiresAtMs) &&
+        credit.expiresAtMs > now,
+    ),
+  );
+}
+
 function formatResetTimestamp(ms: number | null): string {
   if (ms === null) return "unknown";
   return new Date(ms).toLocaleString(undefined, {
@@ -139,13 +156,19 @@ function formatResetTimestamp(ms: number | null): string {
   });
 }
 
-export function formatBankedResetChoice(credit: BankedResetCredit, index: number): string {
+export function formatBankedResetChoice(
+  credit: BankedResetCredit,
+  index: number,
+  autoRedeem = false,
+): string {
   const title = credit.title ?? "Codex banked reset";
   const expires =
     credit.expiresAtMs === null
       ? "no expiry"
       : `expires ${formatResetTimestamp(credit.expiresAtMs)}`;
-  return `${index + 1}. ${title} · ${expires}`;
+  const note =
+    autoRedeem && selectAutoRedeemCredit([credit]) ? " · auto-redeems 5 min before expiry" : "";
+  return `${index + 1}. ${title} · ${expires}${note}`;
 }
 
 export function formatConsumeOutcome(result: ConsumeBankedResetResult): {
@@ -173,6 +196,7 @@ export function formatConsumeOutcome(result: ConsumeBankedResetResult): {
 export function buildBankedResetConfirmation(options: {
   credit?: BankedResetCredit;
   availableCount: number;
+  autoRedeem?: boolean;
   snapshot?: Pick<UsageSnapshot, "fiveHourLeftPercent" | "sevenDayLeftPercent">;
 }): { title: string; message: string } {
   const credit = options.credit;
@@ -181,7 +205,11 @@ export function buildBankedResetConfirmation(options: {
   lines.push("");
   if (credit?.grantedAtMs != null)
     lines.push(`Granted: ${formatResetTimestamp(credit.grantedAtMs)}`);
-  lines.push(`Expires: ${formatResetTimestamp(credit?.expiresAtMs ?? null)}`);
+  const autoNote =
+    options.autoRedeem && credit && selectAutoRedeemCredit([credit])
+      ? " · auto-redeems 5 min before expiry"
+      : "";
+  lines.push(`Expires: ${formatResetTimestamp(credit?.expiresAtMs ?? null)}${autoNote}`);
   lines.push(`Available: ${options.availableCount}`);
   const windows: string[] = [];
   if (options.snapshot?.fiveHourLeftPercent != null)
@@ -199,10 +227,11 @@ export function buildBankedResetConfirmation(options: {
 export async function requestBankedResetCredits(
   ctxOrSignal?: ExtensionContext | AbortSignal,
   signal?: AbortSignal,
+  pinnedCredentials?: CodexCredentials,
 ): Promise<BankedResetCredits | undefined> {
   const ctx = isAbortSignal(ctxOrSignal) ? undefined : ctxOrSignal;
   const requestSignal = isAbortSignal(ctxOrSignal) ? ctxOrSignal : signal;
-  const credentials = await getCodexCredentials(ctx, requestSignal);
+  const credentials = pinnedCredentials ?? (await getCodexCredentials(ctx, requestSignal));
   if (!credentials) return undefined;
   const response = await fetch(RESET_CREDITS_URL, {
     headers: {
@@ -221,8 +250,10 @@ export async function consumeBankedReset(
   creditId: string | undefined,
   redeemRequestId: string,
   signal?: AbortSignal,
+  pinnedCredentials?: CodexCredentials,
 ): Promise<ConsumeBankedResetResult> {
-  const credentials = await getCodexCredentials(ctx, signal);
+  const credentials = pinnedCredentials ?? (await getCodexCredentials(ctx, signal));
+  signal?.throwIfAborted();
   if (!credentials)
     throw new Error("OpenAI Codex authentication is unavailable. Run /login first.");
   const response = await fetch(CONSUME_RESET_URL, {