sidekick-shared 0.24.5 → 0.26.0

package/dist/historicalStore.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Pure mutations of the `historical-data.json` store.
+ *
+ * Ported verbatim from the VS Code extension's HistoricalDataService so the
+ * CLI importer and the extension apply session summaries the same way:
+ * a session's previous contribution is subtracted before the new one is
+ * added (idempotent replacement), daily, hourly, monthly, and all-time
+ * buckets are updated together, and the per-session record list is capped
+ * at `HISTORICAL_SESSION_RETENTION_LIMIT`. Browser-safe: no Node imports.
+ *
+ * @module historicalStore
+ */
+import type { SessionFileStats } from './providers/types';
+import type { HistoricalDataStore, SessionHistoryRecord, SessionSummary } from './types/historicalData';
+export interface ApplySessionSummaryOptions {
+    /** Clock for `updatedAt` stamps (default `new Date()`). */
+    now?: Date;
+    /** Cap on `store.sessions` (default `HISTORICAL_SESSION_RETENTION_LIMIT`). */
+    retentionLimit?: number;
+}
+/** Subtract a previously saved session's contribution from every bucket. */
+export declare function removeSessionSummary(store: HistoricalDataStore, record: SessionHistoryRecord, now?: Date): void;
+/**
+ * Apply a completed session to the daily, hourly, monthly, and all-time
+ * buckets and the capped per-session list. Re-applying the same session id
+ * replaces its earlier contribution instead of double counting it.
+ *
+ * Returns the stored per-session record.
+ */
+export declare function applySessionSummary(store: HistoricalDataStore, summary: SessionSummary, options?: ApplySessionSummaryOptions): SessionHistoryRecord;
+/** Whether a session file has already been folded into the store. */
+export declare function isFileImported(store: HistoricalDataStore, filePath: string): boolean;
+/** Record a session file as imported. Returns false when it was already listed. */
+export declare function markFileImported(store: HistoricalDataStore, filePath: string, now?: Date): boolean;
+export interface SessionSummaryFromStatsOptions {
+    /** Session provider id stored on the record (default `stats.providerId`). */
+    provider?: string;
+    /** Workspace path stored on the record (default `'unknown'`). */
+    project?: string | null;
+}
+/**
+ * Build the summary the history store expects from unified session stats,
+ * so the CLI importer and the extension's first-activation import store the
+ * same per-model cost, tool success/failure split, and unpriced markers.
+ * Pending tool calls count as successes (stats only split out failures).
+ */
+export declare function sessionSummaryFromStats(stats: SessionFileStats, options?: SessionSummaryFromStatsOptions): SessionSummary;

package/dist/historicalStore.js

@@ -0,0 +1,312 @@
+"use strict";
+/**
+ * Pure mutations of the `historical-data.json` store.
+ *
+ * Ported verbatim from the VS Code extension's HistoricalDataService so the
+ * CLI importer and the extension apply session summaries the same way:
+ * a session's previous contribution is subtracted before the new one is
+ * added (idempotent replacement), daily, hourly, monthly, and all-time
+ * buckets are updated together, and the per-session record list is capped
+ * at `HISTORICAL_SESSION_RETENTION_LIMIT`. Browser-safe: no Node imports.
+ *
+ * @module historicalStore
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeSessionSummary = removeSessionSummary;
+exports.applySessionSummary = applySessionSummary;
+exports.isFileImported = isFileImported;
+exports.markFileImported = markFileImported;
+exports.sessionSummaryFromStats = sessionSummaryFromStats;
+const formatting_1 = require("./formatting");
+const historicalData_1 = require("./types/historicalData");
+function mergeModelUsage(existing, incoming) {
+    const map = new Map();
+    for (const record of existing)
+        map.set(record.model, { ...record });
+    for (const record of incoming) {
+        const current = map.get(record.model);
+        if (current) {
+            current.calls += record.calls;
+            current.tokens += record.tokens;
+            current.cost += record.cost;
+            // Unpriced taints: if either side was unpriced, the merged row is too.
+            // Legacy v1 records (priced === undefined) are assumed priced.
+            if (record.priced === false || current.priced === false)
+                current.priced = false;
+        }
+        else {
+            map.set(record.model, { ...record });
+        }
+    }
+    return Array.from(map.values());
+}
+function mergeToolUsage(existing, incoming) {
+    const map = new Map();
+    for (const record of existing)
+        map.set(record.tool, { ...record });
+    for (const record of incoming) {
+        const current = map.get(record.tool);
+        if (current) {
+            current.calls += record.calls;
+            current.successCount += record.successCount;
+            current.failureCount += record.failureCount;
+        }
+        else {
+            map.set(record.tool, { ...record });
+        }
+    }
+    return Array.from(map.values());
+}
+function subtractTokenTotals(target, contribution) {
+    target.inputTokens = Math.max(0, target.inputTokens - contribution.inputTokens);
+    target.outputTokens = Math.max(0, target.outputTokens - contribution.outputTokens);
+    target.cacheWriteTokens = Math.max(0, target.cacheWriteTokens - contribution.cacheWriteTokens);
+    target.cacheReadTokens = Math.max(0, target.cacheReadTokens - contribution.cacheReadTokens);
+}
+function subtractModelUsage(existing, outgoing) {
+    const map = new Map(existing.map((record) => [record.model, { ...record }]));
+    for (const record of outgoing) {
+        const current = map.get(record.model);
+        if (!current)
+            continue;
+        current.calls = Math.max(0, current.calls - record.calls);
+        current.tokens = Math.max(0, current.tokens - record.tokens);
+        current.cost = Math.max(0, current.cost - record.cost);
+        if (current.calls === 0 && current.tokens === 0)
+            map.delete(record.model);
+    }
+    return [...map.values()];
+}
+function subtractToolUsage(existing, outgoing) {
+    const map = new Map(existing.map((record) => [record.tool, { ...record }]));
+    for (const record of outgoing) {
+        const current = map.get(record.tool);
+        if (!current)
+            continue;
+        current.calls = Math.max(0, current.calls - record.calls);
+        current.successCount = Math.max(0, current.successCount - record.successCount);
+        current.failureCount = Math.max(0, current.failureCount - record.failureCount);
+        if (current.calls === 0)
+            map.delete(record.tool);
+    }
+    return [...map.values()];
+}
+function subtractSummary(bucket, summary, now) {
+    subtractTokenTotals(bucket.tokens, summary.tokens);
+    bucket.totalCost = Math.max(0, bucket.totalCost - summary.totalCost);
+    bucket.messageCount = Math.max(0, bucket.messageCount - summary.messageCount);
+    bucket.sessionCount = Math.max(0, bucket.sessionCount - 1);
+    bucket.modelUsage = subtractModelUsage(bucket.modelUsage, summary.modelUsage);
+    bucket.toolUsage = subtractToolUsage(bucket.toolUsage, summary.toolUsage);
+    bucket.updatedAt = now.toISOString();
+}
+function accumulateSummary(bucket, summary, now) {
+    bucket.tokens.inputTokens += summary.tokens.inputTokens;
+    bucket.tokens.outputTokens += summary.tokens.outputTokens;
+    bucket.tokens.cacheWriteTokens += summary.tokens.cacheWriteTokens;
+    bucket.tokens.cacheReadTokens += summary.tokens.cacheReadTokens;
+    bucket.totalCost += summary.totalCost;
+    bucket.messageCount += summary.messageCount;
+    bucket.sessionCount += 1;
+    bucket.modelUsage = mergeModelUsage(bucket.modelUsage, summary.modelUsage);
+    bucket.toolUsage = mergeToolUsage(bucket.toolUsage, summary.toolUsage);
+    bucket.updatedAt = now.toISOString();
+}
+function emptyDaily(date, now) {
+    return {
+        date,
+        tokens: (0, historicalData_1.createEmptyTokenTotals)(),
+        totalCost: 0,
+        messageCount: 0,
+        sessionCount: 0,
+        modelUsage: [],
+        toolUsage: [],
+        updatedAt: now.toISOString(),
+    };
+}
+function emptyMonthly(month, now) {
+    return {
+        month,
+        tokens: (0, historicalData_1.createEmptyTokenTotals)(),
+        totalCost: 0,
+        messageCount: 0,
+        sessionCount: 0,
+        modelUsage: [],
+        toolUsage: [],
+        updatedAt: now.toISOString(),
+    };
+}
+function refreshAllTimeDateRange(store) {
+    const dates = Object.keys(store.daily).sort();
+    store.allTime.firstDate = dates[0] ?? '';
+    store.allTime.lastDate = dates[dates.length - 1] ?? '';
+}
+/** Subtract a previously saved session's contribution from every bucket. */
+function removeSessionSummary(store, record, now = new Date()) {
+    const summary = {
+        sessionId: record.sessionId,
+        startTime: record.startTime,
+        endTime: record.endTime,
+        tokens: { ...record.tokens },
+        totalCost: record.totalCost,
+        messageCount: record.messageCount,
+        modelUsage: record.modelUsage?.map((usage) => ({ ...usage })) ?? [],
+        toolUsage: record.toolUsage?.map((usage) => ({ ...usage })) ?? [],
+        unpricedModelIds: record.unpricedModelIds ? [...record.unpricedModelIds] : undefined,
+    };
+    const date = (0, formatting_1.formatLocalDateKey)(new Date(record.startTime));
+    const month = date.substring(0, 7);
+    const daily = store.daily[date];
+    if (daily) {
+        subtractSummary(daily, summary, now);
+        if (daily.sessionCount === 0)
+            delete store.daily[date];
+    }
+    const hourly = store.hourly?.[date];
+    if (hourly && store.hourly) {
+        const hour = new Date(record.startTime).getHours();
+        const bucket = hourly.find((entry) => entry.hour === hour);
+        if (bucket) {
+            subtractTokenTotals(bucket.tokens, summary.tokens);
+            bucket.totalCost = Math.max(0, bucket.totalCost - summary.totalCost);
+            bucket.messageCount = Math.max(0, bucket.messageCount - summary.messageCount);
+            bucket.sessionCount = Math.max(0, bucket.sessionCount - 1);
+        }
+        store.hourly[date] = hourly.filter((entry) => entry.sessionCount > 0);
+        if (store.hourly[date].length === 0)
+            delete store.hourly[date];
+    }
+    const monthly = store.monthly[month];
+    if (monthly) {
+        subtractSummary(monthly, summary, now);
+        if (monthly.sessionCount === 0)
+            delete store.monthly[month];
+    }
+    subtractSummary(store.allTime, summary, now);
+}
+/**
+ * Apply a completed session to the daily, hourly, monthly, and all-time
+ * buckets and the capped per-session list. Re-applying the same session id
+ * replaces its earlier contribution instead of double counting it.
+ *
+ * Returns the stored per-session record.
+ */
+function applySessionSummary(store, summary, options = {}) {
+    const now = options.now ?? new Date();
+    const retentionLimit = options.retentionLimit ?? historicalData_1.HISTORICAL_SESSION_RETENTION_LIMIT;
+    const date = (0, formatting_1.formatLocalDateKey)(new Date(summary.startTime));
+    const month = date.substring(0, 7);
+    store.sessions ??= [];
+    const previous = store.sessions.find((session) => session.sessionId === summary.sessionId);
+    if (previous)
+        removeSessionSummary(store, previous, now);
+    // Daily
+    store.daily[date] ??= emptyDaily(date, now);
+    accumulateSummary(store.daily[date], summary, now);
+    // Hourly (by the session's local start hour)
+    store.hourly ??= {};
+    store.hourly[date] ??= [];
+    const hour = new Date(summary.startTime).getHours();
+    let hourly = store.hourly[date].find((entry) => entry.hour === hour);
+    if (!hourly) {
+        hourly = {
+            hour,
+            tokens: (0, historicalData_1.createEmptyTokenTotals)(),
+            totalCost: 0,
+            messageCount: 0,
+            sessionCount: 0,
+        };
+        store.hourly[date].push(hourly);
+    }
+    hourly.tokens.inputTokens += summary.tokens.inputTokens;
+    hourly.tokens.outputTokens += summary.tokens.outputTokens;
+    hourly.tokens.cacheWriteTokens += summary.tokens.cacheWriteTokens;
+    hourly.tokens.cacheReadTokens += summary.tokens.cacheReadTokens;
+    hourly.totalCost += summary.totalCost;
+    hourly.messageCount += summary.messageCount;
+    hourly.sessionCount += 1;
+    // Monthly
+    store.monthly[month] ??= emptyMonthly(month, now);
+    accumulateSummary(store.monthly[month], summary, now);
+    // All-time
+    accumulateSummary(store.allTime, summary, now);
+    if (!store.allTime.firstDate || date < store.allTime.firstDate)
+        store.allTime.firstDate = date;
+    if (!store.allTime.lastDate || date > store.allTime.lastDate)
+        store.allTime.lastDate = date;
+    const record = {
+        sessionId: summary.sessionId,
+        provider: summary.provider ?? 'unknown',
+        project: summary.project ?? 'unknown',
+        startTime: summary.startTime,
+        endTime: summary.endTime,
+        tokens: { ...summary.tokens },
+        totalCost: summary.totalCost,
+        messageCount: summary.messageCount,
+        modelUsage: summary.modelUsage.map((usage) => ({ ...usage })),
+        toolUsage: summary.toolUsage.map((usage) => ({ ...usage })),
+        unpricedModelIds: summary.unpricedModelIds ? [...summary.unpricedModelIds] : undefined,
+        qualityScore: summary.qualityScore ?? 0,
+        qualityFactors: summary.qualityFactors ?? [],
+        additions: summary.additions ?? 0,
+        deletions: summary.deletions ?? 0,
+        costPerChangedLine: summary.costPerChangedLine ?? null,
+    };
+    store.sessions = [
+        ...store.sessions.filter((session) => session.sessionId !== summary.sessionId),
+        record,
+    ].slice(-retentionLimit);
+    refreshAllTimeDateRange(store);
+    return record;
+}
+/** Whether a session file has already been folded into the store. */
+function isFileImported(store, filePath) {
+    return store.importedFiles?.includes(filePath) ?? false;
+}
+/** Record a session file as imported. Returns false when it was already listed. */
+function markFileImported(store, filePath, now = new Date()) {
+    store.importedFiles ??= [];
+    if (store.importedFiles.includes(filePath))
+        return false;
+    store.importedFiles.push(filePath);
+    store.lastImportTimestamp = now.toISOString();
+    return true;
+}
+/**
+ * Build the summary the history store expects from unified session stats,
+ * so the CLI importer and the extension's first-activation import store the
+ * same per-model cost, tool success/failure split, and unpriced markers.
+ * Pending tool calls count as successes (stats only split out failures).
+ */
+function sessionSummaryFromStats(stats, options = {}) {
+    const modelUsage = Object.entries(stats.modelUsage).map(([model, usage]) => ({
+        model,
+        calls: usage.calls,
+        tokens: usage.tokens,
+        cost: usage.costUsd,
+        priced: usage.priced,
+    }));
+    const unpricedModelIds = modelUsage.filter((m) => m.priced === false).map((m) => m.model);
+    const toolUsage = Object.entries(stats.toolUsage).map(([tool, calls]) => {
+        const failureCount = stats.toolFailures[tool] ?? 0;
+        return { tool, calls, successCount: Math.max(0, calls - failureCount), failureCount };
+    });
+    return {
+        sessionId: stats.sessionId,
+        startTime: stats.startTime,
+        endTime: stats.endTime || stats.startTime,
+        tokens: {
+            inputTokens: stats.tokens.input,
+            outputTokens: stats.tokens.output,
+            cacheWriteTokens: stats.tokens.cacheWrite,
+            cacheReadTokens: stats.tokens.cacheRead,
+        },
+        totalCost: stats.costUsd,
+        messageCount: stats.messageCount,
+        modelUsage,
+        toolUsage,
+        ...(unpricedModelIds.length > 0 ? { unpricedModelIds } : {}),
+        provider: options.provider ?? stats.providerId,
+        project: options.project ?? 'unknown',
+    };
+}

package/dist/index.d.ts

@@ -3,14 +3,33 @@
  */
 export { normalizeProviderUsage, extractNormalizedUsage, calculateNormalizedUsageCost, } from './usageNormalization';
 export type { UsageProvider, UsageSemantics, UsageNormalizationProvenance, ProviderUsageInput, AnthropicUsageInput, OpenAIUsageInput, SidekickUsageInput, NormalizedUsage, PricingProvenance, NormalizedUsageCostInput, NormalizedUsageCost, } from './usageNormalization';
+export { summarizeTokens, sumTokenTotals, TOKEN_CONTEXT_LABEL, TOKEN_TOTAL_LABEL, } from './tokenSummary';
+export type { TokenSummary, TokenTotalsLike } from './tokenSummary';
 export { 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 { computeSessionFileStats, firstUserPrompt, providerContextSizeFn, readSessionFileStats, } from './sessionStats';
+export { readSessionReportInputs } from './report/sessionReportInputs';
+export type { SessionReportInputs } from './report/sessionReportInputs';
+export { fingerprintString, sessionFingerprintParts } from './sessionFingerprint';
+export { STATE_FILE_NAME, STATE_FILE_SCHEMA_VERSION, billingBlockToStateFile, getStateFilePath, quotaToStateFile, readStateFile, writeStateFile, } from './stateFile';
+export type { SidekickStateFile, SidekickStateInput, StateFileAccount, StateFileBillingBlock, StateFileContext, StateFileQuota, StateFileQuotaWindow, StateFileSession, StateFileWriter, WriteStateFileOptions, } from './stateFile';
+export type { ComputeSessionFileStatsOptions, ReadSessionFileStatsOptions } from './sessionStats';
+export { BILLING_BLOCK_DURATION_MS, computeBillingBlocks, findActiveBillingBlock, } from './usage/billingBlocks';
+export type { BillingBlock, BillingBlockInput, BillingBlockModelUsage, BillingBlockTokens, ComputeBillingBlocksOptions, } from './usage/billingBlocks';
+export { MAX_USAGE_CACHE_FILES, USAGE_CACHE_VERSION, collectUsageEvents, getUsageCacheDir, pruneUsageCache, } from './usage/usageEvents';
+export type { CollectUsageEventsOptions, CollectUsageEventsResult, UsageEventRecord, UsageSessionRecord, } from './usage/usageEvents';
+export { applySessionSummary, isFileImported, markFileImported, removeSessionSummary, sessionSummaryFromStats, } from './historicalStore';
+export type { ApplySessionSummaryOptions, SessionSummaryFromStatsOptions } from './historicalStore';
+export { ACTIVE_SESSION_MTIME_THRESHOLD_MS, importSessionHistory, } from './usage/importSessionHistory';
+export type { ImportSessionHistoryOptions, ImportSessionHistoryResult, } from './usage/importSessionHistory';
+export { bucketUsage, summarizeUsageRows, usageBucketKey, weekKey } from './usage/usageReports';
+export type { BucketUsageOptions, UsageBucketRow, UsageGranularity, UsageGroupDimension, UsageTotals, } from './usage/usageReports';
 export type { ProviderSessionIndex, ListRecentSessionsOptions } from './sessionTranscripts';
-export { ObservedSessionCollector, observedSessionSourceFromProvider, fileFingerprint, } from './observedSessionCollector';
-export type { ObservedSessionReference, ObservedSessionCollectionSource, ProviderObservedSessionCollectionSource, ObservedSessionDiagnosticKind, ObservedSessionDiagnostic, ObservedSessionCollection, ObservedSessionCollectorOptions, } from './observedSessionCollector';
+export { ObservedSessionCollector, observedSessionSourceFromProvider, fileFingerprint, fileFingerprintParts, } from './observedSessionCollector';
+export type { KnownObservedSessionFingerprint, ObservedSessionChange, ObservedSessionChangeBatch, ObservedSessionChangeType, ObservedSessionReference, ObservedSessionFingerprintParts, ObservedSessionSourceSubscribeOptions, ObservedSessionSubscribeOptions, ObservedSessionCollectionSource, ProviderObservedSessionCollectionSource, ObservedSessionDiagnosticKind, ObservedSessionDiagnosticPhase, ObservedSessionDiagnosticSeverity, ObservedSessionDiagnostic, ObservedSessionCollection, ObservedSessionCollectorOptions, } from './observedSessionCollector';
 export type { SessionEvent, ClaudeSessionEvent, MessageUsage, SessionMessage, SessionEventBase, MessageSessionEvent, UserSessionEvent, AssistantSessionEvent, SummarySessionEvent, SystemSessionEvent, ToolUseSessionEvent, ToolResultSessionEvent, TokenUsage, ToolCall, ToolAnalytics, TimelineEvent, PendingToolCall, TaskStatus as SessionTaskStatus, TrackedTask, TaskState, SubagentStats, PendingUserRequest, ResponseLatency, LatencyStats, PlanStep, PlanState, SessionStats, CompactionEvent, TruncationEvent, ContextAttribution, TurnAttribution, ContextSizePoint, PermissionMode, PermissionModeChange, } from './types/sessionEvent';
 export type { OpenCodeSession, OpenCodeMessage, OpenCodePart, OpenCodeTextPart, OpenCodeReasoningPart, OpenCodeToolInvocationPart, OpenCodeCompactionPart, OpenCodeDbToolPart, OpenCodeStepStartPart, OpenCodeStepFinishPart, OpenCodePatchPart, OpenCodeSubtaskPart, OpenCodeAgentPart, OpenCodeFilePart, OpenCodeRetryPart, OpenCodeSnapshotPart, OpenCodeProject, DbProject as OpenCodeDbProject, DbSession as OpenCodeDbSession, DbMessage as OpenCodeDbMessage, DbPart as OpenCodeDbPart, } from './types/opencode';
 export type { CodexRolloutLine, CodexSessionMeta, CodexResponseItem, CodexMessageItem, CodexContentPart, CodexReasoningItem, CodexFunctionCallItem, CodexFunctionCallOutputItem, CodexLocalShellCallItem, CodexWebSearchCallItem, CodexCustomToolCallItem, CodexCustomToolCallOutputItem, CodexCompacted, CodexTurnContext, CodexEventMsg, CodexEvent, CodexTurnStartedEvent, CodexTurnCompleteEvent, CodexTaskStartedEvent, CodexTaskCompleteEvent, CodexTurnAbortedEvent, CodexTokenCountEvent, CodexTokenUsage, CodexRateLimits, CodexAgentMessageEvent, CodexAgentReasoningEvent, CodexUserMessageEvent, CodexExecCommandBeginEvent, CodexExecCommandEndEvent, CodexMcpToolCallBeginEvent, CodexMcpToolCallEndEvent, CodexErrorEvent, CodexContextCompactedEvent, CodexPatchAppliedEvent, CodexBackgroundEvent, CodexGenericEvent, CodexDbThread, CodexReasoningSummary, } from './types/codex';
@@ -44,30 +63,35 @@ export { addDecision, decisionFingerprint } from './writers/decisions';
 export { addNote } from './writers/notes';
 export { renderHandoffUrlTemplate } from './handoffUrl';
 export type { HandoffUrlIdentifiers } from './handoffUrl';
-export type { ProviderId, SessionProvider, SessionProviderBase, SessionFileStats, SessionFileInfo, SearchHit, ProjectFolderInfo, SessionReader, ProviderRuntimeStatus, } from './providers/types';
-export { createProviderSessionAdapterV1, derivePendingUserRequestV1, } from './types/observedSessionV1';
-export type { ObservationProvenanceV1, ObservedAgentSessionV1, ObservedValueV1, PendingUserRequestV1, ProviderCapabilitiesV1, ProviderSessionAdapterV1, SessionEvidenceRefV1, } from './types/observedSessionV1';
-export { detectProvider, getAllDetectedProviders } from './providers/detect';
+export type { ProviderId, SessionProvider, SessionProviderBase, SessionFileStats, SessionFileStatsAvailability, SessionFileInfo, SearchHit, ProjectFolderInfo, SessionReader, SessionProviderOptions, ProviderOperationStatus, SessionProviderDiagnostic, SessionProviderDiagnosticKind, SessionProviderDiagnosticPhase, SessionProviderDiagnosticSeverity, ProviderRuntimeStatus, } from './providers/types';
+export { SESSION_PROVIDER_IDS } from './providers/types';
+export { createSessionProviders } from './providers/factory';
+export type { CreateSessionProvidersOptions, CreateSessionProvidersResult, } from './providers/factory';
+export { createProviderSessionAdapterV1, derivePendingUserRequestV1, getObservedActivityReason, } from './types/observedSessionV1';
+export type { ObservationProvenanceV1, ObservedAgentSessionV1, ObservedValueV1, PendingUserRequestV1, ProviderCapabilitiesV1, ProviderSessionAdapterV1, ProviderSessionAdapterV1Options, SessionEvidenceRefV1, } from './types/observedSessionV1';
+export { _resetProviderDetectionCache, detectProvider, getAllDetectedProviders, } from './providers/detect';
 export { ClaudeCodeProvider } from './providers/claudeCode';
 export { OpenCodeProvider, getOpenCodeDataDir } from './providers/openCode';
 export { CodexProvider, findCodexRolloutFile } from './providers/codex';
+export { walkRolloutFiles, walkRolloutFilesAsync } from './providers/rolloutWalker';
+export type { RolloutFileInfo, WalkRolloutFilesOptions } from './providers/rolloutWalker';
 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, } from './parsers/codexParser';
 export { scanSubagentDir, extractTaskInfo } from './parsers/subagentScanner';
-export { detectSessionActivity } from './parsers/sessionActivityDetector';
-export type { SessionActivityState, SessionActivityResult, } from './parsers/sessionActivityDetector';
-export { encodeWorkspacePath as encodeClaudeWorkspacePath, getSessionDirectory as getClaudeSessionDirectory, discoverSessionDirectory, findActiveSession as findActiveClaudeSession, findAllSessions as findAllClaudeSessions, findSessionsInDirectory, findSubdirectorySessionDirs, getMostRecentlyActiveSessionDir, decodeEncodedPath, getAllProjectFolders as getAllClaudeProjectFolders, resolveWorktreeMainRepo, discoverWorktreeSiblings, findAllSessionsWithWorktrees, } from './parsers/sessionPathResolver';
+export { classifySessionActivity, detectSessionActivity, refreshSessionActivityState, SESSION_ACTIVITY_GRACE_PERIOD_MS, SESSION_ACTIVITY_STALENESS_MS, } from './parsers/sessionActivityDetector';
+export type { ClassifySessionActivityOptions, SessionActivityState, SessionActivityResult, } from './parsers/sessionActivityDetector';
+export { encodeWorkspacePath as encodeClaudeWorkspacePath, getSessionDirectory as getClaudeSessionDirectory, discoverSessionDirectory, findActiveSession as findActiveClaudeSession, findAllSessions as findAllClaudeSessions, findSessionsInDirectory, findSessionFilesWithStats, findSubdirectorySessionDirs, getMostRecentlyActiveSessionDir, decodeEncodedPath, getAllProjectFolders as getAllClaudeProjectFolders, resolveWorktreeMainRepo, discoverWorktreeSiblings, findAllSessionsWithWorktrees, } from './parsers/sessionPathResolver';
 export { scanSubagentTraces } from './parsers/subagentTraceParser';
 export type { SubagentTrace, SubagentTraceEvent } from './parsers/subagentTraceParser';
 export { parseMcpToolName } from './parsers/mcpToolName';
 export type { McpToolNameParts } from './parsers/mcpToolName';
 export { readCodexHistory } from './parsers/codexHistory';
 export type { CodexHistoryEntry, ReadCodexHistoryOptions } from './parsers/codexHistory';
-export { listSessionPreviews, readSessionPreview } from './sessionPreviews';
-export type { ListSessionPreviewsOptions, ReadSessionPreviewOptions, SessionPreview, } from './sessionPreviews';
+export { listSessionPreviews, listSessionPreviewsAsync, readSessionPreview, readSessionPreviewAsync, } from './sessionPreviews';
+export type { AsyncSessionPreviewOptions, ListSessionPreviewsAsyncOptions, ListSessionPreviewsOptions, ReadSessionPreviewAsyncOptions, ReadSessionPreviewOptions, SessionPreview, SessionPreviewListResult, SessionPreviewReadResult, } from './sessionPreviews';
 export { parseDebugLog, filterByLevel, collapseDuplicates, discoverDebugLogs, } from './parsers/debugLogParser';
 export type { DebugLogEntry, DebugLogFile, DebugLogLevel } from './parsers/debugLogParser';
 export { OpenCodeDatabase } from './providers/openCodeDatabase';
@@ -87,12 +111,12 @@ export type { ExtractedPlan, ExtractedPlanStep } from './parsers/planExtractor';
 export { parseChangelog } from './parsers/changelogParser';
 export type { ChangelogEntry } from './parsers/changelogParser';
 export type { FollowEvent, FollowEventType, SessionWatcher, SessionWatcherCallbacks, } from './watchers/types';
-export { createWatcher } from './watchers/factory';
+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 { formatDurationMs, formatTokenCount } from './formatting';
+export { addLocalDays, formatDurationMs, formatLocalDateKey, formatTokenCount, parseLocalDateKey, } from './formatting';
 export type { FormatDurationMsOptions, FormatTokenCountOptions } from './formatting';
 export { formatToolSummary } from './formatters/toolSummary';
 export { isHardNoise, isHardNoiseFollowEvent, getSoftNoiseReason, classifyMessage, classifyFollowEvent, shouldMergeWithPrevious, classifyNoise, } from './formatters/noiseClassifier';
@@ -105,11 +129,11 @@ export { ALL_PHRASES, PHRASE_CATEGORIES, getRandomPhrase } from './phrases';
 export type { PhraseCategory } from './phrases';
 export { EventAggregator, parseTodoDependencies } from './aggregation/EventAggregator';
 export { SessionMonitor } from './sessionMonitor';
-export type { SessionMonitorOptions } from './sessionMonitor';
+export type { SessionMonitorOptions, SessionMonitorSubscribeOptions } from './sessionMonitor';
 export type { SerializedAggregatorState } from './aggregation/EventAggregator';
-export { saveSnapshot, loadSnapshot, deleteSnapshot, isSnapshotValid, getSnapshotPath, } from './aggregation/snapshot';
+export { saveSnapshot, loadSnapshot, deleteSnapshot, isSnapshotValid, pruneSnapshots, MAX_SNAPSHOT_FILES, getSnapshotPath, } from './aggregation/snapshot';
 export type { SessionSnapshot } from './aggregation/snapshot';
-export type { EventAggregatorOptions, AggregatedTokens, ModelUsageStats, BurnRateInfo, SubagentLifecycle, AggregatedMetrics, FrequencyMetric, PatternMetric, HeatmapBucketMetric, ErrorRollup, ErrorRollupEntry, ErrorBucketMetric, } from './aggregation/types';
+export type { EventAggregatorOptions, AggregatedCostProvenance, AggregatedTokens, ModelUsageStats, BurnRateInfo, SubagentLifecycle, AggregatedMetrics, FrequencyMetric, PatternMetric, HeatmapBucketMetric, ErrorRollup, ErrorRollupEntry, ErrorBucketMetric, } from './aggregation/types';
 export { ERROR_HISTORY_SCHEMA_VERSION, MAX_ERROR_HISTORY_SESSIONS, appendErrorHistory, getTopFailingTools, readErrorHistory, } from './errorHistory';
 export type { ErrorHistorySessionRecord, ErrorHistoryStore, TopFailingTool } from './errorHistory';
 export { FrequencyTracker } from './aggregation/FrequencyTracker';
@@ -122,6 +146,8 @@ export { calculateQualityTrend, scoreSessionQuality } from './analytics/qualityS
 export type { QualityFactorContribution, QualityFactorId, SessionQualityScore, QualityTrend, } from './analytics/qualityScore';
 export { calculateCodeImpact } from './analytics/codeImpact';
 export type { CodeImpact, ModelCostInput } from './analytics/codeImpact';
+export { classifyCostProvenance, describeCostProvenance } from './aggregation/costProvenance';
+export type { AggregatedCostProvenanceInput } from './aggregation/costProvenance';
 export { calculateCompactionLedger, formatCompactionLedger } from './analytics/compactionLedger';
 export type { CompactionLedger } from './analytics/compactionLedger';
 export { generateHtmlReport, parseTranscript, parseTranscriptFromEvents, openInBrowser, } from './report';
@@ -137,8 +163,11 @@ export { beginAccountLogin, getAccountLoginStatus, getAccountLoginStatusAsync, f
 export type { AccountLoginCommand, AccountLoginState, AccountLoginStatus, BeginAccountLoginResult, FinalizeAccountLoginOptions, ListAllAccountsResult, SpawnAccountLoginOptions, } from './accountManager';
 export { getAccountsDir, readSavedAccountRegistry, writeSavedAccountRegistry, listSavedAccountProfiles, getActiveSavedAccount, upsertSavedAccountProfile, setActiveSavedAccount, replaceSavedAccountProfiles, removeSavedAccountProfile, } from './accountRegistry';
 export type { AccountProviderId, AccountIdentityMetadata, ResolvedActiveAccount, SavedAccountProfile, SavedAccountRegistry, } from './accountRegistry';
+export { ACCOUNT_PROVIDER_IDS } from './accountRegistry';
 export { getActiveAccountStatus } from './accountStatus';
-export type { ActiveAccountStatus, ActiveProviderAccountStatus } from './accountStatus';
+export type { ActiveAccountStatus, ActiveAccountStatusOptions, ActiveProviderAccountStatus, } from './accountStatus';
+export { onAccountsChanged } from './accountChanges';
+export type { AccountsChangedEvent, OnAccountsChangedOptions } from './accountChanges';
 export { getClaudeProfilesDir, getClaudeProfileHome, claudeKeychainSuffix, claudeKeychainService, isClaudeProfileAuthenticated, readClaudeProfileIdentity, } from './claudeProfiles';
 export type { ClaudeProfileIdentity } from './claudeProfiles';
 export { getCodexProfilesDir, getCodexProfileHome, getCodexMonitoringHomes, getSystemCodexHome, listCodexAccounts, getActiveCodexAccount, resolveActiveCodexAccount, resolveSidekickCodexHome, getCodexExecutionEnv, prepareCodexAccount, prepareCodexAccountAsync, finalizeCodexAccount, finalizeCodexAccountAsync, switchToCodexAccount, switchToCodexAccountAsync, removeCodexAccount, } from './codexProfiles';
@@ -146,13 +175,22 @@ export type { CodexAccountManagerResult } from './codexProfiles';
 export { setTerminalActiveProfile, installShellHook, uninstallShellHook, isShellHookInstalled, 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, SEVEN_DAY_WINDOW_MS, fetchQuota, projectQuotaWindow, withQuotaProjections, } from './quota';
-export type { CodexResetCredit, CodexResetCreditsSnapshot, QuotaProjectionInput, QuotaWindow, QuotaState, } from './quota';
+export { FIVE_HOUR_WINDOW_MS, QUOTA_PROVIDER_IDS, SEVEN_DAY_WINDOW_MS, fetchQuota, projectQuotaWindow, withQuotaProjections, } from './quota';
+export type { CodexResetCredit, CodexResetCreditsSnapshot, QuotaProjectionInput, QuotaProviderId, QuotaWindow, QuotaState, } from './quota';
 export { describeQuotaFailure } from './quotaPresentation';
 export type { QuotaFailureDescriptor } from './quotaPresentation';
 export { QuotaPoller } from './quotaPoller';
 export type { QuotaPollerOptions } from './quotaPoller';
 export { readQuotaSnapshot, writeQuotaSnapshot } from './quotaSnapshots';
+export type { QuotaSnapshotRecord } from './quotaSnapshots';
+export { resolveQuota } from './quotaResolver';
+export type { QuotaResolution, QuotaResolveProviderId, ResolveQuotaOptions, ResolvedQuota, } from './quotaResolver';
+export { classifyQuotaFreshness, formatQuotaAge, QUOTA_AGING_MAX_AGE_MS, QUOTA_FRESH_MAX_AGE_MS, } from './quota';
+export type { QuotaFreshness } from './quota';
+export { DEFAULT_QUOTA_THRESHOLDS, describeQuotaThresholdAlert, evaluateQuotaThresholds, } from './quotaThresholds';
+export type { QuotaAlertMemory, QuotaThresholdAlert, QuotaThresholdConfig, QuotaThresholdEvaluation, QuotaThresholdWindow, } from './quotaThresholds';
+export { parseClaudeStatuslinePayload, quotaFromStatuslinePayload, } from './statusline/claudeStatuslinePayload';
+export type { ClaudeStatuslinePayload, ClaudeStatuslineRateLimitWindow, QuotaFromStatuslineOptions, } from './statusline/claudeStatuslinePayload';
 export { appendQuotaHistorySample, readQuotaHistoryRange, readQuotaHistoryDailyBuckets, pruneQuotaHistory, getWorkspaceIdFromPath, } from './quotaHistory';
 export type { QuotaHistorySample, QuotaHistoryAppendOptions, QuotaHistoryRangeOptions, QuotaHistoryDailyBucket, QuotaHistoryRuntimeProvider, } from './quotaHistory';
 export { fetchCodexResetCreditsFromApi, fetchCodexQuotaFromApi, quotaFromCodexRateLimits, readLatestCodexQuotaFromRollouts, resolveCodexQuota, resolveCodexQuotaFromLocalSources, } from './codexQuota';
@@ -163,14 +201,18 @@ export { fetchZaiQuotaFromApi, quotaStateFromZaiQuotaLimitPayload, readZaiCreden
 export type { ReadZaiCredentialsOptions, ZaiCredentialSource, ZaiCredentials, ZaiPlatform, ZaiQuotaApiOptions, ZaiQuotaResolveOptions, } from './zaiQuotaApi';
 export { MultiProviderQuotaService } from './multiProviderQuotaService';
 export type { MultiProviderQuotaServiceOptions } from './multiProviderQuotaService';
+export { RUNTIME_QUOTA_PROVIDER_IDS } from './providerQuota';
 export type { ProviderQuotaMap, ProviderQuotaState, RuntimeQuotaProvider } from './providerQuota';
 export type { QuotaSnapshotProviderId } from './quotaSnapshots';
 export { BurnRateCalculator, estimateTimeToQuota } from './statusline/BurnRateCalculator';
 export { formatStatusline, selectStatuslineAccount } from './statusline/formatter';
 export type { StatuslineInput, StatuslineSelection } from './statusline/formatter';
-export { getModelContextWindowSize, DEFAULT_CONTEXT_WINDOW } from './modelContext';
-export { parseModelId, getModelPricing, getModelInfo, calculateCost, calculateCostWithPricing, calculateCostWithProvenance, mergeCostSources, shortModelName, getModelDisplayInfo, compareModelIds, sortModelIds, formatCost, } from './modelInfo';
-export type { ModelPricing, CostTokenUsage, CostSource, CostProvenanceInput, CostWithProvenance, ModelInfo, ModelProvider, ParsedModelId, ModelDisplayInfo, } from './modelInfo';
+export { getModelContextWindowSize, resolveModelContextWindow, DEFAULT_CONTEXT_WINDOW, } from './modelContext';
+export type { ModelCatalogMatch, ModelContextWindowProvenance, ModelContextWindowSource, ResolvedModelContextWindow, } from './modelContext';
+export { parseModelId, getModelPricing, resolveModelPricing, getModelInfo, calculateCost, calculateCostWithPricing, calculateCostWithProvenance, mergeCostSources, shortModelName, getModelDisplayInfo, compareModelIds, sortModelIds, formatCost, MODEL_PROVIDER_IDS, } from './modelInfo';
+export type { ModelPricing, CostTokenUsage, CostSource, CostProvenanceInput, CostWithProvenance, ModelInfo, ModelProvider, ParsedModelId, ModelDisplayInfo, ModelPricingMatch, ModelPricingProvenance, ModelPricingSource, ResolvedModelPricing, } from './modelInfo';
+export { exportResolvedModelCatalog, importResolvedModelCatalog, registerModelAlias, resolveModelAlias, RESOLVED_MODEL_CATALOG_SCHEMA_VERSION, } from './modelCatalog';
+export type { ImportResolvedModelCatalogResult, ResolvedModelCatalogEntry, ResolvedModelCatalogSnapshot, } from './modelCatalog';
 export { hydratePricingCatalog, normalizeLiteLlmCatalog, normalizeLiteLlmContextWindows, LITELLM_CATALOG_URL, } from './pricingCatalog';
 export type { HydrateOptions, HydrateResult } from './pricingCatalog';
 export { loadObservedContextWindows, recordObservedContextWindow, getObservedContextWindowPath, } from './observedContextWindows';
@@ -195,5 +237,7 @@ export { fetchProviderStatus, fetchOpenAIStatus } from './providerStatus';
 export type { ProviderStatusState } from './providerStatus';
 export { formatHealthReport, getSessionDiagnostics, runDoctor } from './doctor';
 export type { DeprecatedSetting, DoctorOptions, HealthCheck, HealthCheckStatus, HealthReport, SessionDiagnostics, } from './doctor';
-export { createPeakHoursNotApplicableState, DEFAULT_PEAK_HOURS_TIMEOUT_MS, fetchPeakHoursStatus, isClaudeCodeSessionProvider, scopePeakHoursToSessionProvider, } from './peakHours';
+export { _resetPeakHoursCache, createPeakHoursNotApplicableState, DEFAULT_PEAK_HOURS_TIMEOUT_MS, fetchPeakHoursStatus, getScheduledPeakHoursState, isClaudeCodeSessionProvider, PEAK_HOURS_CACHE_MS, PEAK_HOURS_DESCRIPTION, scopePeakHoursToSessionProvider, } from './peakHours';
 export type { FetchPeakHoursOptions, PeakHoursState } from './peakHours';
+export { FAILING_TOOL_TREND_ARROWS, failingToolTrend, mergeFailingToolWindows, } from './failingTools';
+export type { FailingToolTrend, FailingToolTrendRow, FailingToolWindow } from './failingTools';