limn-review 0.1.136 → 0.1.138

package/README.md

@@ -41,8 +41,8 @@ Claude Review (a code review of any PR, follow-ups, a check against a user
 story you paste, and a chat about the review) and AI Fix are free. By default
 they use your local Claude Code login: if you are signed in to Claude Code,
 there is nothing to set up. An Anthropic API key is the alternative: set
-`ANTHROPIC_API_KEY`. Limn stores no key and charges nothing for it. Codex
-support is coming soon.
+`ANTHROPIC_API_KEY`. Limn stores no key and charges nothing for it. They can
+run on Codex instead (below).
 
 - **First use downloads the AI runtime, once (about 110 MB).** Press
   **Set up AI** in the app, or run `limn ai install`. It goes to
@@ -57,6 +57,27 @@ support is coming soon.
   in to Claude Code.
 - `LIMN_AI_DISABLED=true` turns every AI feature off.
 
+### Codex instead of Claude
+
+Every AI feature can run on Codex, on your own ChatGPT plan. One provider runs
+everything at a time.
+
+```bash
+limn ai install codex   # adds the Codex CLI to the AI download
+limn ai login codex     # sign in with ChatGPT (add --device-auth on a headless machine)
+```
+
+Or press **Set up AI** and sign in from **Settings → AI**. Limn keeps its own
+Codex sign-in in `~/.limn/codex`; your `~/.codex` is not read or changed. Codex
+with an OpenAI API key is not available yet.
+
+- Pick the provider in **Settings → AI**, or set `LIMN_AI_PROVIDER` to
+  `claude`, `codex` or `auto` (the default: Claude when both are signed in,
+  Codex when only Codex is).
+- Each run is labelled with the provider and model that ran it.
+- `limn ai status` shows whether Codex is set up and signed in.
+- `limn ai logout codex` signs Limn's Codex out.
+
 ## Prerequisites
 
 - **Node.js ≥ 20** (with npm).

package/dist/ai/active-runtime.js

@@ -0,0 +1,11 @@
+// THE ACTIVE PROVIDER'S DOWNLOAD — is the program the next run needs installed? Claude's runs need the
+// Claude SDK download (`getAiRuntimeStatus`); Codex's need the Codex program (`getCodexRuntimeStatus`,
+// installed WITH the shared download, so its zod is there too). `/api/me`'s top-level `ai.runtime`
+// and the background sweepers' gate (`agenticRunReady`) both ask this, so a Codex machine is never
+// held back for a missing Claude program, nor a Claude one for a missing Codex.
+import { getAiRuntimeStatus, getCodexRuntimeStatus } from './runtime.js';
+import { activeProviderId } from './provider-setting.js';
+export function activeRuntimeStatus() {
+    return activeProviderId() === 'codex' ? getCodexRuntimeStatus() : getAiRuntimeStatus();
+}
+//# sourceMappingURL=active-runtime.js.map

package/dist/ai/budget.js

@@ -37,160 +37,37 @@
 // There is no shared "≤ 1 means a fraction" guess: each path knows its own scale. Any throw or shape
 // mismatch is "no reading" — the windows are then rolling and the subscription is the reader's pick.
 //
+// CODEX (docs/CODEX-PLAN.md § 8.1): the budget judges the ACTIVE provider. On a ChatGPT sign-in the
+// reading is the app-server's `account/rateLimits/read` (ai/codex/app-server.ts — in memory, probed in
+// the background at most every 5 minutes), and Limn's share of each window is TOKEN-WEIGHTED: its own
+// codex ai_usage tokens ÷ the account's tokens in that window (`account/usage/read`) × the window's
+// whole-percent usedPercent. Same gate, same settings, percentages only. An API key is weekly US$.
+//
 // One budget per ACCOUNT (= per machine), never per workspace.
 import { and, eq, gte, inArray } from 'drizzle-orm';
-import { AI_BUDGET_DAY_MS, AI_BUDGET_WEEK_MS, aiUsageView, decideAiBudget, liveFiveHourReset, liveWeekReset, resolveAiBudgetSettings, rollingSpend, } from '../shared/index.js';
+import { AI_BUDGET_DAY_MS, AI_BUDGET_WEEK_MS, aiUsageView, budgetWindowStart, decideAiBudget, liveFiveHourReset, liveWeekReset, resolveAiBudgetSettings, rollingSpend, } from '../shared/index.js';
 import { db, schema } from '../db/client.js';
 import { LOCAL_ACCOUNT_ID } from '../auth/account.js';
-import { resolveAiCredential, agentAuthOptions } from './credentials.js';
-import { ISOLATED_MCP } from './agent-isolation.js';
-import { claudeExecutableOptions, getAiRuntimeStatus, loadAgentSdk, setAgentMessageObserver, } from './runtime.js';
+import { getActiveProvider, getProvider } from './provider.js';
+import { foldRateLimitEvent, mergeReadings, normaliseStoredReading, parseUsageProbe, } from './providers/claude-usage.js';
+import { setAgentMessageObserver } from './runtime.js';
+import { usageResetFromReading } from '../review/claude-review/auto-retry.js';
+import { codexAccountTokens, codexRateLimitsCached, kickCodexProbe } from './codex/app-server.js';
 export const DAY_MS = AI_BUDGET_DAY_MS;
 export const WEEK_MS = AI_BUDGET_WEEK_MS;
 /** The window "typical cycle cost" is averaged over. */
 export const CYCLE_COST_WINDOW_MS = 28 * DAY_MS;
 /** The usage probe runs at most this often (the header polls every ~2 minutes while visible). */
 export const PROBE_MIN_INTERVAL_MS = 5 * 60 * 1000;
-const PROBE_TIMEOUT_MS = 20_000;
-/** At most this many per-model windows are kept from one reading. */
-const MAX_MODEL_WINDOWS = 8;
 export { decideAiBudget, rollingSpend, liveWeekReset, liveFiveHourReset, aiUsageView };
-// ---- folding the SDK's usage reports (pure) ---------------------------------------------------
-function num(v) {
-    return typeof v === 'number' && Number.isFinite(v) ? v : null;
-}
-/** Epoch seconds or ms → ms. */
-function epochMs(v) {
-    const n = num(v);
-    if (n == null || n <= 0)
-        return null;
-    return n < 1e12 ? n * 1000 : n;
-}
-/** A `rate_limit_event` utilisation is a 0–1 FRACTION (the CLI parses it from the rate-limit header):
- *  → 0–100, explicitly. Out of range or not a number → null. */
-function eventFractionToPct(v) {
-    const n = num(v);
-    if (n == null || n < 0 || n > 1.5)
-        return null;
-    return n * 100;
-}
-/** Claude's window keys this module keeps: the 5-hour, the week, and per-model weeks. */
-const MODEL_WINDOW_KEY = /^seven_day_[a-z0-9_]{1,40}$/;
-/** Put one window into a reading under Claude's key. Unknown keys are ignored. Pure. */
-function withWindow(reading, key, w) {
-    if (key === 'five_hour')
-        return { ...reading, fiveHour: w };
-    if (key === 'seven_day')
-        return { ...reading, week: w };
-    if (MODEL_WINDOW_KEY.test(key)) {
-        const models = { ...(reading.models ?? {}) };
-        if (!(key in models) && Object.keys(models).length >= MAX_MODEL_WINDOWS)
-            return reading;
-        models[key] = w;
-        return { ...reading, models };
-    }
-    return reading;
-}
-const isWindowKey = (k) => k === 'five_hour' || k === 'seven_day' || MODEL_WINDOW_KEY.test(k);
-/**
- * Fold one Agent SDK message into the reading. Returns the NEW reading (the windows this message names
- * merged over the rest), or null when the message names none. Pure.
- *
- * Reads `rate_limit_event.rate_limit_info`: every window in `unifiedWindows` (when the CLI sends
- * them) and otherwise the one named by `rateLimitType` ('five_hour', 'seven_day', 'seven_day_opus',
- * …). Reset times arrive in epoch seconds. Utilisation is a fraction on this path.
- */
-export function foldRateLimitEvent(reading, message, nowMs) {
-    if (!message || typeof message !== 'object')
-        return null;
-    const m = message;
-    if (m.type !== 'rate_limit_event' || !m.rate_limit_info || typeof m.rate_limit_info !== 'object')
-        return null;
-    const info = m.rate_limit_info;
-    const unified = info.unifiedWindows && typeof info.unifiedWindows === 'object'
-        ? info.unifiedWindows
-        : null;
-    const sources = [];
-    if (unified) {
-        for (const [k, v] of Object.entries(unified)) {
-            if (isWindowKey(k) && v && typeof v === 'object')
-                sources.push([k, v]);
-        }
-    }
-    else if (typeof info.rateLimitType === 'string' && isWindowKey(info.rateLimitType)) {
-        sources.push([info.rateLimitType, info]);
-    }
-    let out = {};
-    let any = false;
-    for (const [key, src] of sources) {
-        let utilization = eventFractionToPct(src.utilization);
-        if (utilization == null && src.status === 'rejected')
-            utilization = 100;
-        const resetsAtMs = epochMs(src.resetsAt);
-        if (utilization == null && resetsAtMs == null)
-            continue;
-        out = withWindow(out, key, { utilization, resetsAtMs, observedAtMs: nowMs });
-        any = true;
-    }
-    return any ? mergeReadings(reading, out) : null;
-}
-/** Parse the experimental usage method's answer. Its utilisation is ALREADY 0–100 (measured on a
- *  real login: `seven_day.utilization: 31`) and is kept as-is. Null on any shape mismatch. Pure. */
-export function parseUsageProbe(resp, nowMs) {
-    if (!resp || typeof resp !== 'object')
-        return null;
-    const r = resp;
-    const subscriptionType = typeof r.subscription_type === 'string' && r.subscription_type !== '' ? r.subscription_type : null;
-    let out = {};
-    let any = false;
-    if (r.rate_limits_available === true && r.rate_limits && typeof r.rate_limits === 'object') {
-        for (const [key, v] of Object.entries(r.rate_limits)) {
-            if (!isWindowKey(key) || !v || typeof v !== 'object')
-                continue;
-            const o = v;
-            const u = num(o.utilization);
-            const t = typeof o.resets_at === 'string' ? Date.parse(o.resets_at) : NaN;
-            const utilization = u != null && u >= 0 && u <= 150 ? u : null;
-            const resetsAtMs = Number.isFinite(t) ? t : null;
-            if (utilization == null && resetsAtMs == null)
-                continue;
-            out = withWindow(out, key, { utilization, resetsAtMs, observedAtMs: nowMs });
-            any = true;
-        }
-    }
-    if (!any && subscriptionType == null)
-        return null;
-    return { ...out, subscriptionType };
-}
-function storedWindow(v) {
-    if (!v || typeof v !== 'object')
-        return null;
-    const w = v;
-    const observedAtMs = num(w.observedAtMs);
-    return observedAtMs == null ? null : { utilization: num(w.utilization), resetsAtMs: num(w.resetsAtMs), observedAtMs };
-}
-/** A stored reading of any age → today's shape. Never throws. */
-export function normaliseStoredReading(raw) {
-    if (!raw || typeof raw !== 'object')
-        return null;
-    const r = raw;
-    const week = storedWindow(r.week);
-    const fiveHour = storedWindow(r.fiveHour);
-    let models = null;
-    if (r.models && typeof r.models === 'object') {
-        for (const [k, v] of Object.entries(r.models).slice(0, MAX_MODEL_WINDOWS)) {
-            const w = MODEL_WINDOW_KEY.test(k) ? storedWindow(v) : null;
-            if (w)
-                (models ??= {})[k] = w;
-        }
-    }
-    const subscriptionType = typeof r.subscriptionType === 'string' ? r.subscriptionType : null;
-    if (week == null && fiveHour == null && models == null && subscriptionType == null)
-        return null;
-    return { week, fiveHour, models, subscriptionType };
-}
-// ---- the reading: memory + persistence --------------------------------------------------------
-let memReading; // undefined = not loaded yet
+// Claude's reading folds live in ai/providers/claude-usage.ts since the provider seam; re-exported
+// here under the names this module always had.
+export { foldRateLimitEvent, mergeReadings, normaliseStoredReading, parseUsageProbe };
+// ---- the reading: ONE normalised AiUsageReading per provider (docs/CODEX-PLAN.md § 8.1) ----------
+//
+// Claude's is kept in memory and persisted on `accounts.ai_budget_reading`, so a restart keeps it.
+// No other provider has a reading yet (Phase 2 gives Codex its own): `readingFor` answers null for it.
+let memReading; // Claude's; undefined = not loaded yet
 async function loadReading() {
     if (memReading !== undefined)
         return memReading;
@@ -208,29 +85,21 @@ async function loadReading() {
     }
     return memReading;
 }
-/** One window merged: the new one wins, but keeps the known reset when it read none. */
-function mergeWindow(prev, next) {
-    if (next == null)
-        return prev ?? null;
-    if (next.resetsAtMs == null && prev?.resetsAtMs != null)
-        return { ...next, resetsAtMs: prev.resetsAtMs };
-    return next;
+/**
+ * The provider's latest normalised reading. Codex's is the app-server probe's CACHE
+ * (ai/codex/app-server.ts) — in memory only: the probe refreshes it in the background within seconds
+ * of a restart, and until then the reading is unknown, which never blocks.
+ */
+async function readingFor(provider) {
+    if (provider.id === 'codex')
+        return codexRateLimitsCached();
+    return loadReading();
 }
-/** Merge two readings (pure): each window independently; what `next` does not mention is kept (an
- *  event never names the subscription, and names one or two windows). */
-export function mergeReadings(prev, next) {
-    const models = { ...(prev?.models ?? {}) };
-    for (const [k, w] of Object.entries(next.models ?? {})) {
-        const merged = mergeWindow(models[k], w);
-        if (merged && (k in models || Object.keys(models).length < MAX_MODEL_WINDOWS))
-            models[k] = merged;
-    }
-    return {
-        week: mergeWindow(prev?.week, next.week),
-        fiveHour: mergeWindow(prev?.fiveHour, next.fiveHour),
-        models: Object.keys(models).length === 0 ? null : models,
-        subscriptionType: next.subscriptionType ?? prev?.subscriptionType ?? null,
-    };
+/** Codex on a ChatGPT sign-in: the account's tokens in each budget window (from the probe's cache). */
+async function codexAccountTokensFor(reading, nowMs) {
+    const span = async (which) => codexAccountTokens({ fromMs: budgetWindowStart(reading, nowMs, which).fromMs, toMs: nowMs });
+    const [week, fiveHour] = await Promise.all([span('week'), span('five_hour')]);
+    return { week, fiveHour };
 }
 function storeReading(next) {
     memReading = mergeReadings(memReading ?? null, next);
@@ -244,9 +113,9 @@ function storeReading(next) {
         /* in memory still; the next reading tries again */
     });
 }
-/** The observer ai/runtime.ts calls with every agent message. */
+/** The observer ai/runtime.ts calls with every agent message (the Agent SDK's, so Claude's). */
 export function noteAgentMessage(message, nowMs = Date.now()) {
-    const next = foldRateLimitEvent(null, message, nowMs);
+    const next = getProvider('claude').usage.readingFromMessage(message, nowMs);
     if (next == null)
         return;
     // ⚠ Merge over the PERSISTED reading, never over "not loaded yet": a run's event arriving before
@@ -264,64 +133,15 @@ export function installAiBudgetObserver() {
     setAgentMessageObserver((m) => noteAgentMessage(m));
 }
 // ---- the usage probe ----------------------------------------------------------------------------
+//
+// The probe itself is the provider's (`provider.usage.probe`; Claude's is the Agent SDK's
+// experimental usage method, in ai/providers/claude.ts). Only Claude's reading is stored.
 let lastProbeAtMs = 0;
 let probeInFlight = null;
-/** Ask the Agent SDK's experimental usage method. Spawns the CLI with an empty input stream (no model
- *  call), asks, closes. Throws on anything unexpected; the caller swallows. */
-const sdkUsageProbe = async () => {
-    const sdk = await loadAgentSdk();
-    let release = () => { };
-    const held = new Promise((r) => {
-        release = r;
-    });
-    // An input stream that never yields a turn: the CLI starts, answers control requests, and spends
-    // nothing.
-    async function* noTurns() {
-        await held;
-    }
-    const q = sdk.query({
-        prompt: noTurns(),
-        options: {
-            allowedTools: [],
-            settingSources: [],
-            ...ISOLATED_MCP,
-            ...claudeExecutableOptions(),
-            ...agentAuthOptions(),
-        },
-    });
-    try {
-        const method = q
-            .usage_EXPERIMENTAL_MAY_CHANGE_DO_NOT_RELY_ON_THIS_API_YET;
-        if (typeof method !== 'function')
-            throw new Error('usage method not available');
-        let timer;
-        try {
-            return await Promise.race([
-                method.call(q, { skipBehaviors: true }),
-                new Promise((_, reject) => {
-                    timer = setTimeout(() => reject(new Error('usage probe timed out')), PROBE_TIMEOUT_MS);
-                }),
-            ]);
-        }
-        finally {
-            if (timer)
-                clearTimeout(timer);
-        }
-    }
-    finally {
-        release();
-        try {
-            q.close?.();
-        }
-        catch {
-            /* already gone */
-        }
-    }
-};
-let probeImpl = sdkUsageProbe;
+let probeOverride = null;
 /** Test hook. */
 export function _setUsageProbeForTest(p) {
-    probeImpl = p ?? sdkUsageProbe;
+    probeOverride = p;
     lastProbeAtMs = 0;
     probeInFlight = null;
 }
@@ -335,18 +155,25 @@ export function _resetAiBudgetForTest() {
 /** Start the probe IN THE BACKGROUND when it can help: login route (the caller checks), runtime
  *  ready, not run in the last PROBE_MIN_INTERVAL_MS. Single-flight. Never throws, never awaited by a
  *  request: the caller serves the cached reading. Returns the in-flight promise for tests. */
-export function kickUsageProbe(nowMs = Date.now()) {
+export function kickUsageProbe(nowMs = Date.now(), provider = getActiveProvider()) {
+    // Codex's probe is the app-server's own (account, windows and token counts in one process), with
+    // the same 5-minute floor and single flight.
+    if (provider.id === 'codex')
+        return provider.usage.probeReady() ? kickCodexProbe({ nowMs }) : null;
+    if (provider.id !== 'claude')
+        return null;
     if (probeInFlight)
         return probeInFlight;
     if (nowMs - lastProbeAtMs < PROBE_MIN_INTERVAL_MS)
         return null;
-    if (probeImpl === sdkUsageProbe && getAiRuntimeStatus().runtime !== 'ready')
+    if (probeOverride == null && !provider.usage.probeReady())
         return null;
     lastProbeAtMs = nowMs;
+    const probe = probeOverride ?? (() => provider.usage.probe());
     probeInFlight = (async () => {
         try {
             await loadReading();
-            const parsed = parseUsageProbe(await probeImpl(), Date.now());
+            const parsed = provider.usage.readingFromProbe(await probe(), Date.now());
             if (parsed)
                 storeReading(parsed);
         }
@@ -382,12 +209,25 @@ export async function writeAiBudgetSettings(accountId, body) {
     return next;
 }
 // ---- the status and the gate ----------------------------------------------------------------------
-async function readLedger(accountId, sinceMs) {
+/**
+ * Where the ledger read starts: the week, today, and every account-token span's start (a Codex day
+ * bucket can start before the week window; Limn's tokens must be counted over the account's span
+ * EXACTLY, so the read must reach back to it). Exported for the test.
+ */
+export function ledgerSinceMs(nowMs, accountTokens) {
+    const starts = [nowMs - WEEK_MS, localMidnightMs(nowMs)];
+    for (const s of [accountTokens?.week, accountTokens?.fiveHour])
+        if (s && Number.isFinite(s.fromMs))
+            starts.push(s.fromMs);
+    return Math.min(...starts);
+}
+/** Limn's recorded spend since `sinceMs` — ONE provider's rows only (a budget is per provider). */
+async function readLedger(accountId, sinceMs, providerId) {
     const { aiUsage } = schema;
     const rows = await db
         .select({ at: aiUsage.occurredAt, usd: aiUsage.costUsd, inTok: aiUsage.inputTokens, outTok: aiUsage.outputTokens })
         .from(aiUsage)
-        .where(and(eq(aiUsage.accountId, accountId), gte(aiUsage.occurredAt, new Date(sinceMs))))
+        .where(and(eq(aiUsage.accountId, accountId), eq(aiUsage.provider, providerId), gte(aiUsage.occurredAt, new Date(sinceMs))))
         .execute();
     return rows.map((r) => ({
         atMs: r.at.getTime(),
@@ -398,13 +238,13 @@ async function readLedger(accountId, sinceMs) {
 }
 /** The account's typical automatic-review cycle: the mean recorded cost of a Claude review and of a
  *  diagram run over the last 28 days, and whether any of its workspaces draws diagrams by itself. */
-export async function readCycleCosts(accountId, nowMs) {
+export async function readCycleCosts(accountId, nowMs, providerId = 'claude') {
     const { aiUsage, workspaces } = schema;
     const [rows, ws] = await Promise.all([
         db
             .select({ feature: aiUsage.feature, usd: aiUsage.costUsd })
             .from(aiUsage)
-            .where(and(eq(aiUsage.accountId, accountId), inArray(aiUsage.feature, ['claude_review', 'sequence_diagram']), gte(aiUsage.occurredAt, new Date(nowMs - CYCLE_COST_WINDOW_MS))))
+            .where(and(eq(aiUsage.accountId, accountId), eq(aiUsage.provider, providerId), inArray(aiUsage.feature, ['claude_review', 'sequence_diagram']), gte(aiUsage.occurredAt, new Date(nowMs - CYCLE_COST_WINDOW_MS))))
             .execute(),
         db
             .select({ id: workspaces.id })
@@ -444,21 +284,41 @@ function localMidnightMs(nowMs) {
  */
 export async function aiBudgetSnapshot(accountId, opts = {}) {
     const nowMs = opts.nowMs ?? Date.now();
-    const route = resolveAiCredential().route;
+    // THE PROVIDER's budget (docs/CODEX-PLAN.md § 8.1): its credential route, its reading, its rows of
+    // the ledger — the named one (a manual run's per-run choice), else the default (active) one.
+    const provider = opts.provider ? getProvider(opts.provider) : getActiveProvider();
+    const route = provider.credentialRoute();
     const { settings, isDefault } = await readAiBudgetSettings(accountId);
     const probe = opts.probe ?? 'when_on';
     if (route === 'login' && (probe === 'always' || (probe === 'when_on' && settings.enabled)))
-        kickUsageProbe(nowMs);
-    const [reading, ledger, costs] = await Promise.all([
-        route === 'login' ? loadReading() : Promise.resolve(null),
-        readLedger(accountId, Math.min(nowMs - WEEK_MS, localMidnightMs(nowMs))),
-        settings.enabled && route === 'login' ? readCycleCosts(accountId, nowMs) : Promise.resolve(NO_CYCLE_COSTS),
+        kickUsageProbe(nowMs, provider);
+    const isCodex = provider.id === 'codex';
+    const reading = route === 'login' ? await readingFor(provider) : null;
+    // Codex's share is TOKEN-WEIGHTED (packages/shared ai-budget.ts): the account's tokens over a span,
+    // and Limn's counted over EXACTLY that span — so the ledger is read from the EARLIEST span start (a
+    // day bucket may start before the week window).
+    const accountTokens = isCodex && route === 'login' ? await codexAccountTokensFor(reading, nowMs) : null;
+    const [ledger, costs] = await Promise.all([
+        readLedger(accountId, ledgerSinceMs(nowMs, accountTokens), provider.id),
+        settings.enabled && route === 'login' && !isCodex
+            ? readCycleCosts(accountId, nowMs, provider.id)
+            : Promise.resolve(NO_CYCLE_COSTS),
     ]);
+    const providerId = provider.id;
     return {
         settings,
         isDefault,
-        status: decideAiBudget({ settings, route, reading, ledger, costs, nowMs }),
-        usage: aiUsageView({ settings, route, reading, ledger, nowMs, todayFromMs: localMidnightMs(nowMs) }),
+        status: decideAiBudget({ settings, route, reading, ledger, costs, nowMs, provider: providerId, accountTokens }),
+        usage: aiUsageView({
+            settings,
+            route,
+            reading,
+            ledger,
+            nowMs,
+            todayFromMs: localMidnightMs(nowMs),
+            provider: providerId,
+            accountTokens,
+        }),
     };
 }
 /** The budget's status for an account. Never throws: a failed read is "off" (never blocks). */
@@ -467,7 +327,7 @@ export async function aiBudgetStatus(accountId, opts = {}) {
         return (await aiBudgetSnapshot(accountId, opts)).status;
     }
     catch {
-        return OFF_STATUS(resolveAiCredential().route);
+        return OFF_STATUS(getActiveProvider().credentialRoute());
     }
 }
 // account → when its current pause was first logged (log once per pause).
@@ -490,6 +350,16 @@ export async function allowAutomaticRun(accountId, what, log, statusOf = (a) =>
     return false;
 }
 export function buildAiBudgetGate(log) {
-    return { allowAutomaticRun: (accountId, what) => allowAutomaticRun(accountId, what, log) };
+    return {
+        allowAutomaticRun: (accountId, what) => allowAutomaticRun(accountId, what, log),
+        usageResetAfter: async (provider, failedAtMs) => {
+            try {
+                return usageResetFromReading(await readingFor(getProvider(provider)), failedAtMs);
+            }
+            catch {
+                return null;
+            }
+        },
+    };
 }
 //# sourceMappingURL=budget.js.map