@pasko70/pibo 2.5.2 → 3.0.0

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

@@ -1,10 +1,13 @@
 import { randomUUID } from "node:crypto";
 import { unsupportedAgentRuntimeCapability, } from "../../agent-runtime/capabilities.js";
 import { AgentRuntimeBindingMissingError, AgentRuntimeUnavailableError, } from "../../agent-runtime/errors.js";
+import { isAgentRuntimeBindingPersistence } from "../../sessions/runtime-binding-persistence.js";
+import { PENDING_NATIVE_SESSION_METADATA_KEY } from "../../sessions/runtime-binding.js";
 import { selectRequestedFastMode, selectRequestedModelProfile, selectRequestedThinkingLevel, } from "../../core/model-defaults.js";
 import { CODEX_NATIVE_RUNTIME_CONFIG_SCHEMA, defaultCodexNativeRuntimeConfig, parseCodexNativeRuntimeConfig, } from "./config.js";
 import { diagnoseCodexNativeRuntime, startCodexNativeAppServer, } from "./process.js";
 import { inspectCodexThreadHistory, pageCodexThreadHistory, unavailableCodexThreadHistoryInspection, } from "./history.js";
+import { historyReconciliationDigest, } from "../../agent-runtime/history.js";
 import { CODEX_NATIVE_ADAPTER_ID, CodexNativeThreadController, CodexNativeThreadMissingError, } from "./thread.js";
 import { CODEX_APP_SERVER_PROTOCOL_NAME, CODEX_APP_SERVER_SUPPORTED_RANGE, CODEX_APP_SERVER_VERSION, } from "./protocol-version.js";
 import { CodexNativeTurnController } from "./turn.js";
@@ -13,8 +16,69 @@ import { CodexNativeResourceDelivery } from "./resource-delivery.js";
 import { CODEX_NATIVE_MODEL_OPTIONS_SCHEMA, CODEX_NATIVE_MODEL_PROVIDER_ID, CODEX_NATIVE_REASONING_VALUES, CodexNativeSessionSettingsController, parseCodexNativeProfileOptions, readCodexNativeModelCatalog, readCodexNativePersistedSettings, toAgentRuntimeModelCatalog, } from "./models.js";
 import { CodexNativeAuthController } from "./auth.js";
 import { injectPortableHistoryIntoCodex } from "./portable-history.js";
+import { CODEX_FIRST_USE_METADATA_KEY, CODEX_FIRST_USE_METADATA_VERSION, assertCodexNativeFirstUseMessageId, assertCodexNativeFirstUseDeliveryReceiptTurn, assertCodexNativePendingFirstUseRequest, assertCodexNativePendingFirstUseTurn, beginCodexNativeFirstUseAttempt, codexNativeFirstUseDeliveryReceipt, codexNativePendingFirstUseOwnerLiveness, endCodexNativeFirstUseAttempt, hashCanonicalCodexNativeFirstUsePrompt, isExactCodexNativeFirstUseDeliveryReplay, readCodexNativeFirstUseDeliveryReceipt, readCodexNativePendingFirstUse, } from "./first-use.js";
 export { CODEX_NATIVE_ADAPTER_ID } from "./thread.js";
 export const CODEX_NATIVE_ADAPTER_VERSION = "1.0.0";
+function readPendingFirstUse(binding) {
+    try {
+        return readCodexNativePendingFirstUse(binding);
+    }
+    catch (error) {
+        throw new AgentRuntimeUnavailableError(binding.runtimeInstanceId, error instanceof Error ? error.message : "The pending native Codex first-use metadata is invalid.");
+    }
+}
+function readFirstUseDeliveryReceipt(binding) {
+    try {
+        return readCodexNativeFirstUseDeliveryReceipt(binding);
+    }
+    catch (error) {
+        throw new AgentRuntimeUnavailableError(binding.runtimeInstanceId, error instanceof Error ? error.message : "The delivered native Codex first-use receipt is invalid.");
+    }
+}
+function deliveryReceiptForBinding(binding) {
+    if (binding.metadata?.[CODEX_FIRST_USE_METADATA_KEY] === undefined)
+        return undefined;
+    if (binding.state === "unbound") {
+        const pending = readPendingFirstUse(binding);
+        return pending ? codexNativeFirstUseDeliveryReceipt(pending) : undefined;
+    }
+    return readFirstUseDeliveryReceipt(binding);
+}
+function pendingFirstUseBinding(binding, threadId, messageId, promptHash, owner) {
+    return {
+        ...structuredClone(binding),
+        nativeSessionId: threadId,
+        state: "unbound",
+        protocol: CODEX_APP_SERVER_PROTOCOL_NAME,
+        protocolVersion: CODEX_APP_SERVER_VERSION,
+        adapterVersion: CODEX_NATIVE_ADAPTER_VERSION,
+        locator: { kind: "adapter-resolved" },
+        metadata: {
+            ...(binding.metadata ?? {}),
+            [PENDING_NATIVE_SESSION_METADATA_KEY]: true,
+            [CODEX_FIRST_USE_METADATA_KEY]: {
+                version: CODEX_FIRST_USE_METADATA_VERSION,
+                state: "pending",
+                threadId,
+                messageId,
+                promptHash,
+                ...owner,
+            },
+        },
+    };
+}
+function clearPendingFirstUse(binding) {
+    const metadata = { ...(binding.metadata ?? {}) };
+    delete metadata[CODEX_FIRST_USE_METADATA_KEY];
+    delete metadata[PENDING_NATIVE_SESSION_METADATA_KEY];
+    return {
+        ...structuredClone(binding),
+        nativeSessionId: undefined,
+        state: "unbound",
+        locator: undefined,
+        metadata,
+    };
+}
 function codexNativeCapabilities(structuredUserInput) {
     return {
         lifecycle: {
@@ -111,8 +175,10 @@ export const CODEX_NATIVE_THREAD_CAPABILITIES = codexNativeCapabilities(false);
 function timestamp(seconds) {
     return new Date(seconds * 1_000).toISOString();
 }
-function safeThreadMetadata(thread, previous = {}, settings = {}) {
+function safeThreadMetadata(thread, previous = {}, settings = {}, deliveryReceipt) {
     const { diagnosticCode: _diagnosticCode, diagnosticMessage: _diagnosticMessage, ...metadata } = previous;
+    delete metadata[CODEX_FIRST_USE_METADATA_KEY];
+    delete metadata[PENDING_NATIVE_SESSION_METADATA_KEY];
     return {
         ...metadata,
         ...settings,
@@ -122,9 +188,11 @@ function safeThreadMetadata(thread, previous = {}, settings = {}) {
         threadUpdatedAt: timestamp(thread.updatedAt),
         threadStatus: thread.status.type,
         modelProvider: thread.modelProvider,
+        ...(deliveryReceipt ? { [CODEX_FIRST_USE_METADATA_KEY]: deliveryReceipt } : {}),
     };
 }
 function bindingForThread(input) {
+    const deliveryReceipt = input.previous ? deliveryReceiptForBinding(input.previous) : undefined;
     return {
         ...(input.previous ? structuredClone(input.previous) : {}),
         piboSessionId: input.piboSessionId,
@@ -136,7 +204,7 @@ function bindingForThread(input) {
         protocolVersion: CODEX_APP_SERVER_VERSION,
         adapterVersion: CODEX_NATIVE_ADAPTER_VERSION,
         locator: { kind: "adapter-resolved" },
-        metadata: safeThreadMetadata(input.thread, input.previous?.metadata, input.settings),
+        metadata: safeThreadMetadata(input.thread, input.previous?.metadata, input.settings, deliveryReceipt),
     };
 }
 function validateOpenBinding(input, runtimeInstanceId) {
@@ -163,8 +231,31 @@ function validateOpenBinding(input, runtimeInstanceId) {
     if (binding.state === "bound" && !binding.nativeSessionId) {
         throw new AgentRuntimeUnavailableError(runtimeInstanceId, "The persisted Codex binding has no native thread id.");
     }
+    if (binding.state === "bound")
+        readFirstUseDeliveryReceipt(binding);
     if (binding.state === "unbound" && binding.nativeSessionId) {
-        throw new AgentRuntimeUnavailableError(runtimeInstanceId, "An unbound Codex binding cannot contain a native thread id.");
+        const pending = readPendingFirstUse(binding);
+        const hasCurrentPendingMarker = binding.metadata?.[PENDING_NATIVE_SESSION_METADATA_KEY] === true;
+        const isExactParentLegacyPending = pending?.version === 1
+            && binding.metadata?.[PENDING_NATIVE_SESSION_METADATA_KEY] === undefined;
+        if (!pending
+            || pending.threadId !== binding.nativeSessionId
+            || (!hasCurrentPendingMarker && !isExactParentLegacyPending)
+            || input.piboSession.kind !== "branch") {
+            throw new AgentRuntimeUnavailableError(runtimeInstanceId, "An unbound Codex binding contains an invalid pending native thread identity.");
+        }
+        if (isExactParentLegacyPending) {
+            return {
+                ...binding,
+                metadata: {
+                    ...(binding.metadata ?? {}),
+                    [PENDING_NATIVE_SESSION_METADATA_KEY]: true,
+                },
+            };
+        }
+    }
+    else if (binding.state === "unbound" && binding.metadata?.[CODEX_FIRST_USE_METADATA_KEY] !== undefined) {
+        throw new AgentRuntimeUnavailableError(runtimeInstanceId, "An unbound Codex binding contains pending metadata without a native thread identity.");
     }
     return binding;
 }
@@ -177,6 +268,8 @@ export class CodexNativeThreadSession {
     structuredUserInput;
     reloadProcess;
     productContext;
+    bindingPersistence;
+    firstUseTestFailpoints;
     adapterId = CODEX_NATIVE_ADAPTER_ID;
     cwd;
     capabilities;
@@ -198,12 +291,14 @@ export class CodexNativeThreadSession {
     selectedToolNames = new Set();
     observedToolNames = new Set();
     toolInventoryWarning;
-    constructor(runtimeInstanceId, process, threads, settings, resourceDelivery, binding, structuredUserInput, reloadProcess, productContext) {
+    constructor(runtimeInstanceId, process, threads, settings, resourceDelivery, binding, structuredUserInput, reloadProcess, productContext, bindingPersistence, firstUseTestFailpoints) {
         this.runtimeInstanceId = runtimeInstanceId;
         this.settings = settings;
         this.structuredUserInput = structuredUserInput;
         this.reloadProcess = reloadProcess;
         this.productContext = productContext;
+        this.bindingPersistence = bindingPersistence;
+        this.firstUseTestFailpoints = firstUseTestFailpoints;
         this.process = process;
         this.threads = threads;
         this.resourceDelivery = resourceDelivery;
@@ -219,14 +314,16 @@ export class CodexNativeThreadSession {
             getForkCandidates: () => this.threads.getForkCandidates(),
             forkSession: async (entryId) => await this.runIdleOperation(async () => {
                 const result = await this.threads.fork(this.runtimeInstanceId, this.cwd, entryId, async (threadId) => await this.resourceDelivery.verifyThread(this.process.client, threadId));
-                this.settings.attachThread(this.threads.thread.id, this.threads.configuration);
-                this.updateBindingFromCurrentThread();
+                if (result.current.nativeSessionId) {
+                    this.settings.attachThread(this.threads.thread.id, this.threads.configuration);
+                    this.promoteBindingFromCurrentThread();
+                }
                 return result;
             }),
             cloneSession: async () => await this.runIdleOperation(async () => {
                 const result = await this.threads.clone(this.runtimeInstanceId, this.cwd, async (threadId) => await this.resourceDelivery.verifyThread(this.process.client, threadId));
                 this.settings.attachThread(this.threads.thread.id, this.threads.configuration);
-                this.updateBindingFromCurrentThread();
+                this.promoteBindingFromCurrentThread();
                 return result;
             }),
             getReasoning: () => this.settings.reasoning,
@@ -256,7 +353,7 @@ export class CodexNativeThreadSession {
                     });
                 }
                 await this.turns.compact();
-                this.updateBindingFromCurrentThread();
+                this.refreshBoundBindingFromCurrentThread();
                 return {
                     native: true,
                     method: "thread/compact/start",
@@ -281,7 +378,7 @@ export class CodexNativeThreadSession {
         return this.requests.pendingUserInputs;
     }
     getBinding() {
-        this.updateBindingFromCurrentThread();
+        this.refreshBoundBindingFromCurrentThread();
         return structuredClone(this.binding);
     }
     subscribe(listener) {
@@ -292,12 +389,25 @@ export class CodexNativeThreadSession {
     async prompt(input) {
         this.assertActive();
         await this.ensureFreshResourcesForTurn();
+        this.assertIdle();
         this.operationInFlight = true;
+        let ownedFirstUseAttempt;
         try {
-            await this.turns.start(input.text, this.productContext?.getActiveMessage?.()?.id ?? randomUUID(), this.settings.turnOptions);
-            this.updateBindingFromCurrentThread();
+            const firstUse = await this.acquirePendingFirstUse(this.productContext?.getActiveMessage?.()?.id ?? randomUUID(), input.text);
+            ownedFirstUseAttempt = firstUse.attemptId;
+            if (!firstUse.startTurn)
+                return;
+            await this.firstUseTestFailpoints?.afterPendingBindingPersisted?.();
+            await this.turns.start(input.text, firstUse.messageId, this.settings.turnOptions);
+            await this.firstUseTestFailpoints?.afterNativeTerminalDurable?.();
+            const pending = this.binding.state === "unbound" ? readPendingFirstUse(this.binding) : undefined;
+            if (pending)
+                assertCodexNativePendingFirstUseTurn(pending, this.threads.thread);
+            this.promoteBindingFromCurrentThread();
         }
         finally {
+            if (ownedFirstUseAttempt)
+                endCodexNativeFirstUseAttempt(ownedFirstUseAttempt);
             this.operationInFlight = false;
             if (this.recycleProcessAfterInterruptedTurn && !this.disposed) {
                 this.recycleProcessAfterInterruptedTurn = false;
@@ -531,7 +641,7 @@ export class CodexNativeThreadSession {
             this.requests = this.createRequestController(next.process);
             previousRequests.dispose();
             previousTurns.dispose();
-            this.updateBindingFromCurrentThread();
+            this.refreshBoundBindingFromCurrentThread();
             this.resourceProcessUnavailable = false;
             this.resourceWarning = undefined;
             next = undefined;
@@ -574,7 +684,65 @@ export class CodexNativeThreadSession {
             }
         }
     }
-    updateBindingFromCurrentThread() {
+    refreshBoundBindingFromCurrentThread() {
+        if (this.binding.state !== "bound")
+            return;
+        this.promoteBindingFromCurrentThread();
+    }
+    async acquirePendingFirstUse(messageId, prompt) {
+        if (this.binding.state !== "unbound") {
+            const receipt = readFirstUseDeliveryReceipt(this.binding);
+            if (!receipt || !isExactCodexNativeFirstUseDeliveryReplay(receipt, messageId, prompt)) {
+                return { messageId, startTurn: true };
+            }
+            const firstTurn = assertCodexNativeFirstUseDeliveryReceiptTurn(receipt, this.threads.thread);
+            this.turns.replayTerminalTurn(firstTurn);
+            return { messageId: receipt.messageId, startTurn: false };
+        }
+        assertCodexNativeFirstUseMessageId(messageId);
+        const promptHash = hashCanonicalCodexNativeFirstUsePrompt(prompt);
+        const currentPending = readPendingFirstUse(this.binding);
+        if (currentPending && this.threads.thread.turns.length > 0) {
+            assertCodexNativePendingFirstUseTurn(currentPending, this.threads.thread);
+            assertCodexNativePendingFirstUseRequest(currentPending, messageId, prompt);
+            this.promoteBindingFromCurrentThread();
+            return { messageId: currentPending.messageId, startTurn: false };
+        }
+        if (currentPending) {
+            const ownerLiveness = codexNativePendingFirstUseOwnerLiveness(currentPending);
+            if (ownerLiveness === "active") {
+                throw new Error("Native Codex first use is already owned by another live router.");
+            }
+            if (ownerLiveness === "ambiguous") {
+                throw new Error("Native Codex first-use ownership is ambiguous and cannot be replaced safely.");
+            }
+            assertCodexNativePendingFirstUseRequest(currentPending, messageId, prompt);
+        }
+        if (!isAgentRuntimeBindingPersistence(this.bindingPersistence)) {
+            throw new Error("Native Codex first use requires audited durable cross-process atomic runtime-binding CAS before turn/start.");
+        }
+        const owner = beginCodexNativeFirstUseAttempt();
+        const proposed = pendingFirstUseBinding(this.binding, this.threads.thread.id, messageId, promptHash, owner);
+        try {
+            const expectedRevision = this.binding.revision ?? 1;
+            const persisted = await this.bindingPersistence.compareAndSet(proposed, expectedRevision);
+            const pending = readPendingFirstUse(persisted);
+            if (persisted.revision !== expectedRevision + 1
+                || persisted.state !== "unbound"
+                || persisted.nativeSessionId !== proposed.nativeSessionId
+                || !pending
+                || JSON.stringify(pending) !== JSON.stringify(readPendingFirstUse(proposed))) {
+                throw new Error("Runtime-binding persistence returned an inconsistent Codex first-use claim.");
+            }
+            this.binding = structuredClone(persisted);
+            return { attemptId: owner.attemptId, messageId, startTurn: true };
+        }
+        catch (error) {
+            endCodexNativeFirstUseAttempt(owner.attemptId);
+            throw error;
+        }
+    }
+    promoteBindingFromCurrentThread() {
         this.binding = bindingForThread({
             piboSessionId: this.binding.piboSessionId,
             runtimeInstanceId: this.runtimeInstanceId,
@@ -589,12 +757,38 @@ export class CodexNativeThreadSession {
     }
     assertIdle() {
         this.assertActive();
-        if (this.turns.streaming || this.resourceRefresh || this.resourceProcessUnavailable) {
+        if (this.operationInFlight || this.turns.streaming || this.resourceRefresh || this.resourceProcessUnavailable) {
             throw new Error("Codex runtime controls can only change while the session is idle.");
         }
     }
 }
-export class CodexNativeAgentRuntimeAdapter {
+const codexNativeCompleteHistoryProofs = new WeakMap();
+const codexNativeHistoryReaders = new WeakMap();
+const startCodexNativeHistoryProcess = startCodexNativeAppServer;
+const readCodexNativeHistoryThread = CodexNativeThreadController.read;
+function bindCodexNativeCompleteHistoryProof(page) {
+    const claim = page.reconciliationProof;
+    if (!claim?.complete)
+        return page;
+    const entries = Object.freeze([...claim.entries]);
+    const fullScope = Object.freeze({ entryCount: entries.length, digest: historyReconciliationDigest(entries) });
+    const proof = Object.freeze({
+        complete: true,
+        ...(claim.scopeId ? { scopeId: claim.scopeId } : {}),
+        fullScope,
+        entries,
+    });
+    codexNativeCompleteHistoryProofs.set(proof, { ...(claim.scopeId ? { scopeId: claim.scopeId } : {}), fullScope });
+    return { ...page, reconciliationProof: proof };
+}
+export function isCodexNativeBuiltInHistoryReconciliationProof(proof) {
+    const bound = codexNativeCompleteHistoryProofs.get(proof);
+    return proof.complete
+        && bound !== undefined
+        && proof.scopeId === bound.scopeId
+        && proof.fullScope === bound.fullScope;
+}
+class CodexNativeAgentRuntimeAdapter {
     instanceId;
     descriptor;
     config;
@@ -611,6 +805,24 @@ export class CodexNativeAgentRuntimeAdapter {
         };
         this.displayName = displayName ?? this.descriptor.displayName;
         this.enabled = enabled;
+        const historyConfig = structuredClone(this.config);
+        const historyInstanceId = this.instanceId;
+        codexNativeHistoryReaders.set(this, async (piboSessionId, workspace, threadId, includeTurns) => {
+            const process = await startCodexNativeHistoryProcess({
+                config: historyConfig,
+                runtimeInstanceId: historyInstanceId,
+                piboSessionId,
+                sessionGeneration: `history-${randomUUID()}`,
+                workspace,
+                clientVersion: CODEX_NATIVE_ADAPTER_VERSION,
+            });
+            try {
+                return await readCodexNativeHistoryThread(process.client, threadId, includeTurns);
+            }
+            finally {
+                await process.close();
+            }
+        });
         this.authController = new CodexNativeAuthController({
             config: this.config,
             startProcess: async (sessionGeneration) => await startCodexNativeAppServer({
@@ -724,6 +936,14 @@ export class CodexNativeAgentRuntimeAdapter {
     }
     async openSession(input) {
         const binding = validateOpenBinding(input, this.instanceId);
+        const activeFirstMessage = input.productContext.getActiveMessage?.();
+        const messageStartsLazyFirstUse = binding.state === "unbound"
+            && input.piboSession.kind === "branch"
+            && input.historyHandoff?.mode !== "import"
+            && Boolean(activeFirstMessage?.id);
+        if (messageStartsLazyFirstUse && !isAgentRuntimeBindingPersistence(input.services?.runtimeBindingPersistence)) {
+            throw new AgentRuntimeUnavailableError(this.instanceId, "Native Codex first use requires audited durable cross-process atomic runtime-binding CAS before thread/start.");
+        }
         const sessionGeneration = input.services?.resources?.sessionGeneration
             ?? input.services?.portableTools?.sessionGeneration
             ?? randomUUID();
@@ -801,16 +1021,50 @@ export class CodexNativeAgentRuntimeAdapter {
                     ? { developerInstructions: resourceDelivery.developerInstructions }
                     : {}),
             };
+            const pendingFirstUse = binding.state === "unbound" ? readPendingFirstUse(binding) : undefined;
+            const deliveryReceipt = binding.state === "bound" ? readFirstUseDeliveryReceipt(binding) : undefined;
+            let sessionBinding = binding;
+            let pendingTerminalVerified = false;
             let threads;
             try {
-                threads = binding.state === "bound"
+                threads = binding.state === "bound" || pendingFirstUse
                     ? await CodexNativeThreadController.resume(process.client, binding.nativeSessionId, input.workspace, threadSelection)
                     : await CodexNativeThreadController.start(process.client, input.workspace, threadSelection);
             }
             catch (error) {
-                if (error instanceof CodexNativeThreadMissingError || !resourceDelivery.hasMcpServers)
-                    throw error;
-                throw new Error("Codex could not initialize every selected MCP server.");
+                if (pendingFirstUse && error instanceof CodexNativeThreadMissingError) {
+                    const ownerLiveness = codexNativePendingFirstUseOwnerLiveness(pendingFirstUse);
+                    if (ownerLiveness === "active") {
+                        throw new AgentRuntimeUnavailableError(this.instanceId, "Native Codex first use is owned by another live router and is not yet restart-reconcilable.");
+                    }
+                    if (ownerLiveness === "ambiguous") {
+                        throw new AgentRuntimeUnavailableError(this.instanceId, "Native Codex first-use ownership is ambiguous; the pending identity was retained.");
+                    }
+                    threads = await CodexNativeThreadController.start(process.client, input.workspace, threadSelection);
+                    sessionBinding = clearPendingFirstUse(binding);
+                }
+                else {
+                    if (error instanceof CodexNativeThreadMissingError || !resourceDelivery.hasMcpServers)
+                        throw error;
+                    throw new Error("Codex could not initialize every selected MCP server.");
+                }
+            }
+            if (pendingFirstUse && threads.thread.turns.length > 0) {
+                try {
+                    assertCodexNativePendingFirstUseTurn(pendingFirstUse, threads.thread);
+                    pendingTerminalVerified = true;
+                }
+                catch (error) {
+                    throw new AgentRuntimeUnavailableError(this.instanceId, error instanceof Error ? error.message : "The pending native Codex first turn cannot be verified.");
+                }
+            }
+            if (deliveryReceipt) {
+                try {
+                    assertCodexNativeFirstUseDeliveryReceiptTurn(deliveryReceipt, threads.thread);
+                }
+                catch (error) {
+                    throw new AgentRuntimeUnavailableError(this.instanceId, error instanceof Error ? error.message : "The delivered native Codex first turn cannot be verified.");
+                }
             }
             if (input.historyHandoff?.mode === "import") {
                 if (binding.state === "bound") {
@@ -820,13 +1074,27 @@ export class CodexNativeAgentRuntimeAdapter {
             }
             settings.attachThread(threads.thread.id, threads.configuration);
             await resourceDelivery.verifyThread(process.client, threads.thread.id);
-            return new CodexNativeThreadSession(this.instanceId, process, threads, settings, resourceDelivery, bindingForThread({
-                piboSessionId: input.piboSession.id,
-                runtimeInstanceId: this.instanceId,
-                previous: binding,
-                thread: threads.thread,
-                settings: settings.bindingMetadata,
-            }), this.config.experimentalUserInput, async () => await startProcessBundle(`${sessionGeneration}-credential-${randomUUID()}`), input.productContext);
+            const lazyFirstMessageBranch = sessionBinding.state === "unbound"
+                && input.piboSession.kind === "branch"
+                && input.historyHandoff?.mode !== "import";
+            const openedBinding = lazyFirstMessageBranch
+                ? pendingTerminalVerified
+                    ? bindingForThread({
+                        piboSessionId: input.piboSession.id,
+                        runtimeInstanceId: this.instanceId,
+                        previous: sessionBinding,
+                        thread: threads.thread,
+                        settings: settings.bindingMetadata,
+                    })
+                    : sessionBinding
+                : bindingForThread({
+                    piboSessionId: input.piboSession.id,
+                    runtimeInstanceId: this.instanceId,
+                    previous: sessionBinding,
+                    thread: threads.thread,
+                    settings: settings.bindingMetadata,
+                });
+            return new CodexNativeThreadSession(this.instanceId, process, threads, settings, resourceDelivery, openedBinding, this.config.experimentalUserInput, async () => await startProcessBundle(`${sessionGeneration}-credential-${randomUUID()}`), input.productContext, input.services?.runtimeBindingPersistence, compatibility?.testOnlyFirstUseFailpoints);
         }
         catch (error) {
             settings?.dispose();
@@ -844,7 +1112,10 @@ export class CodexNativeAgentRuntimeAdapter {
             return unavailableCodexThreadHistoryInspection(this.instanceId, input.binding, "codex_native_history_thread_id_missing", "The Codex runtime binding has no native thread id for history lookup.");
         }
         try {
-            const thread = await this.withProcess(input.binding.piboSessionId, input.workspace, async (process) => await CodexNativeThreadController.read(process.client, threadId, false));
+            const readHistory = codexNativeHistoryReaders.get(this);
+            if (!readHistory)
+                throw new Error("Codex built-in history reader is unavailable.");
+            const thread = await readHistory(input.binding.piboSessionId, input.workspace, threadId, false);
             return inspectCodexThreadHistory(this.instanceId, input.binding, thread);
         }
         catch (error) {
@@ -867,15 +1138,18 @@ export class CodexNativeAgentRuntimeAdapter {
             };
         }
         try {
-            const thread = await this.withProcess(input.binding.piboSessionId, input.workspace, async (process) => await CodexNativeThreadController.read(process.client, threadId, true));
-            return pageCodexThreadHistory({
+            const readHistory = codexNativeHistoryReaders.get(this);
+            if (!readHistory)
+                throw new Error("Codex built-in history reader is unavailable.");
+            const thread = await readHistory(input.binding.piboSessionId, input.workspace, threadId, true);
+            return bindCodexNativeCompleteHistoryProof(pageCodexThreadHistory({
                 runtimeInstanceId: this.instanceId,
                 binding: input.binding,
                 thread,
                 cursor: input.cursor,
                 beforeTimestamp: input.beforeTimestamp,
                 limit: input.limit,
-            });
+            }));
         }
         catch (error) {
             if (error instanceof CodexNativeThreadMissingError) {

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

@@ -142,19 +142,28 @@ function serializeMessage(message, maxMessageBytes) {
 function timeoutError(label) {
     return new CodexAppServerClientError("timeout", `${label} timed out`);
 }
-async function waitWithTimeout(promise, timeoutMs, label) {
+async function waitWithTimeout(promise, timeoutMs, label, signal) {
+    if (signal?.aborted)
+        throw new CodexAppServerClientError("aborted", `${label} was aborted`);
     let timer;
+    let onAbort;
     try {
         return await Promise.race([
             promise,
             new Promise((_resolve, reject) => {
                 timer = setTimeout(() => reject(timeoutError(label)), timeoutMs);
             }),
+            ...(signal ? [new Promise((_resolve, reject) => {
+                    onAbort = () => reject(new CodexAppServerClientError("aborted", `${label} was aborted`));
+                    signal.addEventListener("abort", onAbort, { once: true });
+                })] : []),
         ]);
     }
     finally {
         if (timer)
             clearTimeout(timer);
+        if (onAbort)
+            signal?.removeEventListener("abort", onAbort);
     }
 }
 async function sleep(delayMs, signal) {
@@ -231,6 +240,8 @@ export class CodexAppServerClient {
     }
     static async start(options) {
         validateClientOptions(options);
+        if (options.signal?.aborted)
+            throw new CodexAppServerClientError("aborted", "Codex App Server startup was aborted");
         let previousMask;
         if (options.fileCreationMask !== undefined && globalThis.process.platform !== "win32") {
             previousMask = globalThis.process.umask(options.fileCreationMask);
@@ -255,9 +266,13 @@ export class CodexAppServerClient {
         };
         const client = new CodexAppServerClient(process, options, placeholder);
         client.attachProcessListeners();
+        const onAbort = () => {
+            void client.stopProcess(false).catch(() => { });
+        };
+        options.signal?.addEventListener("abort", onAbort, { once: true });
         const deadline = Date.now() + client.startupTimeoutMs;
         try {
-            await waitWithTimeout(client.spawned.promise, client.startupTimeoutMs, "Codex App Server spawn");
+            await waitWithTimeout(client.spawned.promise, client.startupTimeoutMs, "Codex App Server spawn", options.signal);
             client.state = "initializing";
             const initializeResult = await client.requestWithRetry("initialize", {
                 clientInfo: { ...options.clientInfo },
@@ -265,11 +280,12 @@ export class CodexAppServerClient {
             }, {
                 timeoutMs: Math.max(1, deadline - Date.now()),
                 retryOverloaded: true,
+                signal: options.signal,
             }, true);
             const initializeResponse = validateInitializeResponse(initializeResult);
             Object.assign(client.initializeResponse, initializeResponse);
             Object.freeze(client.initializeResponse);
-            await waitWithTimeout(client.writeMessage({ method: "initialized" }, true), Math.max(1, deadline - Date.now()), "Codex App Server initialized notification");
+            await waitWithTimeout(client.writeMessage({ method: "initialized" }, true), Math.max(1, deadline - Date.now()), "Codex App Server initialized notification", options.signal);
             client.state = "ready";
             return client;
         }
@@ -279,6 +295,9 @@ export class CodexAppServerClient {
             await client.stopProcess(false).catch(() => { });
             throw normalized;
         }
+        finally {
+            options.signal?.removeEventListener("abort", onAbort);
+        }
     }
     get snapshot() {
         return {