@scotthuang/agent-knock-knock 0.13.16 → 0.13.18

package/dist/src/terminal-submission-acceptance.js

@@ -1,683 +1,14 @@
-import { createHash } from "node:crypto";
+import { assertPrivateRegularFile, fileEndsWithNewline, openExactRollout, readCodexRolloutHeader, sameRolloutFileIdentity, sameRolloutIdentity, sameStableFile, } from "./codex-rollout-file.js";
+import { codexRolloutInodeKey, validateCodexOpenRootInventoryForAcceptance, validateCodexRecoveryCandidateForAcceptance, } from "./codex-rollout-inventory.js";
+import { assertCodexRolloutLegacyHistory, exactCodexUserResponseText, fingerprintText, isRecord, optionalString, } from "./codex-rollout-records.js";
+import { codexThreadUsesLegacyRollout, } from "./codex-session-provider.js";
+import { exactNativeThreadId, fingerprint, normalizedRolloutIdentity, requiredString, sha256Value, validateCodexRolloutAcceptanceAnchor, validateTerminalSubmissionAcceptanceEvidence, validTimestamp, } from "./terminal-submission-facts.js";
 import fs from "node:fs";
-import path from "node:path";
-import { codexThreadUsesLegacyRollout } from "./codex-session-provider.js";
-import { redactString } from "./runtime-log.js";
-import { exactNativeThreadId, fingerprint, normalizedRolloutIdentity, parsedInteger, requiredString, sha256Value, validTimestamp, validateCodexRolloutAcceptanceAnchor, validateTerminalSubmissionAcceptanceEvidence } from "./terminal-submission-facts.js";
 export { validateCodexRolloutAcceptanceAnchor, validateTerminalSubmissionAcceptanceEvidence };
+export { captureCodexHumanStartedActiveTaskAnchor, observeCodexHumanStartedActiveTask, validateCodexHumanStartedActiveTaskAnchor, } from "./codex-rollout-human-task.js";
+export { detectCodexBoundQuestionnaireAttribution, readCodexAsyncQuestionDurableEvidence, } from "./codex-rollout-interaction-evidence.js";
+export { detectCodexBoundRolloutCompletion, } from "./codex-rollout-bound-completion.js";
 const CODEX_ACCEPTANCE_MAX_BYTES = 16 * 1024 * 1024;
-const CODEX_COMPLETION_MAX_BYTES = 256 * 1024 * 1024;
-const CODEX_COMPLETION_MAX_TEXT_LENGTH = 4000;
-const CODEX_ACTIVE_TASK_SCAN_CHUNK_BYTES = 64 * 1024;
-const CODEX_QUESTIONNAIRE_TAIL_MAX_BYTES = 1024 * 1024;
-const CODEX_QUESTIONNAIRE_MAX_TEXT_LENGTH = 16 * 1024;
-const CODEX_QUESTIONNAIRE_MAX_OPTIONS = 8;
-const CODEX_QUESTIONNAIRE_MAX_QUESTIONS = 3;
-const CODEX_QUESTIONNAIRE_OTHER_LABEL = "None of the above";
-const CODEX_QUESTIONNAIRE_OTHER_DESCRIPTION = "Optionally, add details in notes (tab).";
-const CODEX_QUESTIONNAIRE_CUSTOM_LABEL = "Type something.";
-const CODEX_QUESTIONNAIRE_CUSTOM_DESCRIPTION = "Enter a free-form answer through Codex Notes.";
-const CODEX_ASYNC_QUESTION_TAIL_MAX_BYTES = 4 * 1024 * 1024;
-const CODEX_ASYNC_QUESTION_MAX_ITEMS = 16;
-const CODEX_ASYNC_QUESTION_MAX_QUESTIONS = 16;
-const CODEX_ASYNC_QUESTION_MAX_OPTIONS = 32;
-const CODEX_ASYNC_QUESTION_MAX_TEXT_LENGTH = 4_096;
-const CODEX_ACTIVE_TASK_MAX_RECORD_BYTES = 16 * 1024 * 1024;
-const CODEX_ROLLOUT_HEADER_MAX_BYTES = 1024 * 1024;
-const CODEX_VERSION_PATTERN = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/u;
-const NO_FOLLOW_FLAG = typeof fs.constants.O_NOFOLLOW === "number"
-    ? fs.constants.O_NOFOLLOW
-    : 0;
-/**
- * Capture the latest active native task in an exact open Codex rollout.
- * This is intentionally separate from the pre-send acceptance anchor: all
- * task-start and root-user evidence already exists when this function runs.
- */
-export function captureCodexHumanStartedActiveTaskAnchor(options) {
-    const current = options.currentIdentity;
-    const nativeThreadId = exactNativeThreadId(current.sessionId);
-    const processUuid = requiredString(current.processUuid, "Codex process UUID");
-    const processBirth = requiredString(current.processBirth, "Codex process birth");
-    if (!current.rollout) {
-        throw new Error("the active Codex task has no exact rollout identity");
-    }
-    const rollout = normalizedRolloutIdentity(current.rollout);
-    const maxBytes = positiveByteLimit(options.maxBytes, CODEX_COMPLETION_MAX_BYTES, "Codex active-task capture");
-    const opened = openExactRollout(rollout);
-    try {
-        const before = opened.stat;
-        assertPrivateRegularFile(before);
-        if (before.size === 0) {
-            return undefined;
-        }
-        if (!fileEndsWithNewline(opened.fd, before.size)) {
-            throw new Error("Codex active-task rollout has an incomplete JSONL tail; retry");
-        }
-        const header = readCodexRolloutHeader(opened.fd, before.size);
-        const codexVersion = assertExistingCodexRolloutHeader(header, nativeThreadId);
-        const active = latestCodexHumanStartedActiveTask(opened.fd, before.size, maxBytes);
-        const after = fs.fstatSync(opened.fd);
-        if (!sameStableFile(before, after)) {
-            throw new Error("Codex active-task rollout changed while it was captured; retry");
-        }
-        if (!active) {
-            return undefined;
-        }
-        const base = {
-            schema: "agent-knock-knock/codex-human-started-active-task-anchor",
-            version: 1,
-            native_thread_id: nativeThreadId,
-            process_uuid: processUuid,
-            process_birth: processBirth,
-            captured_at: (options.now ?? new Date()).toISOString(),
-            rollout,
-            turn_id: active.turnId,
-            request_hash: active.requestHash,
-            codex_version: codexVersion,
-            task_started_offset_bytes: active.taskStartedOffsetBytes,
-            user_message_offset_bytes: active.userMessageOffsetBytes,
-            observed_end_offset_bytes: before.size
-        };
-        return {
-            ...base,
-            anchor_fingerprint: fingerprint(base)
-        };
-    }
-    finally {
-        fs.closeSync(opened.fd);
-    }
-}
-/** Observe only the exact human-started task named by the persisted anchor. */
-export function observeCodexHumanStartedActiveTask(options) {
-    try {
-        const anchor = validateCodexHumanStartedActiveTaskAnchor(options.anchor);
-        const maxBytes = positiveByteLimit(options.maxBytes, CODEX_COMPLETION_MAX_BYTES, "Codex active-task observation");
-        const resumeOffsetBytes = codexActiveTaskResumeOffset(anchor, options.resumeOffsetBytes);
-        const opened = openExactRollout(anchor.rollout);
-        try {
-            const before = opened.stat;
-            assertPrivateRegularFile(before);
-            if (before.size < anchor.observed_end_offset_bytes) {
-                throw new Error("Codex active-task rollout was truncated after capture");
-            }
-            if (before.size < resumeOffsetBytes) {
-                throw new Error("Codex active-task rollout was truncated after observation");
-            }
-            assertCodexRolloutLegacyHistory(readCodexRolloutHeader(opened.fd, before.size));
-            assertCodexActiveTaskResumeBoundary(opened.fd, resumeOffsetBytes);
-            const availableBytes = before.size - resumeOffsetBytes;
-            const bytesToRead = Math.min(availableBytes, maxBytes);
-            if (bytesToRead === 0) {
-                assertCodexHumanStartedIdentity(anchor, options.currentIdentity);
-                return {
-                    status: "pending",
-                    observedEndOffsetBytes: before.size,
-                    safeResumeOffsetBytes: resumeOffsetBytes
-                };
-            }
-            const buffer = readExactBytes(opened.fd, resumeOffsetBytes, bytesToRead);
-            const completeLength = completeJsonlPrefixLength(buffer);
-            if (completeLength === 0 && availableBytes > maxBytes) {
-                throw new Error("Codex active-task JSONL record exceeded the bounded read limit");
-            }
-            const completeBuffer = buffer.subarray(0, completeLength);
-            const safeResumeOffsetBytes = resumeOffsetBytes + completeLength;
-            const after = fs.fstatSync(opened.fd);
-            if (!sameStableFile(before, after)) {
-                assertCodexHumanStartedIdentity(anchor, options.currentIdentity);
-                return {
-                    status: "pending",
-                    observedEndOffsetBytes: after.size,
-                    safeResumeOffsetBytes: resumeOffsetBytes
-                };
-            }
-            const suffixRecords = parseCodexJsonlRecords(completeBuffer, "active-task suffix");
-            const laterTaskOffset = suffixRecords.find(({ value }) => isLaterCodexHumanTaskStartedRecord(value))?.offsetBytes;
-            const exactCompletionOffset = suffixRecords.find(({ value }) => isExactCodexTaskCompleteRecord(value, anchor.turn_id))?.offsetBytes;
-            const exactAbortRecords = suffixRecords.filter(({ value }) => isExactCodexTurnAbortedRecord(value, anchor.turn_id));
-            if (exactAbortRecords.length > 1) {
-                throw new Error("the exact Codex active task has duplicate turn_aborted records");
-            }
-            const exactAbort = exactAbortRecords[0];
-            const exactSettlementOffset = [
-                exactCompletionOffset,
-                exactAbort?.offsetBytes
-            ].filter((offset) => offset !== undefined)
-                .sort((left, right) => left - right)[0];
-            if (laterTaskOffset !== undefined &&
-                (exactSettlementOffset === undefined ||
-                    laterTaskOffset < exactSettlementOffset)) {
-                throw new Error("a later Codex human task appeared after the active-task anchor");
-            }
-            if (exactAbort &&
-                (exactCompletionOffset === undefined ||
-                    exactAbort.offsetBytes < exactCompletionOffset)) {
-                return codexHumanStartedTaskAbortCompletion(anchor, exactAbort.value, before.size);
-            }
-            const completion = scanExactCodexTaskComplete(completeBuffer.toString("utf8"), anchor.turn_id);
-            if (completion.status === "failure") {
-                throw new Error(completion.detail);
-            }
-            if (completion.status === "pending") {
-                assertCodexHumanStartedIdentity(anchor, options.currentIdentity);
-                return {
-                    status: "pending",
-                    observedEndOffsetBytes: before.size,
-                    safeResumeOffsetBytes
-                };
-            }
-            if (completion.status === "aborted") {
-                throw new Error("Codex active-task abort evidence escaped its exact lifecycle fence");
-            }
-            return {
-                status: "completed",
-                completion: {
-                    source: "durable",
-                    outcome: "success",
-                    text: truncateCompletionText(redactString(completion.text)),
-                    ...(completion.timestamp ? { timestamp: completion.timestamp } : {}),
-                    id: anchor.turn_id,
-                    confidence: "high",
-                    metadata: {
-                        match: "human_started_bound_rollout_task_complete",
-                        turn_id: anchor.turn_id,
-                        native_thread_id: anchor.native_thread_id,
-                        anchor_fingerprint: anchor.anchor_fingerprint,
-                        observed_end_offset_bytes: before.size
-                    }
-                }
-            };
-        }
-        finally {
-            fs.closeSync(opened.fd);
-        }
-    }
-    catch (error) {
-        if (isRetryableProviderIoError(error)) {
-            return {
-                status: "unavailable",
-                reason: error instanceof Error ? error.message : String(error),
-                retryable: true
-            };
-        }
-        return {
-            status: "invalidated",
-            reason: error instanceof Error ? error.message : String(error)
-        };
-    }
-}
-function codexActiveTaskResumeOffset(anchor, value) {
-    const offset = value === undefined
-        ? anchor.observed_end_offset_bytes
-        : safeByteOffset(value, "Codex active-task resume offset");
-    if (offset < anchor.observed_end_offset_bytes) {
-        throw new Error("Codex active-task resume offset predates its anchor");
-    }
-    return offset;
-}
-function assertCodexActiveTaskResumeBoundary(fd, offset) {
-    if (offset > 0 && byteAtOffset(fd, offset - 1) !== 0x0a) {
-        throw new Error("Codex active-task resume offset is not a JSONL boundary");
-    }
-}
-function completeJsonlPrefixLength(buffer) {
-    if (buffer.length === 0) {
-        return 0;
-    }
-    const newline = buffer.lastIndexOf(0x0a);
-    return newline < 0 ? 0 : newline + 1;
-}
-export function validateCodexHumanStartedActiveTaskAnchor(value) {
-    if (!isRecord(value) ||
-        value.schema !==
-            "agent-knock-knock/codex-human-started-active-task-anchor" ||
-        value.version !== 1) {
-        throw new Error("Codex human-started active-task anchor is invalid");
-    }
-    const allowedKeys = new Set([
-        "schema", "version", "native_thread_id", "process_uuid", "process_birth",
-        "captured_at", "rollout", "turn_id", "request_hash", "codex_version",
-        "task_started_offset_bytes", "user_message_offset_bytes",
-        "observed_end_offset_bytes", "anchor_fingerprint"
-    ]);
-    if (Object.keys(value).some((key) => !allowedKeys.has(key))) {
-        throw new Error("Codex human-started active-task anchor has unsupported fields");
-    }
-    const nativeThreadId = exactNativeThreadId(value.native_thread_id);
-    const turnId = exactNativeThreadId(value.turn_id);
-    const capturedAt = value.captured_at;
-    if (nativeThreadId !== value.native_thread_id ||
-        turnId !== value.turn_id ||
-        !validTimestamp(capturedAt) ||
-        typeof capturedAt !== "string" ||
-        new Date(capturedAt).toISOString() !== capturedAt) {
-        throw new Error("Codex human-started active-task anchor identity is invalid");
-    }
-    for (const [field, label] of [
-        [value.process_uuid, "Codex active-task process UUID"],
-        [value.process_birth, "Codex active-task process birth"]
-    ]) {
-        if (requiredString(field, label) !== field ||
-            field.includes("\0")) {
-            throw new Error(`${label} is not canonical`);
-        }
-    }
-    if (sha256Value(value.request_hash, "Codex active-task request hash") !==
-        value.request_hash) {
-        throw new Error("Codex active-task request hash is not canonical");
-    }
-    if (typeof value.codex_version !== "string" ||
-        !CODEX_VERSION_PATTERN.test(value.codex_version)) {
-        throw new Error("Codex active-task version is invalid");
-    }
-    if (sha256Value(value.anchor_fingerprint, "Codex active-task anchor fingerprint") !== value.anchor_fingerprint) {
-        throw new Error("Codex active-task anchor fingerprint is not canonical");
-    }
-    if (!isRecord(value.rollout)) {
-        throw new Error("Codex human-started active-task rollout identity is invalid");
-    }
-    const rolloutKeys = new Set(["fd", "device", "inode", "path"]);
-    if (Object.keys(value.rollout).some((key) => !rolloutKeys.has(key))) {
-        throw new Error("Codex human-started active-task rollout has unsupported fields");
-    }
-    const rollout = normalizedRolloutIdentity(value.rollout);
-    if (Object.entries(rollout).some(([key, normalized]) => normalized !== value.rollout[key] || normalized.includes("\0")) ||
-        !path.isAbsolute(rollout.path)) {
-        throw new Error("Codex human-started active-task rollout path is not absolute");
-    }
-    const taskStartedOffset = safeByteOffset(value.task_started_offset_bytes, "Codex active-task task_started offset");
-    const userMessageOffset = safeByteOffset(value.user_message_offset_bytes, "Codex active-task user-message offset");
-    const observedEndOffset = safeByteOffset(value.observed_end_offset_bytes, "Codex active-task observed-end offset");
-    if (userMessageOffset <= taskStartedOffset ||
-        observedEndOffset <= userMessageOffset) {
-        throw new Error("Codex human-started active-task byte boundaries are inconsistent");
-    }
-    const { anchor_fingerprint: _anchorFingerprint, ...base } = value;
-    if (fingerprint(base) !== value.anchor_fingerprint) {
-        throw new Error("Codex human-started active-task anchor fingerprint does not match");
-    }
-    return value;
-}
-function assertCodexHumanStartedIdentity(anchor, current) {
-    if (exactNativeThreadId(current.sessionId) !== anchor.native_thread_id ||
-        requiredString(current.processUuid, "Codex process UUID") !==
-            anchor.process_uuid ||
-        requiredString(current.processBirth, "Codex process birth") !==
-            anchor.process_birth ||
-        !current.rollout ||
-        !sameRolloutIdentity(normalizedRolloutIdentity(current.rollout), anchor.rollout)) {
-        throw new Error("Codex process, thread, or rollout identity changed after capture");
-    }
-}
-function latestCodexHumanStartedActiveTask(fd, endOffset, maxBytes) {
-    const lowerBound = Math.max(0, endOffset - maxBytes);
-    const terminalTurns = new Map();
-    const userRecords = [];
-    let userMessageRecordCount = 0;
-    let cursor = endOffset;
-    let leadingRecord = Buffer.alloc(0);
-    let followingRecord;
-    while (cursor > lowerBound) {
-        const readStart = Math.max(lowerBound, cursor - CODEX_ACTIVE_TASK_SCAN_CHUNK_BYTES);
-        const chunk = readExactBytes(fd, readStart, cursor - readStart);
-        const combined = leadingRecord.length > 0
-            ? Buffer.concat([chunk, leadingRecord])
-            : chunk;
-        let recordsBuffer = combined;
-        let recordsOffset = readStart;
-        if (readStart > 0) {
-            const firstNewline = combined.indexOf(0x0a);
-            if (firstNewline < 0) {
-                assertBoundedCodexActiveTaskRecord(combined.length);
-                leadingRecord = Buffer.from(combined);
-                cursor = readStart;
-                continue;
-            }
-            leadingRecord = Buffer.from(combined.subarray(0, firstNewline + 1));
-            assertBoundedCodexActiveTaskRecord(leadingRecord.length);
-            recordsBuffer = combined.subarray(firstNewline + 1);
-            recordsOffset += firstNewline + 1;
-        }
-        else {
-            leadingRecord = Buffer.alloc(0);
-        }
-        const records = parseCodexJsonlRecords(recordsBuffer, "active-task rollout tail");
-        for (let index = records.length - 1; index >= 0; index -= 1) {
-            const record = records[index];
-            const absoluteRecord = {
-                value: record.value,
-                offsetBytes: recordsOffset + record.offsetBytes
-            };
-            if (isCodexUserMessageRecord(absoluteRecord.value)) {
-                userMessageRecordCount += 1;
-            }
-            const decision = inspectCodexActiveTaskRecordInReverse(absoluteRecord, terminalTurns, userRecords, userMessageRecordCount, followingRecord);
-            if (decision.status === "resolved") {
-                return decision.active;
-            }
-            followingRecord = absoluteRecord;
-        }
-        cursor = readStart;
-    }
-    if (lowerBound > 0) {
-        throw new Error("Codex active-task boundary exceeded the bounded reverse scan limit");
-    }
-    return undefined;
-}
-function inspectCodexActiveTaskRecordInReverse(record, terminalTurns, userRecords, userMessageRecordCount, followingRecord) {
-    const { value, offsetBytes } = record;
-    const payload = isRecord(value.payload) ? value.payload : undefined;
-    if (!payload) {
-        return { status: "continue" };
-    }
-    if (value.type === "event_msg" &&
-        (payload.type === "task_complete" || payload.type === "turn_aborted")) {
-        const turnId = exactNativeThreadId(payload.turn_id);
-        const kind = payload.type === "task_complete" ? "completed" : "aborted";
-        const previous = terminalTurns.get(turnId);
-        if (previous) {
-            throw new Error(previous === kind
-                ? `Codex rollout contains duplicate ${String(payload.type)} evidence`
-                : "Codex rollout contains conflicting terminal task evidence");
-        }
-        terminalTurns.set(turnId, kind);
-        return { status: "continue" };
-    }
-    if (isCodexUserResponseRecord(value)) {
-        const userRecord = pairedCodexActiveTaskUserRecord(record, followingRecord);
-        if (userRecord) {
-            userRecords.push(userRecord);
-        }
-        return { status: "continue" };
-    }
-    if (value.type !== "event_msg" || payload.type !== "task_started") {
-        return { status: "continue" };
-    }
-    const turnId = exactNativeThreadId(payload.turn_id);
-    if (terminalTurns.has(turnId)) {
-        return { status: "resolved" };
-    }
-    if (userMessageRecordCount === 0) {
-        return { status: "resolved" };
-    }
-    if (userMessageRecordCount !== 1) {
-        throw new Error("Codex active task has multiple user_message events");
-    }
-    const matchingUsers = userRecords.filter((user) => user.turnId === turnId);
-    if (matchingUsers.length === 0) {
-        throw new Error("Codex active task has no exact adjacent root user row for its user_message event");
-    }
-    if (matchingUsers.length !== 1) {
-        throw new Error("Codex active task has multiple same-turn root user rows");
-    }
-    const [user] = matchingUsers;
-    if (user.pairingIssue === "hash_mismatch") {
-        throw new Error("Codex active-task root user row does not match its user_message event");
-    }
-    if (user.pairingIssue === "turn_mismatch") {
-        throw new Error("Codex active-task root user row does not match its adjacent UserMessage turn");
-    }
-    if (user.requestHash === undefined) {
-        throw new Error("Codex active-task root user row has unsupported prompt content");
-    }
-    if (user.offsetBytes <= offsetBytes) {
-        throw new Error("Codex active-task root user row precedes task_started");
-    }
-    if (userRecords.some((candidate) => candidate.offsetBytes > user.offsetBytes && candidate.turnId !== turnId)) {
-        throw new Error("Codex active task is not the latest native human task");
-    }
-    return {
-        status: "resolved",
-        active: {
-            turnId,
-            requestHash: user.requestHash,
-            taskStartedOffsetBytes: offsetBytes,
-            userMessageOffsetBytes: user.offsetBytes
-        }
-    };
-}
-function assertBoundedCodexActiveTaskRecord(length) {
-    if (length > CODEX_ACTIVE_TASK_MAX_RECORD_BYTES) {
-        throw new Error("Codex active-task JSONL record exceeded the safe read limit");
-    }
-}
-function pairedCodexActiveTaskUserRecord(record, followingRecord) {
-    const payload = isRecord(record.value.payload)
-        ? record.value.payload
-        : undefined;
-    const metadata = payload &&
-        isRecord(payload.internal_chat_message_metadata_passthrough)
-        ? payload.internal_chat_message_metadata_passthrough
-        : undefined;
-    const rawTurnId = optionalString(metadata?.turn_id);
-    // Codex writes one provider-owned user-message event immediately after the
-    // human root response row. Older rollouts use event_msg.user_message; newer
-    // Codex surfaces use event_msg.item_completed with item.type=UserMessage.
-    // Synthetic user-role context has no such adjacent proof.
-    if (!payload ||
-        !rawTurnId ||
-        !isCodexUserMessageRecord(followingRecord?.value)) {
-        return undefined;
-    }
-    const text = exactCodexUserResponseText(payload.content);
-    const requestHash = text === undefined ? undefined : fingerprintText(text);
-    const userMessageHash = codexUserMessageHash(followingRecord?.value);
-    const adjacentTurnId = codexUserMessageTurnId(followingRecord?.value);
-    const rootTurnId = exactNativeThreadId(rawTurnId);
-    const pairingIssue = adjacentTurnId !== undefined &&
-        exactNativeThreadId(adjacentTurnId) !== rootTurnId
-        ? "turn_mismatch"
-        : requestHash === undefined || userMessageHash === undefined
-            ? "unsupported"
-            : requestHash !== userMessageHash
-                ? "hash_mismatch"
-                : undefined;
-    return {
-        offsetBytes: record.offsetBytes,
-        turnId: rootTurnId,
-        ...(pairingIssue ? { pairingIssue } : { requestHash })
-    };
-}
-function isCodexUserResponseRecord(value) {
-    const payload = isRecord(value.payload) ? value.payload : undefined;
-    return value.type === "response_item" &&
-        payload?.type === "message" &&
-        payload.role === "user";
-}
-function codexUserMessageHash(value) {
-    const payload = value && isRecord(value.payload) ? value.payload : undefined;
-    if (value?.type === "event_msg" &&
-        payload?.type === "user_message" &&
-        typeof payload.message === "string") {
-        return fingerprintText(payload.message);
-    }
-    const item = payload?.type === "item_completed" && isRecord(payload.item)
-        ? payload.item
-        : undefined;
-    const content = item?.type === "UserMessage" && Array.isArray(item.content)
-        ? item.content
-        : undefined;
-    if (!content || content.length !== 1)
-        return undefined;
-    const text = content[0];
-    return isRecord(text) && text.type === "text" &&
-        typeof text.text === "string"
-        ? fingerprintText(text.text)
-        : undefined;
-}
-function codexUserMessageTurnId(value) {
-    const payload = value && isRecord(value.payload) ? value.payload : undefined;
-    return value?.type === "event_msg" &&
-        payload?.type === "item_completed" &&
-        isRecord(payload.item) &&
-        payload.item.type === "UserMessage"
-        ? optionalString(payload.turn_id)
-        : undefined;
-}
-function isCodexUserMessageRecord(value) {
-    const payload = value && isRecord(value.payload) ? value.payload : undefined;
-    return value?.type === "event_msg" &&
-        (payload?.type === "user_message" ||
-            (payload?.type === "item_completed" &&
-                isRecord(payload.item) &&
-                payload.item.type === "UserMessage"));
-}
-function isLaterCodexHumanTaskStartedRecord(value) {
-    const payload = isRecord(value.payload) ? value.payload : undefined;
-    // User-role response rows can be same-turn synthetic context. Only a fresh
-    // task_started record is authoritative evidence that the anchor was passed.
-    return value.type === "event_msg" &&
-        payload?.type === "task_started";
-}
-function isExactCodexTaskCompleteRecord(value, expectedTurnId) {
-    const payload = isRecord(value.payload) ? value.payload : undefined;
-    return value.type === "event_msg" &&
-        payload?.type === "task_complete" &&
-        optionalString(payload.turn_id)?.toLowerCase() === expectedTurnId;
-}
-function isExactCodexTurnAbortedRecord(value, expectedTurnId) {
-    const payload = isRecord(value.payload) ? value.payload : undefined;
-    return value.type === "event_msg" &&
-        payload?.type === "turn_aborted" &&
-        optionalString(payload.turn_id)?.toLowerCase() === expectedTurnId;
-}
-function codexHumanStartedTaskAbortCompletion(anchor, value, observedEndOffsetBytes) {
-    const payload = isRecord(value.payload) ? value.payload : undefined;
-    if (!payload || payload.type !== "turn_aborted") {
-        throw new Error("Codex active-task abort evidence is invalid");
-    }
-    const reason = optionalString(payload.reason) ?? "interrupted";
-    if (value.timestamp !== undefined && !validTimestamp(value.timestamp)) {
-        throw new Error("Codex active-task turn_aborted record has an invalid timestamp");
-    }
-    const redactedReason = truncateCompletionText(redactString(reason));
-    return {
-        status: "completed",
-        completion: {
-            source: "durable",
-            outcome: "failure",
-            text: truncateCompletionText(redactString(`Codex task stopped: ${redactedReason}`)),
-            ...(value.timestamp !== undefined
-                ? { timestamp: String(value.timestamp) }
-                : {}),
-            id: anchor.turn_id,
-            confidence: "high",
-            metadata: {
-                match: "human_started_bound_rollout_turn_aborted",
-                turn_id: anchor.turn_id,
-                native_thread_id: anchor.native_thread_id,
-                anchor_fingerprint: anchor.anchor_fingerprint,
-                abort_reason: redactedReason,
-                observed_end_offset_bytes: observedEndOffsetBytes
-            }
-        }
-    };
-}
-function parseCodexJsonlRecords(buffer, label) {
-    if (buffer.length > 0 && buffer[buffer.length - 1] !== 0x0a) {
-        throw new Error(`Codex ${label} ends with an incomplete JSONL record`);
-    }
-    const records = [];
-    let offset = 0;
-    while (offset < buffer.length) {
-        const newline = buffer.indexOf(0x0a, offset);
-        if (newline < 0) {
-            break;
-        }
-        const recordOffset = offset;
-        let lineBuffer = buffer.subarray(offset, newline);
-        if (lineBuffer.at(-1) === 0x0d) {
-            lineBuffer = lineBuffer.subarray(0, lineBuffer.length - 1);
-        }
-        offset = newline + 1;
-        const line = lineBuffer.toString("utf8");
-        if (!line.trim()) {
-            continue;
-        }
-        let parsed;
-        try {
-            parsed = JSON.parse(line);
-        }
-        catch {
-            throw new Error(`Codex ${label} contains invalid JSONL`);
-        }
-        if (!isRecord(parsed)) {
-            throw new Error(`Codex ${label} contains a non-object JSONL record`);
-        }
-        records.push({ value: parsed, offsetBytes: recordOffset });
-    }
-    return records;
-}
-function assertExistingCodexRolloutHeader(buffer, nativeThreadId) {
-    const first = parseCodexJsonlRecords(buffer, "active-task rollout")[0]?.value;
-    const payload = first?.type === "session_meta" && isRecord(first.payload)
-        ? first.payload
-        : undefined;
-    if (!payload ||
-        exactNativeThreadId(payload.id) !== nativeThreadId ||
-        payload.originator !== "codex-tui" ||
-        payload.source !== "cli") {
-        throw new Error("Codex active-task rollout header does not identify the exact CLI thread");
-    }
-    if (!codexThreadUsesLegacyRollout(payload)) {
-        throw new Error("Codex rollout does not use legacy history");
-    }
-    const codexVersion = optionalString(payload.cli_version);
-    if (!codexVersion || !CODEX_VERSION_PATTERN.test(codexVersion)) {
-        throw new Error("Codex active-task rollout header has no exact CLI version");
-    }
-    return codexVersion;
-}
-/**
- * Persisted anchors must check the history contract without widening their
- * existing thread/version requirements. Older legacy headers can be minimal.
- */
-function assertCodexRolloutLegacyHistory(buffer) {
-    const first = parseCodexJsonlRecords(buffer, "rollout header")[0]?.value;
-    const payload = first?.type === "session_meta" && isRecord(first.payload)
-        ? first.payload
-        : undefined;
-    if (payload && !codexThreadUsesLegacyRollout(payload)) {
-        throw new Error("Codex rollout does not use legacy history");
-    }
-}
-function readCodexRolloutHeader(fd, size) {
-    const bytesToRead = Math.min(size, CODEX_ROLLOUT_HEADER_MAX_BYTES);
-    const buffer = readExactBytes(fd, 0, bytesToRead);
-    const newline = buffer.indexOf(0x0a);
-    if (newline < 0) {
-        throw new Error("Codex active-task rollout header exceeded the safe read limit");
-    }
-    return buffer.subarray(0, newline + 1);
-}
-function readExactBytes(fd, offset, length) {
-    const buffer = Buffer.allocUnsafe(length);
-    let total = 0;
-    while (total < length) {
-        const read = fs.readSync(fd, buffer, total, length - total, offset + total);
-        if (read === 0) {
-            break;
-        }
-        total += read;
-    }
-    if (total !== length) {
-        throw new Error("Codex rollout changed while it was being read");
-    }
-    return buffer;
-}
-function positiveByteLimit(value, fallback, label) {
-    const result = value ?? fallback;
-    if (!Number.isSafeInteger(result) || result <= 0) {
-        throw new Error(`${label} byte limit is invalid`);
-    }
-    return result;
-}
-function safeByteOffset(value, label) {
-    if (!Number.isSafeInteger(value) || Number(value) < 0) {
-        throw new Error(`${label} is invalid`);
-    }
-    return Number(value);
-}
 export function captureCodexRolloutAcceptanceAnchor(options) {
     const processUuid = requiredString(options.processUuid, "Codex process UUID");
     const processBirth = requiredString(options.processBirth, "Codex process birth");
@@ -1002,94 +333,6 @@ export function detectCodexCandidateSetRolloutAcceptance({ anchor: anchorValue,
         evidence: matches[0].evidence
     };
 }
-/**
- * Attributes a rendered questionnaire to one exact accepted Codex turn while
- * the process has multiple open root rollouts. No prompt or tool arguments are
- * returned: callers receive only a bounded fingerprint or a typed failure.
- */
-export function detectCodexBoundQuestionnaireAttribution(options) {
-    let inventory;
-    let acceptedThreadId;
-    let acceptedRollout;
-    let acceptanceId;
-    try {
-        inventory = validateCodexOpenRootInventoryForAcceptance(options.currentInventory);
-        acceptedThreadId = exactNativeThreadId(options.acceptedIdentity.sessionId);
-        acceptanceId = exactNativeThreadId(options.acceptanceId);
-        if (!options.acceptedIdentity.rollout) {
-            throw new Error("accepted Codex rollout identity is unavailable");
-        }
-        acceptedRollout = normalizedRolloutIdentity(options.acceptedIdentity.rollout);
-        if (requiredString(options.acceptedIdentity.processUuid, "accepted Codex process UUID") !== inventory.processUuid ||
-            requiredString(options.acceptedIdentity.processBirth, "accepted Codex process birth") !== inventory.processBirth) {
-            return { status: "not_matched", code: "accepted_root_missing" };
-        }
-    }
-    catch {
-        return { status: "unavailable", code: "invalid_inventory" };
-    }
-    let normalizedScreen;
-    try {
-        normalizedScreen = normalizedCodexQuestionnaireScreen(options.screen);
-    }
-    catch {
-        return { status: "unavailable", code: "invalid_screen" };
-    }
-    const acceptedRoots = inventory.roots.filter((root) => root.sessionId.toLowerCase() === acceptedThreadId &&
-        sameRolloutFileIdentity(root.rollout, acceptedRollout));
-    if (acceptedRoots.length !== 1) {
-        return { status: "not_matched", code: "accepted_root_missing" };
-    }
-    let maxBytes;
-    try {
-        maxBytes = positiveByteLimit(options.maxBytesPerRollout, CODEX_QUESTIONNAIRE_TAIL_MAX_BYTES, "Codex questionnaire rollout scan limit");
-    }
-    catch {
-        return { status: "unavailable", code: "rollout_scan_unavailable" };
-    }
-    const pending = [];
-    try {
-        for (const root of inventory.roots) {
-            pending.push(...readPendingCodexRequestUserInput({
-                rollout: root.rollout,
-                nativeThreadId: root.sessionId,
-                maxBytes
-            }));
-        }
-    }
-    catch {
-        return { status: "unavailable", code: "rollout_scan_unavailable" };
-    }
-    const acceptedCalls = pending.filter((call) => call.nativeThreadId === acceptedThreadId &&
-        call.turnId === acceptanceId &&
-        sameRolloutFileIdentity(call.rollout, acceptedRollout));
-    if (acceptedCalls.length !== 1) {
-        return { status: "not_matched", code: "accepted_call_not_unique" };
-    }
-    const matching = options.screen.exactShape &&
-        normalizedScreen.responseKind !== "confirm" &&
-        normalizedScreen.responseKind !== "multi_select"
-        ? pending.filter((call) => codexPendingQuestionnaireMatchesScreen(call, normalizedScreen))
-        : pending;
-    if (matching.length !== 1 || matching[0] !== acceptedCalls[0]) {
-        return { status: "not_matched", code: "screen_signature_not_unique" };
-    }
-    return {
-        status: "matched",
-        evidenceFingerprint: fingerprint({
-            schema: "agent-knock-knock/codex-bound-questionnaire-attribution",
-            version: 1,
-            native_thread_id: acceptedThreadId,
-            turn_id: acceptanceId,
-            rollout: {
-                device: acceptedRollout.device,
-                inode: acceptedRollout.inode,
-                path: acceptedRollout.path
-            },
-            screen: normalizedScreen
-        })
-    };
-}
 export function detectCodexRolloutAcceptance(options) {
     const anchor = validateCodexRolloutAcceptanceAnchor(options.anchor);
     if (anchor.version === 3) {
@@ -1127,504 +370,22 @@ export function detectCodexRolloutAcceptance(options) {
     });
     return scan.status === "accepted" ? scan.evidence : undefined;
 }
-/**
- * Scans the exact rollout and native turn proven by terminal acceptance.
- *
- * Unlike the general Codex context loader, this detector does not retain only
- * a recent-turn window. It starts at the immutable pre-submission byte anchor
- * and matches only the persisted acceptance UUID, so a delayed monitor can
- * recover completion even after later native turns have been appended.
- */
-export function detectCodexBoundRolloutCompletion(options) {
-    let anchor;
-    try {
-        anchor = validateCodexRolloutAcceptanceAnchor(options.anchor);
-    }
-    catch (error) {
-        return codexCompletionFailure("invalid_anchor", error);
-    }
-    const initialDiagnostics = {
-        detector: "codex_exact_bound_rollout",
-        anchor_fingerprint: anchor.anchor_fingerprint,
-        scan_start_offset_bytes: anchor.offset_bytes
-    };
-    let requestHash;
-    let acceptance;
-    let expectedNativeThreadId;
-    try {
-        requestHash = sha256Value(options.requestHash, "terminal request hash");
-        expectedNativeThreadId = anchor.version === 1
-            ? anchor.native_thread_id
-            : exactNativeThreadId(options.acceptanceEvidence.nativeThreadId);
-        acceptance = validateTerminalSubmissionAcceptanceEvidence(options.acceptanceEvidence, {
-            source: "codex_rollout",
-            nativeThreadId: expectedNativeThreadId,
-            requestHash
-        });
-    }
-    catch (error) {
-        return codexCompletionFailure("invalid_acceptance_evidence", error, initialDiagnostics);
-    }
-    const acceptedCandidate = anchor.version === 3
-        ? anchor.candidate_rollouts.find((candidate) => candidate.native_thread_id === expectedNativeThreadId)
-        : undefined;
-    const scanStartOffset = acceptedCandidate?.offset_bytes ??
-        anchor.offset_bytes;
-    const baseDiagnostics = {
-        ...initialDiagnostics,
-        scan_start_offset_bytes: scanStartOffset,
-        native_thread_id: expectedNativeThreadId
-    };
-    let acceptanceId;
-    try {
-        acceptanceId = exactNativeThreadId(acceptance.acceptanceId);
-    }
-    catch (error) {
-        return codexCompletionFailure("acceptance_turn_mismatch", error, baseDiagnostics);
-    }
-    const diagnostics = {
-        ...baseDiagnostics,
-        acceptance_id: acceptanceId
-    };
-    if (acceptance.anchorFingerprint !== anchor.anchor_fingerprint) {
-        return codexCompletionFailure("acceptance_anchor_mismatch", new Error("Codex acceptance evidence belongs to a different byte anchor"), diagnostics);
-    }
-    const evidenceTurnId = optionalString(acceptance.metadata?.turn_id);
-    if (evidenceTurnId !== undefined) {
-        let normalizedEvidenceTurnId;
-        try {
-            normalizedEvidenceTurnId = exactNativeThreadId(evidenceTurnId);
+function acceptedCodexTurnFromSuffix(text, requestHash) {
+    const startedTurns = new Map();
+    const matches = [];
+    for (const line of text.split(/\r?\n/u)) {
+        if (!line) {
+            continue;
         }
-        catch (error) {
-            return codexCompletionFailure("acceptance_turn_mismatch", error, diagnostics);
+        let value;
+        try {
+            value = JSON.parse(line);
         }
-        if (normalizedEvidenceTurnId !== acceptanceId) {
-            return codexCompletionFailure("acceptance_turn_mismatch", new Error("Codex acceptance metadata names a different native turn"), diagnostics);
+        catch {
+            throw new Error("Codex rollout acceptance suffix contains invalid JSONL");
         }
-    }
-    let evidenceAnchorOffset;
-    try {
-        evidenceAnchorOffset = optionalSafeOffset(acceptance.metadata?.anchor_offset_bytes);
-    }
-    catch (error) {
-        return codexCompletionFailure("invalid_acceptance_evidence", error, diagnostics);
-    }
-    if (evidenceAnchorOffset !== undefined &&
-        evidenceAnchorOffset !== scanStartOffset) {
-        return codexCompletionFailure("acceptance_anchor_mismatch", new Error("Codex acceptance evidence has a different byte offset"), diagnostics);
-    }
-    const current = options.currentIdentity;
-    try {
-        if (exactNativeThreadId(current.sessionId) !== expectedNativeThreadId ||
-            requiredString(current.processUuid, "Codex process UUID") !==
-                anchor.process_uuid ||
-            requiredString(current.processBirth, "Codex process birth") !==
-                anchor.process_birth) {
-            throw new Error("Codex process or native thread identity changed during completion polling");
-        }
-    }
-    catch (error) {
-        return codexCompletionFailure("binding_identity_mismatch", error, diagnostics);
-    }
-    if (!current.rollout) {
-        return codexCompletionFailure("rollout_identity_mismatch", new Error("the accepted Codex Turn lost its persisted exact rollout identity"), diagnostics);
-    }
-    let rollout;
-    try {
-        rollout = normalizedRolloutIdentity(current.rollout);
-    }
-    catch (error) {
-        return codexCompletionFailure("rollout_identity_mismatch", error, diagnostics);
-    }
-    const rolloutDiagnostics = {
-        ...diagnostics,
-        rollout_identity_fingerprint: fingerprint(rollout)
-    };
-    const anchoredRollout = anchor.version === 3
-        ? acceptedCandidate?.rollout
-        : anchor.rollout;
-    const anchoredRolloutMatches = !anchoredRollout || (anchor.version === 3
-        ? sameRolloutFileIdentity(anchoredRollout, rollout)
-        : sameRolloutIdentity(anchoredRollout, rollout));
-    if (!anchoredRolloutMatches) {
-        return codexCompletionFailure("rollout_identity_mismatch", new Error("Codex rollout identity changed after terminal acceptance"), rolloutDiagnostics);
-    }
-    let opened;
-    try {
-        opened = openExactRollout(rollout);
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        return codexCompletionFailure(/identity does not match/u.test(message)
-            ? "rollout_identity_mismatch"
-            : "rollout_unreadable", error, rolloutDiagnostics);
-    }
-    try {
-        const before = opened.stat;
-        try {
-            assertPrivateRegularFile(before);
-        }
-        catch (error) {
-            return codexCompletionFailure("rollout_unreadable", error, rolloutDiagnostics);
-        }
-        let evidenceEndOffset;
-        try {
-            evidenceEndOffset = optionalSafeOffset(acceptance.metadata?.observed_end_offset_bytes);
-        }
-        catch (error) {
-            return codexCompletionFailure("invalid_acceptance_evidence", error, rolloutDiagnostics);
-        }
-        if (before.size < scanStartOffset ||
-            (evidenceEndOffset !== undefined && before.size < evidenceEndOffset)) {
-            return codexCompletionFailure("rollout_truncated", new Error("Codex rollout was truncated after native acceptance"), {
-                ...rolloutDiagnostics,
-                observed_end_offset_bytes: before.size
-            });
-        }
-        const bytesToRead = before.size - scanStartOffset;
-        const observedDiagnostics = {
-            ...rolloutDiagnostics,
-            observed_end_offset_bytes: before.size
-        };
-        if (bytesToRead > CODEX_COMPLETION_MAX_BYTES) {
-            return codexCompletionFailure("scan_limit_exceeded", new Error("Codex bound completion suffix exceeded the safe scan limit"), observedDiagnostics);
-        }
-        try {
-            if (before.size > 0) {
-                assertCodexRolloutLegacyHistory(readCodexRolloutHeader(opened.fd, before.size));
-            }
-        }
-        catch (error) {
-            return codexCompletionFailure("rollout_unreadable", error, observedDiagnostics);
-        }
-        if (bytesToRead === 0) {
-            return codexCompletionPending("exact_turn_not_complete", observedDiagnostics, "no post-anchor Codex rollout records are available yet");
-        }
-        if (!fileEndsWithNewline(opened.fd, before.size)) {
-            return codexCompletionPending("partial_rollout_record", observedDiagnostics, "the exact Codex rollout ends with a partial JSONL record");
-        }
-        const buffer = Buffer.allocUnsafe(bytesToRead);
-        const bytesRead = fs.readSync(opened.fd, buffer, 0, bytesToRead, scanStartOffset);
-        const after = fs.fstatSync(opened.fd);
-        if (bytesRead !== bytesToRead || !sameStableFile(before, after)) {
-            return codexCompletionPending("rollout_changed_during_scan", observedDiagnostics, "the exact Codex rollout changed while completion was scanned");
-        }
-        const scan = scanExactCodexTaskComplete(buffer.toString("utf8"), acceptanceId);
-        const scanDiagnostics = {
-            ...observedDiagnostics,
-            scanned_records: scan.scannedRecords,
-            observed_task_complete_records: scan.observedTaskCompleteRecords,
-            observed_turn_aborted_records: scan.observedTurnAbortedRecords
-        };
-        if (scan.status === "failure") {
-            return codexCompletionFailure(scan.code, scan.detail, scanDiagnostics);
-        }
-        if (scan.status === "pending") {
-            return codexCompletionPending("exact_turn_not_complete", scanDiagnostics, "the accepted Codex native turn has no durable task_complete record yet");
-        }
-        if (scan.status === "aborted") {
-            const reason = truncateCompletionText(redactString(scan.reason ?? "interrupted"));
-            const completion = {
-                source: "durable",
-                outcome: "failure",
-                text: truncateCompletionText(redactString(`Codex task stopped: ${reason}`)),
-                ...(scan.timestamp ? { timestamp: scan.timestamp } : {}),
-                id: acceptanceId,
-                confidence: "high",
-                metadata: {
-                    match: "bound_rollout_turn_aborted",
-                    turn_id: acceptanceId,
-                    native_thread_id: expectedNativeThreadId,
-                    anchor_fingerprint: anchor.anchor_fingerprint,
-                    rollout_identity_fingerprint: rolloutDiagnostics.rollout_identity_fingerprint,
-                    abort_reason: reason,
-                    scan_start_offset_bytes: scanStartOffset,
-                    observed_end_offset_bytes: before.size,
-                    scanned_records: scan.scannedRecords,
-                    observed_task_complete_records: scan.observedTaskCompleteRecords,
-                    observed_turn_aborted_records: scan.observedTurnAbortedRecords
-                }
-            };
-            return {
-                status: "completed",
-                completion,
-                diagnostics: {
-                    ...scanDiagnostics,
-                    code: "abort_found"
-                }
-            };
-        }
-        const completion = {
-            source: "durable",
-            outcome: "success",
-            text: truncateCompletionText(redactString(scan.text)),
-            ...(scan.timestamp ? { timestamp: scan.timestamp } : {}),
-            id: acceptanceId,
-            confidence: "high",
-            metadata: {
-                match: "bound_rollout_task_complete",
-                turn_id: acceptanceId,
-                native_thread_id: expectedNativeThreadId,
-                anchor_fingerprint: anchor.anchor_fingerprint,
-                rollout_identity_fingerprint: rolloutDiagnostics.rollout_identity_fingerprint,
-                scan_start_offset_bytes: scanStartOffset,
-                observed_end_offset_bytes: before.size,
-                scanned_records: scan.scannedRecords,
-                observed_task_complete_records: scan.observedTaskCompleteRecords,
-                observed_turn_aborted_records: scan.observedTurnAbortedRecords
-            }
-        };
-        return {
-            status: "completed",
-            completion,
-            diagnostics: {
-                ...scanDiagnostics,
-                code: "completion_found"
-            }
-        };
-    }
-    catch (error) {
-        return codexCompletionFailure("rollout_unreadable", error, rolloutDiagnostics);
-    }
-    finally {
-        try {
-            fs.closeSync(opened.fd);
-        }
-        catch {
-            // The scan result is already fenced by the descriptor identity and both
-            // file snapshots. A close failure cannot make it safe to retry a native
-            // turn, so do not replace that deterministic result with an exception.
-        }
-    }
-}
-function scanExactCodexTaskComplete(text, acceptanceId) {
-    let scannedRecords = 0;
-    let observedTaskCompleteRecords = 0;
-    let observedTurnAbortedRecords = 0;
-    let exactTaskStartedIndex;
-    let laterTaskStartedIndex;
-    const exactMatches = [];
-    const exactAborts = [];
-    for (const rawLine of text.split("\n")) {
-        const line = rawLine.endsWith("\r") ? rawLine.slice(0, -1) : rawLine;
-        if (!line) {
-            continue;
-        }
-        let value;
-        try {
-            value = JSON.parse(line);
-        }
-        catch {
-            return {
-                status: "failure",
-                code: "invalid_rollout_jsonl",
-                detail: `Codex bound completion suffix contains invalid JSONL at record ${scannedRecords + 1}`,
-                scannedRecords,
-                observedTaskCompleteRecords,
-                observedTurnAbortedRecords
-            };
-        }
-        const recordIndex = scannedRecords;
-        scannedRecords += 1;
-        if (isRecord(value) &&
-            value.type === "event_msg" &&
-            isRecord(value.payload) &&
-            value.payload.type === "task_started") {
-            const turnId = optionalString(value.payload.turn_id)?.toLowerCase();
-            if (turnId === acceptanceId) {
-                exactTaskStartedIndex ??= recordIndex;
-            }
-            else if (exactTaskStartedIndex !== undefined &&
-                laterTaskStartedIndex === undefined) {
-                laterTaskStartedIndex = recordIndex;
-            }
-            continue;
-        }
-        if (isRecord(value) &&
-            value.type === "event_msg" &&
-            isRecord(value.payload) &&
-            value.payload.type === "turn_aborted") {
-            observedTurnAbortedRecords += 1;
-            const turnId = optionalString(value.payload.turn_id)?.toLowerCase();
-            if (turnId === acceptanceId) {
-                exactAborts.push({ value, index: recordIndex });
-            }
-            continue;
-        }
-        if (!isRecord(value) ||
-            value.type !== "event_msg" ||
-            !isRecord(value.payload) ||
-            value.payload.type !== "task_complete") {
-            continue;
-        }
-        observedTaskCompleteRecords += 1;
-        const turnId = optionalString(value.payload.turn_id)?.toLowerCase();
-        if (turnId === acceptanceId) {
-            exactMatches.push({ value, index: recordIndex });
-        }
-    }
-    if (exactMatches.length > 1) {
-        return {
-            status: "failure",
-            code: "duplicate_exact_completion",
-            detail: "the exact accepted Codex turn has duplicate task_complete records",
-            scannedRecords,
-            observedTaskCompleteRecords,
-            observedTurnAbortedRecords
-        };
-    }
-    if (exactAborts.length > 1) {
-        return {
-            status: "failure",
-            code: "duplicate_exact_abort",
-            detail: "the exact accepted Codex turn has duplicate turn_aborted records",
-            scannedRecords,
-            observedTaskCompleteRecords,
-            observedTurnAbortedRecords
-        };
-    }
-    if (exactMatches.length > 0 && exactAborts.length > 0) {
-        return {
-            status: "failure",
-            code: "conflicting_exact_settlement",
-            detail: "the exact accepted Codex turn has conflicting completion and abort records",
-            scannedRecords,
-            observedTaskCompleteRecords,
-            observedTurnAbortedRecords
-        };
-    }
-    const exactSettlementIndex = exactMatches[0]?.index ?? exactAborts[0]?.index;
-    if (laterTaskStartedIndex !== undefined &&
-        (exactSettlementIndex === undefined ||
-            laterTaskStartedIndex < exactSettlementIndex)) {
-        return {
-            status: "failure",
-            code: "later_turn_started",
-            detail: "a later Codex native turn started before the exact accepted turn settled",
-            scannedRecords,
-            observedTaskCompleteRecords,
-            observedTurnAbortedRecords
-        };
-    }
-    if (exactAborts.length === 1) {
-        const match = exactAborts[0].value;
-        if (match.timestamp !== undefined && !validTimestamp(match.timestamp)) {
-            return {
-                status: "failure",
-                code: "invalid_exact_abort",
-                detail: "the exact Codex turn_aborted record has an invalid timestamp",
-                scannedRecords,
-                observedTaskCompleteRecords,
-                observedTurnAbortedRecords
-            };
-        }
-        const payload = match.payload;
-        return {
-            status: "aborted",
-            reason: optionalString(payload.reason),
-            ...(match.timestamp !== undefined
-                ? { timestamp: String(match.timestamp) }
-                : {}),
-            scannedRecords,
-            observedTaskCompleteRecords,
-            observedTurnAbortedRecords
-        };
-    }
-    if (exactMatches.length === 0) {
-        return {
-            status: "pending",
-            scannedRecords,
-            observedTaskCompleteRecords,
-            observedTurnAbortedRecords
-        };
-    }
-    const match = exactMatches[0].value;
-    const payload = match.payload;
-    const textValue = optionalString(payload.last_agent_message);
-    if (!textValue) {
-        return {
-            status: "failure",
-            code: "invalid_exact_completion",
-            detail: "the exact Codex task_complete record has no final agent message",
-            scannedRecords,
-            observedTaskCompleteRecords,
-            observedTurnAbortedRecords
-        };
-    }
-    if (match.timestamp !== undefined && !validTimestamp(match.timestamp)) {
-        return {
-            status: "failure",
-            code: "invalid_exact_completion",
-            detail: "the exact Codex task_complete record has an invalid timestamp",
-            scannedRecords,
-            observedTaskCompleteRecords,
-            observedTurnAbortedRecords
-        };
-    }
-    return {
-        status: "completed",
-        text: textValue,
-        ...(match.timestamp !== undefined
-            ? { timestamp: String(match.timestamp) }
-            : {}),
-        scannedRecords,
-        observedTaskCompleteRecords,
-        observedTurnAbortedRecords
-    };
-}
-function codexCompletionPending(code, diagnostics, detail) {
-    return {
-        status: "pending",
-        diagnostics: {
-            ...diagnostics,
-            code,
-            detail
-        }
-    };
-}
-function codexCompletionFailure(code, error, diagnostics = {
-    detector: "codex_exact_bound_rollout"
-}) {
-    const detail = error instanceof Error ? error.message : String(error);
-    return {
-        status: "failure",
-        diagnostics: {
-            ...diagnostics,
-            code,
-            detail: truncateCompletionText(redactString(detail))
-        }
-    };
-}
-function optionalSafeOffset(value) {
-    if (value === undefined) {
-        return undefined;
-    }
-    if (!Number.isSafeInteger(value) || Number(value) < 0) {
-        throw new Error("Codex acceptance evidence byte offset is invalid");
-    }
-    return Number(value);
-}
-function truncateCompletionText(value) {
-    return value.length <= CODEX_COMPLETION_MAX_TEXT_LENGTH
-        ? value
-        : `${value.slice(0, CODEX_COMPLETION_MAX_TEXT_LENGTH - 1)}…`;
-}
-function acceptedCodexTurnFromSuffix(text, requestHash) {
-    const startedTurns = new Map();
-    const matches = [];
-    for (const line of text.split(/\r?\n/u)) {
-        if (!line) {
-            continue;
-        }
-        let value;
-        try {
-            value = JSON.parse(line);
-        }
-        catch {
-            throw new Error("Codex rollout acceptance suffix contains invalid JSONL");
-        }
-        if (!isRecord(value) || !isRecord(value.payload)) {
-            continue;
+        if (!isRecord(value) || !isRecord(value.payload)) {
+            continue;
         }
         const payload = value.payload;
         if (value.type === "event_msg" && payload.type === "task_started") {
@@ -1756,16 +517,6 @@ function scanCodexRolloutAcceptance({ rollout: rolloutValue, nativeThreadId: nat
         fs.closeSync(opened.fd);
     }
 }
-function exactCodexUserResponseText(content) {
-    if (!Array.isArray(content) || content.length !== 1) {
-        return undefined;
-    }
-    const item = content[0];
-    return isRecord(item) && item.type === "input_text" &&
-        typeof item.text === "string"
-        ? item.text
-        : undefined;
-}
 function assertVirginRolloutHeader(options) {
     const firstLine = options.text.split("\n").find((line) => line.trim() !== "");
     if (!firstLine) {
@@ -1797,579 +548,4 @@ function assertVirginRolloutHeader(options) {
         throw new Error("virgin Codex rollout predates its terminal submission anchor");
     }
 }
-function validateCodexOpenRootInventoryForAcceptance(value) {
-    if (!isRecord(value) ||
-        value.schema !==
-            "agent-knock-knock/codex-open-root-rollout-inventory" ||
-        value.version !== 1 ||
-        !["verified_absent", "resolved", "unbound"].includes(String(value.status)) ||
-        !Number.isSafeInteger(value.pid) ||
-        value.pid <= 1 ||
-        !Array.isArray(value.roots) ||
-        value.roots.length > 128 ||
-        !/^[0-9a-f]{64}$/u.test(String(value.inventoryFingerprint))) {
-        throw new Error("Codex open-root rollout inventory is invalid");
-    }
-    requiredString(value.processUuid, "Codex process UUID");
-    requiredString(value.processBirth, "Codex process birth");
-    if (value.processUuid !==
-        `codex-pid:${value.pid}:birth:${value.processBirth}`) {
-        throw new Error("Codex open-root rollout inventory process UUID is inconsistent");
-    }
-    if (value.cwd !== undefined && !path.isAbsolute(value.cwd)) {
-        throw new Error("Codex open-root rollout inventory cwd is not absolute");
-    }
-    if ((value.status === "verified_absent" && value.roots.length !== 0) ||
-        (value.status === "resolved" && value.roots.length !== 1) ||
-        (value.status === "unbound" &&
-            (value.roots.length < 2 ||
-                value.reason !== "multiple_open_root_rollouts"))) {
-        throw new Error("Codex open-root rollout inventory status is inconsistent");
-    }
-    const seenThreads = new Set();
-    const seenFiles = new Set();
-    for (const identity of value.roots) {
-        if (!isRecord(identity)) {
-            throw new Error("Codex open-root rollout inventory identity is invalid");
-        }
-        const nativeThreadId = exactNativeThreadId(identity.sessionId);
-        if (identity.processUuid !== value.processUuid ||
-            identity.processBirth !== value.processBirth ||
-            identity.evidence !== "codex_open_root_rollout") {
-            throw new Error("Codex open-root rollout inventory has mixed process authority");
-        }
-        const rollout = normalizedRolloutIdentity(identity.rollout);
-        if (seenThreads.has(nativeThreadId) ||
-            seenFiles.has(`${rollout.device}:${rollout.inode}`)) {
-            throw new Error("Codex open-root rollout inventory is ambiguous");
-        }
-        seenThreads.add(nativeThreadId);
-        seenFiles.add(`${rollout.device}:${rollout.inode}`);
-    }
-    const { status: _status, inventoryFingerprint, reason: _reason, ...authority } = value;
-    if (fingerprint(authority) !== inventoryFingerprint) {
-        throw new Error("Codex open-root rollout inventory fingerprint does not match");
-    }
-    return value;
-}
-/**
- * Read only the bounded, complete tail of one exact rollout and return async
- * questions belonging to its single currently active native turn. A missing
- * task boundary, a partial record, file drift, or an unsupported payload is a
- * hard absence rather than permission to infer from screen text alone.
- */
-export function readCodexAsyncQuestionDurableEvidence(input) {
-    const rollout = normalizedRolloutIdentity(input.rollout);
-    const nativeThreadId = exactNativeThreadId(input.nativeThreadId);
-    const maxBytes = positiveByteLimit(input.maxBytes, CODEX_ASYNC_QUESTION_TAIL_MAX_BYTES, "Codex async-question rollout scan limit");
-    const opened = openExactRollout(rollout);
-    try {
-        const before = opened.stat;
-        assertPrivateRegularFile(before);
-        const header = readCodexRolloutHeader(opened.fd, before.size);
-        assertExistingCodexRolloutHeader(header, nativeThreadId);
-        if (!fileEndsWithNewline(opened.fd, before.size)) {
-            throw new Error("Codex async-question rollout has a partial JSONL record");
-        }
-        const readStart = Math.max(0, before.size - maxBytes);
-        const length = before.size - readStart;
-        const buffer = Buffer.allocUnsafe(length);
-        if (fs.readSync(opened.fd, buffer, 0, length, readStart) !== length) {
-            throw new Error("Codex async-question rollout changed while it was read");
-        }
-        const after = fs.fstatSync(opened.fd);
-        if (!sameStableFile(before, after)) {
-            throw new Error("Codex async-question rollout changed while it was scanned");
-        }
-        const atBoundary = readStart === 0 ||
-            byteAtOffset(opened.fd, readStart - 1) === 0x0a;
-        const firstComplete = atBoundary ? 0 : buffer.indexOf(0x0a) + 1;
-        if (firstComplete <= 0 && !atBoundary) {
-            throw new Error("Codex async-question rollout record exceeded its bounded tail scan");
-        }
-        const records = parseCodexJsonlRecords(buffer.subarray(firstComplete), "async-question tail");
-        return codexAsyncQuestionEvidenceFromRecords({
-            records,
-            prefixTruncated: readStart > 0
-        });
-    }
-    finally {
-        fs.closeSync(opened.fd);
-    }
-}
-function codexAsyncQuestionEvidenceFromRecords(input) {
-    const active = activeCodexAsyncQuestionTask(input);
-    if (!active)
-        return undefined;
-    const evidence = [];
-    let totalQuestions = 0;
-    for (const { value } of input.records.slice(active.startIndex + 1)) {
-        const payload = isRecord(value.payload) ? value.payload : undefined;
-        if (value.type !== "event_msg" ||
-            payload?.type !== "item_completed" ||
-            exactNativeThreadId(payload.turn_id) !== active.turnId ||
-            !isRecord(payload.item) ||
-            payload.item.type !== "AgentMessage" ||
-            payload.item.delivery !== "async") {
-            continue;
-        }
-        if (evidence.length >= CODEX_ASYNC_QUESTION_MAX_ITEMS) {
-            throw new Error("Codex async-question item count exceeds the safe limit");
-        }
-        const item = codexAsyncQuestionItemEvidence(payload.item, active.turnId);
-        totalQuestions += item.questions.length;
-        if (totalQuestions > CODEX_ASYNC_QUESTION_MAX_QUESTIONS) {
-            throw new Error("Codex active async-question total exceeds the safe limit");
-        }
-        evidence.push(item);
-    }
-    return evidence.length === 0 ? undefined : evidence;
-}
-function activeCodexAsyncQuestionTask(input) {
-    let activeTurnId;
-    let activeStartIndex = -1;
-    let activeClosed = false;
-    input.records.forEach(({ value }, index) => {
-        const payload = isRecord(value.payload) ? value.payload : undefined;
-        if (!payload || value.type !== "event_msg")
-            return;
-        if (payload.type === "task_started") {
-            activeTurnId = exactNativeThreadId(payload.turn_id);
-            activeStartIndex = index;
-            activeClosed = false;
-            return;
-        }
-        if (activeTurnId &&
-            (payload.type === "task_complete" || payload.type === "turn_aborted") &&
-            (payload.turn_id === undefined ||
-                exactNativeThreadId(payload.turn_id) === activeTurnId)) {
-            activeClosed = true;
-        }
-    });
-    if (!activeTurnId || activeStartIndex < 0 || activeClosed) {
-        if (input.prefixTruncated && activeStartIndex < 0) {
-            throw new Error("Codex async-question tail omitted the active task boundary");
-        }
-        return undefined;
-    }
-    return { turnId: activeTurnId, startIndex: activeStartIndex };
-}
-function codexAsyncQuestionItemEvidence(item, turnId) {
-    const itemId = requiredString(item.id, "Codex async-question item id");
-    const rawQuestions = item.questions;
-    if (!Array.isArray(rawQuestions) ||
-        rawQuestions.length < 1 ||
-        rawQuestions.length > CODEX_ASYNC_QUESTION_MAX_QUESTIONS) {
-        throw new Error("Codex async-question count is invalid");
-    }
-    const questions = rawQuestions.map((question) => {
-        if (!isRecord(question)) {
-            throw new Error("Codex async-question payload is invalid");
-        }
-        const title = normalizedCodexQuestionnaireText(question.title, "Codex async-question title");
-        if (title.length > CODEX_ASYNC_QUESTION_MAX_TEXT_LENGTH) {
-            throw new Error("Codex async-question title exceeds the safe limit");
-        }
-        const rawOptions = question.options;
-        if (rawOptions !== undefined && rawOptions !== null &&
-            (!Array.isArray(rawOptions) ||
-                rawOptions.length < 1 ||
-                rawOptions.length > CODEX_ASYNC_QUESTION_MAX_OPTIONS)) {
-            throw new Error("Codex async-question options are invalid");
-        }
-        const options = rawOptions == null
-            ? undefined
-            : rawOptions.map((option) => {
-                const label = normalizedCodexQuestionnaireText(option, "Codex async-question option");
-                if (label.length > CODEX_ASYNC_QUESTION_MAX_TEXT_LENGTH) {
-                    throw new Error("Codex async-question option exceeds the safe limit");
-                }
-                return label;
-            });
-        return {
-            title,
-            ...(options === undefined ? {} : { options })
-        };
-    });
-    return {
-        itemId,
-        turnId,
-        questions,
-        currentIndex: 0,
-        remainingCount: questions.length
-    };
-}
-function readPendingCodexRequestUserInput(input) {
-    const rollout = normalizedRolloutIdentity(input.rollout);
-    const nativeThreadId = exactNativeThreadId(input.nativeThreadId);
-    const opened = openExactRollout(rollout);
-    try {
-        const before = opened.stat;
-        assertPrivateRegularFile(before);
-        const header = readCodexRolloutHeader(opened.fd, before.size);
-        assertExistingCodexRolloutHeader(header, nativeThreadId);
-        if (!fileEndsWithNewline(opened.fd, before.size)) {
-            throw new Error("Codex questionnaire rollout has a partial JSONL record");
-        }
-        const readStart = Math.max(0, before.size - input.maxBytes);
-        const length = before.size - readStart;
-        const buffer = Buffer.allocUnsafe(length);
-        if (fs.readSync(opened.fd, buffer, 0, length, readStart) !== length) {
-            throw new Error("Codex questionnaire rollout changed while it was read");
-        }
-        const after = fs.fstatSync(opened.fd);
-        if (!sameStableFile(before, after)) {
-            throw new Error("Codex questionnaire rollout changed while it was scanned");
-        }
-        const atBoundary = readStart === 0 ||
-            byteAtOffset(opened.fd, readStart - 1) === 0x0a;
-        const firstComplete = atBoundary ? 0 : buffer.indexOf(0x0a) + 1;
-        if (firstComplete <= 0 && !atBoundary) {
-            throw new Error("Codex questionnaire rollout record exceeded its bounded tail scan");
-        }
-        const records = parseCodexJsonlRecords(buffer.subarray(firstComplete), "questionnaire tail");
-        return pendingCodexRequestUserInputFromRecords({
-            records,
-            nativeThreadId,
-            rollout,
-            prefixTruncated: readStart > 0
-        });
-    }
-    finally {
-        fs.closeSync(opened.fd);
-    }
-}
-function pendingCodexRequestUserInputFromRecords(input) {
-    const calls = [];
-    const outputs = new Map();
-    const terminalTurns = new Map();
-    const unscopedTerminalIndexes = [];
-    const startedTurns = [];
-    let sawLifecycle = false;
-    input.records.forEach(({ value }, index) => {
-        const payload = isRecord(value.payload) ? value.payload : undefined;
-        if (!payload)
-            return;
-        if (value.type === "event_msg" &&
-            payload.type === "task_started") {
-            startedTurns.push({
-                index,
-                turnId: exactNativeThreadId(payload.turn_id)
-            });
-            sawLifecycle = true;
-            return;
-        }
-        if (value.type === "event_msg" &&
-            (payload.type === "task_complete" || payload.type === "turn_aborted")) {
-            const rawTurnId = optionalString(payload.turn_id);
-            if (!rawTurnId) {
-                unscopedTerminalIndexes.push(index);
-                sawLifecycle = true;
-                return;
-            }
-            const turnId = exactNativeThreadId(rawTurnId);
-            const indexes = terminalTurns.get(turnId) ?? [];
-            indexes.push(index);
-            terminalTurns.set(turnId, indexes);
-            sawLifecycle = true;
-            return;
-        }
-        if (value.type !== "response_item" ||
-            payload.type !== "function_call" ||
-            payload.name !== "request_user_input") {
-            if (value.type === "response_item" &&
-                payload.type === "function_call_output") {
-                const callId = requiredString(payload.call_id, "Codex questionnaire output call id");
-                const indexes = outputs.get(callId) ?? [];
-                indexes.push(index);
-                outputs.set(callId, indexes);
-            }
-            return;
-        }
-        const metadata = isRecord(payload.internal_chat_message_metadata_passthrough)
-            ? payload.internal_chat_message_metadata_passthrough
-            : undefined;
-        const callId = requiredString(payload.call_id, "Codex questionnaire call id");
-        if (calls.some((call) => call.callId === callId)) {
-            throw new Error("Codex questionnaire call id is duplicated");
-        }
-        calls.push({
-            index,
-            callId,
-            turnId: exactNativeThreadId(metadata?.turn_id),
-            questions: parseCodexRequestUserInputArguments(payload.arguments)
-        });
-    });
-    const pending = calls.filter((call) => {
-        if (outputs.get(call.callId)?.some((index) => index > call.index)) {
-            return false;
-        }
-        if (terminalTurns.get(call.turnId)?.some((index) => index > call.index)) {
-            return false;
-        }
-        if (unscopedTerminalIndexes.some((index) => index > call.index)) {
-            return false;
-        }
-        const precedingStart = latestCodexTaskStartBefore(startedTurns, call.index);
-        if (precedingStart && precedingStart.turnId !== call.turnId) {
-            return false;
-        }
-        return !startedTurns.some((started) => started.index > call.index);
-    });
-    if (input.prefixTruncated &&
-        pending.length === 0 &&
-        !sawLifecycle) {
-        throw new Error("Codex questionnaire tail cannot exclude an omitted pending request");
-    }
-    return pending.map((call) => ({
-        nativeThreadId: input.nativeThreadId,
-        rollout: input.rollout,
-        turnId: call.turnId,
-        questions: call.questions
-    }));
-}
-function latestCodexTaskStartBefore(starts, recordIndex) {
-    let latest;
-    for (const start of starts) {
-        if (start.index >= recordIndex)
-            break;
-        latest = start;
-    }
-    return latest;
-}
-function parseCodexRequestUserInputArguments(value) {
-    if (typeof value !== "string" ||
-        value.length === 0 ||
-        value.length > CODEX_QUESTIONNAIRE_TAIL_MAX_BYTES) {
-        throw new Error("Codex questionnaire arguments are invalid");
-    }
-    let parsed;
-    try {
-        parsed = JSON.parse(value);
-    }
-    catch {
-        throw new Error("Codex questionnaire arguments are not valid JSON");
-    }
-    const questions = isRecord(parsed) ? parsed.questions : undefined;
-    if (!Array.isArray(questions) ||
-        questions.length === 0 ||
-        questions.length > CODEX_QUESTIONNAIRE_MAX_QUESTIONS) {
-        throw new Error("Codex questionnaire question count is invalid");
-    }
-    return questions.map((question) => {
-        if (!isRecord(question)) {
-            throw new Error("Codex questionnaire question is invalid");
-        }
-        const rawOptions = question.options;
-        if (rawOptions !== undefined &&
-            (!Array.isArray(rawOptions) ||
-                rawOptions.length > CODEX_QUESTIONNAIRE_MAX_OPTIONS)) {
-            throw new Error("Codex questionnaire option count is invalid");
-        }
-        return {
-            prompt: normalizedCodexQuestionnaireText(question.question, "Codex questionnaire prompt"),
-            options: (rawOptions ?? []).map((option) => {
-                if (!isRecord(option)) {
-                    throw new Error("Codex questionnaire option is invalid");
-                }
-                return {
-                    label: normalizedCodexQuestionnaireText(option.label, "Codex questionnaire option label"),
-                    ...(option.description === undefined
-                        ? {}
-                        : {
-                            description: normalizedCodexQuestionnaireText(option.description, "Codex questionnaire option description")
-                        })
-                };
-            })
-        };
-    });
-}
-function codexPendingQuestionnaireMatchesScreen(call, screen) {
-    if (screen.currentStep < 1 ||
-        screen.currentStep > screen.totalSteps ||
-        call.questions.length !== screen.totalSteps) {
-        return false;
-    }
-    const question = call.questions[screen.currentStep - 1];
-    if (!question)
-        return false;
-    if (question.prompt !== screen.prompt)
-        return false;
-    if (screen.responseKind === "free_text")
-        return true;
-    if (screen.responseKind !== "single_select")
-        return false;
-    return codexRenderedOptionsMatch(question.options, screen.options ?? []);
-}
-function normalizedCodexQuestionnaireScreen(screen) {
-    if (!Number.isSafeInteger(screen.currentStep) ||
-        !Number.isSafeInteger(screen.totalSteps) ||
-        screen.currentStep < 1 ||
-        screen.totalSteps < 1 ||
-        screen.currentStep > screen.totalSteps ||
-        screen.totalSteps > CODEX_QUESTIONNAIRE_MAX_QUESTIONS ||
-        !["single_select", "multi_select", "free_text", "confirm"].includes(screen.responseKind) ||
-        (screen.options?.length ?? 0) > CODEX_QUESTIONNAIRE_MAX_OPTIONS) {
-        throw new Error("Codex questionnaire screen evidence is invalid");
-    }
-    return {
-        currentStep: screen.currentStep,
-        totalSteps: screen.totalSteps,
-        prompt: normalizedCodexQuestionnaireText(screen.prompt, "Codex questionnaire screen prompt"),
-        responseKind: screen.responseKind,
-        ...(screen.options === undefined
-            ? {}
-            : {
-                options: screen.options.map((option) => ({
-                    label: normalizedCodexQuestionnaireText(option.label, "Codex questionnaire screen option label"),
-                    ...(option.description === undefined
-                        ? {}
-                        : {
-                            description: normalizedCodexQuestionnaireText(option.description, "Codex questionnaire screen option description")
-                        })
-                }))
-            })
-    };
-}
-function normalizedCodexQuestionnaireText(value, label) {
-    if (typeof value !== "string" ||
-        value.length === 0 ||
-        value.length > CODEX_QUESTIONNAIRE_MAX_TEXT_LENGTH ||
-        value.includes("\0")) {
-        throw new Error(`${label} is invalid`);
-    }
-    const normalized = value.replace(/\s+/gu, " ").trim();
-    if (!normalized)
-        throw new Error(`${label} is empty`);
-    return normalized;
-}
-function codexRenderedOptionsMatch(durable, rendered) {
-    if (sameCodexQuestionnaireOptions(durable, rendered))
-        return true;
-    const canonicalOther = {
-        label: CODEX_QUESTIONNAIRE_OTHER_LABEL,
-        description: CODEX_QUESTIONNAIRE_OTHER_DESCRIPTION
-    };
-    if (sameCodexQuestionnaireOptions([...durable, canonicalOther], rendered)) {
-        return true;
-    }
-    return !durable.some((option) => option.label === CODEX_QUESTIONNAIRE_CUSTOM_LABEL) && sameCodexQuestionnaireOptions([
-        ...durable,
-        {
-            label: CODEX_QUESTIONNAIRE_CUSTOM_LABEL,
-            description: CODEX_QUESTIONNAIRE_CUSTOM_DESCRIPTION
-        },
-        canonicalOther
-    ], rendered);
-}
-function sameCodexQuestionnaireOptions(left, right) {
-    return left.length === right.length && left.every((option, index) => option.label === right[index]?.label &&
-        option.description === right[index]?.description);
-}
-function validateCodexRecoveryCandidateForAcceptance(value, anchor) {
-    if (!isRecord(value)) {
-        throw new Error("persisted Codex recovery candidate is invalid");
-    }
-    const sessionId = exactNativeThreadId(value.sessionId);
-    const rollout = normalizedRolloutIdentity(value.rollout);
-    if (value.processUuid !== anchor.process_uuid ||
-        value.processBirth !== anchor.process_birth ||
-        value.evidence !== "codex_open_root_rollout") {
-        throw new Error("persisted Codex recovery candidate has different process authority");
-    }
-    return {
-        sessionId,
-        processUuid: anchor.process_uuid,
-        processBirth: anchor.process_birth,
-        rollout,
-        evidence: "codex_open_root_rollout"
-    };
-}
-function openExactRollout(rollout) {
-    if (!path.isAbsolute(rollout.path)) {
-        throw new Error("Codex rollout path is not absolute");
-    }
-    const before = fs.lstatSync(rollout.path);
-    if (!before.isFile() || before.isSymbolicLink()) {
-        throw new Error("Codex rollout path is not a regular file");
-    }
-    const fd = fs.openSync(rollout.path, fs.constants.O_RDONLY | NO_FOLLOW_FLAG);
-    try {
-        const stat = fs.fstatSync(fd);
-        if (BigInt(stat.dev) !== parsedInteger(rollout.device) ||
-            BigInt(stat.ino) !== parsedInteger(rollout.inode)) {
-            throw new Error("Codex rollout descriptor identity does not match its open file");
-        }
-        return { fd, stat };
-    }
-    catch (error) {
-        fs.closeSync(fd);
-        throw error;
-    }
-}
-function assertPrivateRegularFile(stat) {
-    if (!stat.isFile()) {
-        throw new Error("Codex rollout is not a regular file");
-    }
-    if (process.platform !== "win32" &&
-        typeof process.getuid === "function" &&
-        stat.uid !== process.getuid()) {
-        throw new Error("Codex rollout is not owned by the current user");
-    }
-    if (process.platform !== "win32" && (stat.mode & 0o022) !== 0) {
-        throw new Error("Codex rollout is writable by another user");
-    }
-}
-function fileEndsWithNewline(fd, size) {
-    if (size <= 0) {
-        return true;
-    }
-    const last = Buffer.allocUnsafe(1);
-    return fs.readSync(fd, last, 0, 1, size - 1) === 1 && last[0] === 0x0a;
-}
-function byteAtOffset(fd, offset) {
-    const buffer = Buffer.allocUnsafe(1);
-    return fs.readSync(fd, buffer, 0, 1, offset) === 1
-        ? buffer[0]
-        : undefined;
-}
-function isRetryableProviderIoError(error) {
-    if (!isRecord(error) || typeof error.code !== "string") {
-        return false;
-    }
-    return new Set([
-        "EACCES", "EAGAIN", "EBUSY", "EIO", "EMFILE", "ENFILE", "ENOENT",
-        "EPERM", "ESTALE", "ETIMEDOUT"
-    ]).has(error.code);
-}
-function sameStableFile(left, right) {
-    return left.dev === right.dev &&
-        left.ino === right.ino &&
-        left.size === right.size &&
-        left.mtimeMs === right.mtimeMs &&
-        left.ctimeMs === right.ctimeMs;
-}
-function sameRolloutIdentity(left, right) {
-    return left.fd === right.fd &&
-        sameRolloutFileIdentity(left, right);
-}
-function sameRolloutFileIdentity(left, right) {
-    return left.device === right.device &&
-        left.inode === right.inode &&
-        left.path === right.path;
-}
-function codexRolloutInodeKey(rollout) {
-    return `${rollout.device}:${rollout.inode}`;
-}
-function optionalString(value) {
-    return typeof value === "string" && value.trim().length > 0
-        ? value.trim()
-        : undefined;
-}
-function fingerprintText(value) {
-    return createHash("sha256").update(value).digest("hex");
-}
-function isRecord(value) {
-    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
-}
 //# sourceMappingURL=terminal-submission-acceptance.js.map