sidekick-shared 0.27.5 → 0.28.0

package/dist/esm/zaiQuotaWatcher.js

@@ -0,0 +1,265 @@
+/**
+ * Deprecated event-driven watcher that derives a z.ai coding-plan
+ * `QuotaState` from observed OpenCode assistant turns.
+ *
+ * This watcher is retained for compatibility. Product code now uses
+ * `zaiQuotaApi.ts` to call z.ai's authoritative quota endpoint. The legacy
+ * watcher maintains rolling 5-hour / 7-day windows in memory and recomputes a
+ * derived `QuotaState` whenever a new turn arrives. The consumer is
+ * responsible for feeding it z.ai-routed assistant turns (and any trapped
+ * error events) — typically by subscribing to `SessionMonitor.onSessionEvent`
+ * and filtering on `providerID ∈ {zai, zai-coding-plan}`.
+ *
+ * Optionally writes snapshots + history samples for cross-session cache
+ * and trend visualisation, mirroring `CodexQuotaWatcher`.
+ */
+import { appendQuotaHistorySample } from './quotaHistory';
+import { readQuotaSnapshot, writeQuotaSnapshot } from './quotaSnapshots';
+import { accumulateZaiUsage, inferZaiQuotaState, makeUnavailableZaiQuotaState, parseZaiQuotaError, resolveZaiTier, } from './zaiQuota';
+const DEFAULT_ACCOUNT_ID = 'default';
+const DEFAULT_RECOMPUTE_DEBOUNCE_MS = 1_000;
+const DEFAULT_PRUNE_INTERVAL_MS = 60_000;
+const SEVEN_DAY_MS = 7 * 86_400_000;
+function enrichZaiState(state) {
+    return {
+        ...state,
+        runtimeProvider: 'zai',
+        providerId: 'zai',
+    };
+}
+/**
+ * Watches z.ai-routed OpenCode activity and emits derived `QuotaState`.
+ *
+ * The watcher is event-driven (not a poller): call `ingestAssistantTurn`
+ * for every observed z.ai assistant turn, and `ingestError` whenever a
+ * z.ai business error is observed. The watcher debounces recompute and
+ * emits via `onUpdate` / `onQuotaUpdate`.
+ *
+ * @deprecated Unreachable from every package entrypoint and no longer used by
+ * product code. Use `resolveZaiQuota()` from `zaiQuotaApi` instead.
+ */
+export class ZaiQuotaWatcher {
+    tier;
+    resolveTier;
+    readSnapshot;
+    writeSnapshot;
+    appendHistorySample;
+    workspaceId;
+    accountId;
+    recomputeDebounceMs;
+    pruneIntervalMs;
+    now;
+    listeners = [];
+    /** In-memory rolling 7-day buffer of observed turns. */
+    turns = [];
+    /** Most recent authoritative 5h reset (parsed from a z.ai error event). */
+    authoritativeFiveHourResetAt;
+    /** Most recent authoritative weekly reset (parsed from a z.ai error event). */
+    authoritativeWeeklyResetAt;
+    /** Most recent trapped error (so consumers can show "rate-limited until X"). */
+    lastError = null;
+    lastEmissionKey = null;
+    pendingRecomputeTimer;
+    pruneTimer;
+    running = false;
+    constructor(options = {}) {
+        this.tier = options.tier ?? 'auto';
+        this.resolveTier = options.resolveTier ?? resolveZaiTier;
+        this.readSnapshot = options.readSnapshot ?? readQuotaSnapshot;
+        this.writeSnapshot = options.writeSnapshot ?? writeQuotaSnapshot;
+        this.appendHistorySample = options.appendHistorySample ?? appendQuotaHistorySample;
+        this.workspaceId = options.workspaceId;
+        this.accountId = options.accountId ?? DEFAULT_ACCOUNT_ID;
+        this.recomputeDebounceMs = options.recomputeDebounceMs ?? DEFAULT_RECOMPUTE_DEBOUNCE_MS;
+        this.pruneIntervalMs = options.pruneIntervalMs ?? DEFAULT_PRUNE_INTERVAL_MS;
+        this.now = options.now ?? Date.now;
+    }
+    start() {
+        if (this.running)
+            return;
+        this.running = true;
+        // Emit cached state immediately so consumers don't show "unavailable"
+        // during the gap before the first z.ai turn arrives.
+        this.emitCachedOrUnavailable();
+        this.pruneTimer = setInterval(() => this.pruneOldTurns(), this.pruneIntervalMs);
+    }
+    stop() {
+        if (!this.running)
+            return;
+        this.running = false;
+        if (this.pendingRecomputeTimer) {
+            clearTimeout(this.pendingRecomputeTimer);
+            this.pendingRecomputeTimer = undefined;
+        }
+        if (this.pruneTimer) {
+            clearInterval(this.pruneTimer);
+            this.pruneTimer = undefined;
+        }
+    }
+    dispose() {
+        this.stop();
+        this.listeners.splice(0, this.listeners.length);
+    }
+    onUpdate(cb) {
+        this.listeners.push(cb);
+        return {
+            dispose: () => {
+                const index = this.listeners.indexOf(cb);
+                if (index >= 0)
+                    this.listeners.splice(index, 1);
+            },
+        };
+    }
+    onQuotaUpdate(cb) {
+        return this.onUpdate(cb);
+    }
+    /** Feed an observed z.ai assistant turn. Schedules a debounced recompute. */
+    ingestAssistantTurn(turn) {
+        this.turns.push(turn);
+        this.scheduleRecompute();
+    }
+    /**
+     * Feed multiple turns at once (used for cold-start seeding from the DB).
+     * Schedules a single debounced recompute.
+     */
+    ingestAssistantTurns(turns) {
+        for (const turn of turns)
+            this.turns.push(turn);
+        this.scheduleRecompute();
+    }
+    /** Feed a z.ai error event. Triggers an immediate recompute + emit. */
+    ingestError(error) {
+        const parsed = parseZaiQuotaError(error);
+        if (!parsed)
+            return false;
+        this.lastError = parsed;
+        if (parsed.resetsAt) {
+            // The first observed error after the user crosses a threshold tells
+            // us the authoritative window boundary. Apply to whichever window
+            // the kind maps to.
+            if (parsed.kind === 'exhausted') {
+                this.authoritativeFiveHourResetAt = parsed.resetsAt;
+                // 1310 is "weekly/monthly exhausted" — also pin the weekly window.
+                if (String(parsed.code) === '1310') {
+                    this.authoritativeWeeklyResetAt = parsed.resetsAt;
+                }
+            }
+        }
+        this.scheduleRecompute();
+        return true;
+    }
+    /** Force a recompute+emit now (skipping the debounce). Used by tests. */
+    refresh() {
+        this.recomputeAndEmit();
+    }
+    /** Current in-memory turn count (testing/diagnostics). */
+    get bufferedTurnCount() {
+        return this.turns.length;
+    }
+    // ── internals ──
+    scheduleRecompute() {
+        if (!this.running)
+            return;
+        if (this.pendingRecomputeTimer)
+            clearTimeout(this.pendingRecomputeTimer);
+        this.pendingRecomputeTimer = setTimeout(() => {
+            this.pendingRecomputeTimer = undefined;
+            this.recomputeAndEmit();
+        }, this.recomputeDebounceMs);
+    }
+    recomputeAndEmit() {
+        const nowMs = this.now();
+        if (this.lastError?.resetsAt) {
+            const resetsAt = Date.parse(this.lastError.resetsAt);
+            if (Number.isFinite(resetsAt) && resetsAt <= nowMs) {
+                this.lastError = null;
+            }
+        }
+        const accumulated = accumulateZaiUsage(this.turns, nowMs);
+        const tier = this.resolveTier(this.tier, accumulated);
+        const state = accumulated.fiveHourTurns > 0 || accumulated.weeklyTurns > 0
+            ? inferZaiQuotaState(accumulated, tier, {
+                capturedAt: new Date(nowMs).toISOString(),
+                stale: false,
+                authoritativeFiveHourResetAt: this.authoritativeFiveHourResetAt,
+                authoritativeWeeklyResetAt: this.authoritativeWeeklyResetAt,
+            })
+            : makeUnavailableZaiQuotaState(undefined, tier, new Date(nowMs).toISOString());
+        // If we recently saw an error, override availability so the UI shows it.
+        if (this.lastError) {
+            state.error = this.lastError.message;
+            state.failureKind = this.lastError.kind === 'expired' ? 'auth' : 'rate_limit';
+            state.rateLimitReachedType = this.lastError.kind;
+        }
+        this.writeSnapshot('zai', this.accountId, state);
+        this.maybeAppendHistory(state);
+        this.emitState(enrichZaiState(state));
+    }
+    maybeAppendHistory(state) {
+        if (!this.workspaceId)
+            return;
+        const sample = {
+            timestamp: state.capturedAt ?? new Date(this.now()).toISOString(),
+            runtimeProvider: 'zai',
+            providerId: this.accountId,
+            workspaceId: this.workspaceId,
+            fiveHour: { utilization: state.fiveHour.utilization, resetsAt: state.fiveHour.resetsAt },
+            sevenDay: { utilization: state.sevenDay.utilization, resetsAt: state.sevenDay.resetsAt },
+            available: state.available,
+            error: state.error,
+            source: 'session',
+            stale: state.stale,
+        };
+        try {
+            const result = this.appendHistorySample(sample);
+            if (result && typeof result.catch === 'function') {
+                result.catch(() => {
+                    // History append must never break the live emission path.
+                });
+            }
+        }
+        catch {
+            // Synchronous errors swallowed for the same reason.
+        }
+    }
+    emitCachedOrUnavailable() {
+        const cached = this.readSnapshot('zai', this.accountId);
+        if (cached) {
+            this.emitState(enrichZaiState({
+                ...cached,
+                providerId: 'zai',
+                source: 'cache',
+                stale: true,
+                fiveHourLabel: cached.fiveHourLabel ?? '5-Hour',
+                sevenDayLabel: cached.sevenDayLabel ?? 'Weekly',
+            }));
+            return;
+        }
+        // Initial state with no observations yet.
+        const tier = this.tier === 'auto' ? 'lite' : this.tier;
+        this.emitState(enrichZaiState(makeUnavailableZaiQuotaState(undefined, tier)));
+    }
+    emitState(state) {
+        const nextKey = JSON.stringify(state);
+        if (this.lastEmissionKey === nextKey)
+            return;
+        this.lastEmissionKey = nextKey;
+        for (const listener of this.listeners) {
+            try {
+                listener(state);
+            }
+            catch {
+                // Listener failures must not stop the watcher.
+            }
+        }
+    }
+    pruneOldTurns() {
+        const cutoff = this.now() - SEVEN_DAY_MS;
+        if (this.turns.length === 0)
+            return;
+        const next = this.turns.filter((turn) => turn.timestampMs >= cutoff);
+        if (next.length !== this.turns.length) {
+            this.turns = next;
+        }
+    }
+}

package/dist/fileHead.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Rewrite detection shared by the incremental JSONL readers: a file whose
+ * first bytes changed, or whose resume point no longer follows a newline,
+ * was rewritten rather than appended to.
+ *
+ * @module fileHead
+ */
+/** How many leading bytes identify a file's content. */
+export declare const HEAD_BYTES = 4096;
+/** The recorded prefix of a file: its length and a hash of it. */
+export interface FileHead {
+    bytes: number;
+    hash: string;
+}
+export declare function hashHead(buffer: Buffer): string;
+/** Records the prefix just read (at most `HEAD_BYTES`). */
+export declare function fileHeadOf(prefix: Buffer): FileHead;
+/**
+ * True when `prefix` (the file's current first bytes) still starts with the
+ * recorded head. A file that grew past a short head still matches.
+ */
+export declare function headMatches(known: FileHead, prefix: Buffer): boolean;

package/dist/fileHead.js

@@ -0,0 +1,33 @@
+"use strict";
+/**
+ * Rewrite detection shared by the incremental JSONL readers: a file whose
+ * first bytes changed, or whose resume point no longer follows a newline,
+ * was rewritten rather than appended to.
+ *
+ * @module fileHead
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HEAD_BYTES = void 0;
+exports.hashHead = hashHead;
+exports.fileHeadOf = fileHeadOf;
+exports.headMatches = headMatches;
+const crypto_1 = require("crypto");
+/** How many leading bytes identify a file's content. */
+exports.HEAD_BYTES = 4096;
+function hashHead(buffer) {
+    return (0, crypto_1.createHash)('sha256').update(buffer).digest('hex').slice(0, 32);
+}
+/** Records the prefix just read (at most `HEAD_BYTES`). */
+function fileHeadOf(prefix) {
+    return { bytes: prefix.length, hash: hashHead(prefix) };
+}
+/**
+ * True when `prefix` (the file's current first bytes) still starts with the
+ * recorded head. A file that grew past a short head still matches.
+ */
+function headMatches(known, prefix) {
+    if (!Number.isInteger(known.bytes) || known.bytes < 0 || known.bytes > prefix.length) {
+        return false;
+    }
+    return hashHead(prefix.subarray(0, known.bytes)) === known.hash;
+}

package/dist/index.d.ts

@@ -5,12 +5,12 @@ export { normalizeProviderUsage, extractNormalizedUsage, calculateNormalizedUsag
 export type { UsageProvider, UsageSemantics, UsageNormalizationProvenance, ProviderUsageInput, AnthropicUsageInput, OpenAIUsageInput, SidekickUsageInput, NormalizedUsage, PricingProvenance, NormalizedUsageCostInput, NormalizedUsageCost, } from './usageNormalization';
 export { formatTokenBreakdown, summarizeTokens, sumTokenTotals, TOKEN_CONTEXT_LABEL, TOKEN_MAIN_THREAD_LABEL, TOKEN_SESSION_TOTAL_LABEL, TOKEN_SUBAGENTS_LABEL, TOKEN_TOTAL_LABEL, } from './tokenSummary';
 export type { TokenSummary, TokenTotalsLike } from './tokenSummary';
-export { estimateTextTokens, estimateSerializedTokens } from './tokenEstimation';
+export { ASCII_CHARS_PER_TOKEN, estimateTextTokens, estimateSerializedTokens, } from './tokenEstimation';
 export type { ExactTokenCounterContext, ExactTokenCounter, TokenEstimationMethod, TokenEstimationConfidence, TokenEstimationOptions, TokenEstimate, } from './tokenEstimation';
 export { projectSessionTranscript } from './transcript';
 export type { TranscriptFidelity, TranscriptSourceProvenance, CanonicalTranscriptBlock, CanonicalTranscriptMessage, CanonicalToolCall, CanonicalTranscriptUsageTotals, CanonicalSessionTranscript, ProjectSessionTranscriptOptions, } from './transcript';
 export { listRecentSessions, readSessionTranscript } from './sessionTranscripts';
-export { collectPromptHistory } from './promptHistory';
+export { collectPromptHistory, isPromptHistorySessionSettled, parsePromptHistoryCursor, } from './promptHistory';
 export type { CollectPromptHistoryOptions, PromptHistoryAnswerState, PromptHistoryBound, PromptHistoryBounds, PromptHistoryCursor, PromptHistoryCursorSession, PromptHistoryEntry, PromptHistoryExclusion, PromptHistoryMetadataStatus, PromptHistoryPendingPrompt, PromptHistoryProvider, PromptHistoryResult, PromptHistoryResumeState, PromptHistoryStats, PromptHistoryUsage, } from './promptHistory';
 export { collectSessionPromptHistory } from './sessionPromptHistory';
 export type { CollectSessionPromptHistoryOptions, PromptHistorySession, PromptHistorySessionPrompt, PromptHistorySessionRef, SessionPromptHistoryBound, SessionPromptHistoryBounds, SessionPromptHistoryInclude, SessionPromptHistoryResult, SessionPromptHistoryStats, } from './sessionPromptHistory';
@@ -88,7 +88,8 @@ export type { FindCodexRolloutFileOptions } from './providers/codex';
 export { JsonlParser, TRUNCATION_PATTERNS } from './parsers/jsonl';
 export type { RawSessionEvent, JsonlParserCallbacks, JsonlParserOptions } from './parsers/jsonl';
 export { normalizeToolName, normalizeToolInput, detectPlanModeFromText, convertOpenCodeMessage, parseDbMessageData, parseDbPartData, } from './parsers/openCodeParser';
-export { CodexRolloutParser, extractPatchFilePaths, normalizeCodexToolName, normalizeCodexToolInput, resolveCodexCallUsage, } from './parsers/codexParser';
+export { CodexRolloutParser, DEFAULT_MAX_TRACKED_TOOL_CALLS, extractPatchFilePaths, normalizeCodexToolName, normalizeCodexToolInput, resolveCodexCallUsage, } from './parsers/codexParser';
+export type { CodexRolloutParserOptions } from './parsers/codexParser';
 export { scanSubagentDir, extractTaskInfo, readAgentMeta } from './parsers/subagentScanner';
 export { ClaudeUsageDeduper, SYNTHETIC_MODEL, dedupedRawClaudeUsage, normalizeClaudeUsage, } from './usage/claudeUsageDedupe';
 export { addUsageToSubagent } from './usage/subagentUsage';
@@ -127,8 +128,8 @@ export type { FollowEvent, FollowEventType, SessionWatcher, SessionWatcherCallba
 export { createWatcher, resolveSessionPath } from './watchers/factory';
 export type { CreateWatcherOptions } from './watchers/factory';
 export { toFollowEvents } from './watchers/eventBridge';
-export { createJsonlTail } from './watchers/jsonlTail';
-export type { JsonlTail, JsonlTailBatch, JsonlTailOptions } from './watchers/jsonlTail';
+export { createJsonlTail, DEFAULT_JSONL_TAIL_MAX_LINE_BYTES, DEFAULT_JSONL_TAIL_READ_BYTES, } from './watchers/jsonlTail';
+export type { JsonlTail, JsonlTailBatch, JsonlTailLine, JsonlTailOptions, JsonlTailReset, JsonlTailResetReason, } from './watchers/jsonlTail';
 export { addLocalDays, formatDurationMs, formatLocalDateKey, formatTokenCount, parseLocalDateKey, } from './formatting';
 export type { FormatDurationMsOptions, FormatTokenCountOptions } from './formatting';
 export { formatToolSummary } from './formatters/toolSummary';
@@ -165,10 +166,17 @@ export { calculateCompactionLedger, formatCompactionLedger } from './analytics/c
 export type { CompactionLedger } from './analytics/compactionLedger';
 export { generateHtmlReport, parseTranscript, parseTranscriptFromEvents, openInBrowser, } from './report';
 export type { TranscriptContentBlock, TranscriptEntry, HtmlReportOptions } from './report';
-export { readActiveCredentials, writeActiveCredentials, deleteStoredCredentials, } from './credentialIO';
+export { readActiveCredentials, readClaudeCredentialStore, writeActiveCredentials, deleteStoredCredentials, ClaudeCredentialWriteError, SIDEKICK_KEYCHAIN_COMMENT_PREFIX, } from './credentialIO';
+export type { ClaudeCredentialStoreRead, ClaudeCredentialStoreSource } from './credentialIO';
+export { decideLiveClaudeWrite } from './claudeLiveGuard';
+export type { LiveClaudeStoreState, LiveClaudeWriteDecision, LiveClaudeWriteIntent, LiveClaudeWriteRefusal, LiveClaudeWriteRequest, } from './claudeLiveGuard';
+export { readClaudeCredentialLedger, getClaudeCredentialLedgerPath, } from './claudeCredentialLedger';
+export type { ClaudeCredentialLedgerEntry, ClaudeCredentialHomePurpose, } from './claudeCredentialLedger';
+export { inspectClaudeCredentialStores, repairClaudeCredentialStores, parseKeychainDump, } from './claudeCredentialDoctor';
+export type { ClaudeCredentialFinding, ClaudeCredentialFindingKind, ClaudeCredentialInspection, ClaudeCredentialRepairOutcome, ClaudeCredentialRepairResult, InspectClaudeCredentialStoresOptions, KeychainItemSummary, } from './claudeCredentialDoctor';
 export { readClaudeMaxCredentials, readClaudeMaxCredentialsRaw, readClaudeMaxAccessTokenSync, } from './credentials';
 export type { ClaudeMaxCredentials } from './credentials';
-export { parseClaudeCredentialBlob, claudeCredentialFreshness, isNewerClaudeCredential, resolveClaudeRefreshExpiry, CLAUDE_ACCESS_TOKEN_LIFETIME_MS, CLAUDE_REFRESH_TOKEN_LIFETIME_ESTIMATE_MS, } from './claudeCredentials';
+export { parseClaudeCredentialBlob, claudeCredentialFreshness, isNewerClaudeCredential, resolveClaudeRefreshExpiry, claudeRefreshFingerprint, claudeLoginOnly, mergeClaudeLoginIntoLive, CLAUDE_ACCESS_TOKEN_LIFETIME_MS, CLAUDE_REFRESH_TOKEN_LIFETIME_ESTIMATE_MS, } from './claudeCredentials';
 export type { ClaudeOauthCredentials } from './claudeCredentials';
 export { parseAuthJson as parseCodexAuthJson, readAuthIdentityFromRaw as readCodexAuthIdentity, readLastRefresh as readCodexLastRefresh, readAccessTokenExpiry as readCodexAccessTokenExpiry, identitiesMatch as codexIdentitiesMatch, } from './codexAuth';
 export type { CodexAuthIdentity, CodexAuthJsonFile } from './codexAuth';
@@ -176,7 +184,7 @@ export { ensureDefaultAccounts } from './ensureDefaultAccounts';
 export type { EnsureDefaultAccountStatus, EnsureDefaultAccountsOptions, EnsureDefaultAccountsResult, } from './ensureDefaultAccounts';
 export { readAccountRegistry, writeAccountRegistry, readActiveClaudeAccount, addCurrentAccount, switchToAccount, switchToAccountAsync, syncClaudeLiveState, cleanupAbandonedClaudeLogins, resolveActiveClaudeHome, applyActiveClaudeToLiveHome, reconcileClaudeAuthState, removeAccount, listAccounts, getActiveAccount, resolveActiveClaudeAccount, isMultiAccountEnabled, } from './accounts';
 export type { AccountEntry, AccountRegistry, ActiveAccountInfo, AccountManagerResult, } from './accounts';
-export { beginAccountLogin, getAccountLoginStatus, getAccountLoginStatusAsync, finalizeAccountLogin, finalizeAccountLoginAsync, spawnAccountLogin, switchAccount, switchAccountAsync, undoLastSwitch, getLastSwitch, listAllAccounts, resolveClaudeLoginCommand, } from './accountManager';
+export { beginAccountLogin, getAccountLoginStatus, getAccountLoginStatusAsync, finalizeAccountLogin, finalizeAccountLoginAsync, spawnAccountLogin, switchAccount, switchAccountAsync, undoLastSwitch, getLastSwitch, listAllAccounts, resolveClaudeLoginCommand, discardAccountLogin, } from './accountManager';
 export type { AccountLoginCommand, AccountLoginState, AccountLoginStatus, BeginAccountLoginOptions, BeginAccountLoginResult, BeginAccountLoginSuccess, FinalizeAccountLoginOptions, ListAllAccountsResult, SpawnAccountLoginOptions, } from './accountManager';
 export { readLastSwitch, getLastSwitchPath } from './accountSwitch';
 export type { LastSwitchRecord, SwitchAccountOptions, SwitchAccountResult, SwitchVerification, } from './accountSwitch';
@@ -198,11 +206,12 @@ export { getActiveAccountStatus } from './accountStatus';
 export type { ActiveAccountStatus, ActiveAccountStatusOptions, ActiveProviderAccountStatus, } from './accountStatus';
 export { onAccountsChanged } from './accountChanges';
 export type { AccountsChangedEvent, OnAccountsChangedOptions } from './accountChanges';
-export { getClaudeProfilesDir, getClaudeProfileHome, getLiveClaudeHome, getDefaultClaudeHome, getClaudeConfigPath, claudeKeychainSuffix, claudeKeychainService, claudeKeychainAccountName, buildClaudeChildEnv, CLAUDE_SECURESTORAGE_CONFIG_DIR_ENV, isClaudeProfileAuthenticated, readClaudeProfileIdentity, readLiveClaudeIdentity, } from './claudeProfiles';
+export { getClaudeProfilesDir, getClaudeProfileHome, getClaudeConfigPath, claudeKeychainSuffix, claudeKeychainService, claudeKeychainAccountName, buildClaudeChildEnv, CLAUDE_SECURESTORAGE_CONFIG_DIR_ENV, isClaudeProfileAuthenticated, readClaudeProfileIdentity, readLiveClaudeIdentity, } from './claudeProfiles';
 export type { ClaudeProfileIdentity } from './claudeProfiles';
+export { getLiveClaudeHome, getDefaultClaudeHome, isDefaultClaudeHome, getClaudeProjectsDir, } from './claudePaths';
 export { getCodexProfilesDir, getCodexProfileHome, getCodexMonitoringHomes, getSystemCodexHome, listCodexAccounts, getActiveCodexAccount, resolveActiveCodexAccount, resolveSidekickCodexHome, getCodexExecutionEnv, prepareCodexAccount, prepareCodexAccountAsync, finalizeCodexAccount, finalizeCodexAccountAsync, switchToCodexAccount, switchToCodexAccountAsync, removeCodexAccount, syncCodexLiveState, cleanupAbandonedCodexLogins, getCodexCredentialStoreMode, CODEX_KEYRING_FIX_HINT, } from './codexProfiles';
 export type { CodexAccountManagerResult, CodexCredentialStoreMode } from './codexProfiles';
-export { writeLauncher, removeLauncher } from './terminalSync';
+export { writeAccountLauncher, writeLauncher, removeLauncher } from './terminalSync';
 export { DEFAULT_AUTO_SWITCH_CONFIG, decideAutoSwitch, AutoSwitchController } from './autoSwitch';
 export type { AutoSwitchActiveAccount, AutoSwitchCandidate, AutoSwitchConfig, AutoSwitchControllerOptions, AutoSwitchDecision, AutoSwitchTransitionEvent, } from './autoSwitch';
 export { FIVE_HOUR_WINDOW_MS, QUOTA_PROVIDER_IDS, SEVEN_DAY_WINDOW_MS, fetchQuota, projectQuotaWindow, withQuotaProjections, } from './quota';
@@ -260,6 +269,7 @@ export type { GatherAssetsOptions, GatherAssetsResult } from './extractors/gathe
 export { messageUsageSchema, sessionMessageSchema, sessionEventSchema, permissionModeSchema, extractSessionEvents, } from './schemas/sessionEvent';
 export { quotaWindowSchema, quotaStateSchema, quotaFailureKindSchema, quotaProviderIdSchema, quotaSourceSchema, codexResetCreditSchema, codexResetCreditsSnapshotSchema, peakHoursStateSchema, quotaFailureDescriptorSchema, runtimeQuotaProviderSchema, providerQuotaStateSchema, claudeProviderQuotaStateSchema, codexProviderQuotaStateSchema, zaiProviderQuotaStateSchema, providerQuotaMapSchema, } from './schemas/quota';
 export { quotaHistoryRuntimeProviderSchema, quotaHistorySampleSchema, quotaHistoryDailyBucketSchema, } from './schemas/quotaHistory';
+export { providerAuthenticationEvidenceSchema, providerFailureEvidenceSchema, providerRetryAfterSchema, providerFailureDiagnosisSchema, } from './schemas/providerFailure';
 export { activeProviderAccountStatusSchema, activeAccountStatusSchema, } from './schemas/accountStatus';
 export { accountProviderIdSchema, accountManagerResultSchema, beginAccountLoginResultSchema, accountLoginStatusSchema, accountEntrySchema, savedAccountProfileSchema, listAllAccountsResultSchema, } from './schemas/accountManager';
 export { assistantTurnEventSchema, assistantTurnEventTypeSchema, assistantTurnNarrationStepSchema, assistantTurnProcessSchema, assistantTurnProcessStepSchema, assistantTurnProjectionSchema, assistantTurnReasoningTimelineItemSchema, assistantTurnSubagentSchema, assistantTurnSubagentStatusSchema, assistantTurnTimelineItemSchema, assistantTurnToolGroupStepSchema, assistantTurnToolRefSchema, } from './schemas/assistantTurn';
@@ -271,7 +281,16 @@ export { _resetPeakHoursCache, createPeakHoursNotApplicableState, DEFAULT_PEAK_H
 export type { FetchPeakHoursOptions, PeakHoursState } from './peakHours';
 export { FAILING_TOOL_TREND_ARROWS, failingToolTrend, mergeFailingToolWindows, } from './failingTools';
 export type { FailingToolTrend, FailingToolTrendRow, FailingToolWindow } from './failingTools';
-export { diagnoseProviderFailure } from './providerFailure';
+export { diagnoseProviderFailure, PROVIDER_AUTHENTICATION_SOURCES, PROVIDER_AUTHENTICATION_STATES, PROVIDER_CREDENTIAL_KINDS, PROVIDER_FAILURE_CODES, PROVIDER_FAILURE_EVIDENCE_SOURCES, PROVIDER_RECOVERY_ACTIONS, } from './providerFailure';
 export type { ProviderCredentialKind, ProviderAuthenticationEvidence, ProviderFailureInput, ProviderFailureCode, ProviderRecoveryAction, ProviderRetryAfter, ProviderFailureEvidence, ProviderFailureDiagnosis, } from './providerFailure';
 export type { ProviderServiceSeverity, ProviderServiceComponent, ProviderServiceIncident, ProviderServiceStatusFailureReason, ObservedProviderServiceStatus, UnavailableProviderServiceStatus, ProviderServiceStatus, FetchProviderServiceStatusOptions, } from './providerServiceStatusTypes';
 export { fetchProviderServiceStatus } from './providerServiceStatus';
+export { inspectCodexCredentialStores, repairCodexCredentialStores } from './codexCredentialDoctor';
+export type { CodexCredentialFinding, CodexCredentialInspection, CodexCredentialRepairResult, } from './codexCredentialDoctor';
+export { readStoredCodexAccount, syncCodexLiveStateAsync } from './codexProfiles';
+export { getCodexSessionsDirs, CODEX_SESSIONS_SUBDIR, CODEX_ARCHIVED_SESSIONS_SUBDIR, } from './codexPaths';
+export type { CodexSessionsDirsOptions } from './codexPaths';
+export { classifyTool, TOOL_CATEGORIES } from './toolCategory';
+export type { ClassifyToolOptions, ToolCategory } from './toolCategory';
+export { resolveWorkspaceRoots } from './workspaceRoots';
+export type { ResolveWorkspaceRootsOptions, ResolvedWorkspaceRoots } from './workspaceRoots';