maka-agent 0.2.0-dev.24.20260907 → 0.2.0-dev.26.20260909

package/node_modules/@maka/storage/dist/codex-session-adapter.js

@@ -22,8 +22,12 @@ import { basename, join, resolve, sep } from 'node:path';
 import { isSupportedCodexThreadSource, sanitizeForeignTitle } from '@maka/core/foreign-session';
 import { externalSessionMatchesQuery } from '@maka/core/external-session';
 export const CODEX_SESSION_ADAPTER_ID = 'codex';
-export const CODEX_ROLLOUT_MAX_BYTES = 64 * 1024 * 1024;
+export const CODEX_ROLLOUT_MAX_BYTES = 2 * 1024 * 1024 * 1024;
 const CODEX_ROLLOUT_HEAD_BYTES = 512 * 1024;
+const CODEX_ROLLOUT_READ_BYTES = 64 * 1024;
+const CODEX_ROLLOUT_MAX_RECORD_BYTES = 64 * 1024 * 1024;
+const CODEX_ROLLOUT_MAX_CONVERTED_BYTES = 256 * 1024 * 1024;
+const CODEX_ROLLOUT_MAX_MESSAGES = 250_000;
 const CODEX_SESSION_ID_PATTERN = /^[A-Za-z0-9_-]{1,128}$/;
 const CODEX_UNSAFE_PATH_CHARS = /[\u0000-\u001F\u007F\u0080-\u009F\u061C\u200B-\u200F\u202A-\u202E\u2060-\u2064\u2066-\u2069\uFEFF]/;
 /**
@@ -40,12 +44,19 @@ export class CodexSessionAdapter {
     id = CODEX_SESSION_ADAPTER_ID;
     codexHome;
     maxRolloutBytes;
+    maxRecordBytes;
+    maxConvertedBytes;
+    maxMessages;
     constructor(options = {}) {
         this.codexHome = resolve(options.codexHome ?? process.env.CODEX_HOME ?? join(homedir(), '.codex'));
         this.maxRolloutBytes = options.maxRolloutBytes ?? CODEX_ROLLOUT_MAX_BYTES;
-        if (!Number.isSafeInteger(this.maxRolloutBytes) || this.maxRolloutBytes <= 0) {
-            throw new Error('Codex rollout byte limit must be a positive safe integer');
-        }
+        this.maxRecordBytes = options.maxRecordBytes ?? CODEX_ROLLOUT_MAX_RECORD_BYTES;
+        this.maxConvertedBytes = options.maxConvertedBytes ?? CODEX_ROLLOUT_MAX_CONVERTED_BYTES;
+        this.maxMessages = options.maxMessages ?? CODEX_ROLLOUT_MAX_MESSAGES;
+        assertPositiveSafeInteger(this.maxRolloutBytes, 'Codex rollout byte limit');
+        assertPositiveSafeInteger(this.maxRecordBytes, 'Codex rollout record byte limit');
+        assertPositiveSafeInteger(this.maxConvertedBytes, 'Codex converted message byte limit');
+        assertPositiveSafeInteger(this.maxMessages, 'Codex converted message count limit');
     }
     async detect() {
         return ((await isDirectory(join(this.codexHome, 'sessions'))) ||
@@ -64,13 +75,12 @@ export class CodexSessionAdapter {
         const rolloutPath = await this.resolveRolloutPath(catalogEntry.rolloutPath, sessionId);
         if (!rolloutPath)
             throw new Error(`Codex rollout is unavailable: ${sessionId}`);
-        const text = await readBoundedUtf8File(rolloutPath, this.maxRolloutBytes);
-        const converted = convertCodexRollout(text, sessionId, catalogEntry.name, catalogEntry.cwd);
-        return {
-            sourceSessionId: sessionId,
-            metadata: converted.metadata,
-            messages: converted.messages,
-        };
+        return convertCodexRollout(rolloutPath, sessionId, catalogEntry.name, catalogEntry.cwd, {
+            maxRolloutBytes: this.maxRolloutBytes,
+            maxRecordBytes: this.maxRecordBytes,
+            maxConvertedBytes: this.maxConvertedBytes,
+            maxMessages: this.maxMessages,
+        });
     }
     async listCatalog(query) {
         for (const dbPath of await codexStateDbsNewestFirst(this.codexHome)) {
@@ -181,261 +191,275 @@ export class CodexSessionAdapter {
         }
     }
 }
-function convertCodexRollout(text, expectedSessionId, fallbackName, fallbackCwd) {
-    const records = parseRolloutRecords(text, expectedSessionId);
-    const sessionMeta = records.find((record) => record.value.type === 'session_meta')?.value;
-    const metaPayload = asRecord(sessionMeta?.payload);
-    const actualSessionId = stringField(metaPayload, 'session_id') ?? stringField(metaPayload, 'id');
-    if (actualSessionId !== expectedSessionId) {
-        throw new Error(`Codex rollout Session id mismatch: expected ${expectedSessionId}`);
-    }
-    const metaCwd = safeCodexCwd(metaPayload?.cwd);
-    const messages = [];
-    let activeTurnId;
-    let activeTurnIsExplicit = false;
-    let activeModel = stringField(metaPayload, 'model_provider') ?? 'codex';
-    let lastTimestamp = normalizeEpochMs(sessionMeta?.timestamp) ?? 0;
-    let firstUserText;
-    const failedTurnIds = new Set();
-    const timestampFor = (record) => {
-        const parsed = normalizeEpochMs(record.value.timestamp);
-        if (parsed !== undefined)
-            lastTimestamp = Math.max(lastTimestamp, parsed);
-        else
-            lastTimestamp += 1;
-        return parsed ?? lastTimestamp;
-    };
-    const ensureTurnId = (line) => {
-        activeTurnId ??= generatedCodexId(expectedSessionId, 'turn', line);
-        return activeTurnId;
-    };
-    for (const record of records) {
+async function convertCodexRollout(path, expectedSessionId, fallbackName, fallbackCwd, limits) {
+    const converter = new CodexRolloutConverter(expectedSessionId, fallbackName, fallbackCwd, limits);
+    for await (const record of readCodexRolloutRecords(path, expectedSessionId, limits)) {
+        converter.accept(record);
+    }
+    return converter.finish();
+}
+class CodexRolloutConverter {
+    expectedSessionId;
+    fallbackName;
+    fallbackCwd;
+    limits;
+    messages = [];
+    failedTurnIds = new Set();
+    activeTurnId;
+    activeTurnIsExplicit = false;
+    activeModel = 'codex';
+    lastTimestamp = 0;
+    firstUserText;
+    metaCwd = '';
+    hasSessionMeta = false;
+    convertedBytes = 0;
+    constructor(expectedSessionId, fallbackName, fallbackCwd, limits) {
+        this.expectedSessionId = expectedSessionId;
+        this.fallbackName = fallbackName;
+        this.fallbackCwd = fallbackCwd;
+        this.limits = limits;
+    }
+    accept(record) {
         const envelope = record.value;
+        if (envelope.type === 'session_meta' && !this.hasSessionMeta) {
+            this.hasSessionMeta = true;
+            const metaPayload = asRecord(envelope.payload);
+            const actualSessionId = stringField(metaPayload, 'session_id') ?? stringField(metaPayload, 'id');
+            if (actualSessionId !== this.expectedSessionId) {
+                throw new Error(`Codex rollout Session id mismatch: expected ${this.expectedSessionId}`);
+            }
+            this.metaCwd = safeCodexCwd(metaPayload?.cwd);
+            this.activeModel = stringField(metaPayload, 'model_provider') ?? this.activeModel;
+            const timestamp = normalizeEpochMs(envelope.timestamp);
+            if (timestamp !== undefined)
+                this.lastTimestamp = Math.max(this.lastTimestamp, timestamp);
+            return;
+        }
         const payload = asRecord(envelope.payload);
         if (!payload)
-            continue;
+            return;
         if (envelope.type === 'turn_context') {
-            activeTurnId = stringField(payload, 'turn_id') ?? activeTurnId;
-            activeModel = stringField(payload, 'model') ?? activeModel;
-            continue;
+            this.activeTurnId = stringField(payload, 'turn_id') ?? this.activeTurnId;
+            this.activeModel = stringField(payload, 'model') ?? this.activeModel;
+            return;
         }
         if (envelope.type === 'event_msg') {
             const eventType = stringField(payload, 'type');
             if (eventType === 'task_started' || eventType === 'turn_started') {
                 const turnId = stringField(payload, 'turn_id');
                 if (turnId) {
-                    activeTurnId = turnId;
-                    activeTurnIsExplicit = true;
+                    this.activeTurnId = turnId;
+                    this.activeTurnIsExplicit = true;
                 }
-                continue;
+                return;
             }
             if (eventType === 'item_completed') {
                 const item = asRecord(payload.item);
                 const itemType = stringField(item, 'type')?.toLowerCase();
                 const eventTurnId = stringField(payload, 'turn_id');
                 if (eventTurnId) {
-                    activeTurnId = eventTurnId;
-                    activeTurnIsExplicit = true;
+                    this.activeTurnId = eventTurnId;
+                    this.activeTurnIsExplicit = true;
                 }
                 if (itemType === 'usermessage') {
-                    if (!activeTurnIsExplicit) {
-                        activeTurnId = generatedCodexId(expectedSessionId, 'turn', record.line);
+                    if (!this.activeTurnIsExplicit) {
+                        this.activeTurnId = generatedCodexId(this.expectedSessionId, 'turn', record.line);
                     }
                     const text = codexCompletedItemText(item) || codexCompletedItemMediaText(item);
                     if (text.length === 0)
-                        continue;
-                    firstUserText ??= text;
-                    messages.push({
+                        return;
+                    this.firstUserText ??= text;
+                    this.append({
                         type: 'user',
                         id: stringField(item, 'client_id') ??
                             stringField(item, 'id') ??
-                            generatedCodexId(expectedSessionId, 'user', record.line),
-                        turnId: ensureTurnId(record.line),
-                        ts: timestampFor(record),
+                            generatedCodexId(this.expectedSessionId, 'user', record.line),
+                        turnId: this.ensureTurnId(record.line),
+                        ts: this.timestampFor(record),
                         text,
                     });
-                    continue;
+                    return;
                 }
                 if (itemType === 'agentmessage') {
                     const text = codexCompletedItemText(item);
                     if (text.length === 0)
-                        continue;
+                        return;
                     const providerOptions = codexAssistantProviderOptions(item);
-                    messages.push({
+                    this.append({
                         type: 'assistant',
                         id: stringField(item, 'id') ??
-                            generatedCodexId(expectedSessionId, 'assistant', record.line),
-                        turnId: ensureTurnId(record.line),
-                        ts: timestampFor(record),
+                            generatedCodexId(this.expectedSessionId, 'assistant', record.line),
+                        turnId: this.ensureTurnId(record.line),
+                        ts: this.timestampFor(record),
                         text,
                         ...(providerOptions !== undefined ? { providerOptions } : {}),
-                        modelId: activeModel,
+                        modelId: this.activeModel,
                         contentOrder: ['text'],
                     });
-                    continue;
+                    return;
                 }
                 if (itemType === 'reasoning') {
                     const reasoning = codexCompletedReasoningText(item);
                     if (reasoning.length === 0)
-                        continue;
-                    messages.push({
+                        return;
+                    this.append({
                         type: 'assistant',
                         id: stringField(item, 'id') ??
-                            generatedCodexId(expectedSessionId, 'reasoning', record.line),
-                        turnId: ensureTurnId(record.line),
-                        ts: timestampFor(record),
+                            generatedCodexId(this.expectedSessionId, 'reasoning', record.line),
+                        turnId: this.ensureTurnId(record.line),
+                        ts: this.timestampFor(record),
                         text: '',
                         thinking: { text: reasoning },
                         contentOrder: ['thinking'],
-                        modelId: activeModel,
+                        modelId: this.activeModel,
                     });
-                    continue;
+                    return;
                 }
             }
             if (eventType === 'user_message') {
-                if (!activeTurnIsExplicit) {
-                    activeTurnId = generatedCodexId(expectedSessionId, 'turn', record.line);
+                if (!this.activeTurnIsExplicit) {
+                    this.activeTurnId = generatedCodexId(this.expectedSessionId, 'turn', record.line);
                 }
                 const text = stringField(payload, 'message') ?? mediaOnlyUserText(payload);
                 if (text.length === 0)
-                    continue;
-                firstUserText ??= text;
-                const turnId = ensureTurnId(record.line);
-                messages.push({
+                    return;
+                this.firstUserText ??= text;
+                const turnId = this.ensureTurnId(record.line);
+                this.append({
                     type: 'user',
                     id: stringField(payload, 'client_id') ??
-                        generatedCodexId(expectedSessionId, 'user', record.line),
+                        generatedCodexId(this.expectedSessionId, 'user', record.line),
                     turnId,
-                    ts: timestampFor(record),
+                    ts: this.timestampFor(record),
                     text,
                 });
-                continue;
+                return;
             }
             if (eventType === 'agent_message') {
                 const text = stringField(payload, 'message');
                 if (!text)
-                    continue;
+                    return;
                 const providerOptions = codexAssistantProviderOptions(payload);
-                messages.push({
+                this.append({
                     type: 'assistant',
-                    id: generatedCodexId(expectedSessionId, 'assistant', record.line),
-                    turnId: ensureTurnId(record.line),
-                    ts: timestampFor(record),
+                    id: generatedCodexId(this.expectedSessionId, 'assistant', record.line),
+                    turnId: this.ensureTurnId(record.line),
+                    ts: this.timestampFor(record),
                     text,
                     ...(providerOptions !== undefined ? { providerOptions } : {}),
-                    modelId: activeModel,
+                    modelId: this.activeModel,
                     contentOrder: ['text'],
                 });
-                continue;
+                return;
             }
             if (eventType === 'agent_reasoning') {
                 const reasoning = stringField(payload, 'text');
                 if (!reasoning)
-                    continue;
-                messages.push({
+                    return;
+                this.append({
                     type: 'assistant',
-                    id: generatedCodexId(expectedSessionId, 'reasoning', record.line),
-                    turnId: ensureTurnId(record.line),
-                    ts: timestampFor(record),
+                    id: generatedCodexId(this.expectedSessionId, 'reasoning', record.line),
+                    turnId: this.ensureTurnId(record.line),
+                    ts: this.timestampFor(record),
                     text: '',
                     thinking: { text: reasoning },
                     contentOrder: ['thinking'],
-                    modelId: activeModel,
+                    modelId: this.activeModel,
                 });
-                continue;
+                return;
             }
             if (eventType === 'context_compacted') {
-                messages.push({
+                this.append({
                     type: 'system_note',
-                    id: generatedCodexId(expectedSessionId, 'compact', record.line),
-                    turnId: activeTurnId,
-                    ts: timestampFor(record),
+                    id: generatedCodexId(this.expectedSessionId, 'compact', record.line),
+                    turnId: this.activeTurnId,
+                    ts: this.timestampFor(record),
                     kind: 'context_compacted',
                 });
-                continue;
+                return;
             }
             if (eventType === 'error') {
-                if (activeTurnId && codexErrorAffectsTurnStatus(payload)) {
-                    failedTurnIds.add(activeTurnId);
+                if (this.activeTurnId && codexErrorAffectsTurnStatus(payload)) {
+                    this.failedTurnIds.add(this.activeTurnId);
                 }
-                messages.push({
+                this.append({
                     type: 'system_note',
-                    id: generatedCodexId(expectedSessionId, 'error', record.line),
-                    turnId: activeTurnId,
-                    ts: timestampFor(record),
+                    id: generatedCodexId(this.expectedSessionId, 'error', record.line),
+                    turnId: this.activeTurnId,
+                    ts: this.timestampFor(record),
                     kind: 'error',
                     data: JSON.parse(JSON.stringify(payload)),
                 });
-                continue;
+                return;
             }
             if (eventType === 'task_complete' || eventType === 'turn_complete') {
-                const turnId = stringField(payload, 'turn_id') ?? ensureTurnId(record.line);
-                const failed = failedTurnIds.has(turnId) || payload.error != null;
-                messages.push({
+                const turnId = stringField(payload, 'turn_id') ?? this.ensureTurnId(record.line);
+                const failed = this.failedTurnIds.has(turnId) || payload.error != null;
+                this.append({
                     type: 'turn_state',
-                    id: generatedCodexId(expectedSessionId, 'turn-state', record.line),
+                    id: generatedCodexId(this.expectedSessionId, 'turn-state', record.line),
                     turnId,
-                    ts: timestampFor(record),
+                    ts: this.timestampFor(record),
                     status: failed ? 'failed' : 'completed',
                     ...(failed ? { errorClass: 'codex_error' } : {}),
                 });
-                failedTurnIds.delete(turnId);
-                if (activeTurnId === turnId) {
-                    activeTurnId = undefined;
-                    activeTurnIsExplicit = false;
+                this.failedTurnIds.delete(turnId);
+                if (this.activeTurnId === turnId) {
+                    this.activeTurnId = undefined;
+                    this.activeTurnIsExplicit = false;
                 }
-                continue;
+                return;
             }
             if (eventType === 'turn_aborted') {
-                const turnId = stringField(payload, 'turn_id') ?? ensureTurnId(record.line);
-                const ts = timestampFor(record);
-                messages.push({
+                const turnId = stringField(payload, 'turn_id') ?? this.ensureTurnId(record.line);
+                const ts = this.timestampFor(record);
+                this.append({
                     type: 'turn_state',
-                    id: generatedCodexId(expectedSessionId, 'turn-state', record.line),
+                    id: generatedCodexId(this.expectedSessionId, 'turn-state', record.line),
                     turnId,
                     ts,
                     status: 'aborted',
                     abortedAt: normalizeEpochMs(payload.completed_at) ?? ts,
                     abortSource: stringField(payload, 'reason') ?? 'codex',
                 });
-                if (activeTurnId === turnId) {
-                    activeTurnId = undefined;
-                    activeTurnIsExplicit = false;
+                if (this.activeTurnId === turnId) {
+                    this.activeTurnId = undefined;
+                    this.activeTurnIsExplicit = false;
                 }
-                continue;
+                return;
             }
         }
         if (envelope.type !== 'response_item')
-            continue;
+            return;
         const itemType = stringField(payload, 'type');
         if (itemType === 'function_call' || itemType === 'custom_tool_call') {
             const callId = stringField(payload, 'call_id');
             const toolName = namespacedToolName(payload);
             if (!callId || !toolName)
-                continue;
+                return;
             const rawArgs = itemType === 'function_call'
                 ? stringField(payload, 'arguments')
                 : stringField(payload, 'input');
-            messages.push({
+            this.append({
                 type: 'tool_call',
                 id: callId,
-                turnId: ensureTurnId(record.line),
-                ts: timestampFor(record),
+                turnId: this.ensureTurnId(record.line),
+                ts: this.timestampFor(record),
                 toolName,
                 args: parseJsonString(rawArgs),
             });
-            continue;
+            return;
         }
         if (itemType === 'function_call_output' || itemType === 'custom_tool_call_output') {
             const callId = stringField(payload, 'call_id');
             if (!callId)
-                continue;
-            messages.push({
+                return;
+            this.append({
                 type: 'tool_result',
                 id: stringField(payload, 'id') ??
-                    generatedCodexId(expectedSessionId, 'tool-result', record.line),
-                turnId: ensureTurnId(record.line),
-                ts: timestampFor(record),
+                    generatedCodexId(this.expectedSessionId, 'tool-result', record.line),
+                turnId: this.ensureTurnId(record.line),
+                ts: this.timestampFor(record),
                 toolUseId: callId,
                 // Codex persists the output body but not FunctionCallOutputPayload.success.
                 // Preserve the raw body and avoid guessing failure from its text.
@@ -444,37 +468,134 @@ function convertCodexRollout(text, expectedSessionId, fallbackName, fallbackCwd)
             });
         }
     }
-    const name = sanitizeForeignTitle(fallbackName) || sanitizeForeignTitle(firstUserText) || expectedSessionId;
-    return {
-        sourceSessionId: expectedSessionId,
-        metadata: { name, cwd: metaCwd || fallbackCwd },
-        messages,
-    };
+    finish() {
+        if (!this.hasSessionMeta) {
+            throw new Error(`Codex rollout Session id mismatch: expected ${this.expectedSessionId}`);
+        }
+        const name = sanitizeForeignTitle(this.fallbackName) ||
+            sanitizeForeignTitle(this.firstUserText) ||
+            this.expectedSessionId;
+        return {
+            sourceSessionId: this.expectedSessionId,
+            metadata: { name, cwd: this.metaCwd || this.fallbackCwd },
+            messages: this.messages,
+        };
+    }
+    timestampFor(record) {
+        const parsed = normalizeEpochMs(record.value.timestamp);
+        if (parsed !== undefined)
+            this.lastTimestamp = Math.max(this.lastTimestamp, parsed);
+        else
+            this.lastTimestamp += 1;
+        return parsed ?? this.lastTimestamp;
+    }
+    ensureTurnId(line) {
+        this.activeTurnId ??= generatedCodexId(this.expectedSessionId, 'turn', line);
+        return this.activeTurnId;
+    }
+    append(message) {
+        if (this.messages.length >= this.limits.maxMessages) {
+            throw new Error(`Codex rollout converts to more than ${this.limits.maxMessages} messages`);
+        }
+        const encodedBytes = Buffer.byteLength(JSON.stringify(message), 'utf8');
+        if (encodedBytes > this.limits.maxConvertedBytes - this.convertedBytes) {
+            throw new Error(`Codex rollout converts to more than ${this.limits.maxConvertedBytes} bytes`);
+        }
+        this.convertedBytes += encodedBytes;
+        this.messages.push(message);
+    }
 }
-function parseRolloutRecords(text, sessionId) {
-    const endsWithNewline = text.endsWith('\n');
-    const lines = text.split('\n');
-    if (endsWithNewline)
-        lines.pop();
-    const records = [];
-    for (let index = 0; index < lines.length; index += 1) {
-        const line = lines[index];
-        if (line.trim().length === 0)
-            continue;
-        try {
-            const value = JSON.parse(line);
-            if (!isRecord(value))
-                throw new Error('record is not an object');
-            records.push({ line: index + 1, value });
+async function* readCodexRolloutRecords(path, sessionId, limits) {
+    const handle = await open(path, 'r');
+    try {
+        const metadata = await handle.stat();
+        if (!metadata.isFile())
+            throw new Error('Codex rollout is not a regular file');
+        if (metadata.size > limits.maxRolloutBytes) {
+            throw new Error(`Codex rollout exceeds ${limits.maxRolloutBytes} bytes`);
         }
-        catch (error) {
-            if (!endsWithNewline && index === lines.length - 1)
-                break;
-            const detail = error instanceof Error ? error.message : String(error);
-            throw new Error(`Invalid Codex rollout ${sessionId} at line ${index + 1}: ${detail}`);
+        const snapshotBytes = metadata.size;
+        const pending = [];
+        let pendingBytes = 0;
+        let observedBytes = 0;
+        let line = 0;
+        if (snapshotBytes > 0) {
+            for await (const value of handle.createReadStream({
+                autoClose: false,
+                emitClose: false,
+                start: 0,
+                end: snapshotBytes - 1,
+                highWaterMark: CODEX_ROLLOUT_READ_BYTES,
+            })) {
+                const chunk = Buffer.from(value);
+                observedBytes += chunk.byteLength;
+                if (observedBytes > snapshotBytes) {
+                    throw new Error('Codex rollout changed while being read');
+                }
+                let start = 0;
+                for (;;) {
+                    const newline = chunk.indexOf(0x0a, start);
+                    if (newline === -1)
+                        break;
+                    const segment = chunk.subarray(start, newline);
+                    assertCodexRecordSize(pendingBytes + segment.byteLength, limits.maxRecordBytes, line + 1);
+                    line += 1;
+                    const record = parseCodexRolloutLine(pending.length === 0
+                        ? segment
+                        : Buffer.concat([...pending, segment], pendingBytes + segment.byteLength), sessionId, line, false);
+                    if (record)
+                        yield record;
+                    pending.length = 0;
+                    pendingBytes = 0;
+                    start = newline + 1;
+                }
+                if (start < chunk.byteLength) {
+                    const segment = chunk.subarray(start);
+                    assertCodexRecordSize(pendingBytes + segment.byteLength, limits.maxRecordBytes, line + 1);
+                    pending.push(segment);
+                    pendingBytes += segment.byteLength;
+                }
+            }
+        }
+        if (observedBytes !== snapshotBytes)
+            throw new Error('Codex rollout changed while being read');
+        if (pendingBytes > 0) {
+            line += 1;
+            const record = parseCodexRolloutLine(pending.length === 1 ? pending[0] : Buffer.concat(pending, pendingBytes), sessionId, line, true);
+            if (record)
+                yield record;
         }
     }
-    return records;
+    finally {
+        await handle.close();
+    }
+}
+function parseCodexRolloutLine(bytes, sessionId, line, tolerateTornTail) {
+    const text = bytes.toString('utf8');
+    if (text.trim().length === 0)
+        return undefined;
+    try {
+        const value = JSON.parse(text);
+        if (!isRecord(value))
+            throw new Error('record is not an object');
+        return { line, value };
+    }
+    catch (error) {
+        if (tolerateTornTail)
+            return undefined;
+        const detail = error instanceof Error ? error.message : String(error);
+        throw new Error(`Invalid Codex rollout ${sessionId} at line ${line}: ${detail}`);
+    }
+}
+function assertCodexRecordSize(actualBytes, maxBytes, line) {
+    if (actualBytes > maxBytes) {
+        throw new Error(`Codex rollout record at line ${line} exceeds ${maxBytes} bytes`);
+    }
+}
+function assertPositiveSafeInteger(value, label) {
+    if (!Number.isSafeInteger(value) || value <= 0) {
+        throw new Error(`${label} must be a positive safe integer`);
+    }
 }
 function catalogEntryFromRolloutHead(text, candidate) {
     const lines = text.split('\n');
@@ -644,39 +765,6 @@ async function walkRolloutFiles(root, archived) {
     await visit(root);
     return files;
 }
-async function readBoundedUtf8File(path, maxBytes) {
-    const handle = await open(path, 'r');
-    try {
-        const metadata = await handle.stat();
-        if (!metadata.isFile())
-            throw new Error('Codex rollout is not a regular file');
-        if (metadata.size > maxBytes)
-            throw new Error(`Codex rollout exceeds ${maxBytes} bytes`);
-        const chunks = [];
-        let total = 0;
-        for (;;) {
-            const buffer = Buffer.allocUnsafe(Math.min(64 * 1024, maxBytes + 1 - total));
-            const { bytesRead } = await handle.read(buffer, 0, buffer.length, total);
-            if (bytesRead === 0)
-                break;
-            total += bytesRead;
-            if (total > maxBytes)
-                throw new Error(`Codex rollout exceeds ${maxBytes} bytes`);
-            chunks.push(buffer.subarray(0, bytesRead));
-            if (total === maxBytes) {
-                const probe = Buffer.allocUnsafe(1);
-                if ((await handle.read(probe, 0, 1, total)).bytesRead > 0) {
-                    throw new Error(`Codex rollout exceeds ${maxBytes} bytes`);
-                }
-                break;
-            }
-        }
-        return Buffer.concat(chunks, total).toString('utf8');
-    }
-    finally {
-        await handle.close();
-    }
-}
 async function readUtf8Prefix(path, maxBytes) {
     const handle = await open(path, 'r');
     try {