@teamvibe/poller 0.8.2-rc.2 → 0.8.3-rc.2

package/dist/subscription-runtime.d.ts

@@ -0,0 +1,53 @@
+import { type SubscriptionAccount } from './subscription-pool-client.js';
+import { type ResolvedPoolModel } from './subscription-pool.js';
+import { FileSubscriptionUsageStore, type SubscriptionUsageStore } from './subscription-usage-store.js';
+import { type PoolFetchResult } from './subscription-selection.js';
+import type { SubscriptionPin, TeamVibeQueueMessage, SessionMetrics } from './types.js';
+import type { ClaudeRateLimitInfo } from './claude-rate-limit.js';
+import type { ClaudeQuotaFailure } from './claude-quota.js';
+import type { KilledByPoller } from './classify-failed-iteration.js';
+export interface PoolAttempt {
+    workspaceId: string;
+    accountId: string;
+    accountLabel?: string;
+    observedAt?: number;
+    rateLimitInfo?: ClaudeRateLimitInfo;
+    credentialVersion: string;
+    sessionId?: string;
+    model?: string;
+    success: boolean;
+    exitCode: number | null;
+    killedByPoller?: KilledByPoller;
+    quota?: ClaudeQuotaFailure;
+    metrics?: SessionMetrics;
+}
+export declare class PoolDeferredError extends Error {
+    readonly eligibleAt: number;
+    readonly resetAt?: string | undefined;
+    attempts?: readonly PoolAttempt[];
+    constructor(eligibleAt?: number, resetAt?: string | undefined);
+}
+export interface PoolRuntimeOptions {
+    pin?: SubscriptionPin;
+    pool?: PoolFetchResult<SubscriptionAccount>;
+    attempts?: readonly PoolAttempt[];
+    quotaDeferEpisodes?: number;
+    persist: (sessionId: string, pin: SubscriptionPin, attempts?: readonly PoolAttempt[]) => Promise<void>;
+    complete: (sessionId: string, pin: SubscriptionPin, attempts: readonly PoolAttempt[], rateLimitInfo?: ClaudeRateLimitInfo) => Promise<void>;
+    shouldStop: () => boolean;
+}
+export declare function subscriptionUsageStore(): FileSubscriptionUsageStore;
+export declare function fetchRuntimePool(msg: TeamVibeQueueMessage): Promise<PoolFetchResult<SubscriptionAccount>>;
+export declare function preparePool(msg: TeamVibeQueueMessage, resolved: ResolvedPoolModel, pin?: SubscriptionPin, fetched?: PoolFetchResult<SubscriptionAccount>): Promise<{
+    account: SubscriptionAccount;
+    store: FileSubscriptionUsageStore;
+    pool: PoolFetchResult<SubscriptionAccount>;
+} | {
+    account: undefined;
+    store: FileSubscriptionUsageStore;
+    pool: PoolFetchResult<SubscriptionAccount>;
+}>;
+export declare function accountPin(account: SubscriptionAccount, resolved: ResolvedPoolModel): SubscriptionPin;
+export declare function validateAccount(account: SubscriptionAccount, resolved: ResolvedPoolModel): Promise<void>;
+/** A snapshot TTL/recheck is not a provider reset. Report a reset only when reactive evidence establishes it. */
+export declare function poolDeferredError(pool: PoolFetchResult<SubscriptionAccount>, resolved: ResolvedPoolModel, store: SubscriptionUsageStore, eligibleAt?: number): Promise<PoolDeferredError>;

package/dist/subscription-runtime.js

@@ -0,0 +1,74 @@
+import { emitCandidateUsage } from './pool-telemetry.js';
+import { join } from 'node:path';
+import { config } from './config.js';
+import { getPollerId } from './auth-provider.js';
+import { fetchSubscriptionPool } from './subscription-pool-client.js';
+import { selectPoolForResolvedModel } from './subscription-pool.js';
+import { FileSubscriptionUsageStore } from './subscription-usage-store.js';
+import { POOL_RECHECK_MS } from './subscription-selection.js';
+export class PoolDeferredError extends Error {
+    eligibleAt;
+    resetAt;
+    attempts;
+    constructor(eligibleAt = Date.now() + POOL_RECHECK_MS, resetAt) {
+        super('Subscription pool unavailable; work retained');
+        this.eligibleAt = eligibleAt;
+        this.resetAt = resetAt;
+    }
+}
+export function subscriptionUsageStore() {
+    return new FileSubscriptionUsageStore(join(config.TEAMVIBE_DATA_DIR, 'subscription-usage'));
+}
+export async function fetchRuntimePool(msg) {
+    return fetchSubscriptionPool({ pollerId: getPollerId() || '', workspaceId: msg.teamvibe.workspaceId, channelId: msg.teamvibe.channelId }, { apiUrl: config.TEAMVIBE_API_URL, pollerToken: config.TEAMVIBE_POLLER_TOKEN || '' });
+}
+export async function preparePool(msg, resolved, pin, fetched) {
+    const pool = fetched ?? await fetchRuntimePool(msg);
+    const store = subscriptionUsageStore();
+    if (pool.kind === 'ready')
+        await emitCandidateUsage(msg, pool.accounts, store);
+    if (pool.kind === 'ready' && pin?.workspaceId === msg.teamvibe.workspaceId) {
+        const account = pool.accounts.find(a => a.accountId === pin.accountId);
+        if (account) {
+            const selected = await selectPoolForResolvedModel(resolved, { workspaceId: msg.teamvibe.workspaceId, pool: { kind: 'ready', accounts: [account] }, store, now: Date.now() });
+            if (selected.kind === 'selected')
+                return { account, store, pool };
+        }
+    }
+    const selected = await selectPoolForResolvedModel(resolved, { workspaceId: msg.teamvibe.workspaceId, pool, store, now: Date.now() });
+    if (selected.kind === 'selected')
+        return { account: selected.account, store, pool };
+    if (selected.kind === 'no_accounts_configured')
+        return { account: undefined, store, pool };
+    throw await poolDeferredError(pool, resolved, store, selected.kind === 'deferred' ? selected.eligibleAt : undefined);
+}
+export function accountPin(account, resolved) {
+    return { workspaceId: account.workspaceId, accountId: account.accountId, credentialVersion: account.credentialVersion, ...resolved };
+}
+export async function validateAccount(account, resolved) {
+    const selected = await selectPoolForResolvedModel(resolved, { workspaceId: account.workspaceId, pool: { kind: 'ready', accounts: [account] }, store: subscriptionUsageStore(), now: Date.now() });
+    if (selected.kind !== 'selected')
+        throw new PoolDeferredError(selected.kind === 'deferred' ? selected.eligibleAt : undefined);
+}
+/** A snapshot TTL/recheck is not a provider reset. Report a reset only when reactive evidence establishes it. */
+export async function poolDeferredError(pool, resolved, store, eligibleAt) {
+    if (eligibleAt === undefined) {
+        const selected = await selectPoolForResolvedModel(resolved, { workspaceId: pool.kind === 'ready' ? pool.accounts[0]?.workspaceId ?? '' : '', pool, store, now: Date.now() });
+        eligibleAt = selected.kind === 'deferred' ? selected.eligibleAt : Date.now() + POOL_RECHECK_MS;
+    }
+    if (pool.kind === 'ready') {
+        try {
+            for (const account of pool.accounts) {
+                const selected = await selectPoolForResolvedModel(resolved, { workspaceId: account.workspaceId, pool: { kind: 'ready', accounts: [account] }, store, now: Date.now() });
+                if (selected.kind !== 'deferred' || selected.eligibleAt !== eligibleAt)
+                    continue;
+                const state = await store.read(account);
+                const live = state.reactive.filter(r => !r.quota.resetAt || Date.parse(r.quota.resetAt) > Date.now());
+                if (live.length && live.every(r => r.quota.resetAt && Number.isFinite(Date.parse(r.quota.resetAt))) && live.some(r => Date.parse(r.quota.resetAt) === eligibleAt))
+                    return new PoolDeferredError(eligibleAt, new Date(eligibleAt).toISOString());
+            }
+        }
+        catch { }
+    }
+    return new PoolDeferredError(eligibleAt);
+}

package/dist/subscription-selection.d.ts

@@ -0,0 +1,75 @@
+import type { ClaudeQuotaFailure } from './claude-quota.js';
+export declare const USAGE_THRESHOLD_PERCENT = 90;
+/** Passive snapshots are useful for five minutes, then become unknown. */
+export declare const PASSIVE_USAGE_TTL_MS: number;
+export declare const PROBE_USAGE_TTL_MS = 60000;
+export declare const POOL_RECHECK_MS: number;
+export interface AccountIdentity {
+    workspaceId: string;
+    accountId: string;
+    credentialVersion: string;
+    enabled: boolean;
+}
+export type PoolFetchResult<A extends AccountIdentity = AccountIdentity> = {
+    kind: 'ready';
+    accounts: readonly A[];
+} | {
+    kind: 'no_accounts_configured';
+} | {
+    kind: 'unknown_pool_state';
+} | {
+    kind: 'fetch_unauthorized';
+    status: 401 | 403;
+} | {
+    kind: 'fetch_unavailable';
+    reason: 'configuration' | 'http' | 'network' | 'invalid_response' | 'cancelled' | 'no_usable_accounts';
+    status?: number;
+};
+export interface UsageWindow {
+    window: 'five_hour' | 'seven_day';
+    scope: 'global' | 'sonnet' | 'opus' | 'haiku' | 'uncertain';
+    percent?: number;
+    resetAt?: number;
+}
+export interface UsageObservation {
+    source: 'passive' | 'probe';
+    observedAt: number;
+    windows: readonly UsageWindow[];
+}
+export interface ReactiveExhaustion {
+    observedAt: number;
+    quota: ClaudeQuotaFailure;
+}
+export interface AccountUsageState {
+    usage?: UsageObservation;
+    reactive?: readonly ReactiveExhaustion[];
+}
+export type SelectionOutcome<A extends AccountIdentity = AccountIdentity> = {
+    kind: 'selected';
+    account: A;
+    provenance: 'known';
+    score: number;
+    source: 'passive' | 'probe';
+} | {
+    kind: 'selected';
+    account: A;
+    provenance: 'unknown';
+    uncertainApplicability: boolean;
+} | {
+    kind: 'deferred';
+    eligibleAt: number;
+} | Exclude<PoolFetchResult<A>, {
+    kind: 'ready';
+}>;
+export declare function record(value: unknown): Record<string, unknown>;
+export declare function normalizePassiveUsage(value: unknown, observedAt: number): UsageObservation;
+export declare function normalizeProbeUsage(value: unknown, observedAt: number): UsageObservation;
+export declare function reactiveEligibleAt(reactive: ReactiveExhaustion): number;
+/** Pure policy. Unknown is eligible after every known/reactive blocker is ruled out. */
+export declare function selectSubscriptionAccount<A extends AccountIdentity>(input: {
+    pool: PoolFetchResult<A>;
+    /** Stable account ID within the pool's single workspace. */
+    states: Readonly<Record<string, AccountUsageState | undefined>>;
+    model: string | undefined;
+    now: number;
+}): SelectionOutcome<A>;

package/dist/subscription-selection.js

@@ -0,0 +1,142 @@
+export const USAGE_THRESHOLD_PERCENT = 90;
+/** Passive snapshots are useful for five minutes, then become unknown. */
+export const PASSIVE_USAGE_TTL_MS = 5 * 60_000;
+export const PROBE_USAGE_TTL_MS = 60_000;
+export const POOL_RECHECK_MS = 15 * 60_000;
+export function record(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+function percent(value, scale) {
+    return typeof value === 'number' && Number.isFinite(value) && value >= 0 && value <= scale ? value * (100 / scale) : undefined;
+}
+function epoch(value) {
+    return typeof value === 'number' && Number.isInteger(value) && value > 0 && value <= 253402300799 ? value * 1000 : undefined;
+}
+function date(value) {
+    if (typeof value !== 'string' || !/^\d{4}-\d\d-\d\dT\d\d:\d\d:\d\d(?:\.\d{1,3})?(?:Z|[+-]\d\d:\d\d)$/.test(value))
+        return undefined;
+    const [year, month, day] = value.slice(0, 10).split('-').map(Number);
+    const calendar = new Date(Date.UTC(year, month - 1, day));
+    if (calendar.getUTCFullYear() !== year || calendar.getUTCMonth() + 1 !== month || calendar.getUTCDate() !== day)
+        return undefined;
+    const ms = Date.parse(value);
+    return Number.isFinite(ms) && ms > 0 ? ms : undefined;
+}
+export function normalizePassiveUsage(value, observedAt) {
+    const info = record(value);
+    const windows = [];
+    const unified = record(info['unifiedWindows']);
+    for (const window of ['five_hour', 'seven_day']) {
+        const raw = unified[window];
+        if (raw == null)
+            continue;
+        const item = record(raw);
+        windows.push({ window, scope: 'global', percent: percent(item['utilization'], 1), resetAt: epoch(item['resetsAt']) });
+    }
+    const type = info['rateLimitType'];
+    if (typeof type === 'string') {
+        const legacy = type.match(/^(five_hour|seven_day)(?:_(sonnet|opus|haiku))?$/);
+        windows.push({
+            window: legacy?.[1] === 'five_hour' ? 'five_hour' : 'seven_day',
+            scope: legacy ? (legacy[2] ?? 'global') : 'uncertain',
+            percent: percent(info['utilization'], 1), resetAt: epoch(info['resetsAt']),
+        });
+    }
+    return { source: 'passive', observedAt, windows };
+}
+export function normalizeProbeUsage(value, observedAt) {
+    const info = record(value);
+    const windows = [];
+    for (const [key, window, scope] of [
+        ['five_hour', 'five_hour', 'global'], ['seven_day', 'seven_day', 'global'],
+        ['seven_day_sonnet', 'seven_day', 'sonnet'], ['seven_day_opus', 'seven_day', 'opus'],
+    ]) {
+        const raw = info[key];
+        if (raw == null)
+            continue;
+        const item = record(raw);
+        windows.push({ window, scope, percent: percent(item['utilization'], 100), resetAt: date(item['resets_at']) });
+    }
+    // The optional endpoint is undocumented. Accept only the explicit window /
+    // model form below; arbitrary internal codenames never map to a family.
+    if (Array.isArray(info['limits'])) {
+        for (const raw of info['limits'].slice(0, 128)) {
+            const item = record(raw);
+            const window = item['window'];
+            if (window !== 'five_hour' && window !== 'seven_day') {
+                windows.push({ window: 'seven_day', scope: 'uncertain' });
+                continue;
+            }
+            const model = item['model'];
+            const scope = model === 'global' ? 'global' : typeof model === 'string' ? family(model) ?? 'uncertain' : 'uncertain';
+            windows.push({ window, scope, percent: percent(item['utilization'], 100), resetAt: date(item['resets_at']) });
+        }
+        if (info['limits'].length > 128)
+            windows.push({ window: 'seven_day', scope: 'uncertain' });
+    }
+    return { source: 'probe', observedAt, windows };
+}
+function family(model) {
+    return model?.toLowerCase().match(/^(?:claude-)?(sonnet|opus|haiku)(?:-\d[\w.-]*)?(?:\[1m\])?$/)?.[1];
+}
+function applicable(scope, model) {
+    return scope === 'global' || scope === 'uncertain' || family(model) === undefined || scope === family(model);
+}
+export function reactiveEligibleAt(reactive) {
+    const parsed = reactive.quota.resetAt ? Date.parse(reactive.quota.resetAt) : NaN;
+    return Number.isFinite(parsed) && parsed > reactive.observedAt ? parsed : reactive.observedAt + POOL_RECHECK_MS;
+}
+/** Pure policy. Unknown is eligible after every known/reactive blocker is ruled out. */
+export function selectSubscriptionAccount(input) {
+    if (input.pool.kind !== 'ready')
+        return input.pool;
+    const accounts = input.pool.accounts;
+    if (!accounts.length || accounts.some(a => !a.enabled || a.workspaceId !== accounts[0].workspaceId))
+        return { kind: 'fetch_unavailable', reason: 'invalid_response' };
+    const known = [];
+    const unknown = [];
+    const deadlines = [];
+    for (const account of input.pool.accounts) {
+        if (!account.enabled)
+            continue;
+        const state = input.states[account.accountId];
+        const blockers = [];
+        for (const reactive of state?.reactive ?? []) {
+            // Like durable pause createdAt, future observations expire on clock rollback.
+            if (input.now < reactive.observedAt)
+                continue;
+            const scope = reactive.quota.modelScope;
+            if (scope && family(scope) && family(input.model) && family(scope) !== family(input.model))
+                continue;
+            const until = reactiveEligibleAt(reactive);
+            if (input.now < until)
+                blockers.push(until);
+        }
+        const usage = state?.usage;
+        const expiry = usage ? usage.observedAt + (usage.source === 'passive' ? PASSIVE_USAGE_TTL_MS : PROBE_USAGE_TTL_MS) : 0;
+        const fresh = usage && usage.observedAt <= input.now && input.now < expiry;
+        const windows = fresh ? usage.windows.filter(w => applicable(w.scope, input.model) && (w.resetAt === undefined || w.resetAt > input.now)) : [];
+        const uncertain = windows.some(w => w.scope === 'uncertain' || (w.scope !== 'global' && !family(input.model)));
+        for (const w of windows) {
+            if (w.percent !== undefined && w.percent >= USAGE_THRESHOLD_PERCENT)
+                blockers.push(Math.min(w.resetAt ?? expiry, expiry));
+        }
+        if (blockers.length) {
+            deadlines.push(Math.max(...blockers));
+        }
+        else if (windows.length && !uncertain && windows.every(w => w.percent !== undefined && w.resetAt !== undefined)) {
+            known.push({ account, score: Math.max(...windows.map(w => w.percent)), source: usage.source });
+        }
+        else {
+            unknown.push({ account, uncertainApplicability: uncertain });
+        }
+    }
+    const compare = (a, b) => a.accountId < b.accountId ? -1 : a.accountId > b.accountId ? 1 : 0;
+    known.sort((a, b) => a.score - b.score || compare(a.account, b.account));
+    unknown.sort((a, b) => compare(a.account, b.account));
+    if (known[0])
+        return { kind: 'selected', provenance: 'known', ...known[0] };
+    if (unknown[0])
+        return { kind: 'selected', provenance: 'unknown', ...unknown[0] };
+    return { kind: 'deferred', eligibleAt: Math.min(...deadlines) };
+}

package/dist/subscription-usage-probe.d.ts

@@ -0,0 +1,16 @@
+import { type SubscriptionAccount } from './subscription-pool-client.js';
+import type { ProbeStatus, SubscriptionUsageStore } from './subscription-usage-store.js';
+interface ProbeOptions {
+    fetch?: typeof fetch;
+    now?: () => number;
+    timeoutMs?: number;
+    concurrency?: number;
+}
+export type ProbeResultStatus = ProbeStatus | 'store_unavailable';
+/** Optional background source. Selection NEVER calls/awaits this class. */
+export declare class OptionalSubscriptionUsageProbe {
+    #private;
+    constructor(store: SubscriptionUsageStore, options?: ProbeOptions);
+    probeAccounts(workspaceId: string, accounts: readonly SubscriptionAccount[], signal?: AbortSignal): Promise<Record<string, ProbeResultStatus>>;
+}
+export {};

package/dist/subscription-usage-probe.js

@@ -0,0 +1,106 @@
+import { boundedRequest, readSubscriptionJson } from './subscription-pool-client.js';
+import { normalizeProbeUsage, record } from './subscription-selection.js';
+/** Optional background source. Selection NEVER calls/awaits this class. */
+export class OptionalSubscriptionUsageProbe {
+    #store;
+    #options;
+    #concurrency;
+    #active = 0;
+    #waiting = [];
+    constructor(store, options = {}) {
+        this.#store = store;
+        this.#options = options;
+        this.#concurrency = Math.max(1, Math.min(8, Math.floor(options.concurrency ?? 2) || 2));
+    }
+    async #slot(signal) {
+        if (signal?.aborted)
+            return false;
+        if (this.#active < this.#concurrency) {
+            this.#active++;
+            return true;
+        }
+        return new Promise(resolve => {
+            const start = () => { signal?.removeEventListener('abort', cancel); resolve(true); };
+            const cancel = () => {
+                const index = this.#waiting.indexOf(start);
+                if (index >= 0)
+                    this.#waiting.splice(index, 1);
+                resolve(false);
+            };
+            this.#waiting.push(start);
+            signal?.addEventListener('abort', cancel, { once: true });
+        });
+    }
+    #release() {
+        const next = this.#waiting.shift();
+        if (next)
+            next();
+        else
+            this.#active--;
+    }
+    async probeAccounts(workspaceId, accounts, signal) {
+        const results = Object.create(null);
+        await Promise.all(accounts.filter(a => a.enabled && a.workspaceId === workspaceId).map(async (account) => {
+            if (!await this.#slot(signal)) {
+                results[account.accountId] = 'cancelled';
+                return;
+            }
+            try {
+                results[account.accountId] = await this.#probe(account, signal);
+            }
+            finally {
+                this.#release();
+            }
+        }));
+        return results;
+    }
+    async #probe(account, signal) {
+        const now = () => (this.#options.now ?? Date.now)();
+        if (signal?.aborted)
+            return 'cancelled';
+        try {
+            if (!await this.#store.beginProbe(account, now()))
+                return (await this.#store.read(account)).probe?.status ?? 'unavailable';
+        }
+        catch {
+            return 'store_unavailable';
+        }
+        const outcome = { status: 'unavailable' };
+        try {
+            await boundedRequest(async (signal) => {
+                const response = await (this.#options.fetch ?? fetch)('https://api.anthropic.com/api/oauth/usage', {
+                    method: 'GET', signal, redirect: 'error',
+                    headers: { Authorization: `Bearer ${account.credential.unwrap()}`, 'anthropic-beta': 'oauth-2025-04-20', 'Cache-Control': 'no-store' },
+                });
+                if (response.status === 401) {
+                    outcome.status = 'unauthorized';
+                    return;
+                }
+                if (response.status === 403) {
+                    outcome.status = 'unauthorized';
+                    const body = record(await readSubscriptionJson(response));
+                    if (record(body['error'])['error_code'] === 'oauth_scope_insufficient' || body['error_code'] === 'oauth_scope_insufficient')
+                        outcome.status = 'unsupported';
+                    return;
+                }
+                if (!response.ok)
+                    return;
+                const body = await readSubscriptionJson(response);
+                if (!body || typeof body !== 'object' || Array.isArray(body))
+                    return;
+                outcome.usage = normalizeProbeUsage(body, now());
+                outcome.status = 'ok';
+            }, signal, this.#options.timeoutMs);
+        }
+        catch {
+            outcome.status = signal?.aborted ? 'cancelled' : 'unavailable';
+        }
+        try {
+            await this.#store.finishProbe(account, { status: outcome.status, observedAt: now(), ...(outcome.usage && outcome.status === 'ok' ? { usage: outcome.usage } : {}) });
+        }
+        catch {
+            return 'store_unavailable';
+        }
+        return outcome.status;
+    }
+}

package/dist/subscription-usage-store.d.ts

@@ -0,0 +1,47 @@
+import { type ClaudeRateLimitInfo } from './claude-rate-limit.js';
+import type { ClaudeQuotaFailure } from './claude-quota.js';
+import { type AccountIdentity, type AccountUsageState, type ReactiveExhaustion, type UsageObservation } from './subscription-selection.js';
+export type UsageKey = Pick<AccountIdentity, 'workspaceId' | 'accountId' | 'credentialVersion'>;
+export type ProbeStatus = 'attempted' | 'ok' | 'unsupported' | 'unauthorized' | 'unavailable' | 'cancelled';
+export interface ProbeObservation {
+    status: ProbeStatus;
+    observedAt: number;
+    usage?: UsageObservation;
+}
+export interface StoredAccountUsage {
+    passive?: {
+        rateLimitInfo: ClaudeRateLimitInfo;
+        observedAt: number;
+    };
+    probe?: ProbeObservation;
+    /** Account-level evidence intentionally survives credential rotations. */
+    reactive: readonly ReactiveExhaustion[];
+}
+/** #405 writes after each spawn; callers must handle store errors without falling back to ambient credentials. */
+export interface UsageWriteOptions {
+    expireFutureObservations?: boolean;
+}
+export interface SubscriptionUsageStore {
+    read(key: UsageKey): Promise<StoredAccountUsage>;
+    recordPassive(key: UsageKey, rateLimitInfo: ClaudeRateLimitInfo, observedAt: number, options?: UsageWriteOptions): Promise<void>;
+    recordQuota(key: UsageKey, quota: ClaudeQuotaFailure, observedAt: number, options?: UsageWriteOptions): Promise<void>;
+    /** Persist BEFORE network I/O; one attempt per credential version, including restart. */
+    beginProbe(key: UsageKey, observedAt: number): Promise<boolean>;
+    finishProbe(key: UsageKey, observation: ProbeObservation): Promise<void>;
+}
+export declare function usageStateForSelection(state: StoredAccountUsage, now: number): AccountUsageState;
+export declare class SubscriptionUsageStoreError extends Error {
+    constructor();
+}
+export declare function safeRateLimitInfo(info: unknown): ClaudeRateLimitInfo;
+export declare function safeQuota(quota: ClaudeQuotaFailure): ClaudeQuotaFailure;
+/** One file per version + one reactive file per workspace/account. No credentials or raw provider bodies. */
+export declare class FileSubscriptionUsageStore implements SubscriptionUsageStore {
+    #private;
+    constructor(directory: string);
+    read(key: UsageKey): Promise<StoredAccountUsage>;
+    recordPassive(key: UsageKey, rateLimitInfo: ClaudeRateLimitInfo, observedAt: number, options?: UsageWriteOptions): Promise<void>;
+    recordQuota(key: UsageKey, quota: ClaudeQuotaFailure, observedAt: number, options?: UsageWriteOptions): Promise<void>;
+    beginProbe(key: UsageKey, observedAt: number): Promise<boolean>;
+    finishProbe(key: UsageKey, observation: ProbeObservation): Promise<void>;
+}