vibe-usage-cli 0.0.0-stage → 0.1.1

package/build/core/service.js

@@ -0,0 +1,484 @@
+// The quota service: owns the settings, discovers accounts, reads quotas and hands out
+// snapshots. Settings writes are serialized; reads run per provider, deduplicated.
+import os from 'node:os';
+import { createAntigravityProvider } from "../providers/antigravity.js";
+import { createClaudeProvider } from "../providers/claude.js";
+import { createCodexProvider } from "../providers/codex.js";
+import { createCursorProvider } from "../providers/cursor.js";
+import { HEALTHY_STATUSES } from "../shared/account-state.js";
+import { ACCOUNT_ID_PATTERN, DURATION_MS, MAX_DISMISSED_ACCOUNTS, PROFILE_PROVIDER_IDS, PROVIDER_IDS } from "../shared/catalog.js";
+import { profileFolders } from "../providers/profiles.js";
+import { AppError, ProviderError, providerErrorCode } from "./errors.js";
+import { isObject, pathKey } from "./files.js";
+import { loadMeasurements, measurementOf, saveMeasurements } from "./measurements.js";
+import { normalizeWindow } from "./model.js";
+import { defaultSettings, loadSettingsWithRecovery, saveSettings, validateSettings } from "./settings.js";
+const ADAPTER_FACTORIES = {
+    claude: () => createClaudeProvider(),
+    codex: () => createCodexProvider(),
+    cursor: () => createCursorProvider(),
+    antigravity: () => createAntigravityProvider()
+};
+const FETCH_TIMEOUT_MS = 12000;
+const DISCOVERY_INTERVAL_MS = DURATION_MS.MINUTE;
+// A discovered account disappears only after this many clean discovery passes without it,
+// so a transient read failure never deletes it.
+const MISSES_BEFORE_REMOVAL = 3;
+const DEFAULT_RATE_LIMIT_COOLDOWN_SECONDS = 120;
+// An expired sign-in that could not be renewed is tried again after this.
+const RENEW_INTERVAL_MS = 30 * DURATION_MS.MINUTE;
+// Accounts that mirror running processes rather than files on disk; their absence means
+// "app closed", not "account removed".
+const PROCESS_BOUND_PROVIDERS = new Set(['antigravity']);
+// A sign-in finishes in the browser at the user's pace; a pending account waits this long for it.
+export const SIGN_IN_WINDOW_MS = 10 * DURATION_MS.MINUTE;
+// Whether the app may move work to an account by itself: continuing work that ran out, taking it
+// back to the main account, or opening it again after a restart. Such an account is read first.
+const movesWorkOnItsOwn = (settings) => settings.autoContinue !== 'off' || settings.returnToPrimary === 'auto' || settings.reopenAfterRestart === 'auto';
+// Rejects with request_timeout if `promise` has not settled within `ms`.
+function withTimeout(promise, ms) {
+    let timer;
+    const timeout = new Promise((_, reject) => {
+        timer = setTimeout(() => {
+            reject(new ProviderError('request_timeout'));
+        }, ms);
+    });
+    return Promise.race([promise, timeout]).finally(() => {
+        clearTimeout(timer);
+    });
+}
+// Any user edit (name, primary, enabled, position) makes an account user-managed, except a
+// pending one: it waits for its sign-in whatever the user changed, and discovery makes it the
+// user's. Origin, configDirExplicit and a pending sign-in's time are never taken from the
+// client. A pending account missing from the edit was added after the client's view of the
+// list was taken (accounts are removed by dismissal, not by an edit): it is kept.
+function mergeAccountEdits(current, edited) {
+    const editedIds = new Set(edited.map(a => a.id));
+    const currentIds = new Set(current.map(a => a.id));
+    // Relative order of the accounts present in both, so a removal is not seen as a move.
+    const before = current.map(a => a.id).filter(id => editedIds.has(id));
+    const after = edited.map(a => a.id).filter(id => currentIds.has(id));
+    const addedSince = current.filter(a => a.origin === 'pending' && !editedIds.has(a.id));
+    const merged = edited.map((account) => {
+        const existing = current.find(a => a.id === account.id);
+        const { origin: _origin, configDirExplicit: _explicit, signInUntil: _signInUntil, ...fields } = account;
+        const configDirExplicit = existing ? existing.configDirExplicit : account.configDirExplicit;
+        const userEdited = existing !== undefined &&
+            (account.label !== existing.label ||
+                account.labelKey !== existing.labelKey ||
+                account.primary !== existing.primary ||
+                account.enabled !== existing.enabled ||
+                before.indexOf(account.id) !== after.indexOf(account.id));
+        const origin = existing?.origin === 'pending' ? 'pending' : userEdited ? 'user' : (existing?.origin ?? 'user');
+        return {
+            ...fields,
+            ...(configDirExplicit === undefined ? {} : { configDirExplicit }),
+            origin,
+            ...(origin === 'pending' && existing?.signInUntil !== undefined ? { signInUntil: existing.signInUntil } : {})
+        };
+    });
+    return [...merged, ...addedSince];
+}
+export async function createService({ settingsPath, measurementsPath, renewSignIn, onChange, providers: injected, clock = Date.now, home = os.homedir() }) {
+    const adapters = injected ?? PROVIDER_IDS.map(id => ADAPTER_FACTORIES[id]());
+    const loaded = await loadSettingsWithRecovery(settingsPath);
+    let settings = loaded.settings;
+    let notice = loaded.notice;
+    // Unreadable or newer settings are not overwritten by ordinary changes: the app runs on
+    // defaults in memory until the user resets or imports.
+    const locked = () => notice === 'unrecoverable' || notice === 'future';
+    const providers = adapters.map(adapter => ({ id: adapter.id, status: 'pending', accounts: [] }));
+    const saved = measurementsPath ? await loadMeasurements(measurementsPath, clock()) : new Map();
+    let savingMeasurements = Promise.resolve();
+    const lastRenewal = new Map();
+    const renewing = new Set();
+    let pendingSave = Promise.resolve();
+    const cooldownUntil = new Map();
+    const inFlight = new Map();
+    const consecutiveMisses = new Map();
+    const providerGenerations = new Map();
+    const accountGenerations = new Map();
+    let lastDiscovery = clock();
+    let discoveryRunning = null;
+    const stamp = () => new Date(clock()).toISOString();
+    // Settings writes run one at a time, each on the result of the previous one; a failed write
+    // does not block the next.
+    function serialized(task) {
+        const run = pendingSave.catch(() => undefined).then(task);
+        pendingSave = run;
+        return run;
+    }
+    function rebuild() {
+        for (const provider of providers) {
+            const previous = provider.accounts;
+            provider.accounts = settings.accounts
+                .filter(a => a.providerId === provider.id && a.enabled)
+                .map((account) => {
+                const measured = previous.find(b => b.id === account.id);
+                if (measured && measured.configDir === account.configDir)
+                    return { ...measured, ...account };
+                // Not read yet in this run: the last good reading, as stale. It shows the quota last
+                // known; nothing acts on it, as only a fresh, ok reading counts as quota.
+                const last = saved.get(account.id);
+                return last?.configDir === (account.configDir ?? null)
+                    ? {
+                        ...account,
+                        status: 'stale',
+                        windows: structuredClone(last.windows),
+                        fetchedAt: last.fetchedAt,
+                        ...(last.plan ? { plan: last.plan } : {})
+                    }
+                    : { ...account, status: 'pending', windows: [] };
+            });
+            if (provider.status === 'pending' && provider.accounts.some(a => a.status === 'stale'))
+                provider.status = 'stale';
+        }
+    }
+    // Each account's latest good reading is written after every read, one write at a time.
+    function keepMeasurements() {
+        if (!measurementsPath)
+            return;
+        for (const account of providers.flatMap(p => p.accounts)) {
+            const reading = measurementOf(account);
+            if (reading)
+                saved.set(account.id, reading);
+        }
+        savingMeasurements = savingMeasurements.then(() => saveMeasurements(measurementsPath, saved)).catch(() => undefined);
+    }
+    function snapshot() {
+        return structuredClone({ providers, refreshing: inFlight.size > 0, settings, ...(notice ? { settingsNotice: notice } : {}) });
+    }
+    // Discovery still shows the accounts it finds while the settings are locked, in memory only.
+    async function commit(next, { discovered = false } = {}) {
+        if (locked() && !discovered)
+            throw new AppError('settings_locked');
+        settings = locked() ? validateSettings(next) : await saveSettings(settingsPath, next);
+        rebuild();
+        return snapshot();
+    }
+    // An explicit replacement may write over an unreadable file (which is kept aside).
+    async function replace(next) {
+        if (notice === 'future')
+            throw new AppError('settings_locked');
+        settings = await saveSettings(settingsPath, next);
+        notice = undefined;
+        rebuild();
+        return snapshot();
+    }
+    rebuild();
+    // Removes the account from `next`; the provider's next enabled account becomes primary in its place.
+    function removeAccount(next, accountId) {
+        const removed = next.accounts.find(a => a.id === accountId);
+        next.accounts = next.accounts.filter(a => a.id !== accountId);
+        consecutiveMisses.delete(accountId);
+        if (!removed?.primary)
+            return;
+        const successor = next.accounts.find(a => a.providerId === removed.providerId && a.enabled);
+        if (successor)
+            successor.primary = true;
+    }
+    // Merges one adapter's discovery, made from `seenAt`, into `next`; true when anything changed.
+    function reconcile(next, { adapter, found }, seenAt) {
+        let modified = false;
+        const dismissed = new Set(next.dismissedAccountIds);
+        const foundIds = new Set(found.map(a => a.id));
+        for (const account of found) {
+            consecutiveMisses.delete(account.id);
+            const existing = next.accounts.find(a => a.id === account.id);
+            // Its sign-in is done: the account the user added is theirs from now on.
+            if (existing?.origin === 'pending') {
+                existing.origin = 'user';
+                delete existing.signInUntil;
+                modified = true;
+            }
+            // Dismissal is the user's decision; discovery never re-adds those accounts.
+            if (existing || dismissed.has(account.id))
+                continue;
+            const hasPrimary = next.accounts.some(a => a.providerId === adapter.id && a.primary);
+            next.accounts.push({ ...account, origin: 'discovered', primary: account.primary && !hasPrimary });
+            modified = true;
+        }
+        // Only untouched discovered accounts are removed; anything the user disabled or customized
+        // stays until the user removes it.
+        const vanished = next.accounts.filter(a => a.providerId === adapter.id &&
+            !PROCESS_BOUND_PROVIDERS.has(a.providerId) &&
+            a.origin === 'discovered' &&
+            a.enabled &&
+            !foundIds.has(a.id));
+        for (const account of vanished) {
+            const misses = (consecutiveMisses.get(account.id) ?? 0) + 1;
+            consecutiveMisses.set(account.id, misses);
+            if (misses < MISSES_BEFORE_REMOVAL)
+                continue;
+            next.accounts = next.accounts.filter(a => a !== account);
+            consecutiveMisses.delete(account.id);
+            modified = true;
+        }
+        // A pending account not found by a look made after its sign-in closed never held a sign-in;
+        // a look begun before then may predate a sign-in finished since.
+        const withdrawn = next.accounts.filter(a => a.providerId === adapter.id && a.origin === 'pending' && !foundIds.has(a.id) && (a.signInUntil ?? 0) <= seenAt);
+        for (const account of withdrawn)
+            removeAccount(next, account.id);
+        return modified || withdrawn.length > 0;
+    }
+    async function runDiscovery() {
+        const seenAt = clock();
+        // A failed discovery says nothing about which accounts exist: it never counts as a miss.
+        const results = await Promise.all(adapters.map(adapter => adapter.discover().then(found => ({ adapter, found }), () => null)));
+        // Discovery runs outside the write queue; only the reconciliation is serialized.
+        await serialized(async () => {
+            const next = structuredClone(settings);
+            let modified = false;
+            for (const result of results)
+                if (result)
+                    modified = reconcile(next, result, seenAt) || modified;
+            if (modified)
+                await commit(next, { discovered: true });
+        });
+    }
+    function reconcileDiscovery() {
+        discoveryRunning ??= runDiscovery().finally(() => {
+            discoveryRunning = null;
+        });
+        return discoveryRunning;
+    }
+    await reconcileDiscovery().catch(() => undefined);
+    // The account as configured now, or null when it was removed, disabled or re-pointed while
+    // a read was in flight, or a newer read already reported.
+    function currentTarget(provider, account, generation) {
+        if ((accountGenerations.get(account.id) ?? 0) > generation)
+            return null;
+        accountGenerations.set(account.id, generation);
+        const configured = settings.accounts.find(a => a.id === account.id);
+        if (!configured || configured.configDir !== account.configDir || !configured.enabled)
+            return null;
+        return provider.accounts.find(a => a.id === account.id) ?? account;
+    }
+    function applyResult(target, result, fetchedAt) {
+        const windows = result.windows.map(normalizeWindow);
+        if (!windows.length && result.status !== 'no_limits_reported')
+            throw new ProviderError('invalid_response');
+        if (result.plan)
+            target.plan = result.plan;
+        if (result.signedInAs)
+            target.signedInAs = result.signedInAs;
+        else
+            delete target.signedInAs;
+        if (result.status === 'no_limits_reported') {
+            Object.assign(target, { windows: [], status: 'no_limits_reported', messageCode: 'no_limits_reported', fetchedAt });
+            return;
+        }
+        // A window missing from this response keeps its last value, marked stale.
+        // One that never had a value has nothing to keep.
+        for (const prior of target.windows) {
+            if (!windows.some(w => w.id === prior.id) && prior.remainingPercent !== null)
+                windows.push({ ...prior, stale: true, detailKey: 'staleWindowDetail' });
+        }
+        Object.assign(target, { windows, status: 'ok', fetchedAt });
+        delete target.messageCode;
+    }
+    function applyFailure(target, error, attemptedAt) {
+        const code = providerErrorCode(error);
+        // A failed read keeps the last good measurement, labelled stale.
+        target.status = target.fetchedAt ? 'stale' : code;
+        target.messageCode = code;
+        if (code === 'rate_limited') {
+            const seconds = (error instanceof ProviderError ? error.retryAfterSeconds : undefined) ?? DEFAULT_RATE_LIMIT_COOLDOWN_SECONDS;
+            cooldownUntil.set(target.id, attemptedAt + seconds * 1000);
+        }
+    }
+    // An expired sign-in is renewed when work may move to the account on its own (it could not
+    // take it over unread): once at a time per account, at most once in a while. It runs beside the
+    // refresh, which reports the expiry meanwhile and does not wait; once renewed, the tool's
+    // accounts are read again and the change announced.
+    function renewInBackground(adapter, account, error) {
+        const renew = renewSignIn?.[account.providerId];
+        if (!renew || !movesWorkOnItsOwn(settings) || providerErrorCode(error) !== 'auth_expired' || renewing.has(account.id))
+            return;
+        if (clock() - (lastRenewal.get(account.id) ?? Number.NEGATIVE_INFINITY) < RENEW_INTERVAL_MS)
+            return;
+        lastRenewal.set(account.id, clock());
+        renewing.add(account.id);
+        void renew(account)
+            .catch(() => false)
+            .then(async (renewed) => {
+            if (!renewed)
+                return;
+            // A read already under way may predate the renewal: the tool is read again after it.
+            await inFlight.get(adapter.id)?.catch(() => undefined);
+            await startRefresh(adapter);
+            onChange?.();
+        })
+            .finally(() => renewing.delete(account.id));
+    }
+    async function refreshAccount(adapter, provider, account, generation) {
+        const attemptedAt = clock();
+        if ((cooldownUntil.get(account.id) ?? 0) > attemptedAt)
+            return;
+        const outcome = await withTimeout(adapter.fetch(account), adapter.fetchTimeoutMs ?? FETCH_TIMEOUT_MS).then(result => ({ result }), (error) => ({ error }));
+        const target = currentTarget(provider, account, generation);
+        if (!target)
+            return;
+        try {
+            if ('error' in outcome)
+                throw outcome.error;
+            applyResult(target, outcome.result, stamp());
+        }
+        catch (error) {
+            applyFailure(target, error, attemptedAt);
+            renewInBackground(adapter, target, error);
+        }
+    }
+    const isHealthy = (account) => HEALTHY_STATUSES.has(account.status);
+    async function refreshProvider(adapter) {
+        const provider = providers.find(p => p.id === adapter.id);
+        if (!provider)
+            return;
+        const generation = (providerGenerations.get(adapter.id) ?? 0) + 1;
+        providerGenerations.set(adapter.id, generation);
+        await Promise.all(provider.accounts.map(account => refreshAccount(adapter, provider, account, generation)));
+        const { accounts } = provider;
+        const allHealthy = accounts.length > 0 && accounts.every(isHealthy);
+        provider.status = allHealthy ? 'ok' : accounts.some(a => a.fetchedAt) ? 'stale' : (accounts[0]?.status ?? 'unavailable');
+        if (allHealthy || accounts.some(a => a.status === 'ok'))
+            provider.fetchedAt = stamp();
+        if (accounts.length)
+            delete provider.messageCode;
+        else
+            provider.messageCode = 'no_accounts';
+    }
+    function startRefresh(adapter, fresh = false) {
+        const running = inFlight.get(adapter.id);
+        // Callers wanting a fresh read share the one that starts after the running one.
+        if (running && fresh)
+            return running.catch(() => undefined).then(() => startRefresh(adapter));
+        if (running)
+            return running;
+        const promise = refreshProvider(adapter).finally(() => {
+            if (inFlight.get(adapter.id) === promise)
+                inFlight.delete(adapter.id);
+            keepMeasurements();
+        });
+        inFlight.set(adapter.id, promise);
+        return promise;
+    }
+    async function refresh(providerId, { fresh = false } = {}) {
+        const targets = providerId === undefined ? adapters : adapters.filter(a => a.id === providerId);
+        if (!targets.length)
+            throw new AppError('invalid_provider');
+        if (clock() - lastDiscovery > DISCOVERY_INTERVAL_MS) {
+            lastDiscovery = clock();
+            await reconcileDiscovery().catch(() => undefined);
+        }
+        // Every provider is started and awaited, also those a narrower refresh already started.
+        await Promise.allSettled(targets.map(adapter => startRefresh(adapter, fresh)));
+        // The readings just taken are on disk before the refresh counts as done.
+        await savingMeasurements;
+        return snapshot();
+    }
+    async function dismissAccount(accountId) {
+        if (typeof accountId !== 'string' || !ACCOUNT_ID_PATTERN.test(accountId))
+            throw new AppError('invalid_argument');
+        if (!settings.accounts.some(a => a.id === accountId))
+            throw new AppError('account_not_found');
+        return serialized(() => {
+            const next = structuredClone(settings);
+            next.dismissedAccountIds = [...new Set([...next.dismissedAccountIds, accountId])].slice(-MAX_DISMISSED_ACCOUNTS);
+            removeAccount(next, accountId);
+            return commit(next);
+        });
+    }
+    function addPendingAccount(account) {
+        return serialized(() => {
+            const next = structuredClone(settings);
+            const primary = !next.accounts.some(a => a.providerId === account.providerId);
+            next.accounts.push({ ...account, primary, origin: 'pending', signInUntil: clock() + SIGN_IN_WINDOW_MS });
+            // Adding it again undoes an earlier dismissal of the same folder.
+            next.dismissedAccountIds = next.dismissedAccountIds.filter(id => id !== account.id);
+            return commit(next);
+        });
+    }
+    function withdrawPendingAccount(accountId) {
+        return serialized(() => {
+            if (!settings.accounts.some(a => a.id === accountId && a.origin === 'pending'))
+                return Promise.resolve(snapshot());
+            const next = structuredClone(settings);
+            removeAccount(next, accountId);
+            return commit(next);
+        });
+    }
+    function signInOpened(accountId) {
+        return serialized(() => {
+            const pending = settings.accounts.find(a => a.id === accountId && a.origin === 'pending');
+            if (!pending)
+                return Promise.resolve(snapshot());
+            const next = structuredClone(settings);
+            next.accounts = next.accounts.map(a => (a.id === accountId ? { ...a, signInUntil: clock() + SIGN_IN_WINDOW_MS } : a));
+            return commit(next);
+        });
+    }
+    // Typed or not, every change takes this one validated path.
+    function applySettings(patch) {
+        return serialized(() => {
+            const next = validateSettings({ ...settings, ...patch });
+            return commit({ ...next, accounts: mergeAccountEdits(settings.accounts, next.accounts) });
+        });
+    }
+    const updateSettings = (patch) => applySettings(patch);
+    function updateSettingsFrom(input) {
+        if (!isObject(input))
+            throw new AppError('invalid_argument');
+        return applySettings(input);
+    }
+    async function resetSettings() {
+        await serialized(() => replace({ ...defaultSettings(), ...(settings.window ? { window: settings.window } : {}) }));
+        consecutiveMisses.clear();
+        await reconcileDiscovery();
+        return snapshot();
+    }
+    async function importSettings(document) {
+        if (!isObject(document))
+            throw new AppError('invalid_settings');
+        const { window: _ignored, ...imported } = document;
+        const next = validateSettings({ ...imported, ...(settings.window ? { window: settings.window } : {}) });
+        // An imported account is kept only when its folder is a profile folder of this computer, as
+        // discovery finds them. Another computer's paths mean nothing here, and a folder named by a
+        // file someone handed over would have the app run the tool there, with that folder's
+        // settings and hooks. Discovery adds back each local account it finds.
+        const local = new Set((await Promise.all(PROFILE_PROVIDER_IDS.map(id => profileFolders(id, home)))).flat().map(dir => pathKey(dir)));
+        next.accounts = next.accounts.filter(a => a.configDir === undefined || local.has(pathKey(a.configDir)));
+        await serialized(() => replace(next));
+        await reconcileDiscovery();
+        return snapshot();
+    }
+    function exportSettings() {
+        const { window: _window, ...document } = structuredClone(settings);
+        return document;
+    }
+    function dismissSettingsNotice() {
+        if (notice === 'recovered')
+            notice = undefined;
+        return snapshot();
+    }
+    async function restoreDismissedAccounts() {
+        await updateSettings({ dismissedAccountIds: [] });
+        await reconcileDiscovery();
+        return snapshot();
+    }
+    return {
+        snapshot,
+        refresh,
+        updateSettings,
+        updateSettingsFrom,
+        dismissAccount,
+        addPendingAccount,
+        signInOpened,
+        withdrawPendingAccount,
+        resetSettings,
+        importSettings,
+        exportSettings,
+        dismissSettingsNotice,
+        restoreDismissedAccounts,
+        reconcileDiscovery
+    };
+}

package/build/core/sessions.d.ts

@@ -0,0 +1,87 @@
+import { type Auto, type ClaudePermissionMode, type ProfileProviderId, type ProviderId } from '../shared/catalog.ts';
+import type { SessionSummary } from '../shared/ipc.ts';
+import type { Account } from '../shared/types.ts';
+export interface SessionSources {
+    homeDir: string;
+    profiles: Readonly<Record<ProfileProviderId, readonly string[]>>;
+}
+export declare function sessionSources(homeDir: string, accounts?: readonly Account[]): SessionSources;
+export interface Turn {
+    role: 'user' | 'assistant';
+    text: string;
+}
+export interface Transcript {
+    providerId: ProviderId;
+    sessionId: string;
+    sessionTitle: string;
+    sessionModel: string;
+    initialGoal: string;
+    lastUserMsg: string;
+    lastAssistantMsg: string;
+    turnCount: number;
+    files: string[];
+    recent: Turn[];
+}
+export declare const RECENT_TURNS: {
+    count: number;
+    turnChars: number;
+    totalChars: number;
+};
+export interface RecentSession {
+    providerId: ProviderId;
+    sessionId: string;
+    projectDir: string;
+    updatedAt: number;
+    file: string;
+    model?: string;
+    accountId?: string;
+}
+export interface SessionIdentity {
+    projectDir: string;
+    sessionId: string;
+}
+export declare function recentSessionModel(session: RecentSession): Promise<string>;
+export declare function claudeProjectDir(file: string): string | null;
+export declare function latestClaudeSession(root: string, identity?: SessionIdentity): RecentSession | null;
+export declare function claudeSessionById(root: string, sessionId: string): RecentSession | null;
+export declare function latestCodexSession(root: string, identity?: SessionIdentity): Promise<RecentSession | null>;
+export declare function latestCursorSession(homeDir: string, identity?: SessionIdentity): RecentSession | null;
+export interface StoppedSession extends RecentSession {
+    stoppedAt: number;
+}
+export declare function claudeLimitStop(file: string): {
+    stoppedAt: number;
+    cwd: string;
+    headless: boolean;
+} | null;
+export declare function claudeSessionMode(file: string): {
+    model?: string;
+    permissionMode?: ClaudePermissionMode;
+};
+export interface BackgroundTask {
+    id: string;
+    command: string;
+    outputFile: string | null;
+    startedAt: number;
+}
+export declare function claudeBackgroundTasks(file: string): Promise<BackgroundTask[]>;
+export declare function claudeLastWrittenAt(file: string): number;
+export interface TranscriptWrite {
+    lastRecordAt: number;
+    size: number;
+}
+export declare function claudeTranscriptWrite(file: string): TranscriptWrite | null;
+export declare function claudeTurnEnded(file: string): boolean;
+export declare function codexLimitStop(file: string): {
+    stoppedAt: number;
+} | null;
+export declare function claudeLimitStops(root: string, now: number, maxAgeMs: number): StoppedSession[];
+export declare function codexLimitStops(root: string, now: number, maxAgeMs: number): Promise<StoppedSession[]>;
+export declare function listProviderSessions(providerId: ProviderId | Auto, projectDir: string, sources: SessionSources): Promise<SessionSummary[]>;
+export interface SessionQuery {
+    providerId: ProviderId | Auto;
+    sessionId: string;
+    projectDir: string;
+    sources: SessionSources;
+}
+export declare function readSession({ providerId, sessionId, projectDir, sources }: SessionQuery): Promise<Transcript | null>;