@scotthuang/agent-knock-knock 0.12.37 → 0.13.1

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

@@ -8,6 +8,14 @@ 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_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;
@@ -151,6 +159,9 @@ export function observeCodexHumanStartedActiveTask(options) {
                     safeResumeOffsetBytes
                 };
             }
+            if (completion.status === "aborted") {
+                throw new Error("Codex active-task abort evidence escaped its exact lifecycle fence");
+            }
             return {
                 status: "completed",
                 completion: {
@@ -763,7 +774,7 @@ export function captureCodexCandidateSetRolloutAcceptanceAnchor({ inventory: inv
         anchor_fingerprint: fingerprint(base)
     };
 }
-export function detectCodexCandidateSetRolloutAcceptance({ anchor: anchorValue, currentInventory: inventoryValue, requestHash: requestHashValue }) {
+export function detectCodexCandidateSetRolloutAcceptance({ anchor: anchorValue, currentInventory: inventoryValue, requestHash: requestHashValue, recoveryCandidate: recoveryCandidateValue }) {
     const anchor = validateCodexRolloutAcceptanceAnchor(anchorValue);
     if (anchor.version !== 3) {
         throw new Error("Codex candidate-set acceptance requires a version 3 anchor");
@@ -782,15 +793,41 @@ export function detectCodexCandidateSetRolloutAcceptance({ anchor: anchorValue,
             exact_matches: 0
         };
     }
+    let recoveryCandidate;
+    if (recoveryCandidateValue) {
+        try {
+            recoveryCandidate = validateCodexRecoveryCandidateForAcceptance(recoveryCandidateValue, anchor);
+        }
+        catch (error) {
+            return {
+                status: "uncertain",
+                code: "candidate_inventory_changed",
+                reason: error instanceof Error ? error.message : String(error),
+                inspected_candidates: 0,
+                exact_matches: 0
+            };
+        }
+    }
     const anchoredByThread = new Map(anchor.candidate_rollouts.map((candidate) => [
         candidate.native_thread_id,
         candidate
     ]));
+    const anchoredByFile = new Map(anchor.candidate_rollouts.map((candidate) => [
+        codexRolloutInodeKey(candidate.rollout),
+        candidate
+    ]));
     const currentByThread = new Map(inventory.roots.map((identity) => [identity.sessionId, identity]));
-    for (const identity of inventory.roots) {
+    const currentByFile = new Map(inventory.roots.map((identity) => [
+        codexRolloutInodeKey(identity.rollout),
+        identity
+    ]));
+    for (const identity of [
+        ...inventory.roots,
+        ...(recoveryCandidate ? [recoveryCandidate] : [])
+    ]) {
         const anchored = anchoredByThread.get(identity.sessionId);
         if (anchored &&
-            !sameRolloutIdentity(anchored.rollout, identity.rollout)) {
+            !sameRolloutFileIdentity(anchored.rollout, identity.rollout)) {
             return {
                 status: "uncertain",
                 code: "candidate_inventory_changed",
@@ -799,26 +836,72 @@ export function detectCodexCandidateSetRolloutAcceptance({ anchor: anchorValue,
                 exact_matches: 0
             };
         }
+        const anchoredFile = anchoredByFile.get(codexRolloutInodeKey(identity.rollout));
+        if (anchoredFile &&
+            anchoredFile.native_thread_id !== identity.sessionId) {
+            return {
+                status: "uncertain",
+                code: "candidate_inventory_changed",
+                reason: `Codex candidate rollout changed native thread identity from ` +
+                    `${anchoredFile.native_thread_id} to ${identity.sessionId} after capture`,
+                inspected_candidates: 0,
+                exact_matches: 0
+            };
+        }
     }
-    for (const anchored of anchor.candidate_rollouts) {
-        if (!currentByThread.has(anchored.native_thread_id)) {
+    if (recoveryCandidate) {
+        const currentThread = currentByThread.get(recoveryCandidate.sessionId);
+        const currentFile = currentByFile.get(codexRolloutInodeKey(recoveryCandidate.rollout));
+        if ((currentThread && !sameRolloutFileIdentity(currentThread.rollout, recoveryCandidate.rollout)) ||
+            (currentFile && currentFile.sessionId !== recoveryCandidate.sessionId)) {
             return {
                 status: "uncertain",
                 code: "candidate_inventory_changed",
-                reason: `Codex candidate ${anchored.native_thread_id} is no longer open in the exact process inventory`,
+                reason: "persisted Codex recovery candidate conflicts with the current root inventory",
                 inspected_candidates: 0,
                 exact_matches: 0
             };
         }
     }
-    const candidates = inventory.roots.map((identity) => {
-        const anchored = anchoredByThread.get(identity.sessionId);
-        return {
+    // A Codex thread may close (or reopen) its process FD while the acceptance
+    // poll is running. The captured path/device/inode/offset remains the durable
+    // read authority in that case, so inspect the union rather than treating a
+    // missing lsof row as evidence that the candidate changed identity.
+    const candidates = [
+        ...anchor.candidate_rollouts.map((anchored) => ({
+            identity: currentByThread.get(anchored.native_thread_id) ??
+                (recoveryCandidate?.sessionId === anchored.native_thread_id
+                    ? recoveryCandidate
+                    : {
+                        sessionId: anchored.native_thread_id,
+                        processUuid: anchor.process_uuid,
+                        processBirth: anchor.process_birth,
+                        rollout: anchored.rollout,
+                        evidence: "codex_open_root_rollout"
+                    }),
+            offsetBytes: anchored.offset_bytes,
+            requireFreshHeader: false,
+            currentlyOpen: currentByThread.has(anchored.native_thread_id)
+        })),
+        ...inventory.roots
+            .filter((identity) => !anchoredByThread.has(identity.sessionId))
+            .map((identity) => ({
             identity,
-            offsetBytes: anchored?.offset_bytes ?? 0,
-            requireFreshHeader: anchored === undefined
-        };
-    });
+            offsetBytes: 0,
+            requireFreshHeader: true,
+            currentlyOpen: true
+        })),
+        ...(recoveryCandidate &&
+            !anchoredByThread.has(recoveryCandidate.sessionId) &&
+            !currentByThread.has(recoveryCandidate.sessionId)
+            ? [{
+                    identity: recoveryCandidate,
+                    offsetBytes: 0,
+                    requireFreshHeader: true,
+                    currentlyOpen: false
+                }]
+            : [])
+    ];
     const matches = [];
     let incompleteCandidates = 0;
     for (const candidate of candidates) {
@@ -846,6 +929,16 @@ export function detectCodexCandidateSetRolloutAcceptance({ anchor: anchorValue,
             };
         }
         if (scan.status === "incomplete") {
+            if (!candidate.currentlyOpen) {
+                return {
+                    status: "uncertain",
+                    code: "candidate_scan_invalid",
+                    reason: `Codex candidate ${candidate.identity.sessionId} closed with an ` +
+                        "incomplete rollout record after capture",
+                    inspected_candidates: candidates.indexOf(candidate) + 1,
+                    exact_matches: matches.length
+                };
+            }
             incompleteCandidates += 1;
         }
         else if (scan.status === "accepted") {
@@ -880,6 +973,94 @@ 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) {
@@ -1033,7 +1214,10 @@ export function detectCodexBoundRolloutCompletion(options) {
     const anchoredRollout = anchor.version === 3
         ? acceptedCandidate?.rollout
         : anchor.rollout;
-    if (anchoredRollout && !sameRolloutIdentity(anchoredRollout, 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;
@@ -1092,7 +1276,8 @@ export function detectCodexBoundRolloutCompletion(options) {
         const scanDiagnostics = {
             ...observedDiagnostics,
             scanned_records: scan.scannedRecords,
-            observed_task_complete_records: scan.observedTaskCompleteRecords
+            observed_task_complete_records: scan.observedTaskCompleteRecords,
+            observed_turn_aborted_records: scan.observedTurnAbortedRecords
         };
         if (scan.status === "failure") {
             return codexCompletionFailure(scan.code, scan.detail, scanDiagnostics);
@@ -1100,6 +1285,38 @@ export function detectCodexBoundRolloutCompletion(options) {
         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",
@@ -1116,7 +1333,8 @@ export function detectCodexBoundRolloutCompletion(options) {
                 scan_start_offset_bytes: scanStartOffset,
                 observed_end_offset_bytes: before.size,
                 scanned_records: scan.scannedRecords,
-                observed_task_complete_records: scan.observedTaskCompleteRecords
+                observed_task_complete_records: scan.observedTaskCompleteRecords,
+                observed_turn_aborted_records: scan.observedTurnAbortedRecords
             }
         };
         return {
@@ -1145,7 +1363,11 @@ export function detectCodexBoundRolloutCompletion(options) {
 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) {
@@ -1161,10 +1383,37 @@ function scanExactCodexTaskComplete(text, acceptanceId) {
                 code: "invalid_rollout_jsonl",
                 detail: `Codex bound completion suffix contains invalid JSONL at record ${scannedRecords + 1}`,
                 scannedRecords,
-                observedTaskCompleteRecords
+                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) ||
@@ -1174,26 +1423,85 @@ function scanExactCodexTaskComplete(text, acceptanceId) {
         observedTaskCompleteRecords += 1;
         const turnId = optionalString(value.payload.turn_id)?.toLowerCase();
         if (turnId === acceptanceId) {
-            exactMatches.push(value);
+            exactMatches.push({ value, index: recordIndex });
         }
     }
-    if (exactMatches.length === 0) {
+    if (exactMatches.length > 1) {
         return {
-            status: "pending",
+            status: "failure",
+            code: "duplicate_exact_completion",
+            detail: "the exact accepted Codex turn has duplicate task_complete records",
             scannedRecords,
-            observedTaskCompleteRecords
+            observedTaskCompleteRecords,
+            observedTurnAbortedRecords
         };
     }
-    if (exactMatches.length > 1) {
+    if (exactAborts.length > 1) {
         return {
             status: "failure",
-            code: "duplicate_exact_completion",
-            detail: "the exact accepted Codex turn has duplicate task_complete records",
+            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
+            observedTaskCompleteRecords,
+            observedTurnAbortedRecords
         };
     }
-    const match = exactMatches[0];
+    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) {
@@ -1202,7 +1510,8 @@ function scanExactCodexTaskComplete(text, acceptanceId) {
             code: "invalid_exact_completion",
             detail: "the exact Codex task_complete record has no final agent message",
             scannedRecords,
-            observedTaskCompleteRecords
+            observedTaskCompleteRecords,
+            observedTurnAbortedRecords
         };
     }
     if (match.timestamp !== undefined && !validTimestamp(match.timestamp)) {
@@ -1211,7 +1520,8 @@ function scanExactCodexTaskComplete(text, acceptanceId) {
             code: "invalid_exact_completion",
             detail: "the exact Codex task_complete record has an invalid timestamp",
             scannedRecords,
-            observedTaskCompleteRecords
+            observedTaskCompleteRecords,
+            observedTurnAbortedRecords
         };
     }
     return {
@@ -1221,7 +1531,8 @@ function scanExactCodexTaskComplete(text, acceptanceId) {
             ? { timestamp: String(match.timestamp) }
             : {}),
         scannedRecords,
-        observedTaskCompleteRecords
+        observedTaskCompleteRecords,
+        observedTurnAbortedRecords
     };
 }
 function codexCompletionPending(code, diagnostics, detail) {
@@ -1490,6 +1801,292 @@ function validateCodexOpenRootInventoryForAcceptance(value) {
     }
     return value;
 }
+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");
@@ -1556,10 +2153,16 @@ function sameStableFile(left, right) {
 }
 function sameRolloutIdentity(left, right) {
     return left.fd === right.fd &&
-        left.device === right.device &&
+        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()