sidekick-shared 0.29.1 → 0.30.0

package/dist/esm/providers/compressedRollouts.js

@@ -0,0 +1,330 @@
+/**
+ * Reads Codex rollouts that Codex compressed.
+ *
+ * Codex compresses older rollouts in place to `rollout-<ts>-<id>.jsonl.zst`
+ * (one Zstandard frame), while its state database keeps the `.jsonl` path.
+ * Node ships `zlib.zstdDecompressSync` from 22.15 / 23.8; on older runtimes
+ * (Node 20, older VS Code Electron builds) compressed rollouts cannot be read
+ * and are skipped, reported once as a `read_failed` diagnostic.
+ *
+ * Every reader here takes either form: a `.jsonl` path reads as before, a
+ * `.jsonl.zst` path is decompressed. Compressed rollouts are complete (Codex
+ * only compresses rollouts it no longer writes), so they are read whole and
+ * never tailed.
+ *
+ * Node-only: reads files.
+ *
+ * @module providers/compressedRollouts
+ */
+import * as fs from 'fs';
+import * as zlib from 'zlib';
+/** File-name suffix of a compressed rollout. */
+export const COMPRESSED_ROLLOUT_SUFFIX = '.jsonl.zst';
+/** `undefined`: use the runtime's; `null`: behave as if the runtime lacked it. */
+let decompressOverride;
+function zstdDecompressSync() {
+    if (decompressOverride !== undefined)
+        return decompressOverride;
+    const fn = zlib.zstdDecompressSync;
+    return typeof fn === 'function' ? fn.bind(zlib) : null;
+}
+/** Test hooks; not part of the public entry points. */
+export const __compressedRolloutTesting = {
+    /** Replace the runtime's `zstdDecompressSync` (`null` = unavailable, `undefined` = restore). */
+    setDecompress(fn) {
+        decompressOverride = fn;
+    },
+};
+/** Whether a path (or file name) names a compressed rollout (`*.jsonl.zst`). */
+export function isCompressedRolloutPath(filePath) {
+    return filePath.endsWith(COMPRESSED_ROLLOUT_SUFFIX);
+}
+/** Whether this runtime can decompress Zstandard (`zlib.zstdDecompressSync`). */
+export function isZstdDecompressionAvailable() {
+    return zstdDecompressSync() !== null;
+}
+const UNAVAILABLE_MESSAGE = 'Compressed Codex rollouts (.jsonl.zst) were skipped: this Node.js runtime has no zlib.zstdDecompressSync (Node 22.15 or later).';
+/** The runtime-limit diagnostic is reported once per process unless asked again. */
+let reportedUnavailable = false;
+function reportUnavailable(options) {
+    if (!options?.onDiagnostic || reportedUnavailable)
+        return;
+    reportedUnavailable = true;
+    options.onDiagnostic({
+        providerId: 'codex',
+        kind: 'read_failed',
+        severity: 'info',
+        phase: 'read',
+        message: UNAVAILABLE_MESSAGE,
+    });
+}
+function reportCorrupt(options, error) {
+    options?.onDiagnostic?.({
+        providerId: 'codex',
+        kind: 'read_failed',
+        severity: 'warning',
+        phase: 'read',
+        message: `A compressed Codex rollout could not be decompressed: ${error instanceof Error ? error.message : String(error)}`,
+    });
+}
+/**
+ * Whether compressed rollouts can be read here; when they cannot, reports
+ * the runtime limit through `onDiagnostic` (once per process). Callers that
+ * list rollouts use it to leave `.jsonl.zst` files out instead of listing
+ * sessions they cannot read.
+ */
+export function canReadCompressedRollouts(options) {
+    if (zstdDecompressSync())
+        return true;
+    reportUnavailable(options);
+    return false;
+}
+/** @internal Test hook: report the runtime limit again. */
+export function resetCompressedRolloutDiagnostics() {
+    reportedUnavailable = false;
+}
+function decompress(input, options) {
+    const fn = zstdDecompressSync();
+    if (!fn) {
+        reportUnavailable(options);
+        return null;
+    }
+    try {
+        return fn(input);
+    }
+    catch (error) {
+        reportCorrupt(options, error);
+        return null;
+    }
+}
+/**
+ * The whole content of a rollout: a `.jsonl` file as stored, a `.jsonl.zst`
+ * file decompressed. `null` when the file cannot be read or decompressed
+ * (the latter reported through `onDiagnostic`).
+ */
+export function readRolloutBuffer(filePath, options) {
+    let raw;
+    try {
+        raw = fs.readFileSync(filePath);
+    }
+    catch {
+        return null;
+    }
+    return isCompressedRolloutPath(filePath) ? decompress(raw, options) : raw;
+}
+/** {@link readRolloutBuffer} decoded as UTF-8. */
+export function readRolloutText(filePath, options) {
+    return readRolloutBuffer(filePath, options)?.toString('utf8') ?? null;
+}
+/** Async twin of {@link readRolloutBuffer}; decompression itself is synchronous. */
+export async function readRolloutBufferAsync(filePath, options) {
+    let raw;
+    try {
+        raw = await fs.promises.readFile(filePath);
+    }
+    catch {
+        return null;
+    }
+    return isCompressedRolloutPath(filePath) ? decompress(raw, options) : raw;
+}
+/** Compressed bytes read per step while looking for a decompressed prefix. */
+const HEAD_STEP_BYTES = 64 * 1024;
+/**
+ * Decompresses only as much of a compressed prefix as is needed for
+ * `maxBytes` of content: a truncated Zstandard frame decompresses to the
+ * content of its complete blocks.
+ */
+function decompressHead(readCompressed, compressedSize, maxBytes, options) {
+    const fn = zstdDecompressSync();
+    if (!fn) {
+        reportUnavailable(options);
+        return null;
+    }
+    let length = Math.min(compressedSize, HEAD_STEP_BYTES);
+    for (;;) {
+        let out;
+        try {
+            out = fn(readCompressed(length));
+        }
+        catch (error) {
+            if (length >= compressedSize) {
+                reportCorrupt(options, error);
+                return null;
+            }
+            out = Buffer.alloc(0);
+        }
+        if (out.length >= maxBytes || length >= compressedSize)
+            return out.subarray(0, maxBytes);
+        length = Math.min(compressedSize, length * 4);
+    }
+}
+/**
+ * Up to `maxBytes` of a rollout's content from its start (decompressed for
+ * a `.jsonl.zst`). An empty buffer when the file cannot be read.
+ */
+export function readRolloutHead(filePath, maxBytes, options) {
+    let fd;
+    try {
+        fd = fs.openSync(filePath, 'r');
+    }
+    catch {
+        return Buffer.alloc(0);
+    }
+    try {
+        const size = fs.fstatSync(fd).size;
+        const readPrefix = (length) => {
+            const buffer = Buffer.alloc(length);
+            const bytesRead = fs.readSync(fd, buffer, 0, length, 0);
+            return buffer.subarray(0, bytesRead);
+        };
+        if (!isCompressedRolloutPath(filePath))
+            return readPrefix(Math.min(size, Math.max(0, maxBytes)));
+        return decompressHead(readPrefix, size, Math.max(0, maxBytes), options) ?? Buffer.alloc(0);
+    }
+    catch {
+        return Buffer.alloc(0);
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
+/** Async twin of {@link readRolloutHead}. */
+export async function readRolloutHeadAsync(filePath, maxBytes, options) {
+    if (!isCompressedRolloutPath(filePath)) {
+        let handle = null;
+        try {
+            handle = await fs.promises.open(filePath, 'r');
+            const size = (await handle.stat()).size;
+            const length = Math.min(size, Math.max(0, maxBytes));
+            const buffer = Buffer.alloc(length);
+            const { bytesRead } = await handle.read(buffer, 0, length, 0);
+            return buffer.subarray(0, bytesRead);
+        }
+        catch {
+            return Buffer.alloc(0);
+        }
+        finally {
+            await handle?.close().catch(() => undefined);
+        }
+    }
+    // Compressed prefixes are small; one synchronous read keeps it simple.
+    return readRolloutHead(filePath, maxBytes, options);
+}
+/**
+ * The first `maxLines` complete lines of a rollout (decompressed for a
+ * `.jsonl.zst`) within `maxBytes` of content; a trailing line without a
+ * newline counts when the whole content fit.
+ */
+export function readRolloutFirstLines(filePath, maxLines, maxBytes = 256 * 1024, options) {
+    const head = readRolloutHead(filePath, maxBytes + 1, options);
+    const complete = head.length <= maxBytes;
+    const text = head.subarray(0, maxBytes).toString('utf8');
+    const parts = text.split('\n');
+    const tail = parts.pop() ?? '';
+    const lines = parts.slice(0, maxLines);
+    if (lines.length < maxLines && complete && tail.trim())
+        lines.push(tail);
+    return lines;
+}
+/**
+ * The content size a Zstandard frame header declares (`Frame_Content_Size`),
+ * or `null` when the header omits it or is not a Zstandard frame. Skippable
+ * frames before it are not followed.
+ */
+export function zstdFrameContentSize(header) {
+    if (header.length < 5 || header.readUInt32LE(0) !== 0xfd2fb528)
+        return null;
+    const descriptor = header[4];
+    const fcsFlag = descriptor >> 6;
+    const singleSegment = (descriptor >> 5) & 1;
+    const dictionaryIdFlag = descriptor & 3;
+    const offset = 5 + (singleSegment ? 0 : 1) + [0, 1, 2, 4][dictionaryIdFlag];
+    const fcsBytes = fcsFlag === 0 ? (singleSegment ? 1 : 0) : [0, 2, 4, 8][fcsFlag];
+    if (fcsBytes === 0 || header.length < offset + fcsBytes)
+        return null;
+    switch (fcsBytes) {
+        case 1:
+            return header[offset];
+        case 2:
+            return header.readUInt16LE(offset) + 256;
+        case 4:
+            return header.readUInt32LE(offset);
+        default: {
+            const value = header.readBigUInt64LE(offset);
+            return value <= BigInt(Number.MAX_SAFE_INTEGER) ? Number(value) : null;
+        }
+    }
+}
+/**
+ * Stat of a rollout's content: the file's own for a `.jsonl`; for a
+ * `.jsonl.zst`, the decompressed size (from the frame header, else by
+ * decompressing) with the compressed file's mtime. Rejects like `fs.stat`
+ * when the file is missing; a compressed rollout that cannot be read
+ * rejects too.
+ */
+export async function statRolloutContent(filePath, options) {
+    const stat = await fs.promises.stat(filePath);
+    if (!isCompressedRolloutPath(filePath))
+        return { size: stat.size, mtimeMs: stat.mtimeMs };
+    let declared = null;
+    let handle = null;
+    try {
+        handle = await fs.promises.open(filePath, 'r');
+        const header = Buffer.alloc(18);
+        const { bytesRead } = await handle.read(header, 0, header.length, 0);
+        declared = zstdFrameContentSize(header.subarray(0, bytesRead));
+    }
+    finally {
+        await handle?.close().catch(() => undefined);
+    }
+    if (declared !== null && isZstdDecompressionAvailable()) {
+        return { size: declared, mtimeMs: stat.mtimeMs };
+    }
+    const content = await readRolloutBufferAsync(filePath, options);
+    if (!content)
+        throw new Error('compressed rollout could not be read');
+    return { size: content.length, mtimeMs: stat.mtimeMs };
+}
+/** A read-only handle over a buffer, for scanning decompressed content. */
+function bufferHandle(content) {
+    return {
+        async read(buffer, offset, length, position) {
+            if (position >= content.length || length <= 0)
+                return { bytesRead: 0 };
+            const bytesRead = content.copy(buffer, offset, position, Math.min(content.length, position + length));
+            return { bytesRead };
+        },
+        async close() { },
+    };
+}
+/**
+ * Opens a rollout for positional reads over its content: a file handle for
+ * a `.jsonl`, the decompressed content for a `.jsonl.zst` (with `size`, the
+ * content length). Rejects when the file cannot be opened or decompressed.
+ */
+export async function openRolloutReadHandle(filePath, options) {
+    if (!isCompressedRolloutPath(filePath)) {
+        return { handle: await fs.promises.open(filePath, 'r'), size: null };
+    }
+    const content = await readRolloutBufferAsync(filePath, options);
+    if (!content)
+        throw new Error('compressed rollout could not be read');
+    return { handle: bufferHandle(content), size: content.length };
+}
+/**
+ * The path of a rollout as stored now: `filePath` when it exists, else its
+ * compressed sibling (`<filePath>.zst`) when `includeCompressed` is set and
+ * that exists. `null` when neither does.
+ */
+export function resolveRolloutPath(filePath, options = {}) {
+    if (!filePath)
+        return null;
+    if (fs.existsSync(filePath))
+        return filePath;
+    if (options.includeCompressed && !isCompressedRolloutPath(filePath)) {
+        const compressed = `${filePath}.zst`;
+        if (filePath.endsWith('.jsonl') && fs.existsSync(compressed))
+            return compressed;
+    }
+    return null;
+}

package/dist/esm/providers/factory.js

@@ -37,7 +37,10 @@ export function createSessionProviders(options = {}) {
                 ? new ClaudeCodeProvider(providerOptions)
                 : providerId === 'opencode'
                     ? new OpenCodeProvider(providerOptions)
-                    : new CodexProvider(providerOptions));
+                    : new CodexProvider({
+                        ...providerOptions,
+                        includeCompressedRollouts: options.includeCompressedRollouts === true,
+                    }));
         }
         catch {
             const diagnostic = {

package/dist/esm/providers/rolloutWalker.js

@@ -15,6 +15,10 @@
  * order over the whole history omit both (the `maxFiles` cap still applies);
  * a live session missed this way is picked up by its next watch event.
  *
+ * Codex compresses older rollouts to `rollout-…jsonl.zst`. Those are skipped
+ * unless `includeCompressed` is set; a compressed rollout whose `.jsonl` is
+ * still beside it is skipped either way (the `.jsonl` is the one to read).
+ *
  * The async walker accepts a {@link DirectoryListingCache}: unchanged
  * directories are then one stat each instead of a readdir plus a stat per
  * file, which is what makes repeated discovery over a large history cheap.
@@ -25,16 +29,23 @@ import * as fs from 'fs';
 import * as path from 'path';
 export const DEFAULT_ROLLOUT_WALK_MAX_DEPTH = 6;
 export const DEFAULT_ROLLOUT_WALK_MAX_FILES = 20_000;
-/** Test if a filename is a Codex rollout file. */
+/** Test if a filename is a Codex rollout file (`rollout-….jsonl`; not compressed ones). */
 export function isRolloutFile(filename) {
     return filename.startsWith('rollout-') && filename.endsWith('.jsonl');
 }
+/** Test if a filename is a compressed Codex rollout (`rollout-….jsonl.zst`). */
+export function isCompressedRolloutFile(filename) {
+    return filename.startsWith('rollout-') && filename.endsWith('.jsonl.zst');
+}
 /**
  * Extract the session UUID from a rollout filename.
- * Format: rollout-<timestamp>-<uuid>.jsonl -> <uuid>
+ * Format: rollout-<timestamp>-<uuid>.jsonl (or .jsonl.zst) -> <uuid>
  */
 export function extractRolloutSessionId(filename) {
-    const base = path.basename(filename, '.jsonl');
+    const name = path.basename(filename);
+    const base = name.endsWith('.jsonl.zst')
+        ? name.slice(0, -'.jsonl.zst'.length)
+        : path.basename(name, '.jsonl');
     // rollout-YYYYMMDD-HHMMSS-<uuid> or rollout-<timestamp>-<uuid>
     const parts = base.split('-');
     // The UUID is typically the last 5 segments (8-4-4-4-12)
@@ -58,6 +69,7 @@ function walkState(options) {
         since: options.since !== undefined && Number.isFinite(options.since) ? options.since : null,
         sessionId: options.sessionId ? options.sessionId.trim().toLowerCase() : null,
         includeEmpty: options.includeEmpty ?? false,
+        includeCompressed: options.includeCompressed ?? false,
         cache: options.cache ?? null,
         revalidateRecent: options.revalidateRecent ?? false,
         stats: options.stats,
@@ -68,10 +80,15 @@ function byNameDescending(a, b) {
     return b.name.localeCompare(a.name);
 }
 function matchesFilter(state, name) {
-    if (!isRolloutFile(name))
+    if (!isRolloutFile(name) && !(state.includeCompressed && isCompressedRolloutFile(name))) {
         return false;
+    }
     return (state.sessionId === null || extractRolloutSessionId(name).toLowerCase() === state.sessionId);
 }
+/** A compressed rollout whose uncompressed rollout is listed beside it. */
+function shadowedByPlain(name, has) {
+    return isCompressedRolloutFile(name) && has(name.slice(0, -'.zst'.length));
+}
 function record(state, fullPath, name, stat) {
     if (!state.includeEmpty && stat.size <= 0)
         return;
@@ -130,11 +147,14 @@ function visitSync(state, dir, depth, segments) {
         return;
     }
     entries.sort(byNameDescending);
+    const names = state.includeCompressed ? new Set(entries.map((entry) => entry.name)) : null;
     for (const entry of entries) {
         if (state.results.length >= state.cap)
             return;
         if (!entry.isFile() || !matchesFilter(state, entry.name))
             continue;
+        if (names && shadowedByPlain(entry.name, (name) => names.has(name)))
+            continue;
         const fullPath = path.join(dir, entry.name);
         try {
             record(state, fullPath, entry.name, fs.statSync(fullPath));
@@ -185,6 +205,11 @@ async function visitCached(state, cache, dir, depth, segments) {
         const stat = listing.files.get(name);
         if (!stat)
             continue;
+        // The listing may come from a walk with other options: filter again.
+        if (!matchesFilter(state, name))
+            continue;
+        if (shadowedByPlain(name, (other) => listing.files.has(other)))
+            continue;
         record(state, path.join(dir, name), name, { size: stat.sizeBytes, mtimeMs: stat.mtimeMs });
     }
     await yieldToEventLoop();
@@ -209,12 +234,15 @@ async function visitAsync(state, dir, depth, segments) {
         return;
     }
     entries.sort(byNameDescending);
+    const names = state.includeCompressed ? new Set(entries.map((entry) => entry.name)) : null;
     let sinceYield = 0;
     for (const entry of entries) {
         if (state.results.length >= state.cap)
             return;
         if (!entry.isFile() || !matchesFilter(state, entry.name))
             continue;
+        if (names && shadowedByPlain(entry.name, (name) => names.has(name)))
+            continue;
         const fullPath = path.join(dir, entry.name);
         try {
             const stat = await fs.promises.stat(fullPath);

package/dist/esm/schemas/sessionEvent.js

@@ -8,7 +8,7 @@
  */
 import { z } from 'zod';
 import { normalizedUsageSchema } from './usageNormalization';
-import { taskNotificationPromptFromAttachment } from '../subagentSpawn';
+import { TASK_STATUS_BLOCK_TYPE, TASK_STATUS_ORIGIN_KIND, isFinalTaskStatus, taskNotificationPromptFromAttachment, taskStatusFromAttachment, } from '../subagentSpawn';
 // ── MessageUsage ──
 export const messageUsageSchema = z.object({
     input_tokens: z.number(),
@@ -41,6 +41,8 @@ export const permissionModeSchema = z.enum([
     'acceptEdits',
     'bypassPermissions',
     'plan',
+    'auto',
+    'dontAsk',
 ]);
 // ── SessionEvent ──
 const eventBaseShape = {
@@ -53,8 +55,8 @@ const eventBaseShape = {
     promptSource: z.string().optional(),
     cwd: z.string().optional(),
     gitBranch: z.string().optional(),
-    // A mode this release doesn't know (Claude Code added `auto`) is dropped
-    // rather than rejecting the whole line with its prompt or tool results.
+    // A mode this release doesn't know is dropped rather than rejecting the
+    // whole line with its prompt or tool results.
     permissionMode: permissionModeSchema.optional().catch(undefined),
     rateLimits: z
         .object({
@@ -144,6 +146,9 @@ export const systemSessionEventSchema = z.object({
     type: z.literal('system'),
     message: sessionMessageSchema.optional(),
     ...eventBaseShape,
+    // Claude Code's system-line subtype (`agents_killed`, `turn_duration`, …);
+    // a malformed one is dropped rather than rejecting the line.
+    subtype: z.string().optional().catch(undefined),
 });
 export const toolUseSessionEventSchema = z.object({
     type: z.literal('tool_use'),
@@ -183,7 +188,7 @@ function extractSessionEventsWithProvenance(raw, depth, inherited, options) {
     if (direct.success)
         return [{ ...inherited, ...direct.data }];
     if (options.includeTaskNotifications) {
-        const notification = taskNotificationAttachmentEvent(raw);
+        const notification = taskNotificationAttachmentEvent(raw) ?? taskStatusAttachmentEvent(raw);
         if (notification)
             return [{ ...inherited, ...notification }];
     }
@@ -220,6 +225,29 @@ function taskNotificationAttachmentEvent(raw) {
     const parsed = systemSessionEventSchema.safeParse(candidate);
     return parsed.success ? parsed.data : null;
 }
+/** The `system` event for a background agent's final `task_status` attachment, or `null`. */
+function taskStatusAttachmentEvent(raw) {
+    const status = taskStatusFromAttachment(raw);
+    if (!status || !isFinalTaskStatus(status.status))
+        return null;
+    const line = raw;
+    const candidate = {
+        type: 'system',
+        timestamp: line.timestamp,
+        origin: { kind: TASK_STATUS_ORIGIN_KIND },
+        message: {
+            role: 'system',
+            sourceLabel: 'task status',
+            content: [{ type: TASK_STATUS_BLOCK_TYPE, ...status }],
+        },
+    };
+    for (const key of ['entrypoint', 'isSidechain', 'cwd', 'gitBranch']) {
+        if (line[key] !== undefined)
+            candidate[key] = line[key];
+    }
+    const parsed = systemSessionEventSchema.safeParse(candidate);
+    return parsed.success ? parsed.data : null;
+}
 function progressProvenance(raw) {
     const value = raw;
     const provenance = {};

package/dist/esm/sessionMonitor.js

@@ -31,12 +31,18 @@ export class SessionMonitor {
         const sessionPath = this.provider.findActiveSession(workspacePath);
         return sessionPath ? this.attach(sessionPath, replay) : null;
     }
+    /**
+     * Reads and aggregates what the session gained since the last call. When
+     * the reader had to start over (the file was truncated, rewritten, or
+     * replaced) the aggregator is reset first and the returned events are the
+     * session from the beginning.
+     */
     poll() {
         if (!this.reader)
             return [];
+        const events = this.reader.readNew();
         if (this.reader.wasTruncated())
             this.aggregator.reset();
-        const events = this.reader.readNew();
         this.consume(events);
         return events;
     }

package/dist/esm/sessionPreviews.js

@@ -18,6 +18,7 @@
  * @module sessionPreviews
  */
 import * as fs from 'fs';
+import { isCompressedRolloutPath, readRolloutHead } from './providers/compressedRollouts';
 function emptyPrefixScan() {
     return { firstTimestamp: null, workspacePath: null };
 }
@@ -415,6 +416,12 @@ function scanPrefix(sessionPath, maxPrefixBytes) {
     const result = { firstTimestamp: null, workspacePath: null };
     let content;
     let sawWholeFile;
+    if (isCompressedRolloutPath(sessionPath)) {
+        // A compressed Codex rollout: scan its decompressed prefix.
+        const head = readRolloutHead(sessionPath, Math.max(1, maxPrefixBytes) + 1);
+        parsePrefixInto(result, head.subarray(0, Math.max(1, maxPrefixBytes)).toString('utf8'), head.length <= maxPrefixBytes);
+        return result;
+    }
     try {
         const descriptor = fs.openSync(sessionPath, 'r');
         try {
@@ -470,6 +477,8 @@ function scanPrefix(sessionPath, maxPrefixBytes) {
 }
 async function scanPrefixAsync(sessionPath, maxPrefixBytes) {
     const result = { firstTimestamp: null, workspacePath: null };
+    if (isCompressedRolloutPath(sessionPath))
+        return scanPrefix(sessionPath, maxPrefixBytes);
     let handle = null;
     try {
         handle = await fs.promises.open(sessionPath, 'r');

package/dist/esm/sessionPromptHistory.js

@@ -13,7 +13,7 @@
  * `sessionIds` continues. Scope fails closed as in `collectPromptHistory()`,
  * and replies or signals that belong to an out-of-scope prompt are dropped.
  */
-import * as fs from 'fs';
+import { statRolloutContent } from './providers/compressedRollouts';
 import { DEFAULT_BOUNDS, PROMPT_HISTORY_ORDINAL_MAX_RECORD_BYTES, compareStrings, emptyStats, listCandidates, resolveRoots, scanFile, } from './promptHistory';
 import { createSessionRecordExtractor, } from './sessionPromptSignals';
 const DEFAULT_SESSION_BOUNDS = {
@@ -188,7 +188,9 @@ function definedBounds(bounds) {
 async function selectCandidates(options, listingRoots) {
     const sinceMs = options.since ? options.since.getTime() : null;
     const providers = options.providers ?? ['claude-code', 'codex'];
-    let candidates = await listCandidates(providers, listingRoots, sinceMs);
+    let candidates = await listCandidates(providers, listingRoots, sinceMs, {
+        includeCompressedRollouts: options.includeCompressedRollouts,
+    });
     if (options.sessionIds || options.sessionRefs) {
         const ids = new Set(options.sessionIds ?? []);
         const keys = new Set();
@@ -206,7 +208,7 @@ async function selectCandidates(options, listingRoots) {
     const selected = [];
     for (const candidate of candidates) {
         try {
-            selected.push({ candidate, stat: await fs.promises.stat(candidate.filePath) });
+            selected.push({ candidate, stat: await statRolloutContent(candidate.filePath) });
         }
         catch {
             // Gone since it was listed.