sidekick-shared 0.24.5 → 0.26.0

package/dist/sessionPreviews.d.ts

@@ -17,7 +17,7 @@
  *
  * @module sessionPreviews
  */
-import type { ProviderId, SessionProviderBase } from './providers/types';
+import type { ProviderId, SessionProviderBase, SessionProviderDiagnostic } from './providers/types';
 export interface SessionPreview {
     provider: ProviderId;
     sessionId: string;
@@ -36,7 +36,11 @@ export interface SessionPreview {
     workspacePath: string | null;
 }
 export interface ReadSessionPreviewOptions {
-    /** Byte budget for the generic prefix scan (default 16 KiB). */
+    /**
+     * Byte budget for the generic prefix scan (default 16 KiB). `0` skips the
+     * scan entirely for callers that ignore `firstTimestamp` and
+     * `workspacePath`; both come back `null` and the file is not opened.
+     */
     maxPrefixBytes?: number;
 }
 export interface ListSessionPreviewsOptions extends ReadSessionPreviewOptions {
@@ -47,14 +51,41 @@ export interface ListSessionPreviewsOptions extends ReadSessionPreviewOptions {
     /** Skip files whose mtime is not strictly newer than this — cheap incremental refresh. */
     since?: Date | string;
 }
+export interface AsyncSessionPreviewOptions {
+    /** Maximum concurrent stat/read units (default 4, hard-capped at 16). */
+    concurrency?: number;
+    /** Cooperative scheduler hook; defaults to setImmediate. */
+    yieldBetweenReads?: () => Promise<void> | void;
+}
+export interface ReadSessionPreviewAsyncOptions extends ReadSessionPreviewOptions, AsyncSessionPreviewOptions {
+}
+export interface ListSessionPreviewsAsyncOptions extends ListSessionPreviewsOptions, AsyncSessionPreviewOptions {
+}
+export interface SessionPreviewReadResult {
+    preview: SessionPreview | null;
+    diagnostics: SessionProviderDiagnostic[];
+}
+export interface SessionPreviewListResult {
+    previews: SessionPreview[];
+    diagnostics: SessionProviderDiagnostic[];
+    /** True when more candidates existed than `limit` allowed; the caller may offer a larger limit. */
+    hasMore: boolean;
+}
 /**
  * Reads a bounded preview of one session file. Returns `null` when the file is
  * missing or unreadable; malformed content degrades to `null` fields instead
  * of throwing.
  */
 export declare function readSessionPreview(provider: SessionProviderBase, sessionPath: string, options?: ReadSessionPreviewOptions): SessionPreview | null;
+/** Event-loop-safe counterpart to readSessionPreview with per-call degradation status. */
+export declare function readSessionPreviewAsync(provider: SessionProviderBase, sessionPath: string, options?: ReadSessionPreviewAsyncOptions): Promise<SessionPreviewReadResult>;
 /**
  * Lists previews across providers, newest first. Enumeration is stat-only;
  * content is read only for the post-`limit` survivors.
  */
 export declare function listSessionPreviews(providers: SessionProviderBase[], options?: ListSessionPreviewsOptions): SessionPreview[];
+/**
+ * Lists previews without blocking the caller loop on corpus-wide synchronous
+ * work. SQLite-backed providers perform at most one subprocess per call.
+ */
+export declare function listSessionPreviewsAsync(providers: SessionProviderBase[], options?: ListSessionPreviewsAsyncOptions): Promise<SessionPreviewListResult>;

package/dist/sessionPreviews.js

@@ -53,26 +53,49 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.readSessionPreview = readSessionPreview;
+exports.readSessionPreviewAsync = readSessionPreviewAsync;
 exports.listSessionPreviews = listSessionPreviews;
+exports.listSessionPreviewsAsync = listSessionPreviewsAsync;
 const fs = __importStar(require("fs"));
+function emptyPrefixScan() {
+    return { firstTimestamp: null, workspacePath: null };
+}
 const DEFAULT_PREFIX_BYTES = 16 * 1024;
 const DEFAULT_LIMIT = 50;
+const DEFAULT_CONCURRENCY = 4;
+const MAX_CONCURRENCY = 16;
 /**
  * Reads a bounded preview of one session file. Returns `null` when the file is
  * missing or unreadable; malformed content degrades to `null` fields instead
  * of throwing.
  */
 function readSessionPreview(provider, sessionPath, options = {}) {
-    let stats;
+    let sizeBytes;
     let modifiedAt;
     try {
-        stats = fs.statSync(sessionPath);
+        const stats = fs.statSync(sessionPath);
+        sizeBytes = stats.size;
         // Inside the try: an out-of-range mtime RangeErrors on serialization,
         // and this function's contract is to degrade, not throw.
         modifiedAt = stats.mtime.toISOString();
     }
     catch {
-        return null;
+        let metadata;
+        try {
+            metadata = provider.getSessionMetadata?.(sessionPath);
+        }
+        catch {
+            return null;
+        }
+        if (!metadata)
+            return null;
+        sizeBytes = 0;
+        try {
+            modifiedAt = metadata.mtime.toISOString();
+        }
+        catch {
+            return null;
+        }
     }
     let firstUserPrompt = null;
     try {
@@ -88,18 +111,49 @@ function readSessionPreview(provider, sessionPath, options = {}) {
     catch {
         // A provider that cannot identify the file still yields a usable preview.
     }
-    const prefix = scanPrefix(sessionPath, options.maxPrefixBytes ?? DEFAULT_PREFIX_BYTES);
+    const prefixBudget = options.maxPrefixBytes ?? DEFAULT_PREFIX_BYTES;
+    const prefix = prefixBudget > 0 ? scanPrefix(sessionPath, prefixBudget) : emptyPrefixScan();
     return {
         provider: provider.id,
         sessionId,
         filePath: sessionPath,
         modifiedAt,
-        sizeBytes: stats.size,
+        sizeBytes,
         firstUserPrompt,
         firstTimestamp: prefix.firstTimestamp,
         workspacePath: prefix.workspacePath,
     };
 }
+/** Event-loop-safe counterpart to readSessionPreview with per-call degradation status. */
+async function readSessionPreviewAsync(provider, sessionPath, options = {}) {
+    let labels;
+    const diagnostics = [];
+    try {
+        labels = await extractLabelsAsync(provider, [sessionPath], options);
+    }
+    catch {
+        labels = new Map([[sessionPath, null]]);
+        diagnostics.push({
+            providerId: provider.id,
+            kind: 'read_failed',
+            severity: 'warning',
+            phase: 'read',
+            message: `${provider.id} session label was unavailable.`,
+        });
+    }
+    const info = await statSessionFileAsync(provider, sessionPath);
+    if (!info) {
+        return {
+            preview: null,
+            diagnostics: dedupeDiagnostics([...diagnostics, ...providerDiagnostics(provider)]),
+        };
+    }
+    const preview = await readSessionPreviewFromInfoAsync(provider, info, labels.get(sessionPath) ?? null, options);
+    return {
+        preview,
+        diagnostics: dedupeDiagnostics([...diagnostics, ...providerDiagnostics(provider)]),
+    };
+}
 /**
  * Lists previews across providers, newest first. Enumeration is stat-only;
  * content is read only for the post-`limit` survivors.
@@ -125,11 +179,87 @@ function listSessionPreviews(providers, options = {}) {
     }
     return previews;
 }
+/**
+ * Lists previews without blocking the caller loop on corpus-wide synchronous
+ * work. SQLite-backed providers perform at most one subprocess per call.
+ */
+async function listSessionPreviewsAsync(providers, options = {}) {
+    const limit = Math.max(0, options.limit ?? DEFAULT_LIMIT);
+    const sinceMs = resolveSinceMs(options.since);
+    const candidates = [];
+    const operationDiagnostics = [];
+    await Promise.all(providers.map(async (provider) => {
+        let files = [];
+        try {
+            files = provider.listSessionFilesAsync
+                ? await provider.listSessionFilesAsync(options.workspacePath)
+                : await enumerateSessionFilesAsyncFallback(provider, options.workspacePath, options);
+        }
+        catch {
+            files = [];
+            operationDiagnostics.push({
+                providerId: provider.id,
+                kind: 'read_failed',
+                severity: 'error',
+                phase: 'enumerate',
+                message: `${provider.id} session enumeration failed.`,
+            });
+        }
+        for (const info of files) {
+            const mtimeMs = info.mtime.getTime();
+            if (sinceMs !== null && mtimeMs <= sinceMs)
+                continue;
+            candidates.push({ provider, info });
+        }
+    }));
+    candidates.sort((left, right) => right.info.mtime.getTime() - left.info.mtime.getTime());
+    const selected = candidates.slice(0, limit);
+    const labels = new Map();
+    await Promise.all(providers.map(async (provider) => {
+        const paths = selected
+            .filter((item) => item.provider === provider)
+            .map((item) => item.info.path);
+        if (paths.length === 0)
+            return;
+        try {
+            labels.set(provider, await extractLabelsAsync(provider, paths, options));
+        }
+        catch {
+            labels.set(provider, new Map(paths.map((sessionPath) => [sessionPath, null])));
+            operationDiagnostics.push({
+                providerId: provider.id,
+                kind: 'read_failed',
+                severity: 'warning',
+                phase: 'read',
+                message: `${provider.id} session labels were unavailable.`,
+            });
+        }
+    }));
+    const previews = await mapWithConcurrency(selected, async ({ provider, info }) => {
+        const preview = await readSessionPreviewFromInfoAsync(provider, info, labels.get(provider)?.get(info.path) ?? info.label ?? null, options);
+        await yieldControl(options);
+        return preview;
+    }, concurrency(options));
+    return {
+        previews: previews.filter((preview) => preview !== null),
+        hasMore: candidates.length > limit,
+        diagnostics: dedupeDiagnostics([
+            ...operationDiagnostics,
+            ...providers.flatMap(providerDiagnostics),
+        ]),
+    };
+}
 function resolveSinceMs(since) {
     if (since === undefined)
         return null;
     const ms = since instanceof Date ? since.getTime() : Date.parse(since);
-    return Number.isFinite(ms) ? ms : null;
+    if (!Number.isFinite(ms)) {
+        // An unparseable cutoff used to mean "no cutoff", silently returning
+        // every session. Fail loudly instead so a typo cannot masquerade as a
+        // full listing.
+        throw new RangeError(`Invalid \`since\` value: ${String(since)}`);
+    }
+    return ms;
 }
 function enumerateSessionFiles(provider, workspacePath) {
     try {
@@ -169,6 +299,151 @@ function statSessionFile(sessionPath) {
         return null;
     }
 }
+async function statSessionFileAsync(provider, sessionPath) {
+    try {
+        const stat = await fs.promises.stat(sessionPath);
+        return {
+            path: sessionPath,
+            mtime: stat.mtime,
+            sizeBytes: stat.size,
+            sessionId: safeSessionId(provider, sessionPath),
+        };
+    }
+    catch {
+        let metadata = null;
+        try {
+            // Async first: for DB-backed synthetic paths the sync variant can spawn
+            // a blocking sqlite3 subprocess, defeating this API's event-loop safety.
+            if (provider.getSessionMetadataAsync) {
+                metadata = await provider.getSessionMetadataAsync(sessionPath);
+            }
+            else {
+                metadata = provider.getSessionMetadata?.(sessionPath) ?? null;
+            }
+        }
+        catch {
+            metadata = null;
+        }
+        if (!metadata)
+            return null;
+        return {
+            path: sessionPath,
+            mtime: metadata.mtime,
+            sizeBytes: 0,
+            sessionId: safeSessionId(provider, sessionPath),
+        };
+    }
+}
+async function extractLabelsAsync(provider, sessionPaths, options) {
+    if (provider.extractSessionLabelsAsync) {
+        // Callers deliberately do not retry through the synchronous provider path
+        // if this batch fails: DB-backed providers could otherwise spawn once per
+        // session after their single async batch failed.
+        return provider.extractSessionLabelsAsync(sessionPaths);
+    }
+    const values = new Map();
+    for (const sessionPath of sessionPaths) {
+        values.set(sessionPath, await extractLabelWithYield(provider, sessionPath, options));
+    }
+    return values;
+}
+async function enumerateSessionFilesAsyncFallback(provider, workspacePath, options) {
+    await yieldControl(options);
+    const paths = workspacePath
+        ? provider.findAllSessions(workspacePath)
+        : provider.listAllSessionFiles
+            ? provider.listAllSessionFiles().map((item) => item.path)
+            : provider
+                .getAllProjectFolders()
+                .flatMap((folder) => provider.findSessionsInDirectory(folder.dir));
+    return (await mapWithConcurrency([...new Set(paths)], async (sessionPath) => {
+        const info = await statSessionFileAsync(provider, sessionPath);
+        await yieldControl(options);
+        return info;
+    }, concurrency(options))).filter((item) => item !== null);
+}
+async function readSessionPreviewFromInfoAsync(provider, info, firstUserPrompt, options) {
+    let modifiedAt;
+    try {
+        modifiedAt = info.mtime.toISOString();
+    }
+    catch {
+        return null;
+    }
+    const prefixBudget = options.maxPrefixBytes ?? DEFAULT_PREFIX_BYTES;
+    const prefix = prefixBudget > 0 ? await scanPrefixAsync(info.path, prefixBudget) : emptyPrefixScan();
+    return {
+        provider: provider.id,
+        sessionId: info.sessionId ?? safeSessionId(provider, info.path),
+        filePath: info.path,
+        modifiedAt,
+        sizeBytes: info.sizeBytes ?? 0,
+        firstUserPrompt,
+        firstTimestamp: prefix.firstTimestamp ?? info.createdAt?.toISOString() ?? null,
+        workspacePath: prefix.workspacePath ?? info.workspacePath ?? null,
+    };
+}
+async function extractLabelWithYield(provider, sessionPath, options) {
+    await yieldControl(options);
+    try {
+        return provider.extractSessionLabel(sessionPath);
+    }
+    catch {
+        return null;
+    }
+}
+function safeSessionId(provider, sessionPath) {
+    try {
+        return provider.getSessionId(sessionPath);
+    }
+    catch {
+        return '';
+    }
+}
+function concurrency(options) {
+    const requested = options.concurrency ?? DEFAULT_CONCURRENCY;
+    if (!Number.isFinite(requested))
+        return DEFAULT_CONCURRENCY;
+    return Math.min(MAX_CONCURRENCY, Math.max(1, Math.floor(requested)));
+}
+async function yieldControl(options) {
+    if (options.yieldBetweenReads) {
+        await options.yieldBetweenReads();
+        return;
+    }
+    await new Promise((resolve) => setImmediate(resolve));
+}
+async function mapWithConcurrency(values, mapper, maxConcurrency) {
+    const results = new Array(values.length);
+    let cursor = 0;
+    await Promise.all(Array.from({ length: Math.min(maxConcurrency, values.length) }, async () => {
+        while (true) {
+            const index = cursor++;
+            if (index >= values.length)
+                return;
+            results[index] = await mapper(values[index]);
+        }
+    }));
+    return results;
+}
+function providerDiagnostics(provider) {
+    try {
+        return [...(provider.getLastOperationStatus?.().diagnostics ?? [])];
+    }
+    catch {
+        return [];
+    }
+}
+function dedupeDiagnostics(diagnostics) {
+    const seen = new Set();
+    return diagnostics.filter((diagnostic) => {
+        const key = `${diagnostic.providerId}\0${diagnostic.kind}\0${diagnostic.phase}`;
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}
 /**
  * Parses complete JSONL lines out of the first `maxPrefixBytes` of a file,
  * taking the first top-level `timestamp` string and the first workspace path
@@ -232,3 +507,55 @@ function scanPrefix(sessionPath, maxPrefixBytes) {
     }
     return result;
 }
+async function scanPrefixAsync(sessionPath, maxPrefixBytes) {
+    const result = { firstTimestamp: null, workspacePath: null };
+    let handle = null;
+    try {
+        handle = await fs.promises.open(sessionPath, 'r');
+        const stats = await handle.stat();
+        const readBytes = Math.min(stats.size, Math.max(1, maxPrefixBytes));
+        const buffer = Buffer.alloc(readBytes);
+        const { bytesRead } = await handle.read(buffer, 0, readBytes, 0);
+        parsePrefixInto(result, buffer.toString('utf8', 0, bytesRead), bytesRead >= stats.size);
+    }
+    catch {
+        return result;
+    }
+    finally {
+        await handle?.close().catch(() => undefined);
+    }
+    return result;
+}
+function parsePrefixInto(result, content, sawWholeFile) {
+    const lines = content.split('\n');
+    const completeLines = sawWholeFile ? lines : lines.slice(0, -1);
+    for (const line of completeLines) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        let parsed;
+        try {
+            parsed = JSON.parse(trimmed);
+        }
+        catch {
+            continue;
+        }
+        if (parsed === null || typeof parsed !== 'object')
+            continue;
+        if (result.firstTimestamp === null && typeof parsed.timestamp === 'string') {
+            result.firstTimestamp = parsed.timestamp;
+        }
+        if (result.workspacePath === null) {
+            if (typeof parsed.cwd === 'string' && parsed.cwd)
+                result.workspacePath = parsed.cwd;
+            else if (parsed.type === 'session_meta') {
+                const payload = parsed.payload;
+                if (payload && typeof payload.cwd === 'string' && payload.cwd) {
+                    result.workspacePath = payload.cwd;
+                }
+            }
+        }
+        if (result.firstTimestamp !== null && result.workspacePath !== null)
+            break;
+    }
+}

package/dist/sessionStats.d.ts

@@ -0,0 +1,51 @@
+/**
+ * One `readSessionStats()` implementation for every session provider.
+ *
+ * Claude Code, Codex, and OpenCode used to compute session stats three
+ * different ways (a hand-rolled JSONL scan, an aggregator drain, and a direct
+ * SQLite read with hardcoded zeros). Every provider now drains its reader once
+ * into the shared `EventAggregator`, so per-model totals use the
+ * cache-inclusive vocabulary, cost carries provenance, tool failures are
+ * split out, and compaction and truncation counts are real for all three.
+ */
+import type { EventAggregatorOptions } from './aggregation/types';
+import type { ProviderId, SessionFileStats, SessionFileStatsAvailability, SessionProviderBase } from './providers/types';
+import type { SessionEvent } from './types/sessionEvent';
+export interface ComputeSessionFileStatsOptions {
+    providerId: ProviderId;
+    sessionId: string;
+    filePath: string;
+    /** Label to use; derived from the first user prompt when omitted or null. */
+    label?: string | null;
+    /** Provider-specific context formula, forwarded to the aggregator. */
+    computeContextSize?: EventAggregatorOptions['computeContextSize'];
+    /** Defaults to `full`. */
+    availability?: SessionFileStatsAvailability;
+    unavailableReason?: string;
+}
+export interface ReadSessionFileStatsOptions {
+    /**
+     * Cheap label source consulted before the events (for example a SQLite
+     * thread title). Return null to fall back to the first user prompt.
+     */
+    resolveLabel?: () => string | null;
+}
+/**
+ * First user prompt in a session, compacted to one line and truncated the
+ * way every provider's `extractSessionLabel()` truncates (60 characters).
+ */
+export declare function firstUserPrompt(events: readonly SessionEvent[], maxLength?: number): string | null;
+/** Compute stats for an already-read event array through the shared aggregator. */
+export declare function computeSessionFileStats(events: readonly SessionEvent[], options: ComputeSessionFileStatsOptions): SessionFileStats;
+/** The aggregator's context-size hook for a provider, or undefined for the default formula. */
+export declare function providerContextSizeFn(provider: SessionProviderBase): EventAggregatorOptions['computeContextSize'];
+/**
+ * Read a session once through the provider's reader and compute its stats.
+ *
+ * The reader is drained with `readAll()` and then `flush()`ed so a final line
+ * without a trailing newline is included, and it is never opened a second
+ * time for the label. A source that cannot be read yields
+ * `availability: 'unavailable'` with a reason instead of silent zeros; a
+ * reader that reports truncation yields `partial`.
+ */
+export declare function readSessionFileStats(provider: SessionProviderBase, sessionPath: string, options?: ReadSessionFileStatsOptions): SessionFileStats;

package/dist/sessionStats.js

@@ -0,0 +1,166 @@
+"use strict";
+/**
+ * One `readSessionStats()` implementation for every session provider.
+ *
+ * Claude Code, Codex, and OpenCode used to compute session stats three
+ * different ways (a hand-rolled JSONL scan, an aggregator drain, and a direct
+ * SQLite read with hardcoded zeros). Every provider now drains its reader once
+ * into the shared `EventAggregator`, so per-model totals use the
+ * cache-inclusive vocabulary, cost carries provenance, tool failures are
+ * split out, and compaction and truncation counts are real for all three.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.firstUserPrompt = firstUserPrompt;
+exports.computeSessionFileStats = computeSessionFileStats;
+exports.providerContextSizeFn = providerContextSizeFn;
+exports.readSessionFileStats = readSessionFileStats;
+const EventAggregator_1 = require("./aggregation/EventAggregator");
+const LABEL_MAX_LENGTH = 60;
+function isTextBlock(block) {
+    return (typeof block === 'object' &&
+        block !== null &&
+        typeof block.text === 'string' &&
+        typeof block.type === 'string' &&
+        ['text', 'input_text', 'output_text'].includes(block.type));
+}
+function messageText(content) {
+    if (typeof content === 'string')
+        return content;
+    if (!Array.isArray(content))
+        return null;
+    const block = content.find((item) => isTextBlock(item) && item.text.trim().length > 0);
+    return block && isTextBlock(block) ? block.text : null;
+}
+/**
+ * First user prompt in a session, compacted to one line and truncated the
+ * way every provider's `extractSessionLabel()` truncates (60 characters).
+ */
+function firstUserPrompt(events, maxLength = LABEL_MAX_LENGTH) {
+    for (const event of events) {
+        if (event.type !== 'user')
+            continue;
+        const text = messageText(event.message?.content);
+        if (!text)
+            continue;
+        const compact = text.replace(/\s+/g, ' ').trim();
+        if (!compact)
+            continue;
+        return compact.length > maxLength ? `${compact.slice(0, maxLength - 3)}...` : compact;
+    }
+    return null;
+}
+/** Compute stats for an already-read event array through the shared aggregator. */
+function computeSessionFileStats(events, options) {
+    const aggregator = new EventAggregator_1.EventAggregator({
+        providerId: options.providerId,
+        computeContextSize: options.computeContextSize,
+    });
+    for (const event of events)
+        aggregator.processEvent(event);
+    const metrics = aggregator.getMetrics();
+    const modelUsage = {};
+    for (const model of metrics.modelStats) {
+        // `tokens` is the aggregator's cache-inclusive total for the model, the
+        // same figure `summarizeTokens().total` reports.
+        modelUsage[model.model] = {
+            calls: model.calls,
+            tokens: model.tokens,
+            costUsd: model.cost,
+            priced: model.priced !== false,
+        };
+    }
+    const toolUsage = {};
+    const toolFailures = {};
+    for (const tool of metrics.toolStats) {
+        toolUsage[tool.name] = tool.successCount + tool.failureCount + tool.pendingCount;
+        if (tool.failureCount > 0)
+            toolFailures[tool.name] = tool.failureCount;
+    }
+    return {
+        providerId: options.providerId,
+        sessionId: options.sessionId,
+        filePath: options.filePath,
+        label: options.label ?? firstUserPrompt(events),
+        startTime: metrics.sessionStartTime ?? '',
+        endTime: metrics.lastEventTime ?? '',
+        messageCount: metrics.messageCount,
+        tokens: {
+            input: metrics.tokens.inputTokens,
+            output: metrics.tokens.outputTokens,
+            cacheWrite: metrics.tokens.cacheWriteTokens,
+            cacheRead: metrics.tokens.cacheReadTokens,
+        },
+        modelUsage,
+        toolUsage,
+        toolFailures,
+        compactionEstimate: metrics.compactionCount,
+        truncationCount: metrics.truncationCount,
+        costUsd: metrics.tokens.costUsd,
+        costProvenance: metrics.tokens.costProvenance,
+        unpricedCalls: metrics.tokens.unpricedCalls,
+        availability: options.availability ?? 'full',
+        ...(options.unavailableReason ? { unavailableReason: options.unavailableReason } : {}),
+        reportedCost: metrics.tokens.costUsd,
+    };
+}
+/** The aggregator's context-size hook for a provider, or undefined for the default formula. */
+function providerContextSizeFn(provider) {
+    if (!provider.computeContextSize)
+        return undefined;
+    return (usage) => provider.computeContextSize({ ...usage, model: '', timestamp: new Date() });
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function describeMissingSource(provider) {
+    const status = provider.getRuntimeStatus?.();
+    if (status && !status.available) {
+        return status.message ?? `Provider runtime unavailable (${status.kind}).`;
+    }
+    return 'Session source not found.';
+}
+/**
+ * Read a session once through the provider's reader and compute its stats.
+ *
+ * The reader is drained with `readAll()` and then `flush()`ed so a final line
+ * without a trailing newline is included, and it is never opened a second
+ * time for the label. A source that cannot be read yields
+ * `availability: 'unavailable'` with a reason instead of silent zeros; a
+ * reader that reports truncation yields `partial`.
+ */
+function readSessionFileStats(provider, sessionPath, options = {}) {
+    const base = {
+        providerId: provider.id,
+        sessionId: provider.getSessionId(sessionPath),
+        filePath: sessionPath,
+    };
+    let reader;
+    let events;
+    try {
+        reader = provider.createReader(sessionPath);
+        events = reader.readAll();
+        // Readers buffer line-oriented input; flushing emits a trailing partial
+        // line into the same array `readAll()` returned.
+        reader.flush();
+    }
+    catch (error) {
+        return computeSessionFileStats([], {
+            ...base,
+            availability: 'unavailable',
+            unavailableReason: errorMessage(error),
+        });
+    }
+    if (events.length === 0 && !reader.exists()) {
+        return computeSessionFileStats([], {
+            ...base,
+            availability: 'unavailable',
+            unavailableReason: describeMissingSource(provider),
+        });
+    }
+    return computeSessionFileStats(events, {
+        ...base,
+        label: options.resolveLabel?.() ?? undefined,
+        computeContextSize: providerContextSizeFn(provider),
+        availability: reader.wasTruncated() ? 'partial' : 'full',
+    });
+}