sidekick-shared 0.25.0 → 0.26.0

package/dist/quotaResolver.js

@@ -0,0 +1,213 @@
+"use strict";
+/**
+ * One quota resolution path for every Sidekick surface.
+ *
+ * `sidekick quota`, `quota --all`, the MCP facts server, and both dashboards
+ * used to pick between the live API, session logs, and the persisted snapshot
+ * in four different orders. `resolveQuota()` applies one precedence:
+ *
+ * 1. a fresh persisted snapshot (younger than `QUOTA_FRESH_MAX_AGE_MS`, whatever
+ *    its origin: the official status-line sample, a session log, or an earlier
+ *    API call) — zero network;
+ * 2. a session-derived sample (Codex rollouts carry rate limits; Claude and
+ *    z.ai have no local equivalent);
+ * 3. the provider API, when `allowApi` is not disabled;
+ * 4. an aging or stale snapshot, labelled as such, with the API failure attached;
+ * 5. an unavailable state describing why nothing could be resolved.
+ *
+ * `preferFresh: false` skips step 1 (the `--refresh` flag). Every result carries
+ * `source`, `capturedSource`, `freshness`, `ageMs`, and a `resolution` tag.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveQuota = resolveQuota;
+const accounts_1 = require("./accounts");
+const codexProfiles_1 = require("./codexProfiles");
+const codexQuota_1 = require("./codexQuota");
+const credentials_1 = require("./credentials");
+const quota_1 = require("./quota");
+const quotaPresentation_1 = require("./quotaPresentation");
+const quotaSnapshots_1 = require("./quotaSnapshots");
+const zaiQuotaApi_1 = require("./zaiQuotaApi");
+const ZAI_DEFAULT_ACCOUNT_ID = 'default';
+const CLAUDE_NO_CREDENTIALS_ERROR = 'No OAuth token available';
+function snapshotProviderId(providerId) {
+    return providerId;
+}
+function defaultResolveCodexAccount(options) {
+    // Self-heal the saved pointer to the live login first so the snapshot key and
+    // the display identity both track reality after a native `codex login`.
+    (0, codexProfiles_1.resolveActiveCodexAccount)(options);
+    return (0, codexProfiles_1.getActiveCodexAccount)();
+}
+function resolveIdentity(options) {
+    const selfHeal = options.selfHeal ?? true;
+    switch (options.providerId) {
+        case 'claude-code': {
+            const account = (options.resolveClaudeAccount ?? accounts_1.resolveActiveClaudeAccount)({ selfHeal });
+            return {
+                accountId: options.accountId ?? account.registryAccountId,
+                codexAccount: null,
+                accountLabel: account.label ?? account.email,
+                accountDetail: account.email,
+            };
+        }
+        case 'codex': {
+            const profile = (options.resolveCodexAccount ?? defaultResolveCodexAccount)({ selfHeal });
+            return {
+                accountId: options.accountId ?? profile?.id,
+                codexAccount: profile,
+                accountLabel: profile?.label,
+                accountDetail: profile?.email,
+            };
+        }
+        case 'zai':
+            return { accountId: options.accountId ?? ZAI_DEFAULT_ACCOUNT_ID, codexAccount: null };
+    }
+}
+async function defaultClaudeAccessToken() {
+    const credentials = await (0, credentials_1.readClaudeMaxCredentials)();
+    return credentials?.accessToken ?? null;
+}
+function zeroWindows() {
+    return { fiveHour: { utilization: 0, resetsAt: '' }, sevenDay: { utilization: 0, resetsAt: '' } };
+}
+function unavailableState(providerId, error, capturedAt) {
+    return {
+        ...zeroWindows(),
+        available: false,
+        error,
+        failureKind: 'unknown',
+        providerId,
+        capturedAt,
+        ...(providerId === 'codex' ? { fiveHourLabel: 'Primary', sevenDayLabel: 'Secondary' } : {}),
+    };
+}
+async function fetchFromApi(options, identity, capturedAt) {
+    switch (options.providerId) {
+        case 'claude-code': {
+            const token = await (options.getClaudeAccessToken ?? defaultClaudeAccessToken)();
+            if (!token) {
+                return {
+                    ...zeroWindows(),
+                    available: false,
+                    error: CLAUDE_NO_CREDENTIALS_ERROR,
+                    failureKind: 'auth',
+                    providerId: 'claude-code',
+                    source: 'api',
+                    capturedAt,
+                };
+            }
+            const state = await (0, quota_1.fetchQuota)(token, { fetchImpl: options.fetchImpl });
+            return { ...state, providerId: 'claude-code', source: 'api', capturedAt };
+        }
+        case 'codex':
+            return (0, codexQuota_1.fetchCodexQuotaFromApi)({
+                codexHome: options.codexHome,
+                fetchImpl: options.fetchImpl,
+                accessToken: options.codexAccessToken,
+                accountId: identity.codexAccount?.providerAccountId,
+                capturedAt,
+            });
+        case 'zai':
+            return (0, zaiQuotaApi_1.fetchZaiQuotaFromApi)({ ...options.zai, fetchImpl: options.fetchImpl, capturedAt });
+    }
+}
+function withAge(state, now) {
+    if (state.ageMs !== undefined && state.freshness !== undefined)
+        return state;
+    const capturedMs = state.capturedAt ? Date.parse(state.capturedAt) : NaN;
+    const ageMs = Number.isFinite(capturedMs) ? Math.max(0, now.getTime() - capturedMs) : undefined;
+    return {
+        ...state,
+        ...(ageMs !== undefined ? { ageMs } : {}),
+        freshness: (0, quota_1.classifyQuotaFreshness)(ageMs),
+    };
+}
+function enrich(providerId, state, identity) {
+    switch (providerId) {
+        case 'claude-code':
+            return {
+                ...(0, quota_1.withQuotaProjections)(state),
+                runtimeProvider: 'claude',
+                providerId: 'claude-code',
+                accountLabel: identity.accountLabel,
+                accountDetail: identity.accountDetail,
+            };
+        case 'codex':
+            return (0, codexQuota_1.enrichCodexQuota)(state, identity.codexAccount);
+        default:
+            return (0, zaiQuotaApi_1.enrichZaiQuota)(state);
+    }
+}
+function snapshotResolution(state) {
+    if (state.freshness === 'fresh')
+        return 'snapshot-fresh';
+    if (state.freshness === 'aging')
+        return 'snapshot-aging';
+    return 'snapshot-stale';
+}
+/**
+ * Resolve the current quota for one provider with the shared precedence
+ * described at the top of this file.
+ *
+ * The result always has `runtimeProvider`, `resolution`, `freshness`, and
+ * (when a capture time is known) `ageMs`; `failure` describes an API failure
+ * even when older numbers were returned from a snapshot.
+ */
+async function resolveQuota(options) {
+    const providerId = options.providerId;
+    const now = options.now ?? new Date();
+    const capturedAt = now.toISOString();
+    const preferFresh = options.preferFresh ?? true;
+    const allowApi = options.allowApi ?? true;
+    const readSnapshot = options.readSnapshot ?? quotaSnapshots_1.readQuotaSnapshot;
+    const writeSnapshot = options.writeSnapshot ?? quotaSnapshots_1.writeQuotaSnapshot;
+    const identity = resolveIdentity(options);
+    const finish = (state, resolution) => {
+        const enriched = withAge(enrich(providerId, state, identity), now);
+        return {
+            ...enriched,
+            failure: enriched.failure ?? (0, quotaPresentation_1.describeQuotaFailure)(enriched),
+            resolution,
+        };
+    };
+    const stored = identity.accountId
+        ? readSnapshot(snapshotProviderId(providerId), identity.accountId, now)
+        : null;
+    const snapshot = stored?.available ? stored : null;
+    if (preferFresh && snapshot && snapshot.freshness === 'fresh') {
+        return finish(snapshot, 'snapshot-fresh');
+    }
+    if (providerId === 'codex') {
+        const local = (0, codexQuota_1.resolveCodexQuotaFromLocalSources)({
+            workspacePath: options.workspacePath,
+            provider: options.codexProvider,
+            activeAccount: identity.codexAccount,
+            codexHome: options.codexHome,
+            // Only rollout hits count as "session-derived"; the snapshot fallback is
+            // handled below so it can be labelled by age.
+            readSnapshot: () => null,
+            writeSnapshot,
+        });
+        if (local)
+            return finish(local, 'session');
+    }
+    let apiState = null;
+    if (allowApi) {
+        apiState = await fetchFromApi(options, identity, capturedAt);
+        if (apiState.available) {
+            if (identity.accountId) {
+                writeSnapshot(snapshotProviderId(providerId), identity.accountId, apiState);
+            }
+            return finish(apiState, 'api');
+        }
+    }
+    if (snapshot) {
+        const fallback = finish(snapshot, snapshotResolution(snapshot));
+        return apiState ? { ...fallback, failure: (0, quotaPresentation_1.describeQuotaFailure)(apiState) } : fallback;
+    }
+    return finish(apiState ??
+        unavailableState(providerId, stored
+            ? 'The last persisted quota sample was unavailable.'
+            : 'No quota data is available yet; run the provider once so a sample can be recorded.', capturedAt), 'unavailable');
+}

package/dist/quotaSnapshots.d.ts

@@ -1,4 +1,4 @@
-import type { QuotaState } from './quota';
+import { type QuotaState } from './quota';
 import type { AccountProviderId } from './accountRegistry';
 /**
  * Storage key for a quota snapshot. Extends `AccountProviderId` with `'zai'`
@@ -6,5 +6,18 @@ import type { AccountProviderId } from './accountRegistry';
  * store still needs a stable key for the z.ai quota cache.
  */
 export type QuotaSnapshotProviderId = AccountProviderId | 'zai';
+export interface QuotaSnapshotRecord {
+    providerId: QuotaSnapshotProviderId;
+    accountId: string;
+    quota: QuotaState;
+}
 export declare function writeQuotaSnapshot(providerId: QuotaSnapshotProviderId, accountId: string, quota: QuotaState): void;
-export declare function readQuotaSnapshot(providerId: QuotaSnapshotProviderId, accountId: string): QuotaState | null;
+/**
+ * Read the persisted snapshot for one provider/account.
+ *
+ * `stale: true` and `source: 'cache'` mean "not a live fetch"; the age of the
+ * sample is reported separately as `ageMs` and `freshness` so a reader can
+ * tell a ten-second-old snapshot from a two-day-old one, and the original
+ * origin is kept as `capturedSource` (`statusline`, `session`, or `api`).
+ */
+export declare function readQuotaSnapshot(providerId: QuotaSnapshotProviderId, accountId: string, now?: Date): QuotaState | null;

package/dist/quotaSnapshots.js

@@ -39,6 +39,7 @@ const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const paths_1 = require("./paths");
 const atomic_1 = require("./writers/atomic");
+const quota_1 = require("./quota");
 const codex_1 = require("./types/codex");
 function getQuotaSnapshotPath() {
     return path.join((0, paths_1.getConfigDir)(), 'quota-snapshots.json');
@@ -113,11 +114,17 @@ function writeQuotaSnapshot(providerId, accountId, quota) {
         const store = readStore();
         const index = store.snapshots.findIndex((item) => item.providerId === providerId && item.accountId === accountId);
         const existingQuota = index >= 0 ? store.snapshots[index].quota : undefined;
+        // `ageMs`, `freshness`, `stale`, and `capturedSource` are read-time facts: a
+        // sample that came back from `readQuotaSnapshot()` and is written again keeps
+        // its original source rather than being stored as `cache`.
+        const { capturedSource, ...sample } = quota;
+        delete sample.ageMs;
+        delete sample.freshness;
         const snapshot = {
-            ...quota,
+            ...sample,
             providerId,
             capturedAt: quota.capturedAt ?? new Date().toISOString(),
-            source: quota.source ?? 'session',
+            source: sample.source && sample.source !== 'cache' ? sample.source : (capturedSource ?? 'session'),
             stale: false,
             resetCredits: quota.resetCredits ?? (providerId === 'codex' ? existingQuota?.resetCredits : undefined),
         };
@@ -131,15 +138,30 @@ function writeQuotaSnapshot(providerId, accountId, quota) {
         writeStore(store);
     });
 }
-function readQuotaSnapshot(providerId, accountId) {
+/**
+ * Read the persisted snapshot for one provider/account.
+ *
+ * `stale: true` and `source: 'cache'` mean "not a live fetch"; the age of the
+ * sample is reported separately as `ageMs` and `freshness` so a reader can
+ * tell a ten-second-old snapshot from a two-day-old one, and the original
+ * origin is kept as `capturedSource` (`statusline`, `session`, or `api`).
+ */
+function readQuotaSnapshot(providerId, accountId, now = new Date()) {
     const store = readStore();
     const snapshot = store.snapshots.find((item) => item.providerId === providerId && item.accountId === accountId);
     if (!snapshot)
         return null;
+    const capturedMs = snapshotTimeMs(snapshot.quota);
+    const ageMs = capturedMs > 0 ? Math.max(0, now.getTime() - capturedMs) : undefined;
+    const storedSource = snapshot.quota.capturedSource ?? snapshot.quota.source;
+    const capturedSource = storedSource && storedSource !== 'cache' ? storedSource : undefined;
     return {
         ...snapshot.quota,
         providerId,
         source: 'cache',
+        ...(capturedSource ? { capturedSource } : {}),
         stale: true,
+        ...(ageMs !== undefined ? { ageMs } : {}),
+        freshness: (0, quota_1.classifyQuotaFreshness)(ageMs),
     };
 }

package/dist/quotaThresholds.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Threshold-crossing detection for subscription quota windows.
+ *
+ * Pure and host-neutral: the VS Code extension and the CLI dashboard both
+ * feed it every quota sample and raise whatever alerts it returns, so a user
+ * hears "your five-hour window is at 80%" the same way in both. Alerts fire
+ * once per threshold per reset window, on the rising edge; when a window
+ * resets the memory resets with it.
+ *
+ * @module quotaThresholds
+ */
+import type { QuotaState } from './quota';
+export type QuotaThresholdWindow = 'fiveHour' | 'sevenDay';
+export interface QuotaThresholdConfig {
+    /** Utilization percentages (0–100) that raise an alert for the five-hour window. */
+    fiveHour: readonly number[];
+    /** Utilization percentages (0–100) that raise an alert for the seven-day window. */
+    sevenDay: readonly number[];
+}
+/**
+ * Defaults tuned to the two surprises users report: the afternoon five-hour
+ * cutoff (warn at 80%, escalate at 95%) and the mid-week weekly cap (90%).
+ */
+export declare const DEFAULT_QUOTA_THRESHOLDS: QuotaThresholdConfig;
+interface WindowMemory {
+    resetsAt: string;
+    /** Highest threshold already alerted for this reset window (0 = none). */
+    level: number;
+}
+/** Opaque per-window state; keep it between samples and pass it back in. */
+export interface QuotaAlertMemory {
+    fiveHour?: WindowMemory;
+    sevenDay?: WindowMemory;
+}
+export interface QuotaThresholdAlert {
+    window: QuotaThresholdWindow;
+    /** The threshold that was crossed. */
+    threshold: number;
+    /** Utilization at the time of the sample. */
+    utilization: number;
+    /** ISO reset time of the window, when known. */
+    resetsAt: string;
+    /** Escalation hint: the highest configured threshold is `critical`. */
+    severity: 'warning' | 'critical';
+}
+export interface QuotaThresholdEvaluation {
+    alerts: QuotaThresholdAlert[];
+    memory: QuotaAlertMemory;
+}
+/**
+ * Compare a quota sample against the thresholds and the alerts already
+ * raised. Unavailable samples produce no alerts and leave the memory alone.
+ */
+export declare function evaluateQuotaThresholds(quota: QuotaState, config?: QuotaThresholdConfig, memory?: QuotaAlertMemory): QuotaThresholdEvaluation;
+/** One-line, reset-aware message: `Claude five-hour window at 82% (resets 14:00)`. */
+export declare function describeQuotaThresholdAlert(alert: QuotaThresholdAlert, options?: {
+    providerLabel?: string;
+    now?: Date;
+}): string;
+export {};

package/dist/quotaThresholds.js

@@ -0,0 +1,90 @@
+"use strict";
+/**
+ * Threshold-crossing detection for subscription quota windows.
+ *
+ * Pure and host-neutral: the VS Code extension and the CLI dashboard both
+ * feed it every quota sample and raise whatever alerts it returns, so a user
+ * hears "your five-hour window is at 80%" the same way in both. Alerts fire
+ * once per threshold per reset window, on the rising edge; when a window
+ * resets the memory resets with it.
+ *
+ * @module quotaThresholds
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_QUOTA_THRESHOLDS = void 0;
+exports.evaluateQuotaThresholds = evaluateQuotaThresholds;
+exports.describeQuotaThresholdAlert = describeQuotaThresholdAlert;
+/**
+ * Defaults tuned to the two surprises users report: the afternoon five-hour
+ * cutoff (warn at 80%, escalate at 95%) and the mid-week weekly cap (90%).
+ */
+exports.DEFAULT_QUOTA_THRESHOLDS = {
+    fiveHour: [80, 95],
+    sevenDay: [90],
+};
+function sanitizeThresholds(values) {
+    return [...new Set(values.filter((v) => Number.isFinite(v) && v > 0 && v <= 100))].sort((a, b) => a - b);
+}
+function evaluateWindow(window, quota, thresholds, previous) {
+    const sorted = sanitizeThresholds(thresholds);
+    const utilization = Number.isFinite(quota.utilization) ? quota.utilization : 0;
+    const resetsAt = quota.resetsAt ?? '';
+    let level = 0;
+    for (const threshold of sorted)
+        if (utilization >= threshold)
+            level = threshold;
+    const previousLevel = previous && previous.resetsAt === resetsAt ? previous.level : 0;
+    const memory = { resetsAt, level: Math.max(level, previousLevel) };
+    if (level <= previousLevel)
+        return { alert: null, memory };
+    return {
+        alert: {
+            window,
+            threshold: level,
+            utilization,
+            resetsAt,
+            severity: level >= sorted[sorted.length - 1] ? 'critical' : 'warning',
+        },
+        memory,
+    };
+}
+/**
+ * Compare a quota sample against the thresholds and the alerts already
+ * raised. Unavailable samples produce no alerts and leave the memory alone.
+ */
+function evaluateQuotaThresholds(quota, config = exports.DEFAULT_QUOTA_THRESHOLDS, memory = {}) {
+    if (!quota.available)
+        return { alerts: [], memory };
+    const fiveHour = evaluateWindow('fiveHour', quota.fiveHour, config.fiveHour, memory.fiveHour);
+    const sevenDay = evaluateWindow('sevenDay', quota.sevenDay, config.sevenDay, memory.sevenDay);
+    return {
+        alerts: [fiveHour.alert, sevenDay.alert].filter((alert) => alert !== null),
+        memory: { fiveHour: fiveHour.memory, sevenDay: sevenDay.memory },
+    };
+}
+const WINDOW_LABELS = {
+    fiveHour: 'five-hour window',
+    sevenDay: 'seven-day window',
+};
+function formatResetTime(resetsAt, now) {
+    const ms = Date.parse(resetsAt);
+    if (!Number.isFinite(ms))
+        return null;
+    const reset = new Date(ms);
+    const sameDay = reset.getFullYear() === now.getFullYear() &&
+        reset.getMonth() === now.getMonth() &&
+        reset.getDate() === now.getDate();
+    return new Intl.DateTimeFormat(undefined, {
+        ...(sameDay ? {} : { weekday: 'short' }),
+        hour: '2-digit',
+        minute: '2-digit',
+        hour12: false,
+    }).format(reset);
+}
+/** One-line, reset-aware message: `Claude five-hour window at 82% (resets 14:00)`. */
+function describeQuotaThresholdAlert(alert, options = {}) {
+    const provider = options.providerLabel ?? 'Claude';
+    const reset = formatResetTime(alert.resetsAt, options.now ?? new Date());
+    const suffix = reset ? ` (resets ${reset})` : '';
+    return `${provider} ${WINDOW_LABELS[alert.window]} at ${Math.round(alert.utilization)}%${suffix}`;
+}

package/dist/report/htmlReportGenerator.js

@@ -6,6 +6,8 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateHtmlReport = generateHtmlReport;
+const costProvenance_1 = require("../aggregation/costProvenance");
+const tokenSummary_1 = require("../tokenSummary");
 const htmlHelpers_1 = require("./htmlHelpers");
 const logo_1 = require("./logo");
 /**
@@ -14,7 +16,7 @@ const logo_1 = require("./logo");
 function generateHtmlReport(metrics, transcript, options = {}) {
     const { sessionFileName, includeThinking = true, includeToolDetail = true, theme = 'dark', } = options;
     const duration = (0, htmlHelpers_1.formatDuration)(metrics.sessionStartTime, metrics.lastEventTime);
-    const totalTokens = metrics.tokens.inputTokens + metrics.tokens.outputTokens;
+    const totalTokens = (0, tokenSummary_1.summarizeTokens)(metrics.tokens).total;
     return `<!DOCTYPE html>
 <html lang="en" data-theme="${theme}">
 <head>
@@ -430,7 +432,7 @@ function generateStatsCards(metrics, totalTokens, duration) {
             sub: metrics.sessionStartTime ? (0, htmlHelpers_1.formatTimestamp)(metrics.sessionStartTime) + ' start' : '',
         },
         {
-            label: 'Total Tokens',
+            label: tokenSummary_1.TOKEN_TOTAL_LABEL,
             value: (0, htmlHelpers_1.fmtTokens)(totalTokens),
             sub: `${(0, htmlHelpers_1.fmtTokens)(metrics.tokens.inputTokens)} in / ${(0, htmlHelpers_1.fmtTokens)(metrics.tokens.outputTokens)} out`,
         },
@@ -445,8 +447,12 @@ function generateStatsCards(metrics, totalTokens, duration) {
             sub: `${metrics.toolStats.length} unique tools`,
         },
     ];
-    if (metrics.tokens.reportedCost > 0) {
-        cards.push({ label: 'Cost', value: (0, htmlHelpers_1.fmtCost)(metrics.tokens.reportedCost), sub: 'reported' });
+    if (metrics.tokens.costUsd > 0 || metrics.tokens.unpricedCalls > 0) {
+        cards.push({
+            label: 'Cost',
+            value: metrics.tokens.costUsd > 0 ? (0, htmlHelpers_1.fmtCost)(metrics.tokens.costUsd) : '—',
+            sub: (0, htmlHelpers_1.escapeHtml)((0, costProvenance_1.describeCostProvenance)(metrics.tokens)),
+        });
     }
     return `<div class="container">
 <div class="stats-grid">

package/dist/report/sessionReportInputs.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Everything an HTML session report needs, from one read of the session.
+ *
+ * `sidekick report`, the CLI dashboard's report action, and the extension used
+ * to replay a session through a watcher for metrics and then parse the file a
+ * second time for the transcript. This reads the provider's canonical events
+ * once and derives both.
+ *
+ * @module report/sessionReportInputs
+ */
+import type { AggregatedMetrics } from '../aggregation/types';
+import type { SessionProviderBase } from '../providers/types';
+import type { SessionEvent } from '../types/sessionEvent';
+import type { TranscriptEntry } from './types';
+export interface SessionReportInputs {
+    sessionPath: string;
+    /** Canonical provider events, already flushed. */
+    events: SessionEvent[];
+    metrics: AggregatedMetrics;
+    transcript: TranscriptEntry[];
+}
+/** Read a session once and build the aggregator metrics and report transcript from it. */
+export declare function readSessionReportInputs(provider: SessionProviderBase, sessionPath: string): SessionReportInputs;

package/dist/report/sessionReportInputs.js

@@ -0,0 +1,34 @@
+"use strict";
+/**
+ * Everything an HTML session report needs, from one read of the session.
+ *
+ * `sidekick report`, the CLI dashboard's report action, and the extension used
+ * to replay a session through a watcher for metrics and then parse the file a
+ * second time for the transcript. This reads the provider's canonical events
+ * once and derives both.
+ *
+ * @module report/sessionReportInputs
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readSessionReportInputs = readSessionReportInputs;
+const EventAggregator_1 = require("../aggregation/EventAggregator");
+const sessionStats_1 = require("../sessionStats");
+const transcriptParser_1 = require("./transcriptParser");
+/** Read a session once and build the aggregator metrics and report transcript from it. */
+function readSessionReportInputs(provider, sessionPath) {
+    const reader = provider.createReader(sessionPath);
+    const events = reader.readAll();
+    reader.flush();
+    const aggregator = new EventAggregator_1.EventAggregator({
+        providerId: provider.id,
+        computeContextSize: (0, sessionStats_1.providerContextSizeFn)(provider),
+    });
+    for (const event of events)
+        aggregator.processEvent(event);
+    return {
+        sessionPath,
+        events,
+        metrics: aggregator.getMetrics(),
+        transcript: (0, transcriptParser_1.parseTranscriptFromEvents)(events),
+    };
+}

package/dist/schemas/index.d.ts

@@ -36,3 +36,5 @@ export type { AccountProviderId, SavedAccountProfile } from '../accountRegistry'
 export type { AccountLoginStatus, BeginAccountLoginResult, ListAllAccountsResult, } from '../accountManager';
 export { assistantTurnEventSchema, assistantTurnEventTypeSchema, assistantTurnNarrationStepSchema, assistantTurnProcessSchema, assistantTurnProcessStepSchema, assistantTurnProjectionSchema, assistantTurnReasoningTimelineItemSchema, assistantTurnSubagentSchema, assistantTurnSubagentStatusSchema, assistantTurnTimelineItemSchema, assistantTurnToolGroupStepSchema, assistantTurnToolRefSchema, } from './assistantTurn';
 export type { AssistantTurnEvent, AssistantTurnEventType, AssistantTurnProcess, AssistantTurnProcessStep, AssistantTurnProjection, AssistantTurnSubagent, AssistantTurnSubagentStatus, AssistantTurnTimelineItem, AssistantTurnToolRef, } from '../turns/assistantTurn';
+export { sidekickStateFileSchema, stateFileAccountSchema, stateFileBillingBlockSchema, stateFileContextSchema, stateFileQuotaSchema, stateFileQuotaWindowSchema, stateFileSessionSchema, stateFileWriterSchema, } from './stateFile';
+export type { SidekickStateFile, StateFileAccount, StateFileBillingBlock, StateFileContext, StateFileQuota, StateFileQuotaWindow, StateFileSession, StateFileWriter, } from '../stateFile';

package/dist/schemas/index.js

@@ -13,7 +13,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.activeAccountStatusSchema = exports.activeProviderAccountStatusSchema = exports.quotaHistoryDailyBucketSchema = exports.quotaHistorySampleSchema = exports.quotaHistoryRuntimeProviderSchema = exports.providerQuotaMapSchema = exports.zaiProviderQuotaStateSchema = exports.codexProviderQuotaStateSchema = exports.claudeProviderQuotaStateSchema = exports.providerQuotaStateSchema = exports.runtimeQuotaProviderSchema = exports.quotaFailureDescriptorSchema = exports.peakHoursStateSchema = exports.codexResetCreditsSnapshotSchema = exports.codexResetCreditSchema = exports.quotaSourceSchema = exports.quotaProviderIdSchema = exports.quotaFailureKindSchema = exports.quotaStateSchema = exports.quotaWindowSchema = exports.sessionEvidenceRefV1Schema = exports.providerSessionAdapterV1Schema = exports.providerCapabilitiesV1Schema = exports.pendingUserRequestV1Schema = exports.observedValueV1Schema = exports.observedAgentSessionV1Schema = exports.observationProvenanceV1Schema = exports.canonicalSessionTranscriptSchema = exports.canonicalTranscriptMessageSchema = exports.canonicalToolCallSchema = exports.canonicalTranscriptBlockSchema = exports.transcriptSourceProvenanceSchema = exports.tokenEstimateSchema = exports.normalizedUsageCostSchema = exports.normalizedUsageSchema = exports.toolResultSessionEventSchema = exports.toolUseSessionEventSchema = exports.systemSessionEventSchema = exports.summarySessionEventSchema = exports.assistantSessionEventSchema = exports.userSessionEventSchema = exports.extractSessionEvents = exports.permissionModeSchema = exports.sessionEventSchema = exports.sessionMessageSchema = exports.messageUsageSchema = exports.SESSION_PROVIDER_IDS = exports.RUNTIME_QUOTA_PROVIDER_IDS = exports.QUOTA_PROVIDER_IDS = exports.ACCOUNT_PROVIDER_IDS = void 0;
-exports.assistantTurnToolRefSchema = exports.assistantTurnToolGroupStepSchema = exports.assistantTurnTimelineItemSchema = exports.assistantTurnSubagentStatusSchema = exports.assistantTurnSubagentSchema = exports.assistantTurnReasoningTimelineItemSchema = exports.assistantTurnProjectionSchema = exports.assistantTurnProcessStepSchema = exports.assistantTurnProcessSchema = exports.assistantTurnNarrationStepSchema = exports.assistantTurnEventTypeSchema = exports.assistantTurnEventSchema = exports.listAllAccountsResultSchema = exports.savedAccountProfileSchema = exports.accountEntrySchema = exports.accountLoginStatusSchema = exports.beginAccountLoginResultSchema = exports.accountManagerResultSchema = exports.accountProviderIdSchema = void 0;
+exports.stateFileWriterSchema = exports.stateFileSessionSchema = exports.stateFileQuotaWindowSchema = exports.stateFileQuotaSchema = exports.stateFileContextSchema = exports.stateFileBillingBlockSchema = exports.stateFileAccountSchema = exports.sidekickStateFileSchema = exports.assistantTurnToolRefSchema = exports.assistantTurnToolGroupStepSchema = exports.assistantTurnTimelineItemSchema = exports.assistantTurnSubagentStatusSchema = exports.assistantTurnSubagentSchema = exports.assistantTurnReasoningTimelineItemSchema = exports.assistantTurnProjectionSchema = exports.assistantTurnProcessStepSchema = exports.assistantTurnProcessSchema = exports.assistantTurnNarrationStepSchema = exports.assistantTurnEventTypeSchema = exports.assistantTurnEventSchema = exports.listAllAccountsResultSchema = exports.savedAccountProfileSchema = exports.accountEntrySchema = exports.accountLoginStatusSchema = exports.beginAccountLoginResultSchema = exports.accountManagerResultSchema = exports.accountProviderIdSchema = void 0;
 var providerIds_1 = require("../providerIds");
 Object.defineProperty(exports, "ACCOUNT_PROVIDER_IDS", { enumerable: true, get: function () { return providerIds_1.ACCOUNT_PROVIDER_IDS; } });
 Object.defineProperty(exports, "QUOTA_PROVIDER_IDS", { enumerable: true, get: function () { return providerIds_1.QUOTA_PROVIDER_IDS; } });
@@ -94,3 +94,12 @@ Object.defineProperty(exports, "assistantTurnSubagentStatusSchema", { enumerable
 Object.defineProperty(exports, "assistantTurnTimelineItemSchema", { enumerable: true, get: function () { return assistantTurn_1.assistantTurnTimelineItemSchema; } });
 Object.defineProperty(exports, "assistantTurnToolGroupStepSchema", { enumerable: true, get: function () { return assistantTurn_1.assistantTurnToolGroupStepSchema; } });
 Object.defineProperty(exports, "assistantTurnToolRefSchema", { enumerable: true, get: function () { return assistantTurn_1.assistantTurnToolRefSchema; } });
+var stateFile_1 = require("./stateFile");
+Object.defineProperty(exports, "sidekickStateFileSchema", { enumerable: true, get: function () { return stateFile_1.sidekickStateFileSchema; } });
+Object.defineProperty(exports, "stateFileAccountSchema", { enumerable: true, get: function () { return stateFile_1.stateFileAccountSchema; } });
+Object.defineProperty(exports, "stateFileBillingBlockSchema", { enumerable: true, get: function () { return stateFile_1.stateFileBillingBlockSchema; } });
+Object.defineProperty(exports, "stateFileContextSchema", { enumerable: true, get: function () { return stateFile_1.stateFileContextSchema; } });
+Object.defineProperty(exports, "stateFileQuotaSchema", { enumerable: true, get: function () { return stateFile_1.stateFileQuotaSchema; } });
+Object.defineProperty(exports, "stateFileQuotaWindowSchema", { enumerable: true, get: function () { return stateFile_1.stateFileQuotaWindowSchema; } });
+Object.defineProperty(exports, "stateFileSessionSchema", { enumerable: true, get: function () { return stateFile_1.stateFileSessionSchema; } });
+Object.defineProperty(exports, "stateFileWriterSchema", { enumerable: true, get: function () { return stateFile_1.stateFileWriterSchema; } });