nterminal 1.3.2 → 1.3.3

package/dist/server/terminal/transcriptStore.js

@@ -0,0 +1,779 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { chmod, mkdir, open, readdir, rename, rm, rmdir, stat, statfs, unlink, utimes } from 'node:fs/promises';
+import { join } from 'node:path';
+import { performance } from 'node:perf_hooks';
+import { normalizeTranscriptSearchQuery, transcriptSearchQueryError } from '../../shared/transcriptSearch.js';
+import { cursorMatchesSource, decodeCursor, encodeCursor, fileFingerprint, readRenderedTranscriptWindow, readTranscriptHistoryPage, TRANSCRIPT_PARSER_VERSION } from './transcriptHistory.js';
+const SEGMENT_BYTES = 128 * 1024;
+const SEARCH_SEGMENT_BYTES = 1024 * 1024;
+const SEARCH_BYTES = 8 * 1024 * 1024;
+const SEARCH_MS = 100;
+const MAX_DISK_BYTES = 5 * 1024 * 1024 * 1024;
+const RETENTION_MS = 7 * 24 * 60 * 60 * 1000;
+const MIN_FREE_BYTES = 512 * 1024 * 1024;
+const MAINTENANCE_MS = 5 * 60 * 1000;
+const BACKGROUND_POLL_MS = 30_000;
+const UNKNOWN_CACHE_BYTES = 64 * 1024 * 1024;
+const MAX_JSON_BYTES = 16 * 1024 * 1024;
+const DUPLICATE_CONTEXT = 64 * 1024;
+const MAX_QUEUE = 8;
+/** Disposable private derived data; source JSONL remains authoritative.
+ * One instance per state directory. No open descriptors or rendered records are
+ * retained between calls. The queue bounds both work and waiting request memory.
+ */
+export class TranscriptStore {
+    options;
+    root;
+    busy = false;
+    queue = [];
+    jobs = new Map();
+    diskUsage = new Map();
+    maintenanceAt = 0;
+    maintenanceRetryAt = 0;
+    accountingReady = false;
+    maintenance;
+    revisions = new Map();
+    spaceCheckedAt = 0;
+    freeBytes = 0;
+    timer;
+    wakeAt = 0;
+    disposed = false;
+    backgroundAbort = new AbortController();
+    constructor(rootDir, options = {}) {
+        this.options = options;
+        this.root = join(rootDir, 'transcript-store');
+        this.wakeBackground(1000);
+    }
+    dispose() {
+        this.disposed = true;
+        clearTimeout(this.timer);
+        this.backgroundAbort.abort();
+        this.jobs.clear();
+        void this.maintenance?.return(undefined).catch(() => { });
+    }
+    readPage(terminalId, source, options = {}, signal) {
+        return this.schedule(async () => {
+            const session = await this.session(source, options.includeTools ?? false, signal);
+            try {
+                const cursor = options.around ?? options.cursor;
+                const around = options.around ? decodeCursor(options.around) : null;
+                if (cursor) {
+                    const decoded = decodeCursor(cursor);
+                    if (!decoded || !cursorMatchesSource(decoded, source, session.manifest.identity)
+                        || (decoded.snapshotSize !== undefined && decoded.snapshotSize > session.manifest.size))
+                        return null;
+                }
+                const result = await readTranscriptHistoryPage(terminalId, source, {
+                    ...options, ...(cursor === undefined ? {} : { cursor }), includeTools: options.includeTools ?? false,
+                    ...(options.around === undefined ? {} : { archiveTrailer: false })
+                }, async (handle, before, bytes, end) => {
+                    // The history reader borrows this session's descriptor and fixed end.
+                    if (fileFingerprint(await handle.stat()) !== session.manifest.identity || end > session.manifest.size)
+                        return null;
+                    const window = await this.pageWindow(session, before, bytes, end, options);
+                    if (around?.matchOffset !== undefined) {
+                        window.records = window.records.map(record => record.endOffset === around.beforeOffset
+                            ? { ...record, block: searchContext(record.block, around.matchOffset) } : record);
+                    }
+                    return window;
+                }, signal, { handle: session.handle, size: session.manifest.size });
+                return await this.commit(session) ? result : null;
+            }
+            finally {
+                await session.handle.close();
+            }
+        }, signal);
+    }
+    search(terminalId, source, options, signal) {
+        const query = normalizeTranscriptSearchQuery(options.query);
+        if (transcriptSearchQueryError(query))
+            return Promise.resolve(null);
+        return this.schedule(async () => {
+            const includeTools = options.includeTools ?? false;
+            const session = await this.session(source, includeTools, signal);
+            try {
+                const key = this.key(source, includeTools);
+                const previous = options.cursor ? parseSearchCursor(options.cursor) : undefined;
+                if (previous === null || (previous && (previous.key !== key || previous.query !== query
+                    || previous.identity !== session.manifest.identity
+                    || (previous.snapshot === session.manifest.size && previous.snapshotMtime !== session.manifest.mtime)
+                    || previous.snapshot > session.manifest.size)))
+                    return null;
+                const snapshot = previous?.snapshot ?? session.manifest.size;
+                let before = previous?.before ?? snapshot;
+                const initialBefore = before;
+                let scannedBytes = 0;
+                const hits = [];
+                // Cache setup is not search work. Even on a busy disk, process at
+                // least one window/record before returning a continuation cursor.
+                const started = performance.now();
+                while (before > 0 && hits.length < 20 && scannedBytes < SEARCH_BYTES &&
+                    (before === initialBefore || performance.now() - started < SEARCH_MS)) {
+                    signal?.throwIfAborted();
+                    const remaining = SEARCH_BYTES - scannedBytes;
+                    const cached = this.segment(session, before, snapshot);
+                    if (scannedBytes > 0 && (cached ? cached.bytes > remaining : remaining < 4 * SEGMENT_BYTES))
+                        break;
+                    const bytesBefore = session.readBytes;
+                    const window = await this.window(session, before, snapshot, Math.min(SEARCH_SEGMENT_BYTES, Math.max(SEGMENT_BYTES, remaining - 4 * SEGMENT_BYTES)));
+                    let stopped = false;
+                    for (let index = window.records.length - 1; index >= 0; index -= 1) {
+                        if (index % 16 === 0) {
+                            await yieldLoop();
+                            signal?.throwIfAborted();
+                        }
+                        const record = window.records[index];
+                        const normalized = record.block.normalize('NFC');
+                        const text = normalized.toLowerCase();
+                        const match = text.indexOf(query);
+                        before = record.startOffset;
+                        if (match >= 0) {
+                            const header = record.block.slice(0, record.block.indexOf('\n'));
+                            const metadata = /^(?:\[([^\]]+)\] )?(.*)$/.exec(header);
+                            hits.push({
+                                id: `${session.manifest.identity}:${record.startOffset}`,
+                                preview: normalized.slice(Math.max(0, match - 80), match + query.length + 160),
+                                timestamp: metadata[1] ?? '', role: metadata[2] ?? '',
+                                cursor: encodeCursor(source, record.endOffset, session.manifest.identity, snapshot, match)
+                            });
+                        }
+                        if (hits.length === 20 || performance.now() - started >= SEARCH_MS) {
+                            stopped = true;
+                            break;
+                        }
+                    }
+                    if (!stopped)
+                        before = window.startOffset;
+                    scannedBytes += session.readBytes - bytesBefore;
+                }
+                if (!await this.commit(session))
+                    return null;
+                return {
+                    terminalId, source: { provider: source.provider, sessionId: source.sessionId },
+                    query, hits, scannedBytes, complete: before === 0,
+                    cursor: before === 0 ? null : encodeSearchCursor({
+                        v: 2, key, snapshotMtime: previous?.snapshotMtime ?? session.manifest.mtime,
+                        identity: session.manifest.identity, query, snapshot, before
+                    })
+                };
+            }
+            finally {
+                await session.handle.close();
+            }
+        }, signal);
+    }
+    key(source, tools) {
+        return createHash('sha256').update(JSON.stringify([source.provider, source.sessionId, source.filePath, tools])).digest('hex');
+    }
+    async session(source, includeTools, signal, background = false) {
+        signal?.throwIfAborted();
+        const dir = join(this.root, this.key(source, includeTools));
+        const handle = await open(source.filePath, 'r');
+        try {
+            const info = await handle.stat();
+            const identity = fileFingerprint(info);
+            let cacheAvailable = true;
+            try {
+                await mkdir(this.root, { recursive: true, mode: 0o700 });
+                await chmod(this.root, 0o700);
+                await mkdir(dir, { mode: 0o700, recursive: true });
+                await chmod(dir, 0o700);
+            }
+            catch {
+                cacheAvailable = false;
+            }
+            const cachedManifest = cacheAvailable ? await readJson(join(dir, 'manifest.json')) : null;
+            let manifest = validManifest(cachedManifest) ? cachedManifest : null;
+            const previousFiles = manifest?.segments.map(segment => segment.file) ?? [];
+            if (!manifest || manifest.version !== TRANSCRIPT_PARSER_VERSION || manifest.identity !== identity
+                || info.size < manifest.size || (info.size === manifest.size && info.mtimeMs !== manifest.mtime)) {
+                manifest = { version: TRANSCRIPT_PARSER_VERSION, identity, size: info.size, mtime: info.mtimeMs, segments: [] };
+            }
+            else if (info.size > manifest.size) {
+                // Only the tail can change during an append: open records and Codex
+                // duplicate context. Keep the immutable prefix without a rebuild.
+                const oldSize = manifest.size;
+                manifest.segments = manifest.segments.filter(segment => segment.end + DUPLICATE_CONTEXT < oldSize);
+                manifest.size = info.size;
+                manifest.mtime = info.mtimeMs;
+            }
+            manifest.accessedAt = background
+                ? (manifest.accessedAt ?? this.jobs.get(this.key(source, includeTools))?.accessedAt ?? 0)
+                : Date.now();
+            manifest.source = source;
+            manifest.includeTools = includeTools;
+            return { dir, manifest, handle, source, includeTools, signal, readBytes: 0, cacheAvailable, background, previousFiles };
+        }
+        catch (error) {
+            await handle.close();
+            throw error;
+        }
+    }
+    async window(session, before, snapshot, readBytes = SEGMENT_BYTES) {
+        session.signal?.throwIfAborted();
+        const contextEnd = Math.min(snapshot, before + DUPLICATE_CONTEXT);
+        const fromCache = await this.cachedWindow(session, before, snapshot);
+        if (fromCache)
+            return fromCache;
+        const countedHandle = {
+            read: async (buffer, offset, length, position) => {
+                session.signal?.throwIfAborted();
+                const result = await session.handle.read(buffer, offset, length, position);
+                session.readBytes += result.bytesRead;
+                return result;
+            }
+        };
+        // Stop new extraction at an existing segment boundary. History's small
+        // windows and search's larger windows then form one non-overlapping index.
+        let floor = 0;
+        for (const segment of session.manifest.segments) {
+            if (segment.end < before)
+                floor = Math.max(floor, segment.end);
+        }
+        const result = await readRenderedTranscriptWindow(countedHandle, session.source, before, readBytes, snapshot, 0, session.includeTools, session.signal, floor);
+        if (!result || result.startOffset >= before)
+            throw new Error('Transcript changed while reading');
+        if (session.cacheAvailable) {
+            try {
+                if (!await this.canWrite()) {
+                    session.cacheAvailable = false;
+                    return result;
+                }
+                const file = `${randomUUID()}.json`;
+                const bytes = await atomicJson(session.dir, file, result);
+                this.revisions.set(session.dir, (this.revisions.get(session.dir) ?? 0) + 1);
+                this.diskUsage.set(session.dir, (this.diskUsage.get(session.dir) ?? 0) + bytes);
+                this.freeBytes -= bytes;
+                session.manifest.segments = session.manifest.segments.filter(segment => segment.end <= result.startOffset || segment.start >= before);
+                session.manifest.segments.push({ file, start: result.startOffset, end: before, contextEnd, bytes, used: Date.now() });
+            }
+            catch {
+                session.cacheAvailable = false;
+            }
+        }
+        return result;
+    }
+    async cachedWindow(session, before, snapshot) {
+        const cached = this.segment(session, before, snapshot);
+        if (cached) {
+            const result = await readJson(join(session.dir, cached.file), bytes => { session.readBytes += bytes; });
+            if (validWindow(result, cached.start, cached.end)) {
+                cached.used = Date.now();
+                return { startOffset: cached.start, records: result.records.filter(record => record.startOffset < before) };
+            }
+            session.manifest.segments = session.manifest.segments.filter(segment => segment !== cached);
+        }
+        return null;
+    }
+    segment(session, before, snapshot) {
+        if (!session.cacheAvailable)
+            return undefined;
+        return session.manifest.segments.find(segment => segment.start < before && before <= segment.end
+            && segment.contextEnd === Math.min(snapshot, segment.end + DUPLICATE_CONTEXT));
+    }
+    async pageWindow(session, before, bytes, snapshot, options) {
+        const records = [];
+        let offset = before;
+        let chars = 0;
+        let lines = 0;
+        const targetRecords = Number.isInteger(options.limit) && options.limit > 0 ? Math.min(1000, options.limit) : 400;
+        const targetLines = Number.isInteger(options.maxLines) && options.maxLines > 0 ? Math.min(5000, options.maxLines) : 5000;
+        const floor = Math.max(0, before - bytes);
+        while (offset > 0) {
+            session.signal?.throwIfAborted();
+            const warmOnly = offset <= floor;
+            if (warmOnly && (records.length >= targetRecords || lines >= targetLines || chars >= 1024 * 1024))
+                break;
+            // Beyond the bounded cold window, expand by rendered content, not raw
+            // tool payload bytes. A cache gap stops expansion rather than rebuilding.
+            const window = warmOnly ? await this.cachedWindow(session, offset, snapshot) : await this.window(session, offset, snapshot);
+            if (!window)
+                break;
+            records.unshift(...window.records);
+            for (const record of window.records) {
+                chars += record.block.length;
+                lines += record.block.split('\n').length;
+            }
+            offset = window.startOffset;
+        }
+        return { startOffset: offset, records };
+    }
+    async commit(session) {
+        session.signal?.throwIfAborted();
+        const current = await stat(session.source.filePath);
+        if (fileFingerprint(current) !== session.manifest.identity || current.size < session.manifest.size
+            || (current.size === session.manifest.size && current.mtimeMs !== session.manifest.mtime))
+            return false;
+        if (!session.background && this.options.background !== false && !this.disposed) {
+            const key = this.key(session.source, session.includeTools);
+            const job = this.jobs.get(key);
+            this.jobs.set(key, {
+                ...job,
+                source: session.source, includeTools: session.includeTools,
+                accessedAt: session.manifest.accessedAt, next: job?.next ?? 0,
+                ...(job?.completeStamp === undefined ? {} : { completeStamp: job.completeStamp })
+            });
+            this.wakeBackground(250);
+        }
+        if (!session.cacheAvailable)
+            return true;
+        try {
+            await this.persist(session);
+        }
+        catch {
+            // Cache I/O is optional; a successfully read and validated source is not.
+            session.cacheAvailable = false;
+        }
+        session.signal?.throwIfAborted();
+        return true;
+    }
+    async persist(session) {
+        if (!await this.canWrite()) {
+            session.cacheAvailable = false;
+            return;
+        }
+        // Commit segments before the manifest. This is a disposable cache: atomic
+        // rename prevents partial JSON visibility; validation recovers missing or
+        // damaged files after power loss without fsync per tiny segment.
+        const manifestBytes = await atomicJson(session.dir, 'manifest.json', session.manifest);
+        this.revisions.set(session.dir, (this.revisions.get(session.dir) ?? 0) + 1);
+        const keep = new Set(['manifest.json', ...session.manifest.segments.map(segment => segment.file)]);
+        for (const entry of session.previousFiles) {
+            if (!keep.has(entry))
+                await rm(join(session.dir, entry), { force: true });
+        }
+        this.diskUsage.set(session.dir, manifestBytes + session.manifest.segments.reduce((sum, segment) => sum + segment.bytes, 0));
+        const accessed = new Date(session.manifest.accessedAt ?? 0);
+        await utimes(session.dir, accessed, accessed);
+        session.signal?.throwIfAborted();
+    }
+    async cleanup() {
+        if (!this.maintenance) {
+            if (Date.now() < this.maintenanceRetryAt)
+                return;
+            if (Date.now() < this.maintenanceAt && this.totalBytes() < MAX_DISK_BYTES)
+                return;
+            this.maintenance = this.scanCache();
+        }
+        const started = performance.now();
+        try {
+            for (let i = 0; i < 32 && !this.disposed && !this.queue.length; i++) {
+                const step = await this.maintenance.next();
+                if (step.done) {
+                    this.maintenance = undefined;
+                    this.maintenanceAt = this.maintenanceRetryAt > Date.now()
+                        ? this.maintenanceRetryAt : Date.now() + MAINTENANCE_MS;
+                    return;
+                }
+                if (performance.now() - started >= 10)
+                    return;
+            }
+        }
+        catch {
+            this.maintenance = undefined;
+            this.maintenanceRetryAt = Date.now() + BACKGROUND_POLL_MS;
+            this.maintenanceAt = Date.now() + BACKGROUND_POLL_MS;
+        }
+    }
+    async *scanCache() {
+        const now = Date.now();
+        const sessions = [];
+        const entries = await readdir(this.root, { withFileTypes: true }).catch((error) => {
+            if (error.code === 'ENOENT')
+                return [];
+            throw error;
+        });
+        const seen = new Set();
+        for (const entry of entries) {
+            if (entry.isDirectory() && /^\.evict-[a-f0-9-]+$/.test(entry.name)) {
+                const dir = join(this.root, entry.name);
+                seen.add(dir);
+                yield* this.removeRetiredCache(dir);
+                continue;
+            }
+            if (!entry.isDirectory() || !/^[a-f0-9]{64}$/.test(entry.name))
+                continue;
+            const dir = join(this.root, entry.name);
+            seen.add(dir);
+            let bytes = 0;
+            try {
+                const revision = this.revisions.get(dir) ?? 0;
+                const info = await stat(dir);
+                const metadata = await readJson(join(dir, 'manifest.json'));
+                const manifest = validManifest(metadata) ? metadata : null;
+                const referenced = new Set(['manifest.json', ...manifest?.segments.map(segment => segment.file) ?? []]);
+                for (const file of await readdir(dir, { withFileTypes: true })) {
+                    // A foreground request may replace segments between maintenance slices.
+                    // Never delete files using a manifest captured before that write.
+                    if ((this.revisions.get(dir) ?? 0) !== revision)
+                        break;
+                    if (file.isFile() && !referenced.has(file.name)) {
+                        await rm(join(dir, file.name), { force: true });
+                    }
+                    else if (file.isFile()) {
+                        bytes += (await stat(join(dir, file.name))).size;
+                    }
+                    yield;
+                }
+                if ((this.revisions.get(dir) ?? 0) !== revision) {
+                    // The writer maintained its accounting; revisit orphans next cycle.
+                    sessions.push({ dir, used: this.jobs.get(entry.name)?.accessedAt ?? Date.now(), bytes: this.diskUsage.get(dir) ?? 0 });
+                    continue;
+                }
+                const used = Math.max(manifest?.accessedAt ?? info.mtimeMs, this.jobs.get(entry.name)?.accessedAt ?? 0);
+                sessions.push({ dir, used, bytes });
+                this.diskUsage.set(dir, bytes);
+                if (manifest?.source && typeof manifest.includeTools === 'boolean'
+                    && now - used < RETENTION_MS && this.options.background !== false
+                    && this.key(manifest.source, manifest.includeTools) === entry.name && !this.jobs.has(entry.name)) {
+                    this.jobs.set(entry.name, { source: manifest.source, includeTools: manifest.includeTools, accessedAt: used, next: 0 });
+                }
+            }
+            catch (error) {
+                await this.cacheInspectionFailed(dir, error, bytes);
+            }
+            yield;
+        }
+        // New directories can be created while this scan yields. Do not discard
+        // their writer-maintained accounting just because they were not in entries.
+        for (const dir of this.diskUsage.keys()) {
+            if (!seen.has(dir)) {
+                try {
+                    await stat(dir);
+                }
+                catch (error) {
+                    await this.cacheInspectionFailed(dir, error);
+                }
+            }
+            yield;
+        }
+        this.accountingReady = true;
+        for (const session of sessions.sort((a, b) => a.used - b.used)) {
+            const key = session.dir.slice(this.root.length + 1);
+            const used = Math.max(session.used, this.jobs.get(key)?.accessedAt ?? 0);
+            // A request since enumeration makes this entry an eviction candidate for
+            // the next cycle, when its LRU position can be sorted accurately.
+            if (used > session.used)
+                continue;
+            if (this.totalBytes() < MAX_DISK_BYTES && Date.now() - used < RETENTION_MS)
+                continue;
+            const retired = join(this.root, `.evict-${randomUUID()}`);
+            try {
+                // Detach the old cache atomically. A foreground request can now create
+                // the original directory without sharing any paths with this deletion.
+                await rename(session.dir, retired);
+                this.diskUsage.set(retired, this.diskUsage.get(session.dir) ?? session.bytes);
+                this.diskUsage.delete(session.dir);
+                this.revisions.delete(session.dir);
+                this.jobs.delete(key);
+            }
+            catch (error) {
+                await this.cacheInspectionFailed(session.dir, error, session.bytes);
+                yield;
+                continue;
+            }
+            yield;
+            yield* this.removeRetiredCache(retired);
+        }
+    }
+    async cacheInspectionFailed(dir, error, observed = 0) {
+        if (error.code === 'ENOENT') {
+            try {
+                await stat(dir);
+            }
+            catch (missing) {
+                if (missing.code === 'ENOENT') {
+                    this.diskUsage.delete(dir);
+                    return;
+                }
+            }
+        }
+        // Unknown usage is not zero. Retain known usage, or a conservative reserve
+        // until a later inspection succeeds; statfs remains the disk safety guard.
+        this.diskUsage.set(dir, Math.max(observed, this.diskUsage.get(dir) ?? UNKNOWN_CACHE_BYTES));
+        this.maintenanceRetryAt = Date.now() + BACKGROUND_POLL_MS;
+    }
+    async *removeRetiredCache(dir) {
+        if (!this.diskUsage.has(dir))
+            this.diskUsage.set(dir, UNKNOWN_CACHE_BYTES);
+        try {
+            for (const entry of await readdir(dir, { withFileTypes: true })) {
+                // Cache files are flat. Do not recurse into unexpected directories or
+                // follow symlinks. unlink removes only the link itself.
+                if (!entry.isDirectory()) {
+                    try {
+                        await unlink(join(dir, entry.name));
+                    }
+                    catch (error) {
+                        if (error.code !== 'ENOENT')
+                            await this.cacheInspectionFailed(dir, error);
+                    }
+                }
+                yield;
+            }
+            await rmdir(dir);
+            this.diskUsage.delete(dir);
+        }
+        catch (error) {
+            await this.cacheInspectionFailed(dir, error);
+        }
+        yield;
+    }
+    totalBytes() {
+        let bytes = 0;
+        for (const size of this.diskUsage.values())
+            bytes += size;
+        return bytes;
+    }
+    async canWrite() {
+        if (Date.now() >= this.spaceCheckedAt) {
+            const space = await statfs(this.root);
+            this.freeBytes = space.bavail * space.bsize;
+            this.spaceCheckedAt = Date.now() + BACKGROUND_POLL_MS;
+        }
+        return this.accountingReady && this.freeBytes > MIN_FREE_BYTES && this.totalBytes() < MAX_DISK_BYTES;
+    }
+    wakeBackground(delay) {
+        if (this.disposed || this.options.background === false)
+            return;
+        const wakeAt = Date.now() + delay;
+        if (this.timer && this.wakeAt <= wakeAt)
+            return;
+        clearTimeout(this.timer);
+        this.wakeAt = wakeAt;
+        this.timer = setTimeout(() => {
+            this.timer = undefined;
+            void this.runBackground().finally(() => {
+                let next = this.maintenance ? 0 : Math.min(Date.now() + BACKGROUND_POLL_MS, this.maintenanceAt);
+                for (const job of this.jobs.values())
+                    next = Math.min(next, job.next);
+                this.wakeBackground(Math.max(this.maintenance ? 25 : 250, next - Date.now()));
+            });
+        }, delay);
+        this.timer.unref();
+    }
+    async runBackground() {
+        // Background work never joins the foreground queue. One bounded extraction
+        // finishes before queued user requests run, then the next slice yields.
+        if (this.disposed || this.busy || this.queue.length)
+            return;
+        await this.schedule(async () => {
+            await this.cleanup();
+            if (this.queue.length || this.maintenance)
+                return null;
+            const now = Date.now();
+            for (const [key, job] of this.jobs) {
+                if (now - job.accessedAt >= RETENTION_MS) {
+                    this.jobs.delete(key);
+                    continue;
+                }
+                if (job.next > now)
+                    continue;
+                // Rotate jobs so a large archive cannot starve other sessions.
+                this.jobs.delete(key);
+                this.jobs.set(key, job);
+                job.next = now + BACKGROUND_POLL_MS;
+                try {
+                    if (!await this.canWrite())
+                        break;
+                    const info = await stat(job.source.filePath);
+                    const stamp = `${fileFingerprint(info)}:${info.size}:${info.mtimeMs}`;
+                    if (job.completeStamp === stamp)
+                        break;
+                    delete job.completeStamp;
+                    const session = await this.session(job.source, job.includeTools, this.backgroundAbort.signal, true);
+                    try {
+                        if (!session.cacheAvailable)
+                            break;
+                        let before = session.manifest.size;
+                        const segments = [...session.manifest.segments].sort((a, b) => b.end - a.end);
+                        for (const segment of segments) {
+                            if (segment.end < before)
+                                break;
+                            if (segment.start < before && segment.contextEnd === Math.min(session.manifest.size, segment.end + DUPLICATE_CONTEXT)) {
+                                before = segment.start;
+                            }
+                        }
+                        if (job.preferArchive && before > 0) {
+                            let covered = 0;
+                            for (let index = segments.length - 1; index >= 0; index--) {
+                                const segment = segments[index];
+                                if (segment.contextEnd !== Math.min(session.manifest.size, segment.end + DUPLICATE_CONTEXT))
+                                    continue;
+                                if (segment.start > covered) {
+                                    before = segment.start;
+                                    break;
+                                }
+                                covered = Math.max(covered, segment.end);
+                            }
+                        }
+                        if (before > 0) {
+                            await this.window(session, before, session.manifest.size, SEARCH_SEGMENT_BYTES);
+                            if (await this.commit(session) && session.cacheAvailable) {
+                                job.next = 0;
+                                job.preferArchive = !job.preferArchive;
+                            }
+                        }
+                        else {
+                            job.completeStamp = stamp;
+                        }
+                    }
+                    finally {
+                        await session.handle.close();
+                    }
+                }
+                catch (error) {
+                    if (error.code === 'ENOENT')
+                        this.jobs.delete(key);
+                }
+                break;
+            }
+            return null;
+        }, this.backgroundAbort.signal);
+    }
+    schedule(work, signal) {
+        if (this.disposed || signal?.aborted)
+            return Promise.resolve(null);
+        if (this.busy && this.queue.length >= MAX_QUEUE)
+            return Promise.resolve(null);
+        return new Promise((resolve) => {
+            const entry = {
+                signal, reject: () => resolve(null),
+                abort: () => {
+                    const index = this.queue.indexOf(entry);
+                    if (index >= 0)
+                        this.queue.splice(index, 1);
+                    resolve(null);
+                },
+                start: () => {
+                    signal?.removeEventListener('abort', entry.abort);
+                    this.busy = true;
+                    void (async () => {
+                        try {
+                            signal?.throwIfAborted();
+                            const result = await work();
+                            resolve(signal?.aborted ? null : result);
+                        }
+                        catch {
+                            resolve(null);
+                        }
+                        finally {
+                            this.busy = false;
+                            this.queue.shift()?.start();
+                        }
+                    })();
+                }
+            };
+            if (this.busy) {
+                this.queue.push(entry);
+                signal?.addEventListener('abort', entry.abort, { once: true });
+            }
+            else
+                entry.start();
+        });
+    }
+}
+async function atomicJson(dir, name, value) {
+    const data = JSON.stringify(value);
+    const temporary = join(dir, `${randomUUID()}.tmp`);
+    const handle = await open(temporary, 'wx', 0o600);
+    try {
+        await handle.writeFile(data);
+    }
+    finally {
+        await handle.close();
+    }
+    await rename(temporary, join(dir, name));
+    return Buffer.byteLength(data);
+}
+async function readJson(path, onRead) {
+    let handle;
+    try {
+        handle = await open(path, 'r');
+        await handle.chmod(0o600);
+        const info = await handle.stat();
+        if (info.size > MAX_JSON_BYTES)
+            return null;
+        const data = await handle.readFile('utf8');
+        onRead?.(Buffer.byteLength(data));
+        return JSON.parse(data);
+    }
+    catch {
+        return null;
+    }
+    finally {
+        await handle?.close();
+    }
+}
+function isObject(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function isOffset(value) {
+    return typeof value === 'number' && Number.isSafeInteger(value) && value >= 0;
+}
+function validManifest(value) {
+    if (!isObject(value) || !isOffset(value.size))
+        return false;
+    const size = value.size;
+    return typeof value.identity === 'string' && isOffset(value.version)
+        && typeof value.mtime === 'number' && Number.isFinite(value.mtime)
+        && (value.accessedAt === undefined || isOffset(value.accessedAt))
+        && (value.includeTools === undefined || typeof value.includeTools === 'boolean')
+        && (value.source === undefined || (isObject(value.source)
+            && (value.source.provider === 'codex' || value.source.provider === 'claude')
+            && typeof value.source.sessionId === 'string' && typeof value.source.filePath === 'string'))
+        && Array.isArray(value.segments)
+        && value.segments.every((segment) => isObject(segment)
+            && typeof segment.file === 'string' && /^[a-f0-9-]+\.json$/.test(segment.file)
+            && isOffset(segment.start) && isOffset(segment.end)
+            && segment.end > segment.start && segment.end <= size
+            && isOffset(segment.contextEnd) && segment.contextEnd >= segment.end && segment.contextEnd <= size
+            && isOffset(segment.bytes) && typeof segment.used === 'number' && Number.isFinite(segment.used));
+}
+function validWindow(value, start, end) {
+    if (!isObject(value))
+        return false;
+    let previousEnd = start;
+    return value.startOffset === start && Array.isArray(value.records) && value.records.every((record) => {
+        if (!isObject(record) || !isOffset(record.startOffset) || !isOffset(record.endOffset))
+            return false;
+        const valid = record.startOffset >= previousEnd
+            && record.startOffset >= start && record.startOffset < end
+            && record.endOffset > record.startOffset && record.endOffset <= end && typeof record.block === 'string';
+        previousEnd = record.endOffset;
+        return valid;
+    });
+}
+function encodeSearchCursor(cursor) {
+    return Buffer.from(JSON.stringify(cursor)).toString('base64url');
+}
+function parseSearchCursor(value) {
+    if (value.length > 4096)
+        return null;
+    try {
+        const cursor = JSON.parse(Buffer.from(value, 'base64url').toString('utf8'));
+        return cursor.v === 2 && typeof cursor.key === 'string' && typeof cursor.identity === 'string'
+            && typeof cursor.query === 'string' && Number.isFinite(cursor.snapshotMtime)
+            && Number.isSafeInteger(cursor.snapshot) && Number.isSafeInteger(cursor.before)
+            && cursor.before >= 0 && cursor.snapshot >= cursor.before ? cursor : null;
+    }
+    catch {
+        return null;
+    }
+}
+function yieldLoop() {
+    return new Promise(resolve => setImmediate(resolve));
+}
+// Search hits can lie beyond the normal per-message display cap. Keep the
+// original speaker header and a bounded excerpt without changing cached text.
+function searchContext(block, offset) {
+    const text = block.normalize('NFC');
+    const headerEnd = text.indexOf('\n');
+    if (headerEnd < 0 || (text.length <= 4000 && text.split('\n').length <= 32))
+        return text;
+    const position = Math.max(headerEnd + 1, Math.min(offset, text.length));
+    const prefix = text.slice(Math.max(headerEnd + 1, position - 1000), position).split('\n').slice(-8).join('\n');
+    const suffix = text.slice(position, position + 4000).split('\n').slice(0, 24).join('\n');
+    return `${text.slice(0, headerEnd)}\n${position - prefix.length > headerEnd + 1 ? '[earlier text omitted]\n' : ''}${prefix}${suffix}${position + suffix.length < text.length ? '\n[later text omitted]' : ''}`;
+}
+//# sourceMappingURL=transcriptStore.js.map