sidekick-shared 0.27.6 → 0.28.1

package/dist/esm/promptHistory.js

@@ -0,0 +1,1221 @@
+/**
+ * Node-only collection of human-typed prompts from Claude Code and Codex
+ * session logs, scoped to a set of workspace roots.
+ *
+ * Parse-only: no redaction and no network I/O. Scope fails closed — a prompt
+ * is returned only when the working directory recorded on its log line (or,
+ * for Codex, its session/turn context) realpath-resolves to an allowed root
+ * or somewhere inside one. Every bound stops cleanly and is reported in
+ * `boundsHit`; nothing is silently truncated and no bound throws.
+ *
+ * Files are streamed in fixed-size chunks and every pass stops at a complete
+ * line, so a large or busy log is read across several calls: the cursor holds
+ * where each file stopped and the next call continues from there. A single
+ * record over `maxRecordBytes` is skipped without being buffered and reported
+ * in `exclusions`, the only way a record is permanently left out.
+ *
+ * A prompt can be written before its answer. The cursor then keeps the byte
+ * offset of that prompt's line and its answer-tracking state (never text), and
+ * the prompt is returned again under the same identity once its first
+ * answering call brings model or usage (`metadataStatus` says how settled).
+ */
+import { createHash } from 'crypto';
+import * as fs from 'fs';
+import * as path from 'path';
+import { HUMAN_CODEX_SOURCES, humanPromptText } from './humanPrompt';
+import { listClaudeSessionFilesAsync } from './providers/claudeListing';
+import { listCodexSessionFilesAsync } from './providers/codexRollouts';
+import { DirectoryListingCache } from './providers/directoryListingCache';
+import { realpathOrNull, resolveWorkspaceRoots } from './workspaceRoots';
+import { fileHeadOf, HEAD_BYTES, headMatches } from './fileHead';
+/** @internal */
+export const DEFAULT_BOUNDS = {
+    maxSessions: 1000,
+    maxFileBytes: 16 * 1024 * 1024,
+    maxTotalBytes: 256 * 1024 * 1024,
+    maxRecordBytes: 16 * 1024 * 1024,
+    maxEntries: 10_000,
+    deadlineMs: 30_000,
+};
+const DEFAULT_READ_CHUNK_BYTES = 1024 * 1024;
+const MAX_EXCLUSIONS = 1000;
+const CHECK_EVERY_LINES = 500;
+const ALL_PROVIDERS = ['claude-code', 'codex'];
+let readChunkBytes = DEFAULT_READ_CHUNK_BYTES;
+/** Test hooks; not part of the public entry points. */
+export const __promptHistoryTesting = {
+    setReadChunkBytes(bytes) {
+        readChunkBytes = bytes === null ? DEFAULT_READ_CHUNK_BYTES : Math.max(1, Math.floor(bytes));
+    },
+};
+/** Collect human-typed prompts from Claude Code and Codex logs under the given roots. */
+export async function collectPromptHistory(options) {
+    const bounds = { ...DEFAULT_BOUNDS, ...definedBounds(options.bounds) };
+    const startedAt = Date.now();
+    const boundsHit = new Set();
+    const stats = emptyStats();
+    const { sessions: previous, next: previousNext } = acceptedCursor(options.cursor);
+    const cursor = { version: 3, sessions: { ...previous } };
+    const entries = [];
+    const exclusions = [];
+    const changed = new Map();
+    let hasMore = false;
+    let progressed = false;
+    let scannedRoots = [];
+    const markChanged = (candidate) => {
+        changed.set(candidate.key, {
+            provider: candidate.provider,
+            sessionId: candidate.sessionId,
+            sessionKey: candidate.key,
+        });
+    };
+    const shouldStop = () => {
+        if (options.signal?.aborted)
+            return 'aborted';
+        if (Date.now() - startedAt >= bounds.deadlineMs)
+            return 'deadline';
+        return null;
+    };
+    const finish = () => ({
+        entries: entries.sort(compareEntries),
+        cursor,
+        stats,
+        boundsHit: [...boundsHit],
+        exclusions,
+        hasMore,
+        changed: [...changed.values()],
+        progressed,
+        roots: scannedRoots,
+    });
+    const realpaths = new Map();
+    const { roots, listingRoots } = resolveRoots(options.workspacePaths, options.includeWorktrees !== false, realpaths);
+    scannedRoots = roots;
+    if (roots.length === 0)
+        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 moved = movedSessionKeys(previous, candidates);
+    const context = {
+        roots,
+        sinceMs,
+        stats,
+        realpaths,
+        bounds,
+        shouldStop,
+        entriesSoFar: () => entries.length,
+        exclude: (exclusion) => {
+            if (exclusions.length < MAX_EXCLUSIONS)
+                exclusions.push(exclusion);
+        },
+    };
+    let totalBytes = 0;
+    let scannedAny = false;
+    // A call-wide stop remembers where it stopped so the next call starts there.
+    const stopAt = (candidate, bound) => {
+        boundsHit.add(bound);
+        cursor.next = candidate.key;
+        hasMore = true;
+    };
+    for (const candidate of candidates) {
+        const stop = shouldStop();
+        if (stop) {
+            stopAt(candidate, stop);
+            break;
+        }
+        if (scannedAny && entries.length >= bounds.maxEntries) {
+            stopAt(candidate, 'maxEntries');
+            break;
+        }
+        let stat;
+        try {
+            stat = await fs.promises.stat(candidate.filePath);
+        }
+        catch {
+            continue;
+        }
+        let prior = validSession(previous[candidate.key]);
+        const sessionRef = `${candidate.provider}:${candidate.sessionId}`;
+        const movedFrom = prior ? undefined : moved.get(sessionRef);
+        const carried = movedFrom ? validSession(previous[movedFrom]) : undefined;
+        // The same session under a new path (Codex archives a thread by moving its
+        // rollout): carry the entry over, but only when the new file starts with
+        // the recorded head. Another file that merely shares the id (an unlisted
+        // file is not necessarily gone) keeps its own entry and is read as new.
+        if (movedFrom && carried?.head && (await fileStartsWith(candidate.filePath, carried.head))) {
+            moved.delete(sessionRef);
+            prior = carried;
+            delete cursor.sessions[movedFrom];
+            cursor.sessions[candidate.key] = carried;
+            markChanged(candidate);
+        }
+        if (prior && isSettled(prior) && prior.size === stat.size && prior.mtimeMs === stat.mtimeMs) {
+            stats.sessionsSkippedUnchanged++;
+            continue;
+        }
+        if (stats.sessionsScanned >= bounds.maxSessions) {
+            stopAt(candidate, 'maxSessions');
+            break;
+        }
+        const remainingTotal = bounds.maxTotalBytes - totalBytes;
+        if (scannedAny && remainingTotal <= 0) {
+            stopAt(candidate, 'maxTotalBytes');
+            break;
+        }
+        const budget = bounds.maxFileBytes <= remainingTotal
+            ? { bytes: bounds.maxFileBytes, bound: 'maxFileBytes', forceProgress: !scannedAny }
+            : {
+                bytes: Math.max(0, remainingTotal),
+                bound: 'maxTotalBytes',
+                forceProgress: !scannedAny,
+            };
+        stats.sessionsScanned++;
+        scannedAny = true;
+        let outcome;
+        try {
+            outcome = await scanFile(candidate, stat, prior, budget, context);
+        }
+        catch {
+            continue;
+        }
+        totalBytes += outcome.bytesRead;
+        for (const entry of outcome.entries)
+            entry.sessionKey = candidate.key;
+        entries.push(...outcome.entries);
+        if (outcome.progressed)
+            progressed = true;
+        if (!outcome.session ||
+            JSON.stringify(outcome.session) !== JSON.stringify(previous[candidate.key])) {
+            markChanged(candidate);
+        }
+        if (outcome.notInteractive)
+            stats.sessionsNotInteractive++;
+        else if (outcome.inScope === 0 && outcome.outOfScope > 0)
+            stats.sessionsOutOfScope++;
+        if (outcome.session) {
+            cursor.sessions[candidate.key] = outcome.session;
+            if (outcome.session.backlog)
+                stats.sessionsWithBacklog++;
+        }
+        else {
+            // Rewritten under us: forget the file so the next call reads it from the start.
+            delete cursor.sessions[candidate.key];
+            stats.sessionsRewritten++;
+            hasMore = true;
+        }
+        if (outcome.stoppedBy === 'maxFileBytes' && outcome.progressed) {
+            // Per-file budget: move on so one large file cannot starve the others.
+            boundsHit.add('maxFileBytes');
+            stats.filesOverSizeLimit++;
+            hasMore = true;
+        }
+        else if (outcome.stoppedBy) {
+            // A file that could not move within its budget starts the next call, where
+            // the first file may always finish its first record.
+            if (outcome.stoppedBy === 'maxFileBytes')
+                stats.filesOverSizeLimit++;
+            stopAt(candidate, outcome.stoppedBy);
+            break;
+        }
+        await yieldToEventLoop();
+    }
+    return finish();
+}
+/** @internal */
+export function emptyStats() {
+    return {
+        sessionsScanned: 0,
+        sessionsSkippedUnchanged: 0,
+        sessionsOutOfScope: 0,
+        filesOverSizeLimit: 0,
+        sessionsWithBacklog: 0,
+        sessionsRewritten: 0,
+        sessionsNotInteractive: 0,
+        recordsOverSizeLimit: 0,
+        recordsMalformed: 0,
+        promptsMissingTimestamp: 0,
+        promptsOutOfScope: 0,
+    };
+}
+function definedBounds(bounds) {
+    const result = {};
+    if (!bounds)
+        return result;
+    for (const key of Object.keys(DEFAULT_BOUNDS)) {
+        const value = bounds[key];
+        if (typeof value === 'number' && !Number.isNaN(value))
+            result[key] = Math.max(0, value);
+    }
+    return result;
+}
+function acceptedCursor(cursor) {
+    if (!cursor || ![1, 2, 3].includes(cursor.version))
+        return { sessions: {} };
+    const sessions = cursor.sessions;
+    return {
+        sessions: typeof sessions === 'object' && sessions !== null
+            ? sessions
+            : {},
+        ...(typeof cursor.next === 'string' ? { next: cursor.next } : {}),
+    };
+}
+function isOffset(value) {
+    return typeof value === 'number' && Number.isInteger(value) && value >= 0;
+}
+function validSession(session) {
+    if (!session || typeof session !== 'object')
+        return undefined;
+    const valid = isOffset(session.offset) &&
+        Number.isInteger(session.lastOrdinal) &&
+        session.lastOrdinal >= -1 &&
+        typeof session.size === 'number' &&
+        typeof session.mtimeMs === 'number';
+    return valid ? session : undefined;
+}
+/**
+ * True when a cursor entry's last pass reached the end of its file with no
+ * prompt still waiting for its answer: an unchanged file needs no read.
+ */
+export function isPromptHistorySessionSettled(session) {
+    return validSession(session) !== undefined && isSettled(session);
+}
+/**
+ * Validates a stored cursor (versions 1 to 3). Returns it as a version-3
+ * cursor with malformed session entries dropped, or undefined when it is
+ * not a cursor at all.
+ */
+export function parsePromptHistoryCursor(value) {
+    if (!value || typeof value !== 'object')
+        return undefined;
+    const candidate = value;
+    if (typeof candidate.version !== 'number' || ![1, 2, 3].includes(candidate.version)) {
+        return undefined;
+    }
+    const { sessions, next } = acceptedCursor(value);
+    const valid = {};
+    for (const [key, session] of Object.entries(sessions)) {
+        if (validSession(session))
+            valid[key] = session;
+    }
+    return { version: 3, sessions: valid, ...(next !== undefined ? { next } : {}) };
+}
+/** A session whose last pass reached the end and needs no migration. */
+function isSettled(session) {
+    if (session.backlog || session.skipping)
+        return false;
+    if (session.state?.excluded)
+        return true;
+    if (!session.head)
+        return false;
+    return !session.pending || session.pending.answer !== undefined;
+}
+function resumePlan(session) {
+    if (!session)
+        return { kind: 'fresh' };
+    const pending = session.pending;
+    if (!pending)
+        return { kind: 'continue', session };
+    const basic = Number.isInteger(pending.ordinal) &&
+        pending.ordinal === session.lastOrdinal &&
+        isOffset(pending.offset) &&
+        pending.offset <= session.offset &&
+        typeof pending.emitted === 'string';
+    if (!basic)
+        return { kind: 'continue', session };
+    const answer = pending.answer;
+    if (answer === undefined) {
+        return session.skipping ? { kind: 'continue', session } : { kind: 'replay', session, pending };
+    }
+    const carried = typeof answer === 'object' &&
+        answer !== null &&
+        (answer.status === 'pending' || answer.status === 'provisional') &&
+        isOffset(pending.lineBytes) &&
+        pending.offset + pending.lineBytes < session.offset &&
+        typeof pending.timestamp === 'string';
+    return carried ? { kind: 'continue', session, carried: pending } : { kind: 'continue', session };
+}
+/** Digest of what a consumer would store for an entry besides its identity and text. */
+function metadataDigest(entry) {
+    const usage = entry.usage
+        ? [
+            entry.usage.inputTokens ?? null,
+            entry.usage.outputTokens ?? null,
+            entry.usage.cacheReadTokens ?? null,
+            entry.usage.cacheWriteTokens ?? null,
+        ]
+        : null;
+    return createHash('sha256')
+        .update(JSON.stringify([entry.model ?? null, usage, entry.metadataStatus]))
+        .digest('hex')
+        .slice(0, 16);
+}
+function compareEntries(left, right) {
+    return (compareStrings(left.provider, right.provider) ||
+        compareStrings(left.sessionId, right.sessionId) ||
+        left.ordinal - right.ordinal);
+}
+/** @internal */
+export function compareStrings(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}
+function rotate(candidates, nextKey) {
+    const index = nextKey ? candidates.findIndex((candidate) => candidate.key === nextKey) : -1;
+    return index <= 0 ? candidates : [...candidates.slice(index), ...candidates.slice(0, index)];
+}
+/** @internal */
+export function resolveRoots(workspacePaths, includeWorktrees, realpaths) {
+    return resolveWorkspaceRoots(workspacePaths, { includeWorktrees }, realpaths);
+}
+/** Fail-closed scope check on a recorded working directory. */
+function scopedCwd(cwd, roots, realpaths) {
+    if (typeof cwd !== 'string' || cwd.length === 0)
+        return null;
+    const real = realpathOrNull(cwd, realpaths);
+    if (!real)
+        return null;
+    for (const root of roots) {
+        if (real === root)
+            return real;
+        const prefix = root.endsWith(path.sep) ? root : root + path.sep;
+        if (real.startsWith(prefix))
+            return real;
+    }
+    return null;
+}
+/** @internal */
+export async function listCandidates(providers, listingRoots, sinceMs) {
+    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' ? listClaudeSessionFilesAsync : listCodexSessionFilesAsync;
+        const cache = new DirectoryListingCache();
+        for (const root of listingRoots) {
+            let files;
+            try {
+                files = await list(root, listOptions, cache);
+            }
+            catch {
+                files = [];
+            }
+            for (const file of files) {
+                if (byPath.has(file.path))
+                    continue;
+                const sessionId = file.sessionId ?? path.basename(file.path, '.jsonl');
+                byPath.set(file.path, {
+                    provider,
+                    sessionId,
+                    filePath: file.path,
+                    key: `${provider}:${sessionId}:${hashPath(file.path)}`,
+                });
+            }
+        }
+    }
+    return [...byPath.values()].sort((left, right) => compareStrings(left.provider, right.provider) ||
+        compareStrings(left.sessionId, right.sessionId) ||
+        compareStrings(left.key, right.key));
+}
+/** True when the file's first bytes still match a recorded head. */
+async function fileStartsWith(filePath, head) {
+    let handle;
+    try {
+        handle = await fs.promises.open(filePath, 'r');
+        return headMatches(head, await readAt(handle, 0, Math.min(HEAD_BYTES, head.bytes)));
+    }
+    catch {
+        return false;
+    }
+    finally {
+        await handle?.close();
+    }
+}
+/**
+ * Cursor entries whose file is no longer listed, by `provider:sessionId`, for
+ * sessions that are listed again under another path.
+ */
+function movedSessionKeys(previous, candidates) {
+    const listedKeys = new Set(candidates.map((candidate) => candidate.key));
+    const listedIds = new Set(candidates.map((candidate) => `${candidate.provider}:${candidate.sessionId}`));
+    const moved = new Map();
+    for (const [key, value] of Object.entries(previous)) {
+        if (listedKeys.has(key))
+            continue;
+        const session = validSession(value);
+        if (!session)
+            continue;
+        const id = `${session.provider}:${session.sessionId}`;
+        if (listedIds.has(id) && !moved.has(id))
+            moved.set(id, key);
+    }
+    return moved;
+}
+function hashPath(filePath) {
+    return createHash('sha256').update(filePath).digest('hex').slice(0, 12);
+}
+async function readAt(handle, offset, length) {
+    const buffer = Buffer.alloc(length);
+    let read = 0;
+    while (read < length) {
+        const { bytesRead } = await handle.read(buffer, read, length - read, offset + read);
+        if (bytesRead === 0)
+            break;
+        read += bytesRead;
+    }
+    return read === length ? buffer : buffer.subarray(0, read);
+}
+function yieldToEventLoop() {
+    return new Promise((resolve) => setImmediate(resolve));
+}
+/**
+ * Checks that the prefix and resume point recorded for a file still hold.
+ * Returns the head to store, or null when the file was truncated or rewritten.
+ */
+async function verifyFile(handle, size, session) {
+    const headBytes = Math.min(HEAD_BYTES, size);
+    const head = await readAt(handle, 0, headBytes);
+    let bytesRead = head.length;
+    if (head.length !== headBytes)
+        return null;
+    if (session) {
+        if (session.offset > size)
+            return null;
+        const known = session.head;
+        if (known && !headMatches(known, head))
+            return null;
+        if (session.offset > 0 && !session.skipping) {
+            const before = await readAt(handle, session.offset - 1, 1);
+            bytesRead += before.length;
+            if (before.length !== 1 || before[0] !== 0x0a)
+                return null;
+        }
+    }
+    return { head: fileHeadOf(head), bytesRead };
+}
+/** @internal */
+export async function scanFile(candidate, stat, prior, budget, context) {
+    const handle = await fs.promises.open(candidate.filePath, 'r');
+    try {
+        let bytesRead = 0;
+        const verified = await verifyFile(handle, stat.size, prior);
+        let plan = resumePlan(prior);
+        let head = verified?.head;
+        if (verified) {
+            bytesRead += verified.bytesRead;
+        }
+        else {
+            // Offsets and ordinals of a rewritten file are meaningless: start over.
+            if (prior)
+                context.stats.sessionsRewritten++;
+            plan = { kind: 'fresh' };
+            const fresh = await verifyFile(handle, stat.size, undefined);
+            if (!fresh)
+                throw new Error('file changed while reading');
+            bytesRead += fresh.bytesRead;
+            head = fresh.head;
+        }
+        const session = plan.kind === 'fresh' ? undefined : plan.session;
+        if (session?.state?.excluded) {
+            return {
+                entries: [],
+                progressed: true,
+                session: {
+                    provider: candidate.provider,
+                    sessionId: candidate.sessionId,
+                    size: stat.size,
+                    mtimeMs: stat.mtimeMs,
+                    lastOrdinal: session.lastOrdinal,
+                    offset: stat.size,
+                    state: session.state,
+                    ...(head ? { head } : {}),
+                },
+                bytesRead,
+                stoppedBy: null,
+                notInteractive: true,
+                inScope: 0,
+                outOfScope: 0,
+            };
+        }
+        const scanner = candidate.provider === 'claude-code'
+            ? new ClaudeLineScanner(candidate, plan, context)
+            : new CodexLineScanner(candidate, plan, context);
+        const startOffset = plan.kind === 'fresh'
+            ? 0
+            : plan.kind === 'replay'
+                ? plan.pending.offset
+                : plan.session.offset;
+        const stream = await streamLines(handle, startOffset, stat.size, plan.kind === 'continue' && plan.session.skipping === true, budget, context, candidate, scanner);
+        bytesRead += stream.bytesRead;
+        if (stream.excluded) {
+            return {
+                entries: [],
+                progressed: true,
+                session: {
+                    provider: candidate.provider,
+                    sessionId: candidate.sessionId,
+                    size: stat.size,
+                    mtimeMs: stat.mtimeMs,
+                    lastOrdinal: scanner.lastOrdinal(),
+                    offset: stat.size,
+                    state: scanner.resumeState() ?? { excluded: true },
+                    ...(head ? { head } : {}),
+                },
+                bytesRead,
+                stoppedBy: null,
+                notInteractive: true,
+                inScope: 0,
+                outOfScope: 0,
+            };
+        }
+        const update = await scanner.carriedUpdate(handle);
+        bytesRead += update.bytesRead;
+        if (update.rewritten) {
+            return {
+                entries: [],
+                progressed: false,
+                session: undefined,
+                bytesRead,
+                stoppedBy: null,
+                notInteractive: false,
+                inScope: 0,
+                outOfScope: 0,
+            };
+        }
+        const entries = scanner.returnedEntries();
+        if (update.entry)
+            entries.push(update.entry);
+        const state = scanner.resumeState();
+        const pending = scanner.pendingPrompt();
+        // A truncated read also keeps a backlog, so the next call re-verifies the file.
+        const backlog = stream.offset < stat.size && (stream.stoppedBy !== null || stream.truncated);
+        return {
+            entries,
+            progressed: stream.offset > startOffset || stream.skipping,
+            session: {
+                provider: candidate.provider,
+                sessionId: candidate.sessionId,
+                size: stat.size,
+                mtimeMs: stat.mtimeMs,
+                lastOrdinal: scanner.lastOrdinal(),
+                offset: stream.offset,
+                ...(state ? { state } : {}),
+                ...(pending ? { pending } : {}),
+                ...(backlog ? { backlog: true } : {}),
+                ...(stream.skipping ? { skipping: true } : {}),
+                ...(head ? { head } : {}),
+            },
+            bytesRead,
+            stoppedBy: backlog ? stream.stoppedBy : null,
+            notInteractive: false,
+            inScope: scanner.inScopeCount(),
+            outOfScope: scanner.outOfScopeCount(),
+        };
+    }
+    finally {
+        await handle.close();
+    }
+}
+/**
+ * Feeds complete JSONL lines from `[start, end)` to the scanner in fixed-size
+ * chunks. Lines split only at `\n`, which never occurs inside a multi-byte
+ * UTF-8 sequence, so decoding whole lines is exact whatever the chunk edges.
+ * A line longer than `maxRecordBytes` is dropped as it streams past.
+ */
+async function streamLines(handle, start, end, resumeSkipping, budget, context, candidate, scanner) {
+    const { maxRecordBytes, maxEntries } = context.bounds;
+    const chunk = Buffer.allocUnsafe(Math.max(1, Math.min(readChunkBytes, end - start || 1)));
+    let position = start;
+    let committed = start;
+    let lineStart = start;
+    let skipping = resumeSkipping;
+    let pieces = [];
+    let pieceBytes = 0;
+    let bytesRead = 0;
+    let lines = 0;
+    let stoppedBy = null;
+    let truncated = false;
+    // The first file of a call always finishes its first record, so no budget can stall it.
+    const mayStop = () => !(budget.forceProgress && committed === start && !skipping);
+    const result = (excluded = false) => ({
+        offset: skipping ? position : committed,
+        skipping,
+        bytesRead,
+        stoppedBy,
+        truncated,
+        excluded,
+    });
+    while (position < end) {
+        const stop = context.shouldStop();
+        if (stop) {
+            stoppedBy = stop;
+            break;
+        }
+        const allowance = budget.bytes - bytesRead;
+        if (allowance <= 0 && mayStop()) {
+            stoppedBy = budget.bound;
+            break;
+        }
+        const want = Math.min(chunk.length, end - position, allowance > 0 ? allowance : chunk.length);
+        const { bytesRead: got } = await handle.read(chunk, 0, want, position);
+        if (got === 0) {
+            // Truncated while reading; the next call's verification sees the rewrite.
+            truncated = true;
+            break;
+        }
+        bytesRead += got;
+        const view = chunk.subarray(0, got);
+        let index = 0;
+        while (index < got) {
+            const newline = view.indexOf(0x0a, index);
+            const segmentEnd = newline === -1 ? got : newline;
+            if (!skipping) {
+                const segmentBytes = segmentEnd - index;
+                if (pieceBytes + segmentBytes > maxRecordBytes) {
+                    skipping = true;
+                    pieces = [];
+                    pieceBytes = 0;
+                    context.stats.recordsOverSizeLimit++;
+                    context.exclude({
+                        provider: candidate.provider,
+                        sessionId: candidate.sessionId,
+                        reason: 'oversizedRecord',
+                        offset: lineStart,
+                    });
+                }
+                else if (newline === -1 && segmentBytes > 0) {
+                    // The chunk buffer is reused, so a partial line keeps a copy.
+                    pieces.push(Buffer.from(view.subarray(index, segmentEnd)));
+                    pieceBytes += segmentBytes;
+                }
+            }
+            if (newline === -1)
+                break;
+            if (skipping) {
+                skipping = false;
+            }
+            else {
+                let line;
+                if (pieces.length === 0) {
+                    line = view.toString('utf8', index, newline);
+                }
+                else {
+                    pieces.push(view.subarray(index, newline));
+                    line = Buffer.concat(pieces).toString('utf8');
+                }
+                const lineOffset = lineStart;
+                const lineBytes = position + newline - lineStart;
+                if (acceptLine(line, lineOffset, lineBytes, scanner, context, candidate) === 'excluded') {
+                    committed = position + newline + 1;
+                    return result(true);
+                }
+            }
+            pieces = [];
+            pieceBytes = 0;
+            index = newline + 1;
+            committed = position + index;
+            lineStart = committed;
+            lines++;
+            if (mayStop() && context.entriesSoFar() + scanner.entryCount() >= maxEntries) {
+                stoppedBy = 'maxEntries';
+                position += index;
+                return result();
+            }
+            if (lines % CHECK_EVERY_LINES === 0) {
+                await yieldToEventLoop();
+                const stop = context.shouldStop();
+                if (stop) {
+                    stoppedBy = stop;
+                    position += index;
+                    return result();
+                }
+            }
+        }
+        position += got;
+    }
+    return result();
+}
+function acceptLine(line, lineOffset, lineBytes, scanner, context, candidate) {
+    if (!line.trim())
+        return 'ok';
+    let record;
+    try {
+        record = JSON.parse(line);
+    }
+    catch {
+        context.stats.recordsMalformed++;
+        context.exclude({
+            provider: candidate.provider,
+            sessionId: candidate.sessionId,
+            reason: 'malformedRecord',
+            offset: lineOffset,
+        });
+        return 'ok';
+    }
+    if (typeof record !== 'object' || record === null)
+        return 'ok';
+    const row = record;
+    const accepted = scanner.accept(row, lineOffset, lineBytes);
+    if (accepted === 'ok' && context.observe) {
+        context.observe(row, { ordinal: scanner.lastOrdinal(), lineOffset });
+    }
+    return accepted;
+}
+/** Shared per-file prompt bookkeeping for both providers. */
+class LineScanner {
+    candidate;
+    context;
+    entries = [];
+    nextOrdinal;
+    inScope = 0;
+    outOfScope = 0;
+    /** Latest emitted prompt still collecting answer metadata. */
+    open = null;
+    /** The carried prompt once it has been closed during this pass. */
+    closedCarried = null;
+    /** Version 2 replay: the prompt already returned with this digest is not returned again. */
+    suppress = null;
+    constructor(candidate, plan, context) {
+        this.candidate = candidate;
+        this.context = context;
+        if (plan.kind === 'fresh') {
+            this.nextOrdinal = 0;
+        }
+        else if (plan.kind === 'replay') {
+            this.nextOrdinal = plan.pending.ordinal;
+            this.suppress = { ordinal: plan.pending.ordinal, emitted: plan.pending.emitted };
+        }
+        else {
+            this.nextOrdinal = plan.session.lastOrdinal + 1;
+            const carried = plan.carried;
+            if (carried?.answer &&
+                carried.lineBytes !== undefined &&
+                carried.lineBytes <= context.bounds.maxRecordBytes &&
+                carried.timestamp !== undefined) {
+                const answer = carried.answer;
+                const usage = answer.usage ? compactUsage(answer.usage) : undefined;
+                this.open = {
+                    entry: {
+                        provider: candidate.provider,
+                        sessionId: candidate.sessionId,
+                        ordinal: carried.ordinal,
+                        timestamp: carried.timestamp,
+                        text: '',
+                        cwd: '',
+                        ...(typeof answer.model === 'string' ? { model: answer.model } : {}),
+                        ...(usage ? { usage } : {}),
+                        metadataStatus: answer.status,
+                    },
+                    lineOffset: carried.offset,
+                    lineBytes: carried.lineBytes,
+                    ...(carried.state ? { stateBefore: { ...carried.state } } : {}),
+                    answerId: typeof answer.id === 'string' ? answer.id : null,
+                    carried: { emitted: carried.emitted },
+                };
+            }
+        }
+    }
+    resumeState() {
+        return undefined;
+    }
+    lastOrdinal() {
+        return this.nextOrdinal - 1;
+    }
+    entryCount() {
+        return this.entries.length;
+    }
+    inScopeCount() {
+        return this.inScope;
+    }
+    outOfScopeCount() {
+        return this.outOfScope;
+    }
+    returnedEntries() {
+        const suppress = this.suppress;
+        if (!suppress)
+            return [...this.entries];
+        // A replayed prompt is returned again only when its metadata changed.
+        return this.entries.filter((entry) => entry.ordinal !== suppress.ordinal || metadataDigest(entry) !== suppress.emitted);
+    }
+    pendingPrompt() {
+        const open = this.open;
+        if (!open)
+            return undefined;
+        const entry = open.entry;
+        const status = entry.metadataStatus === 'provisional' ? 'provisional' : 'pending';
+        const answer = {
+            status,
+            ...(open.answerId !== null ? { id: open.answerId } : {}),
+            ...(entry.model ? { model: entry.model } : {}),
+            ...(entry.usage ? { usage: { ...entry.usage } } : {}),
+        };
+        return {
+            ordinal: entry.ordinal,
+            offset: open.lineOffset,
+            lineBytes: open.lineBytes,
+            timestamp: entry.timestamp,
+            emitted: metadataDigest(entry),
+            ...(open.stateBefore ? { state: { ...open.stateBefore } } : {}),
+            answer,
+        };
+    }
+    /**
+     * The carried prompt returned again when its metadata changed in this pass.
+     * Its text is re-read from its own line, which must still match exactly.
+     */
+    async carriedUpdate(handle) {
+        const carried = this.closedCarried ?? (this.open?.carried ? this.open : null);
+        if (!carried?.carried)
+            return { bytesRead: 0, rewritten: false };
+        const entry = carried.entry;
+        if (metadataDigest(entry) === carried.carried.emitted)
+            return { bytesRead: 0, rewritten: false };
+        const raw = await readAt(handle, carried.lineOffset, carried.lineBytes + 1);
+        const rewritten = { bytesRead: raw.length, rewritten: true };
+        if (raw.length !== carried.lineBytes + 1 || raw[carried.lineBytes] !== 0x0a)
+            return rewritten;
+        let record;
+        try {
+            record = JSON.parse(raw.toString('utf8', 0, carried.lineBytes));
+        }
+        catch {
+            return rewritten;
+        }
+        if (typeof record !== 'object' || record === null)
+            return rewritten;
+        const row = record;
+        const text = this.promptTextOf(row);
+        if (text === null || row.timestamp !== entry.timestamp)
+            return rewritten;
+        const place = this.promptPlaceOf(row, carried.stateBefore);
+        const scoped = scopedCwd(place.cwd, this.context.roots, this.context.realpaths);
+        if (!scoped) {
+            // The directory no longer resolves inside the roots: fail closed.
+            this.context.stats.promptsOutOfScope++;
+            return { bytesRead: raw.length, rewritten: false };
+        }
+        if (carried === this.open)
+            carried.carried = { emitted: metadataDigest(entry) };
+        return {
+            entry: {
+                ...entry,
+                text,
+                cwd: scoped,
+                ...(place.gitBranch ? { gitBranch: place.gitBranch } : {}),
+                ...(entry.usage ? { usage: { ...entry.usage } } : {}),
+            },
+            bytesRead: raw.length,
+            rewritten: false,
+        };
+    }
+    /** The open prompt's answer is complete, or will never arrive. */
+    closeOpen() {
+        const open = this.open;
+        if (!open)
+            return;
+        open.entry.metadataStatus = 'final';
+        if (open.carried)
+            this.closedCarried = open;
+        this.open = null;
+    }
+    /** Assign an ordinal to a human prompt and emit it when in scope. */
+    recordPrompt(text, timestamp, cwd, gitBranch, lineOffset, lineBytes, stateBefore) {
+        const ordinal = this.nextOrdinal++;
+        this.closeOpen();
+        if (typeof timestamp !== 'string' || Number.isNaN(Date.parse(timestamp))) {
+            this.context.stats.promptsMissingTimestamp++;
+            return;
+        }
+        const scoped = scopedCwd(cwd, this.context.roots, this.context.realpaths);
+        if (!scoped) {
+            this.outOfScope++;
+            this.context.stats.promptsOutOfScope++;
+            return;
+        }
+        this.inScope++;
+        if (this.context.sinceMs !== null && Date.parse(timestamp) < this.context.sinceMs)
+            return;
+        const entry = {
+            provider: this.candidate.provider,
+            sessionId: this.candidate.sessionId,
+            ordinal,
+            timestamp,
+            text,
+            cwd: scoped,
+            ...(gitBranch ? { gitBranch } : {}),
+            metadataStatus: 'pending',
+        };
+        this.entries.push(entry);
+        this.open = {
+            entry,
+            lineOffset,
+            lineBytes,
+            answerId: null,
+            ...(stateBefore ? { stateBefore } : {}),
+        };
+    }
+}
+function transcriptMessage(candidate, record, role, content, extra, eventIndex) {
+    return {
+        role: 'user',
+        timestamp: typeof record.timestamp === 'string' ? record.timestamp : '',
+        content,
+        text: content
+            .filter((block) => block.type === 'text')
+            .map((block) => block.text ?? '')
+            .join('\n'),
+        tools: [],
+        commands: [],
+        source: {
+            provider: candidate.provider,
+            sessionId: candidate.sessionId,
+            originalRole: role,
+            eventIndex,
+            eventType: 'user',
+            ...extra,
+        },
+    };
+}
+function stringField(value) {
+    return typeof value === 'string' && value.length > 0 ? value : undefined;
+}
+function tokenCount(value) {
+    return typeof value === 'number' && Number.isFinite(value) && value >= 0 ? value : undefined;
+}
+function compactUsage(usage) {
+    const result = {};
+    for (const [key, value] of Object.entries(usage)) {
+        if (typeof value === 'number')
+            result[key] = value;
+    }
+    return Object.keys(result).length > 0 ? result : undefined;
+}
+function claudeUserText(candidate, record, message, blocks, eventIndex) {
+    const origin = record.origin;
+    const canonical = transcriptMessage(candidate, record, typeof message.role === 'string' ? message.role : 'user', blocks, {
+        entrypoint: stringField(record.entrypoint),
+        isMeta: record.isMeta === true ? true : undefined,
+        isSidechain: record.isSidechain === true ? true : undefined,
+        isCompactSummary: record.isCompactSummary === true ? true : undefined,
+        originKind: origin && typeof origin.kind === 'string' ? origin.kind : undefined,
+        promptSource: stringField(record.promptSource),
+    }, eventIndex);
+    return humanPromptText(canonical, 'claude-code');
+}
+class ClaudeLineScanner extends LineScanner {
+    lineIndex = 0;
+    promptTextOf(record) {
+        const message = record.message;
+        if (record.type !== 'user' || typeof message !== 'object' || message === null)
+            return null;
+        return claudeUserText(this.candidate, record, message, claudeBlocks(message.content), 0);
+    }
+    promptPlaceOf(record) {
+        return { cwd: record.cwd, gitBranch: stringField(record.gitBranch) };
+    }
+    accept(record, lineOffset, lineBytes) {
+        const index = this.lineIndex++;
+        const message = record.message;
+        if (typeof message !== 'object' || message === null)
+            return 'ok';
+        if (record.type === 'user') {
+            const blocks = claudeBlocks(message.content);
+            const text = claudeUserText(this.candidate, record, message, blocks, index);
+            if (text === null) {
+                // A tool result means the first answering call already finished.
+                if (this.open !== null &&
+                    this.open.answerId !== null &&
+                    record.isSidechain !== true &&
+                    blocks.some((block) => block.type === 'tool_result')) {
+                    this.closeOpen();
+                }
+                return 'ok';
+            }
+            this.recordPrompt(text, record.timestamp, record.cwd, stringField(record.gitBranch), lineOffset, lineBytes);
+            return 'ok';
+        }
+        const open = this.open;
+        if (record.type !== 'assistant' || !open || record.isSidechain === true)
+            return 'ok';
+        // Synthetic records (API errors, interrupts) are not model calls.
+        if (message.model === '<synthetic>')
+            return 'ok';
+        const id = stringField(message.id) ?? `line:${lineOffset}`;
+        if (open.answerId === null)
+            open.answerId = id;
+        if (id !== open.answerId) {
+            // A later tool-loop call: the first answering call is over and keeps its attribution.
+            this.closeOpen();
+            return 'ok';
+        }
+        const entry = open.entry;
+        const model = stringField(message.model);
+        if (model)
+            entry.model = model;
+        const usage = message.usage;
+        if (usage && typeof usage === 'object') {
+            // Split records of one call repeat its usage; the latest replaces, never adds.
+            const mapped = compactUsage({
+                inputTokens: tokenCount(usage.input_tokens),
+                outputTokens: tokenCount(usage.output_tokens),
+                cacheReadTokens: tokenCount(usage.cache_read_input_tokens),
+                cacheWriteTokens: tokenCount(usage.cache_creation_input_tokens),
+            });
+            if (mapped)
+                entry.usage = mapped;
+        }
+        // Claude Code writes the call's final stop_reason and usage on every split record.
+        if (stringField(message.stop_reason))
+            this.closeOpen();
+        else
+            entry.metadataStatus = 'provisional';
+        return 'ok';
+    }
+}
+function claudeBlocks(content) {
+    if (typeof content === 'string')
+        return [{ type: 'text', text: content }];
+    if (!Array.isArray(content))
+        return [];
+    const blocks = [];
+    for (const item of content) {
+        if (typeof item !== 'object' || item === null)
+            continue;
+        const block = item;
+        if (block.type === 'text' && typeof block.text === 'string') {
+            blocks.push({ type: 'text', text: block.text });
+        }
+        else if (block.type === 'tool_result') {
+            blocks.push({ type: 'tool_result' });
+        }
+        else if (block.type === 'image') {
+            blocks.push({ type: 'image' });
+        }
+        else {
+            blocks.push({ type: 'unknown' });
+        }
+    }
+    return blocks;
+}
+class CodexLineScanner extends LineScanner {
+    lineIndex = 0;
+    state;
+    constructor(candidate, plan, context) {
+        super(candidate, plan, context);
+        // A replay restarts at the open prompt's line, so it needs the state from just before it.
+        const initial = plan.kind === 'replay'
+            ? plan.pending.state
+            : plan.kind === 'continue'
+                ? plan.session.state
+                : undefined;
+        this.state = { ...(initial ?? {}) };
+    }
+    resumeState() {
+        return { ...this.state };
+    }
+    promptTextOf(record) {
+        const payload = record.payload;
+        if (!isCodexUserMessage(record, payload))
+            return null;
+        const canonical = transcriptMessage(this.candidate, record, 'user', codexBlocks(payload.content), {}, 0);
+        return humanPromptText(canonical, 'codex');
+    }
+    promptPlaceOf(_record, stateBefore) {
+        return { cwd: stateBefore?.cwd, gitBranch: stateBefore?.gitBranch };
+    }
+    accept(record, lineOffset, lineBytes) {
+        const index = this.lineIndex++;
+        const payload = record.payload;
+        if (typeof payload !== 'object' || payload === null)
+            return 'ok';
+        const state = this.state;
+        if (record.type === 'session_meta') {
+            // Forked sessions embed their parent's session_meta after their own; only the first counts.
+            if (state.meta)
+                return 'ok';
+            state.meta = true;
+            const source = typeof payload.source === 'string' ? payload.source : null;
+            if (!source || !HUMAN_CODEX_SOURCES.includes(source) || stringField(payload.forked_from_id)) {
+                state.excluded = true;
+                return 'excluded';
+            }
+            state.cwd = stringField(payload.cwd);
+            const git = payload.git;
+            state.gitBranch = git && typeof git === 'object' ? stringField(git.branch) : undefined;
+            return 'ok';
+        }
+        if (record.type === 'turn_context') {
+            const cwd = stringField(payload.cwd);
+            if (cwd)
+                state.cwd = cwd;
+            const model = stringField(payload.model);
+            if (model)
+                state.model = model;
+            return 'ok';
+        }
+        if (isCodexUserMessage(record, payload)) {
+            // Without session metadata the source (and thus interactivity) is unknown: fail closed.
+            if (!state.meta) {
+                state.excluded = true;
+                return 'excluded';
+            }
+            const canonical = transcriptMessage(this.candidate, record, 'user', codexBlocks(payload.content), {}, index);
+            const text = humanPromptText(canonical, 'codex');
+            if (text === null)
+                return 'ok';
+            this.recordPrompt(text, record.timestamp, state.cwd, state.gitBranch, lineOffset, lineBytes, {
+                ...state,
+            });
+            return 'ok';
+        }
+        const open = this.open;
+        if (record.type === 'event_msg' && payload.type === 'token_count' && open) {
+            // The first token_count after the prompt is the first answering call, complete.
+            const info = payload.info;
+            const last = info && typeof info === 'object' ? info.last_token_usage : undefined;
+            if (!last || typeof last !== 'object')
+                return 'ok';
+            const input = tokenCount(last.input_tokens);
+            const cached = tokenCount(last.cached_input_tokens);
+            const mapped = compactUsage({
+                inputTokens: input !== undefined ? Math.max(0, input - (cached ?? 0)) : undefined,
+                outputTokens: tokenCount(last.output_tokens),
+                cacheReadTokens: cached,
+                cacheWriteTokens: tokenCount(last.cache_write_input_tokens),
+            });
+            if (mapped)
+                open.entry.usage = mapped;
+            if (state.model)
+                open.entry.model = state.model;
+            this.closeOpen();
+        }
+        return 'ok';
+    }
+}
+function isCodexUserMessage(record, payload) {
+    return (record.type === 'response_item' &&
+        typeof payload === 'object' &&
+        payload !== null &&
+        payload.type === 'message' &&
+        payload.role === 'user');
+}
+function codexBlocks(content) {
+    if (!Array.isArray(content))
+        return [];
+    const blocks = [];
+    for (const item of content) {
+        if (typeof item !== 'object' || item === null)
+            continue;
+        const block = item;
+        if ((block.type === 'input_text' || block.type === 'text') && typeof block.text === 'string') {
+            blocks.push({ type: 'text', text: block.text });
+        }
+        else if (block.type === 'input_image') {
+            blocks.push({ type: 'image' });
+        }
+        else {
+            blocks.push({ type: 'unknown' });
+        }
+    }
+    return blocks;
+}