@pasko70/pibo 2.5.2 → 3.0.0

package/dist/agent-runtimes/codex-native/first-use.js

@@ -0,0 +1,294 @@
+import { createHash, randomUUID } from "node:crypto";
+import { readFileSync } from "node:fs";
+import { PENDING_NATIVE_SESSION_METADATA_KEY, } from "../../sessions/runtime-binding.js";
+export const CODEX_FIRST_USE_METADATA_KEY = "codexNativeFirstUse";
+export const CODEX_FIRST_USE_METADATA_VERSION = 3;
+const LEGACY_BYTE_EXACT_METADATA_VERSIONS = new Set([1, 2]);
+const MAX_NATIVE_ID_LENGTH = 512;
+const MAX_MESSAGE_ID_LENGTH = 512;
+const MAX_PROCESS_START_ID_LENGTH = 64;
+const MAX_PID = 0x7fff_ffff;
+const SHA256_PATTERN = /^[a-f0-9]{64}$/;
+const UUID_V4_PATTERN = /^[a-f0-9]{8}-[a-f0-9]{4}-4[a-f0-9]{3}-[89ab][a-f0-9]{3}-[a-f0-9]{12}$/;
+const PROCESS_START_ID_PATTERN = /^([1-9][0-9]{0,9}):([1-9][0-9]{0,30})$/;
+const TERMINAL_TURN_STATUSES = new Set(["completed", "interrupted", "failed"]);
+const PROCESS_INSTANCE_ID = randomUUID();
+const activeAttemptIds = new Set();
+function boundedNonEmptyString(value, maximumLength) {
+    return typeof value === "string"
+        && value.length > 0
+        && value.length <= maximumLength
+        && !/[\u0000-\u001f\u007f]/.test(value);
+}
+function validPid(value) {
+    return Number.isSafeInteger(value) && Number(value) > 0 && Number(value) <= MAX_PID;
+}
+function errorCode(error) {
+    return error && typeof error === "object" && "code" in error && typeof error.code === "string"
+        ? error.code
+        : undefined;
+}
+function probeLinuxProcess(pid, readProcStat) {
+    let stat;
+    try {
+        stat = readProcStat(pid);
+    }
+    catch (error) {
+        return ["ENOENT", "ESRCH"].includes(errorCode(error) ?? "")
+            ? { liveness: "dead" }
+            : { liveness: "ambiguous" };
+    }
+    const close = stat.lastIndexOf(")");
+    if (close < 2 || close + 2 >= stat.length)
+        return { liveness: "ambiguous" };
+    const fields = stat.slice(close + 2).trim().split(/\s+/);
+    if (fields.length <= 19)
+        return { liveness: "ambiguous" };
+    if (fields[0] === "Z")
+        return { liveness: "dead" };
+    const startTicks = fields[19];
+    if (!startTicks || !/^[1-9][0-9]{0,30}$/.test(startTicks))
+        return { liveness: "ambiguous" };
+    return { liveness: "active", startId: `${pid}:${startTicks}` };
+}
+function probePortableProcess(pid, probePid) {
+    try {
+        probePid(pid);
+        return "active";
+    }
+    catch (error) {
+        return errorCode(error) === "ESRCH" ? "dead" : "ambiguous";
+    }
+}
+function defaultReadProcStat(pid) {
+    return readFileSync(`/proc/${pid}/stat`, "utf8");
+}
+function defaultProbePid(pid) {
+    process.kill(pid, 0);
+}
+function hashUtf8(value) {
+    return createHash("sha256").update(value, "utf8").digest("hex");
+}
+/**
+ * Canonical first-use prompts use LF line endings and Unicode NFC. Pibo hashes
+ * this representation before native execution and when proving native history.
+ */
+export function canonicalizeCodexNativeFirstUsePrompt(prompt) {
+    return prompt.replace(/\r\n?/g, "\n").normalize("NFC");
+}
+export function hashCanonicalCodexNativeFirstUsePrompt(prompt) {
+    return hashUtf8(canonicalizeCodexNativeFirstUsePrompt(prompt));
+}
+function hashPersistedPromptEvidence(identity, prompt) {
+    return LEGACY_BYTE_EXACT_METADATA_VERSIONS.has(identity.version)
+        ? hashUtf8(prompt)
+        : hashCanonicalCodexNativeFirstUsePrompt(prompt);
+}
+export function codexNativeFirstUseDeliveryReceipt(pending) {
+    return {
+        version: pending.version,
+        state: "delivered",
+        messageId: pending.messageId,
+        promptHash: pending.promptHash,
+    };
+}
+export function readCodexNativePendingFirstUse(binding) {
+    const value = binding.metadata?.[CODEX_FIRST_USE_METADATA_KEY];
+    if (value === undefined)
+        return undefined;
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new Error("The pending native Codex first-use metadata is invalid.");
+    }
+    const record = value;
+    const allowedKeys = new Set([
+        "version",
+        "state",
+        "threadId",
+        "messageId",
+        "promptHash",
+        "attemptId",
+        "ownerPid",
+        "ownerProcessStartId",
+        "ownerProcessInstanceId",
+    ]);
+    const ownerProcessStartId = record.ownerProcessStartId;
+    const startMatch = typeof ownerProcessStartId === "string"
+        ? PROCESS_START_ID_PATTERN.exec(ownerProcessStartId)
+        : undefined;
+    if (Object.keys(record).some((key) => !allowedKeys.has(key))
+        || (record.version !== 1 && record.version !== 2 && record.version !== CODEX_FIRST_USE_METADATA_VERSION)
+        || record.state !== "pending"
+        || !boundedNonEmptyString(record.threadId, MAX_NATIVE_ID_LENGTH)
+        || !boundedNonEmptyString(record.messageId, MAX_MESSAGE_ID_LENGTH)
+        || typeof record.promptHash !== "string"
+        || !SHA256_PATTERN.test(record.promptHash)
+        || typeof record.attemptId !== "string"
+        || !UUID_V4_PATTERN.test(record.attemptId)
+        || !validPid(record.ownerPid)
+        || typeof record.ownerProcessInstanceId !== "string"
+        || !UUID_V4_PATTERN.test(record.ownerProcessInstanceId)
+        || (ownerProcessStartId !== undefined
+            && (typeof ownerProcessStartId !== "string"
+                || ownerProcessStartId.length > MAX_PROCESS_START_ID_LENGTH
+                || !startMatch
+                || Number(startMatch[1]) !== record.ownerPid))) {
+        throw new Error("The pending native Codex first-use metadata is invalid.");
+    }
+    return record;
+}
+export function readCodexNativeFirstUseDeliveryReceipt(binding) {
+    const value = binding.metadata?.[CODEX_FIRST_USE_METADATA_KEY];
+    if (value === undefined)
+        return undefined;
+    if (binding.state !== "bound"
+        || binding.metadata?.[PENDING_NATIVE_SESSION_METADATA_KEY] !== undefined
+        || !value
+        || typeof value !== "object"
+        || Array.isArray(value)) {
+        throw new Error("The delivered native Codex first-use receipt is invalid.");
+    }
+    const record = value;
+    const allowedKeys = new Set(["version", "state", "messageId", "promptHash"]);
+    if (Object.keys(record).some((key) => !allowedKeys.has(key))
+        || (record.version !== 1 && record.version !== 2 && record.version !== CODEX_FIRST_USE_METADATA_VERSION)
+        || record.state !== "delivered"
+        || !boundedNonEmptyString(record.messageId, MAX_MESSAGE_ID_LENGTH)
+        || typeof record.promptHash !== "string"
+        || !SHA256_PATTERN.test(record.promptHash)) {
+        throw new Error("The delivered native Codex first-use receipt is invalid.");
+    }
+    return record;
+}
+export function beginCodexNativeFirstUseAttempt() {
+    const attemptId = randomUUID();
+    let ownerProcessStartId;
+    if (process.platform === "linux") {
+        const probe = probeLinuxProcess(process.pid, defaultReadProcStat);
+        if (probe.liveness !== "active" || !probe.startId) {
+            throw new Error("Native Codex first use cannot establish the current process identity safely.");
+        }
+        ownerProcessStartId = probe.startId;
+    }
+    activeAttemptIds.add(attemptId);
+    return {
+        attemptId,
+        ownerPid: process.pid,
+        ...(ownerProcessStartId ? { ownerProcessStartId } : {}),
+        ownerProcessInstanceId: PROCESS_INSTANCE_ID,
+    };
+}
+export function endCodexNativeFirstUseAttempt(attemptId) {
+    activeAttemptIds.delete(attemptId);
+}
+export function codexNativePendingFirstUseOwnerLiveness(pending, dependencies = {}) {
+    const platform = dependencies.platform ?? process.platform;
+    const currentPid = dependencies.currentPid ?? process.pid;
+    const currentProcessInstanceId = dependencies.currentProcessInstanceId ?? PROCESS_INSTANCE_ID;
+    let processLiveness;
+    let observedStartId;
+    if (platform === "linux") {
+        const probe = probeLinuxProcess(pending.ownerPid, dependencies.readProcStat ?? defaultReadProcStat);
+        processLiveness = probe.liveness;
+        observedStartId = probe.startId;
+        if (processLiveness !== "active")
+            return processLiveness;
+        if (!pending.ownerProcessStartId || !observedStartId)
+            return "ambiguous";
+        if (pending.ownerProcessStartId !== observedStartId)
+            return "dead";
+    }
+    else {
+        processLiveness = probePortableProcess(pending.ownerPid, dependencies.probePid ?? defaultProbePid);
+        if (processLiveness !== "active")
+            return processLiveness;
+    }
+    if (pending.ownerPid !== currentPid)
+        return "active";
+    if (pending.ownerProcessInstanceId !== currentProcessInstanceId)
+        return "ambiguous";
+    return activeAttemptIds.has(pending.attemptId) ? "active" : "dead";
+}
+function exactTextUserItem(item) {
+    if (item.type !== "userMessage" || !Array.isArray(item.content) || item.content.length !== 1)
+        return undefined;
+    const part = item.content[0];
+    if (!part || typeof part !== "object" || Array.isArray(part))
+        return undefined;
+    const record = part;
+    if (record.type !== "text" || typeof record.text !== "string")
+        return undefined;
+    if (item.clientId !== undefined && item.clientId !== null && typeof item.clientId !== "string")
+        return undefined;
+    return { ...(item.clientId !== undefined ? { clientId: item.clientId } : {}), text: record.text };
+}
+function assertCodexNativeFirstUseTurnEvidence(identity, turn, state) {
+    if (!TERMINAL_TURN_STATUSES.has(turn.status)) {
+        throw new Error(`The ${state} native Codex first turn is not terminal and cannot be reconciled safely.`);
+    }
+    const userItems = turn.items.filter((item) => item.type === "userMessage");
+    const evidence = userItems.map(exactTextUserItem);
+    if (evidence.length === 0 || evidence.some((item) => !item)) {
+        throw new Error(`The ${state} native Codex first turn has ambiguous user input evidence.`);
+    }
+    const exactEvidence = evidence;
+    const evidenceWithClientIds = exactEvidence.filter((item) => item.clientId !== undefined && item.clientId !== null);
+    let firstRequestEvidence;
+    if (evidenceWithClientIds.length > 0) {
+        if (evidenceWithClientIds.length !== exactEvidence.length) {
+            throw new Error(`The ${state} native Codex first turn has ambiguous user input evidence.`);
+        }
+        const matches = evidenceWithClientIds.filter((item) => item.clientId === identity.messageId);
+        if (matches.length === 0) {
+            throw new Error(`The ${state} native Codex first turn does not match the persisted message id.`);
+        }
+        if (matches.length > 1) {
+            throw new Error(`The ${state} native Codex first turn has ambiguous user input evidence.`);
+        }
+        firstRequestEvidence = matches[0];
+    }
+    else {
+        if (exactEvidence.length !== 1) {
+            throw new Error(`The ${state} native Codex first turn has ambiguous user input evidence.`);
+        }
+        firstRequestEvidence = exactEvidence[0];
+    }
+    if (hashPersistedPromptEvidence(identity, firstRequestEvidence.text) !== identity.promptHash) {
+        throw new Error(`The ${state} native Codex first turn does not match the persisted prompt hash.`);
+    }
+    if (firstRequestEvidence.clientId !== undefined
+        && firstRequestEvidence.clientId !== null
+        && !boundedNonEmptyString(firstRequestEvidence.clientId, MAX_MESSAGE_ID_LENGTH)) {
+        throw new Error(`The ${state} native Codex first turn has invalid message identity evidence.`);
+    }
+}
+export function assertCodexNativePendingFirstUseTurn(pending, thread) {
+    if (thread.id !== pending.threadId || thread.turns.length !== 1) {
+        throw new Error("The pending native Codex first turn is missing, multiple, or belongs to another thread.");
+    }
+    assertCodexNativeFirstUseTurnEvidence(pending, thread.turns[0], "pending");
+}
+export function assertCodexNativeFirstUseDeliveryReceiptTurn(receipt, thread) {
+    const firstTurn = thread.turns[0];
+    if (!firstTurn)
+        throw new Error("The delivered native Codex first turn is missing.");
+    assertCodexNativeFirstUseTurnEvidence(receipt, firstTurn, "delivered");
+    return firstTurn;
+}
+export function isExactCodexNativeFirstUseDeliveryReplay(receipt, messageId, prompt) {
+    if (messageId !== receipt.messageId)
+        return false;
+    if (hashPersistedPromptEvidence(receipt, prompt) !== receipt.promptHash) {
+        throw new Error("Native Codex first-use replay reuses the delivered message id with a different prompt.");
+    }
+    return true;
+}
+export function assertCodexNativePendingFirstUseRequest(pending, messageId, prompt) {
+    if (messageId !== pending.messageId || hashPersistedPromptEvidence(pending, prompt) !== pending.promptHash) {
+        throw new Error("Native Codex first-use retry does not match the persisted message id and prompt.");
+    }
+}
+export function assertCodexNativeFirstUseMessageId(messageId) {
+    if (!boundedNonEmptyString(messageId, MAX_MESSAGE_ID_LENGTH)) {
+        throw new Error("Native Codex first-use message id is invalid.");
+    }
+}

package/dist/agent-runtimes/codex-native/history.js

@@ -1,5 +1,7 @@
+import { historyReconciliationDigest } from "../../agent-runtime/history.js";
 import { redactCodexNativeSensitiveText } from "./redaction.js";
 import { CODEX_NATIVE_ADAPTER_ID } from "./thread.js";
+import { TRACE_RECONCILIATION_ENTRY_CAP } from "../../shared/trace-limits.js";
 const CODEX_HISTORY_CURSOR_PREFIX = "codex-history:";
 const DEFAULT_HISTORY_LIMIT = 100;
 const MAX_HISTORY_LIMIT = 200;
@@ -67,7 +69,7 @@ function reasoningParts(item) {
         .map(redactCodexNativeSensitiveText);
     return values.length > 0 ? [{ type: "reasoning", text: values.join("\n") }] : [];
 }
-function itemEntry(thread, turn, item, sequence) {
+function itemEntry(thread, turn, item, sequence, historyPosition, historyScopeId) {
     const createdAt = isoFromSeconds(turn.startedAt ?? turn.completedAt, thread.updatedAt);
     const base = {
         id: `codex:${thread.id}:${turn.id}:${item.id}`,
@@ -75,6 +77,8 @@ function itemEntry(thread, turn, item, sequence) {
         source: "native",
         createdAt,
         sequence,
+        historyPosition,
+        historyScopeId,
         turnId: turn.id,
         nativeTurnId: turn.id,
         nativeEntryId: item.id,
@@ -159,7 +163,7 @@ function itemEntry(thread, turn, item, sequence) {
     }
     return undefined;
 }
-export function codexThreadHistoryEntries(thread) {
+export function codexThreadHistoryEntries(thread, historyScopeId = `codex:${thread.id}`) {
     const entries = [];
     let sequence = 0;
     if (thread.name) {
@@ -169,13 +173,15 @@ export function codexThreadHistoryEntries(thread) {
             source: "native",
             createdAt: isoFromSeconds(thread.createdAt, thread.createdAt),
             sequence: sequence++,
+            historyPosition: `codex:${thread.id}:session-info`,
+            historyScopeId,
             nativeEntryId: thread.id,
             name: redactCodexNativeSensitiveText(thread.name),
         });
     }
-    for (const turn of thread.turns) {
-        for (const item of turn.items) {
-            const entry = itemEntry(thread, turn, item, sequence);
+    for (const [turnIndex, turn] of thread.turns.entries()) {
+        for (const [itemIndex, item] of turn.items.entries()) {
+            const entry = itemEntry(thread, turn, item, sequence, `codex:${thread.id}:turn:${turnIndex}:item:${itemIndex}:${item.type}`, historyScopeId);
             if (!entry)
                 continue;
             entries.push(entry);
@@ -187,7 +193,9 @@ export function codexThreadHistoryEntries(thread) {
                 type: "message",
                 source: "native",
                 createdAt: isoFromSeconds(turn.completedAt ?? turn.startedAt, thread.updatedAt),
-                sequence: sequence++,
+                sequence,
+                historyPosition: `codex:${thread.id}:turn:${turnIndex}:error`,
+                historyScopeId,
                 turnId: turn.id,
                 nativeTurnId: turn.id,
                 nativeEntryId: `${turn.id}:error`,
@@ -196,6 +204,7 @@ export function codexThreadHistoryEntries(thread) {
                 status: "error",
                 error: "Codex turn failed.",
             });
+            sequence += 1;
         }
     }
     return entries;
@@ -256,7 +265,8 @@ function selectedLimit(value) {
     return Math.min(value, MAX_HISTORY_LIMIT);
 }
 export function pageCodexThreadHistory(input) {
-    const allEntries = codexThreadHistoryEntries(input.thread);
+    const historyScopeId = `codex:${input.runtimeInstanceId}:${input.thread.id}`;
+    const allEntries = codexThreadHistoryEntries(input.thread, historyScopeId);
     const beforeTimestampMs = input.beforeTimestamp === undefined ? undefined : Date.parse(input.beforeTimestamp);
     if (beforeTimestampMs !== undefined && Number.isNaN(beforeTimestampMs)) {
         throw new Error("Codex native history beforeTimestamp is invalid.");
@@ -270,11 +280,20 @@ export function pageCodexThreadHistory(input) {
     const start = Math.max(0, end - limit);
     const entries = filtered.slice(start, end);
     const hasMore = start > 0;
+    const proofComplete = allEntries.length <= TRACE_RECONCILIATION_ENTRY_CAP;
     return {
         runtimeInstanceId: input.runtimeInstanceId,
         adapterId: CODEX_NATIVE_ADAPTER_ID,
         source: "native",
         entries,
+        reconciliationProof: proofComplete
+            ? {
+                complete: true,
+                scopeId: historyScopeId,
+                fullScope: { entryCount: allEntries.length, digest: historyReconciliationDigest(allEntries) },
+                entries: allEntries,
+            }
+            : { complete: false, scopeId: historyScopeId, entries },
         orderOffset: start,
         ...(hasMore ? { nextCursor: encodeCursor({ v: 1, threadId: input.thread.id, beforeIndex: start }) } : {}),
         hasMore,

package/dist/agent-runtimes/codex-native/process.js

@@ -419,6 +419,12 @@ export async function startCodexNativeAppServer(input) {
     if (!input.clientVersion.trim()) {
         throw new CodexNativeProcessError("start_failed", "Codex App Server client version is required.");
     }
+    if (input.realtimeSidebandBaseUrl !== undefined && !input.realtimeSidebandBaseUrl.trim()) {
+        throw new CodexNativeProcessError("start_failed", "Codex realtime sideband base URL must not be empty.");
+    }
+    if (input.realtimeWebrtcCallBaseUrl !== undefined && !input.realtimeWebrtcCallBaseUrl.trim()) {
+        throw new CodexNativeProcessError("start_failed", "Codex realtime WebRTC call base URL must not be empty.");
+    }
     const paths = await prepareCodexNativeSessionPaths(input);
     let client;
     try {
@@ -431,6 +437,13 @@ export async function startCodexNativeAppServer(input) {
             `tools.experimental_request_user_input.enabled=${input.config.experimentalUserInput}`,
             "-c",
             `features.default_mode_request_user_input=${input.config.experimentalUserInput}`,
+            ...(input.realtimeConversation ? ["-c", "features.realtime_conversation=true"] : []),
+            ...(input.realtimeSidebandBaseUrl
+                ? ["-c", `experimental_realtime_ws_base_url=${JSON.stringify(input.realtimeSidebandBaseUrl)}`]
+                : []),
+            ...(input.realtimeWebrtcCallBaseUrl
+                ? ["-c", `experimental_realtime_webrtc_call_base_url=${JSON.stringify(input.realtimeWebrtcCallBaseUrl)}`]
+                : []),
         ]);
         client = await CodexAppServerClient.start({
             command: invocation.command,
@@ -450,6 +463,7 @@ export async function startCodexNativeAppServer(input) {
             shutdownTimeoutMs: input.config.shutdownTimeoutMs,
             killTimeoutMs: input.config.killTimeoutMs,
             onDiagnostic: input.onDiagnostic,
+            signal: input.signal,
         });
         const [reportedHome, expectedHome] = await Promise.all([
             realpath(client.initializeResponse.codexHome).catch(() => resolve(client.initializeResponse.codexHome)),

package/dist/agent-runtimes/codex-native/thread.js

@@ -165,17 +165,14 @@ function secondsToIso(seconds) {
     const date = new Date(Number(seconds) * 1_000);
     return Number.isNaN(date.getTime()) ? undefined : date.toISOString();
 }
-function itemText(item) {
-    if (item.type === "agentMessage" && typeof item.text === "string")
-        return redactCodexNativeSensitiveText(item.text);
-    if (item.type === "userMessage" && Array.isArray(item.content)) {
-        const text = item.content
-            .filter((part) => isRecord(part) && part.type === "text" && typeof part.text === "string")
-            .map((part) => redactCodexNativeSensitiveText(part.text))
-            .join("\n");
-        return text || undefined;
-    }
-    return undefined;
+function userMessageText(item) {
+    if (item.type !== "userMessage" || !Array.isArray(item.content))
+        return undefined;
+    const text = item.content
+        .filter((part) => isRecord(part) && part.type === "text" && typeof part.text === "string")
+        .map((part) => redactCodexNativeSensitiveText(part.text))
+        .join("\n");
+    return text || undefined;
 }
 function threadLeafId(thread) {
     return thread.turns.at(-1)?.id ?? null;
@@ -204,12 +201,21 @@ export function codexThreadInfo(runtimeInstanceId, thread) {
         firstMessage: thread.preview ? redactCodexNativeSensitiveText(thread.preview) : undefined,
     };
 }
-export function codexThreadForkCandidates(thread) {
-    return thread.turns.map((turn) => {
-        const text = [...turn.items].reverse().map(itemText).find((candidate) => candidate?.trim()) ?? `Codex turn ${turn.id}`;
-        return { entryId: turn.id, text };
+function codexThreadForkTargets(thread) {
+    return thread.turns.flatMap((turn, index) => {
+        const userMessage = turn.items.find((item) => item.type === "userMessage");
+        if (!userMessage)
+            return [];
+        return [{
+                entryId: userMessage.id,
+                text: userMessageText(userMessage) ?? `Codex turn ${turn.id}`,
+                ...(index > 0 ? { previousTurnId: thread.turns[index - 1].id } : {}),
+            }];
     });
 }
+export function codexThreadForkCandidates(thread) {
+    return codexThreadForkTargets(thread).map(({ entryId, text }) => ({ entryId, text }));
+}
 export class CodexNativeThreadController {
     client;
     currentThread;
@@ -241,6 +247,7 @@ export class CodexNativeThreadController {
             ...(selection.sandbox ? { sandbox: selection.sandbox } : {}),
             ...(selection.config ? { config: structuredClone(selection.config) } : {}),
             ...(selection.developerInstructions ? { developerInstructions: selection.developerInstructions } : {}),
+            ...(selection.personality !== undefined ? { personality: selection.personality } : {}),
         });
     }
     static async resume(client, threadId, workspace, selection = {}) {
@@ -265,6 +272,7 @@ export class CodexNativeThreadController {
                 ...(selection.sandbox ? { sandbox: selection.sandbox } : {}),
                 ...(selection.config ? { config: structuredClone(selection.config) } : {}),
                 ...(selection.developerInstructions ? { developerInstructions: selection.developerInstructions } : {}),
+                ...(selection.personality !== undefined ? { personality: selection.personality } : {}),
             });
         }
         catch (error) {
@@ -345,15 +353,29 @@ export class CodexNativeThreadController {
             .sort((left, right) => right.updatedAt - left.updatedAt || right.createdAt - left.createdAt)
             .map((thread) => codexThreadInfo(runtimeInstanceId, thread));
     }
-    async fork(runtimeInstanceId, workspace, lastTurnId, validateThread) {
-        if (!lastTurnId.trim())
-            throw new Error("Codex thread fork requires a native turn id.");
-        return await this.forkAt(runtimeInstanceId, workspace, lastTurnId, validateThread);
+    async fork(runtimeInstanceId, workspace, entryId, validateThread) {
+        if (!entryId.trim())
+            throw new Error("Codex thread fork requires a native user-message id.");
+        const target = codexThreadForkTargets(this.currentThread).find((candidate) => candidate.entryId === entryId);
+        if (target) {
+            if (!target.previousTurnId) {
+                return this.branchBeforeFirstTurn(runtimeInstanceId, workspace, target);
+            }
+            return await this.forkAt(runtimeInstanceId, workspace, target.previousTurnId, validateThread, target);
+        }
+        const legacyTurn = this.currentThread.turns.find((turn) => turn.id === entryId);
+        if (!legacyTurn)
+            throw new Error(`Codex fork target "${entryId}" was not found.`);
+        const legacyText = legacyTurn.items.map(userMessageText).find((text) => text?.trim());
+        return await this.forkAt(runtimeInstanceId, workspace, entryId, validateThread, {
+            entryId,
+            text: legacyText ?? `Codex turn ${entryId}`,
+        });
     }
     async clone(runtimeInstanceId, workspace, validateThread) {
         return await this.forkAt(runtimeInstanceId, workspace, undefined, validateThread);
     }
-    async forkAt(runtimeInstanceId, workspace, lastTurnId, validateThread) {
+    async forkAt(runtimeInstanceId, workspace, lastTurnId, validateThread, selectedTarget) {
         const previousThread = this.currentThread;
         const previous = codexThreadSnapshot(runtimeInstanceId, previousThread);
         const params = {
@@ -376,9 +398,6 @@ export class CodexNativeThreadController {
                 throw new CodexNativeThreadProtocolError("Codex thread/fork returned the source thread id.");
             }
             await validateThread?.(forked.id);
-            const selectedText = lastTurnId
-                ? codexThreadForkCandidates(previousThread).find((candidate) => candidate.entryId === lastTurnId)?.text
-                : undefined;
             this.knownThreads.set(previousThread.id, structuredClone(previousThread));
             this.knownThreads.set(forked.id, structuredClone(forked));
             this.currentThread = forked;
@@ -387,12 +406,27 @@ export class CodexNativeThreadController {
                 previous,
                 current: codexThreadSnapshot(runtimeInstanceId, forked),
                 cancelled: false,
-                ...(selectedText ? { selectedText } : {}),
-                ...(lastTurnId ? { summaryEntryId: lastTurnId } : {}),
+                ...(selectedTarget?.text ? { selectedText: selectedTarget.text } : {}),
+                ...(selectedTarget ? { summaryEntryId: selectedTarget.entryId } : {}),
             };
         }
         catch (error) {
             return normalizeThreadError(error, previousThread.id);
         }
     }
+    branchBeforeFirstTurn(runtimeInstanceId, workspace, target) {
+        const previousThread = this.currentThread;
+        return {
+            previous: codexThreadSnapshot(runtimeInstanceId, previousThread),
+            current: {
+                adapterId: CODEX_NATIVE_ADAPTER_ID,
+                runtimeInstanceId,
+                cwd: workspace,
+                leafId: null,
+            },
+            cancelled: false,
+            selectedText: target.text,
+            summaryEntryId: target.entryId,
+        };
+    }
 }

package/dist/agent-runtimes/codex-native/turn.js

@@ -319,6 +319,33 @@ export class CodexNativeTurnController {
             throw error;
         }
     }
+    replayTerminalTurn(turn) {
+        if (this.disposed)
+            throw new Error("Codex native turn controller is disposed.");
+        if (this.pending)
+            throw new Error("Codex native session already has an active turn.");
+        if (turn.status === "inProgress") {
+            throw new CodexNativeTurnProtocolError("Codex cannot replay a non-terminal native turn.");
+        }
+        const replay = newPendingTurn();
+        this.assignTurnId(replay, turn.id);
+        replay.started = true;
+        for (const item of turn.items)
+            this.completeItem(replay, item);
+        this.finishIncompleteItems(replay, turn.status);
+        if (turn.status === "failed") {
+            const message = errorMessage(turn.error);
+            this.emit({
+                type: "turn_failed",
+                message,
+                details: providerErrorDetails(turn.error, message, false),
+                turnId: turn.id,
+            });
+        }
+        else {
+            this.emit({ type: "turn_completed", status: turn.status, turnId: turn.id });
+        }
+    }
     async compact() {
         if (this.disposed)
             throw new Error("Codex native turn controller is disposed.");

package/dist/agent-runtimes/history-proof.js

@@ -0,0 +1,8 @@
+import { isCodexNativeBuiltInHistoryReconciliationProof } from "./codex-native/adapter.js";
+import { isOmpBuiltInHistoryReconciliationProof } from "./omp/adapter.js";
+import { isPiBuiltInHistoryReconciliationProof } from "./pi/adapter.js";
+export function isBuiltInHistoryReconciliationProof(proof) {
+    return proof !== undefined && (isPiBuiltInHistoryReconciliationProof(proof)
+        || isOmpBuiltInHistoryReconciliationProof(proof)
+        || isCodexNativeBuiltInHistoryReconciliationProof(proof));
+}