@monotykamary/pi-better-openai 0.2.1 → 0.2.3

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 and confirmation show each credit's actual local auto-redemption date and time (expiry minus five minutes) beside its 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. Automatic reservations recheck the five-minute eligibility window while holding an exclusive filesystem lock, and attempted credit IDs remain blocked even after later redemptions or restarts. Simultaneously expiring credits are not drained, and later credits wait for their own final five-minute window. 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. Update/restart all pi instances to use the current guard. Separate machines/agent directories cannot coordinate this local guard; instances using the same account should share an agent directory.
+
+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.1",
+  "version": "0.2.3",
   "description": "Improve OpenAI in pi with fast mode, usage stats, realtime voice, image generation, and footer polish.",
   "keywords": [
     "fast",

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,178 @@ 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, {
+          expiresAtMs: credit.expiresAtMs,
+        })
+      )
+        return;
+      // Filesystem contention or a clock adjustment must not turn a valid
+      // reservation into a POST for an expired or not-yet-due credit.
+      const remainingMs = credit.expiresAtMs - Date.now();
+      if (remainingMs <= 0 || remainingMs > BANKED_RESET_AUTO_REDEEM_LEAD_MS) 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 +281,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,88 @@
+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";
+
+type RedemptionReservation = {
+  blockedUntilMs: number;
+  creditHash: string;
+  attemptedCreditHashes?: string[];
+};
+
+// 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,
+  options: { expiresAtMs?: number } = {},
+): boolean {
+  if (!accountId.trim() || !creditId.trim()) return false;
+  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: RedemptionReservation | undefined;
+    try {
+      previous = JSON.parse(readFileSync(path, "utf8"));
+      if (
+        !previous ||
+        typeof previous.blockedUntilMs !== "number" ||
+        !Number.isFinite(previous.blockedUntilMs) ||
+        typeof previous.creditHash !== "string" ||
+        !/^[0-9a-f]{64}$/.test(previous.creditHash) ||
+        (previous.attemptedCreditHashes !== undefined &&
+          (!Array.isArray(previous.attemptedCreditHashes) ||
+            !previous.attemptedCreditHashes.every(
+              (hash) => typeof hash === "string" && /^[0-9a-f]{64}$/.test(hash),
+            ) ||
+            !previous.attemptedCreditHashes.includes(previous.creditHash)))
+      )
+        throw new Error("Invalid reservation");
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== "ENOENT")
+        throw new Error("Banked reset safety reservation unavailable.");
+    }
+    // Check the actual clock under the account lock, not a cached timer's time.
+    // Manual, explicitly confirmed redemptions do not supply an expiry limit.
+    const now = Date.now();
+    if (
+      options.expiresAtMs !== undefined &&
+      (!Number.isFinite(options.expiresAtMs) ||
+        options.expiresAtMs <= now ||
+        options.expiresAtMs - now > BANKED_RESET_AUTO_REDEEM_LEAD_MS)
+    )
+      return false;
+    const creditHash = digest(creditId);
+    // Migrate old single-credit state. Never forget an uncertain attempt just
+    // because another credit was subsequently redeemed.
+    const attemptedCreditHashes =
+      previous?.attemptedCreditHashes ?? (previous ? [previous.creditHash] : []);
+    if ((previous && previous.blockedUntilMs > now) || attemptedCreditHashes.includes(creditHash))
+      return false;
+    writeFileSync(
+      path,
+      JSON.stringify({
+        blockedUntilMs: now + BANKED_RESET_AUTO_REDEEM_LEAD_MS,
+        creditHash,
+        attemptedCreditHashes: [...attemptedCreditHashes, creditHash],
+      }),
+      { mode: 0o600, flush: true },
+    );
+    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,24 @@ function formatResetTimestamp(ms: number | null): string {
   });
 }
 
-export function formatBankedResetChoice(credit: BankedResetCredit, index: number): string {
+function formatAutoRedeemNote(credit: BankedResetCredit | undefined, enabled = false): string {
+  if (!enabled || !credit || !selectAutoRedeemCredit([credit]) || credit.expiresAtMs === null)
+    return "";
+  return ` · auto-redeems ${formatResetTimestamp(credit.expiresAtMs - BANKED_RESET_AUTO_REDEEM_LEAD_MS)}`;
+}
+
+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 = formatAutoRedeemNote(credit, autoRedeem);
+  return `${index + 1}. ${title} · ${expires}${note}`;
 }
 
 export function formatConsumeOutcome(result: ConsumeBankedResetResult): {
@@ -173,6 +201,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 +210,8 @@ 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 = formatAutoRedeemNote(credit, options.autoRedeem);
+  lines.push(`Expires: ${formatResetTimestamp(credit?.expiresAtMs ?? null)}${autoNote}`);
   lines.push(`Available: ${options.availableCount}`);
   const windows: string[] = [];
   if (options.snapshot?.fiveHourLeftPercent != null)
@@ -199,10 +229,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 +252,11 @@ export async function consumeBankedReset(
   creditId: string | undefined,
   redeemRequestId: string,
   signal?: AbortSignal,
+  pinnedCredentials?: CodexCredentials,
 ): Promise<ConsumeBankedResetResult> {
-  const credentials = await getCodexCredentials(ctx, signal);
+  if (!creditId?.trim()) throw new Error("An explicit banked reset credit is required.");
+  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, {
@@ -233,11 +267,7 @@ export async function consumeBankedReset(
       "chatgpt-account-id": credentials.accountId,
       "content-type": "application/json",
     },
-    body: JSON.stringify(
-      creditId
-        ? { credit_id: creditId, redeem_request_id: redeemRequestId }
-        : { redeem_request_id: redeemRequestId },
-    ),
+    body: JSON.stringify({ credit_id: creditId, redeem_request_id: redeemRequestId }),
     signal,
   });
   if (!response.ok) throw new Error(`Codex reset consume request failed (${response.status})`);