sidekick-shared 0.29.0 → 0.30.0

package/dist/parsers/subagentEndState.js

@@ -0,0 +1,65 @@
+"use strict";
+/**
+ * Whether a Claude Code subagent transcript ended cleanly, read line by line.
+ *
+ * Clean means: the last user or assistant line is an assistant line that
+ * stopped with `end_turn` or `stop_sequence`, and every `tool_use` in the
+ * transcript has its `tool_result`. A user line after that (a resumed agent's
+ * new prompt) makes it unfinished again.
+ *
+ * Pure. Internal to the subagent parsers.
+ *
+ * @module parsers/subagentEndState
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubagentEndTracker = void 0;
+const ENDED_STOP_REASONS = new Set(['end_turn', 'stop_sequence']);
+/** Bounds the unanswered-call set for pathological transcripts. */
+const MAX_PENDING_TOOL_USES = 4096;
+class SubagentEndTracker {
+    unanswered = new Set();
+    lastWasCleanAssistant = false;
+    /** Feeds one parsed JSONL line, in file order. */
+    observe(raw) {
+        if (!raw || typeof raw !== 'object')
+            return;
+        const line = raw;
+        if (line.type !== 'assistant' && line.type !== 'user')
+            return;
+        const message = line.message && typeof line.message === 'object'
+            ? line.message
+            : undefined;
+        const content = Array.isArray(message?.content) ? message.content : [];
+        if (line.type === 'user') {
+            for (const block of content) {
+                if (!block || typeof block !== 'object')
+                    continue;
+                const typed = block;
+                if (typed.type === 'tool_result' && typeof typed.tool_use_id === 'string') {
+                    this.unanswered.delete(typed.tool_use_id);
+                }
+            }
+            this.lastWasCleanAssistant = false;
+            return;
+        }
+        let callsTool = false;
+        for (const block of content) {
+            if (!block || typeof block !== 'object')
+                continue;
+            const typed = block;
+            if (typed.type !== 'tool_use')
+                continue;
+            callsTool = true;
+            if (typeof typed.id === 'string' && this.unanswered.size < MAX_PENDING_TOOL_USES) {
+                this.unanswered.add(typed.id);
+            }
+        }
+        const stop = typeof message?.stop_reason === 'string' ? message.stop_reason : '';
+        this.lastWasCleanAssistant = !callsTool && ENDED_STOP_REASONS.has(stop);
+    }
+    /** Whether the lines so far end cleanly. */
+    endedCleanly() {
+        return this.lastWasCleanAssistant && this.unanswered.size === 0;
+    }
+}
+exports.SubagentEndTracker = SubagentEndTracker;

package/dist/parsers/subagentScanner.d.ts

@@ -8,15 +8,28 @@
  * @module parsers/subagentScanner
  */
 import type { SubagentStats, TaskState } from '../types/sessionEvent';
+/** Fields of a Claude Code `agent-<id>.meta.json`; each is present only when well-typed. */
+export interface AgentMeta {
+    agentType?: string;
+    description?: string;
+    /** The tool_use id of the `Agent` / `Task` call that spawned this agent. */
+    toolUseId?: string;
+    /** The agent that spawned this one, for spawns nested inside a subagent. */
+    parentAgentId?: string;
+    /** `'background'` for an agent launched in the background. */
+    requestShape?: string;
+    /** Written as `true` once a background agent is done (newer Claude Code). */
+    finished?: boolean;
+    /** The user stopped the agent. */
+    stoppedByUser?: boolean;
+}
 /**
  * Reads `agent-<id>.meta.json` (written by Claude Code next to the transcript)
- * for the spawn's agent type and description. Missing or malformed files
- * yield an empty object.
+ * for the spawn's agent type, description, spawning tool_use id, parent agent,
+ * and completion flags. Missing or malformed files yield an empty object;
+ * wrongly typed fields are left out.
  */
-export declare function readAgentMeta(agentFilePath: string): {
-    agentType?: string;
-    description?: string;
-};
+export declare function readAgentMeta(agentFilePath: string): AgentMeta;
 /**
  * Scans subagent directory for agent JSONL files and extracts tool calls.
  *

package/dist/parsers/subagentScanner.js

@@ -51,28 +51,50 @@ const path = __importStar(require("path"));
 const claudeUsageDedupe_1 = require("../usage/claudeUsageDedupe");
 const subagentUsage_1 = require("../usage/subagentUsage");
 const subagentStatsCache_1 = require("./subagentStatsCache");
+const subagentSpawn_1 = require("../subagentSpawn");
+const subagentEndState_1 = require("./subagentEndState");
 /**
  * Pattern for matching subagent JSONL files.
  * Files are named like: agent-<hash>.jsonl
  */
 const AGENT_FILE_PATTERN = /^agent-(.+)\.jsonl$/;
+function metaString(value) {
+    return typeof value === 'string' && value ? value : undefined;
+}
 /**
  * Reads `agent-<id>.meta.json` (written by Claude Code next to the transcript)
- * for the spawn's agent type and description. Missing or malformed files
- * yield an empty object.
+ * for the spawn's agent type, description, spawning tool_use id, parent agent,
+ * and completion flags. Missing or malformed files yield an empty object;
+ * wrongly typed fields are left out.
  */
 function readAgentMeta(agentFilePath) {
     try {
         const metaPath = agentFilePath.replace(/\.jsonl$/, '.meta.json');
         const parsed = JSON.parse(fs.readFileSync(metaPath, 'utf-8'));
-        return {
-            ...(typeof parsed.agentType === 'string' && parsed.agentType
-                ? { agentType: parsed.agentType }
-                : {}),
-            ...(typeof parsed.description === 'string' && parsed.description
-                ? { description: parsed.description }
-                : {}),
-        };
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed))
+            return {};
+        const record = parsed;
+        const meta = {};
+        const agentType = metaString(record.agentType);
+        if (agentType)
+            meta.agentType = agentType;
+        const description = metaString(record.description);
+        if (description)
+            meta.description = description;
+        const toolUseId = metaString(record.toolUseId);
+        if (toolUseId)
+            meta.toolUseId = toolUseId;
+        const parentAgentId = metaString(record.parentAgentId);
+        if (parentAgentId)
+            meta.parentAgentId = parentAgentId;
+        const requestShape = metaString(record.requestShape);
+        if (requestShape)
+            meta.requestShape = requestShape;
+        if (typeof record.finished === 'boolean')
+            meta.finished = record.finished;
+        if (typeof record.stoppedByUser === 'boolean')
+            meta.stoppedByUser = record.stoppedByUser;
+        return meta;
     }
     catch {
         return {};
@@ -178,6 +200,7 @@ function parseAgentFile(filePath, agentId, log) {
         let description;
         const tokens = { agentId, toolCalls: [], inputTokens: 0, outputTokens: 0 };
         const usageDeduper = new claudeUsageDedupe_1.ClaudeUsageDeduper();
+        const endTracker = new subagentEndState_1.SubagentEndTracker();
         let startTime;
         let endTime;
         // Task tracking state
@@ -194,6 +217,7 @@ function parseAgentFile(filePath, agentId, log) {
                 if (!startTime)
                     startTime = eventTimestamp;
                 endTime = eventTimestamp;
+                endTracker.observe(event);
                 // Extract token usage from assistant messages. Split lines of one
                 // response repeat its usage, so count each response once.
                 const usage = (0, claudeUsageDedupe_1.dedupedRawClaudeUsage)(event, usageDeduper);
@@ -247,8 +271,8 @@ function parseAgentFile(filePath, agentId, log) {
                                 }
                             }
                             toolCalls.push(toolCall);
-                            // If this is a Task tool call (spawning another subagent), extract info
-                            if (toolUse.name === 'Task' && toolUse.input) {
+                            // If this is an Agent/Task call (spawning another subagent), extract info
+                            if ((0, subagentSpawn_1.isSubagentSpawnTool)(toolUse.name) && toolUse.input) {
                                 if (toolUse.input.subagent_type && !agentType) {
                                     agentType = String(toolUse.input.subagent_type);
                                 }
@@ -316,6 +340,7 @@ function parseAgentFile(filePath, agentId, log) {
                 startTime,
                 endTime,
                 durationMs,
+                endedCleanly: endTracker.endedCleanly(),
             };
         }
         return null;

package/dist/parsers/subagentTraceParser.d.ts

@@ -5,10 +5,13 @@
  * (not just stats) for drill-down trace visualization. Applies noise classification
  * and tool summary formatting from the formatters module.
  *
- * Three-phase parent-child linking:
- * 1. Result-based: match toolUseResult.agentId → parent tool_use_id
- * 2. Team summary: parse <teammate-message> XML blocks
- * 3. Positional fallback: timestamp ordering + proximity
+ * Parent-child linking, exact links first:
+ * 1. Meta `parentAgentId` (Claude Code writes it for nested spawns)
+ * 2. The child's spawning tool_use id (meta `toolUseId`) found in another
+ *    trace's `Agent` / `Task` calls
+ * Only traces without that spawn metadata (older Claude Code) fall back to:
+ * 3. Team summary: parse <teammate-message> XML blocks
+ * 4. Positional fallback: timestamp ordering + proximity
  *
  * @module parsers/subagentTraceParser
  */
@@ -41,8 +44,33 @@ export interface SubagentTrace {
     children: SubagentTrace[];
     /** Basic stats (tokens, duration, etc.) */
     stats: SubagentStats;
-    /** Parent tool_use_id that spawned this agent */
+    /**
+     * Parent tool_use_id that spawned this agent: the spawning `Agent` / `Task`
+     * call's id when Claude Code recorded it (also for top-level traces, whose
+     * spawn is in the main session). For a heuristic link without that
+     * metadata it holds the parent's agent id, as before; see `parentAgentId`.
+     */
     parentToolUseId?: string;
+    /** Path of this agent's `agent-<id>.jsonl` transcript. */
+    filePath?: string;
+    /** The tool_use id of the call that spawned this agent (meta `toolUseId`). */
+    spawnToolUseId?: string;
+    /** Agent id of the parent trace, for agents spawned by another subagent. */
+    parentAgentId?: string;
+    /** Launched in the background (meta `requestShape: 'background'`). */
+    background?: boolean;
+    /** Claude Code marked the background agent done (meta `finished`). */
+    finished?: boolean;
+    /** The user stopped the agent (meta `stoppedByUser`). */
+    stoppedByUser?: boolean;
+    /** Time of the transcript's last record (the same as `stats.endTime`). */
+    lastActivityAt?: Date;
+    /**
+     * The transcript ended cleanly: its last assistant turn stopped with
+     * `end_turn` / `stop_sequence` and no tool call is unanswered. A resumed
+     * agent's next prompt clears it.
+     */
+    endedCleanly?: boolean;
 }
 /**
  * Scans and parses subagent traces with full conversation events.

package/dist/parsers/subagentTraceParser.js

@@ -6,10 +6,13 @@
  * (not just stats) for drill-down trace visualization. Applies noise classification
  * and tool summary formatting from the formatters module.
  *
- * Three-phase parent-child linking:
- * 1. Result-based: match toolUseResult.agentId → parent tool_use_id
- * 2. Team summary: parse <teammate-message> XML blocks
- * 3. Positional fallback: timestamp ordering + proximity
+ * Parent-child linking, exact links first:
+ * 1. Meta `parentAgentId` (Claude Code writes it for nested spawns)
+ * 2. The child's spawning tool_use id (meta `toolUseId`) found in another
+ *    trace's `Agent` / `Task` calls
+ * Only traces without that spawn metadata (older Claude Code) fall back to:
+ * 3. Team summary: parse <teammate-message> XML blocks
+ * 4. Positional fallback: timestamp ordering + proximity
  *
  * @module parsers/subagentTraceParser
  */
@@ -55,6 +58,9 @@ const noiseClassifier_1 = require("../formatters/noiseClassifier");
 const claudeUsageDedupe_1 = require("../usage/claudeUsageDedupe");
 const subagentUsage_1 = require("../usage/subagentUsage");
 const subagentScanner_1 = require("./subagentScanner");
+const subagentEndState_1 = require("./subagentEndState");
+const subagentSpawn_1 = require("../subagentSpawn");
+const ownKey_1 = require("../ownKey");
 // ── Constants ──
 const AGENT_FILE_PATTERN = /^agent-(.+)\.jsonl$/;
 // ── Public API ──
@@ -86,10 +92,8 @@ function scanSubagentTraces(sessionDir, sessionId) {
             if (trace)
                 traces.push(trace);
         }
-        // Link parent-child relationships
-        linkTraces(traces);
-        // Return only top-level traces (those without parents)
-        return traces.filter((t) => !t.parentToolUseId);
+        // Link parent-child relationships; returns the traces with no parent agent.
+        return linkTraces(traces);
     }
     catch {
         return [];
@@ -106,6 +110,7 @@ function parseAgentTrace(filePath, agentId) {
         let description;
         const tokens = { agentId, toolCalls: [], inputTokens: 0, outputTokens: 0 };
         const usageDeduper = new claudeUsageDedupe_1.ClaudeUsageDeduper();
+        const endTracker = new subagentEndState_1.SubagentEndTracker();
         let startTime;
         let endTime;
         for (const line of lines) {
@@ -115,6 +120,7 @@ function parseAgentTrace(filePath, agentId) {
                 if (!startTime)
                     startTime = timestamp;
                 endTime = timestamp;
+                endTracker.observe(raw);
                 // Build SessionEvent from raw JSONL
                 const sessionEvent = rawToSessionEvent(raw);
                 if (!sessionEvent)
@@ -169,8 +175,8 @@ function parseAgentTrace(filePath, agentId) {
                                 input: block.input || {},
                                 timestamp,
                             });
-                            // Extract agent info from Task tool
-                            if (block.name === 'Task' && block.input) {
+                            // Extract agent info from an Agent/Task spawn
+                            if ((0, subagentSpawn_1.isSubagentSpawnTool)(block.name) && block.input) {
                                 if (block.input.subagent_type && !agentType) {
                                     agentType = String(block.input.subagent_type);
                                 }
@@ -207,6 +213,16 @@ function parseAgentTrace(filePath, agentId) {
             agentId,
             agentType,
             description,
+            filePath,
+            ...(meta.toolUseId
+                ? { spawnToolUseId: meta.toolUseId, parentToolUseId: meta.toolUseId }
+                : {}),
+            ...(meta.parentAgentId ? { parentAgentId: meta.parentAgentId } : {}),
+            ...(meta.requestShape ? { background: meta.requestShape === 'background' } : {}),
+            ...(meta.finished !== undefined ? { finished: meta.finished } : {}),
+            ...(meta.stoppedByUser !== undefined ? { stoppedByUser: meta.stoppedByUser } : {}),
+            ...(endTime ? { lastActivityAt: endTime } : {}),
+            endedCleanly: endTracker.endedCleanly(),
             events,
             children: [],
             stats: {
@@ -223,6 +239,7 @@ function parseAgentTrace(filePath, agentId) {
                 startTime,
                 endTime,
                 durationMs,
+                endedCleanly: endTracker.endedCleanly(),
             },
         };
     }
@@ -231,23 +248,61 @@ function parseAgentTrace(filePath, agentId) {
     }
 }
 // ── Parent-Child Linking ──
+/**
+ * Nests child traces under their parents and returns the traces with no
+ * parent agent. Exact metadata links come first; the heuristics only place
+ * traces Claude Code recorded no spawn metadata for.
+ */
 function linkTraces(traces) {
     const traceById = new Map();
     for (const trace of traces) {
         traceById.set(trace.agentId, trace);
     }
-    // Phase 1: Result-based linking
-    // Look for tool_result events that contain agentId references
+    const parentOf = new Map();
+    const attach = (parent, child) => {
+        if (parent === child || parentOf.has(child))
+            return false;
+        // Never nest an agent under its own descendant (malformed metadata).
+        for (let up = parent; up; up = parentOf.get(up)) {
+            if (up === child)
+                return false;
+        }
+        parentOf.set(child, parent);
+        parent.children.push(child);
+        return true;
+    };
+    // Phase 1: the meta file names the parent agent
+    for (const child of traces) {
+        const parent = child.parentAgentId ? traceById.get(child.parentAgentId) : undefined;
+        if (parent)
+            attach(parent, child);
+    }
+    // Phase 2: the child's spawning call is in another trace
+    const spawnOwner = new Map();
     for (const trace of traces) {
-        for (const traceEvent of trace.events) {
-            const evt = traceEvent.event;
-            if (evt.type === 'tool_use' && evt.tool?.name === 'Task') {
-                // The tool_use_id from this call should appear as a result in the parent
-                // but we can link via timestamp proximity to child traces
-            }
+        for (const id of spawnToolUseIdsOf(trace)) {
+            if (!spawnOwner.has(id))
+                spawnOwner.set(id, trace);
         }
     }
-    // Phase 2: Team summary linking
+    for (const child of traces) {
+        if (parentOf.has(child) || !child.spawnToolUseId)
+            continue;
+        const parent = spawnOwner.get(child.spawnToolUseId);
+        if (parent && attach(parent, child))
+            child.parentAgentId ??= parent.agentId;
+    }
+    // Heuristic links set parentAgentId and, as before, parentToolUseId to the
+    // parent's agent id.
+    const unresolved = (trace) => !parentOf.has(trace) && !trace.spawnToolUseId && !trace.parentAgentId;
+    const linkHeuristically = (parent, child) => {
+        if (!attach(parent, child))
+            return false;
+        child.parentAgentId = parent.agentId;
+        child.parentToolUseId = parent.agentId;
+        return true;
+    };
+    // Phase 3: Team summary linking
     for (const trace of traces) {
         for (const traceEvent of trace.events) {
             const content = traceEvent.event.message?.content;
@@ -255,45 +310,56 @@ function linkTraces(traces) {
                 // Parse teammate agent IDs from XML blocks
                 const matches = content.matchAll(/agent[_-]id['":\s]+([a-f0-9]+)/gi);
                 for (const match of matches) {
-                    const childId = match[1];
-                    const child = traceById.get(childId);
-                    if (child && child !== trace && !child.parentToolUseId) {
-                        child.parentToolUseId = trace.agentId;
-                        trace.children.push(child);
-                    }
+                    const child = traceById.get(match[1]);
+                    if (child && unresolved(child))
+                        linkHeuristically(trace, child);
                 }
             }
         }
     }
-    // Phase 3: Positional fallback — timestamp proximity
+    // Phase 4: Positional fallback — timestamp proximity
     // Traces without parents that fall within another trace's time window
-    const parentless = traces.filter((t) => !t.parentToolUseId);
-    for (const child of parentless) {
+    for (const child of traces.filter(unresolved)) {
         if (!child.stats.startTime)
             continue;
         const childStart = child.stats.startTime.getTime();
-        // Find a trace that was active (Task tool call) right before this child started
+        // Find a top-level trace that spawned an agent right before this child started
         for (const potential of traces) {
-            if (potential === child)
+            if (potential === child || parentOf.has(potential))
                 continue;
-            if (potential.parentToolUseId)
-                continue; // Already linked
             for (const traceEvent of potential.events) {
                 const evt = traceEvent.event;
-                if (evt.type === 'assistant' && evt.tool?.name === 'Task') {
+                if (evt.type === 'assistant' && (0, subagentSpawn_1.isSubagentSpawnTool)(evt.tool?.name)) {
                     const taskTime = new Date(evt.timestamp).getTime();
                     // Within 2 seconds before child start
                     if (taskTime <= childStart && childStart - taskTime < 2000) {
-                        child.parentToolUseId = potential.agentId;
-                        potential.children.push(child);
+                        linkHeuristically(potential, child);
                         break;
                     }
                 }
             }
-            if (child.parentToolUseId)
+            if (parentOf.has(child))
                 break;
         }
     }
+    return traces.filter((trace) => !parentOf.has(trace));
+}
+/** Ids of the `Agent` / `Task` calls a trace made. */
+function spawnToolUseIdsOf(trace) {
+    const ids = [];
+    for (const traceEvent of trace.events) {
+        const content = traceEvent.event.message?.content;
+        if (!Array.isArray(content))
+            continue;
+        for (const block of content) {
+            if (block?.type === 'tool_use' &&
+                typeof block.id === 'string' &&
+                (0, subagentSpawn_1.isSubagentSpawnTool)(block.name)) {
+                ids.push(block.id);
+            }
+        }
+    }
+    return ids;
 }
 // ── Helpers ──
 function rawToSessionEvent(raw) {
@@ -308,7 +374,7 @@ function rawToSessionEvent(raw) {
         tool_result: 'tool_result',
         summary: 'summary',
     };
-    const mappedType = typeMap[type];
+    const mappedType = (0, ownKey_1.ownValue)(typeMap, type);
     if (!mappedType)
         return null;
     const message = raw.message;

package/dist/pricingCatalog.js

@@ -59,6 +59,7 @@ const node_fs_1 = require("node:fs");
 const path = __importStar(require("node:path"));
 const modelContext_1 = require("./modelContext");
 const modelInfo_1 = require("./modelInfo");
+const ownKey_1 = require("./ownKey");
 const paths_1 = require("./paths");
 const atomic_1 = require("./writers/atomic");
 // ── Constants ──
@@ -156,7 +157,7 @@ function normalizeLiteLlmCatalog(raw) {
             continue;
         // Catalog keys use both `provider/model` and bare `model` forms. Record both
         // the raw key and the bare-model form so lookups work regardless of caller.
-        out[key] = pricing;
+        (0, ownKey_1.setOwnValue)(out, key, pricing);
         const bare = stripProviderPrefix(key);
         if (bare && bare !== key && !out[bare]) {
             out[bare] = pricing;
@@ -193,7 +194,7 @@ function normalizeLiteLlmContextWindows(raw) {
         const window = entry.max_input_tokens;
         if (typeof window !== 'number' || !Number.isFinite(window) || window <= 0)
             continue;
-        out[key] = window;
+        (0, ownKey_1.setOwnValue)(out, key, window);
         const bare = stripProviderPrefix(key);
         if (bare && bare !== key) {
             const seen = aliasWindows.get(bare) ?? new Set();

package/dist/promptHistory.d.ts

@@ -23,8 +23,8 @@
  * the prompt is returned again under the same identity once its first
  * answering call brings model or usage (`metadataStatus` says how settled).
  */
-import * as fs from 'fs';
 import { type HumanPromptProvider } from './humanPrompt';
+import { type RolloutContentStat } from './providers/compressedRollouts';
 export type PromptHistoryProvider = HumanPromptProvider;
 export type PromptHistoryBound = 'maxSessions' | 'maxFileBytes' | 'maxTotalBytes' | 'maxEntries' | 'deadline' | 'aborted';
 export interface PromptHistoryBounds {
@@ -235,6 +235,14 @@ export interface CollectPromptHistoryOptions {
      * both modes, so a cursor written in one mode resumes in the other.
      */
     includeText?: boolean;
+    /**
+     * Codex: also scan compressed rollouts (`….jsonl.zst`, decompressed when
+     * the runtime has `zlib.zstdDecompressSync`; skipped otherwise). Offsets
+     * and sizes in the cursor are then those of the decompressed content, so
+     * a session whose rollout Codex compressed continues where it stopped.
+     * Default false.
+     */
+    includeCompressedRollouts?: boolean;
 }
 export interface PromptHistoryResult {
     /** Ordered by provider, session, then ordinal. */
@@ -375,6 +383,8 @@ export declare function resolveRoots(workspacePaths: string[], includeWorktrees:
     listingRoots: string[];
 };
 /** @internal */
-export declare function listCandidates(providers: PromptHistoryProvider[], listingRoots: string[], sinceMs: number | null): Promise<Candidate[]>;
+export declare function listCandidates(providers: PromptHistoryProvider[], listingRoots: string[], sinceMs: number | null, options?: {
+    includeCompressedRollouts?: boolean;
+}): Promise<Candidate[]>;
 /** @internal */
-export declare function scanFile(candidate: Candidate, stat: fs.Stats, prior: PromptHistoryCursorSession | undefined, budget: FileBudget, context: ScanContext): Promise<FileOutcome>;
+export declare function scanFile(candidate: Candidate, fileStat: RolloutContentStat, prior: PromptHistoryCursorSession | undefined, budget: FileBudget, context: ScanContext): Promise<FileOutcome>;

package/dist/promptHistory.js

@@ -69,11 +69,11 @@ exports.resolveRoots = resolveRoots;
 exports.listCandidates = listCandidates;
 exports.scanFile = scanFile;
 const crypto_1 = require("crypto");
-const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const humanPrompt_1 = require("./humanPrompt");
 const claudeListing_1 = require("./providers/claudeListing");
 const codexRollouts_1 = require("./providers/codexRollouts");
+const compressedRollouts_1 = require("./providers/compressedRollouts");
 const directoryListingCache_1 = require("./providers/directoryListingCache");
 const workspaceRoots_1 = require("./workspaceRoots");
 const fileHead_1 = require("./fileHead");
@@ -150,7 +150,9 @@ async function collectPromptHistory(options) {
         return finish();
     const sinceMs = options.since ? options.since.getTime() : null;
     const providers = options.providers ?? ALL_PROVIDERS;
-    const candidates = rotate(await listCandidates(providers, listingRoots, sinceMs), previousNext);
+    const candidates = rotate(await listCandidates(providers, listingRoots, sinceMs, {
+        includeCompressedRollouts: options.includeCompressedRollouts,
+    }), previousNext);
     const moved = movedSessionKeys(previous, candidates);
     const context = {
         roots,
@@ -186,7 +188,8 @@ async function collectPromptHistory(options) {
         }
         let stat;
         try {
-            stat = await fs.promises.stat(candidate.filePath);
+            // A compressed rollout's size is its decompressed content's.
+            stat = await (0, compressedRollouts_1.statRolloutContent)(candidate.filePath);
         }
         catch {
             continue;
@@ -291,7 +294,7 @@ async function collectPromptHistory(options) {
  */
 async function readPromptOrdinalMarks(provider, sessionId, filePath) {
     const marks = [];
-    const stat = await fs.promises.stat(filePath);
+    const stat = await (0, compressedRollouts_1.statRolloutContent)(filePath);
     const unbounded = Number.MAX_SAFE_INTEGER;
     const context = {
         roots: [],
@@ -480,19 +483,24 @@ function scopedCwd(cwd, roots, realpaths) {
     return null;
 }
 /** @internal */
-async function listCandidates(providers, listingRoots, sinceMs) {
+async function listCandidates(providers, listingRoots, sinceMs, options = {}) {
     const byPath = new Map();
     const listOptions = sinceMs !== null ? { since: sinceMs } : {};
     for (const provider of [...new Set(providers)]) {
         if (!ALL_PROVIDERS.includes(provider))
             continue;
         // Listings are only candidate supersets; scope is re-checked per prompt.
-        const list = provider === 'claude-code' ? claudeListing_1.listClaudeSessionFilesAsync : codexRollouts_1.listCodexSessionFilesAsync;
         const cache = new directoryListingCache_1.DirectoryListingCache();
         for (const root of listingRoots) {
             let files;
             try {
-                files = await list(root, listOptions, cache);
+                files =
+                    provider === 'claude-code'
+                        ? await (0, claudeListing_1.listClaudeSessionFilesAsync)(root, listOptions, cache)
+                        : await (0, codexRollouts_1.listCodexSessionFilesAsync)(root, {
+                            ...listOptions,
+                            includeCompressed: options.includeCompressedRollouts === true && (0, compressedRollouts_1.canReadCompressedRollouts)(),
+                        }, cache);
             }
             catch {
                 files = [];
@@ -514,11 +522,11 @@ async function listCandidates(providers, listingRoots, sinceMs) {
         compareStrings(left.sessionId, right.sessionId) ||
         compareStrings(left.key, right.key));
 }
-/** True when the file's first bytes still match a recorded head. */
+/** True when the file's first bytes (a compressed rollout's content) still match a recorded head. */
 async function fileStartsWith(filePath, head) {
     let handle;
     try {
-        handle = await fs.promises.open(filePath, 'r');
+        ({ handle } = await (0, compressedRollouts_1.openRolloutReadHandle)(filePath));
         return (0, fileHead_1.headMatches)(head, await readAt(handle, 0, Math.min(fileHead_1.HEAD_BYTES, head.bytes)));
     }
     catch {
@@ -591,8 +599,11 @@ async function verifyFile(handle, size, session) {
     return { head: (0, fileHead_1.fileHeadOf)(head), bytesRead };
 }
 /** @internal */
-async function scanFile(candidate, stat, prior, budget, context) {
-    const handle = await fs.promises.open(candidate.filePath, 'r');
+async function scanFile(candidate, fileStat, prior, budget, context) {
+    // A compressed rollout is scanned over its decompressed content.
+    const opened = await (0, compressedRollouts_1.openRolloutReadHandle)(candidate.filePath);
+    const handle = opened.handle;
+    const stat = opened.size === null ? fileStat : { size: opened.size, mtimeMs: fileStat.mtimeMs };
     try {
         let bytesRead = 0;
         const verified = await verifyFile(handle, stat.size, prior);