@zq-silk/yui 0.13.2 → 0.13.3

package/dist/runtime/agentHost.js

@@ -10,7 +10,7 @@ import { callFileTaskController } from "../controller/clientRuntime.js";
 import { isForeignHandoverLockHeld } from "../release/runtimeRelease.js";
 import { publishStructuredProviderAccepted, publishStructuredProviderActivationTerminal, publishStructuredConversationRecoverability, publishStructuredProviderOpened, publishStructuredProviderTerminal } from "../controller/structuredProviderObservation.js";
 import { validateAgentHostLaunchPayload } from "./launchBroker.js";
-import { ProviderDeliveryUnknownError, ProviderConversationMissingError, ProviderTurnRejectedError, startStructuredProviderSession } from "./structuredProviderHost.js";
+import { ProviderDeliveryUnknownError, ProviderConversationMissingError, ProviderTurnBusyError, ProviderTurnRejectedError, startStructuredProviderSession } from "./structuredProviderHost.js";
 import { sameProviderAuthorityFence, validateProviderAuthorityFence } from "./providerAuthorityFence.js";
 import { validateRuntimeProcessExitObservation } from "./processExitObservation.js";
 import { persistRuntimeProcessExitObservation, replayRuntimeProcessExitOutbox } from "./processExitOutbox.js";
@@ -18,6 +18,8 @@ import { readRuntimeStopReceipt, removeRuntimeStopReceipt, writeRuntimeStopRecei
 import { AGENT_HOST_CONTROL_TIMEOUT_MS, AGENT_HOST_READY_TIMEOUT_MS } from "./runtimeDeadlines.js";
 export const AGENT_HOST_CONTROL_PROTOCOL = "yui-agent-host/v2";
 const HOST_CONTROL_MAX_BYTES = 32 * 1024;
+const CODEX_CLIENT_STABLE_MS = 5_000;
+const MAX_CONSECUTIVE_CODEX_DISCONNECTS = 3;
 export function serializeAgentHostLaunchControl(control) {
     return JSON.stringify(validateControl(control));
 }
@@ -28,6 +30,10 @@ export async function runAgentHost(input) {
     let session;
     let sessionPayload;
     let activeTurnPayload;
+    let activeTurnAttemptId;
+    let activeNativeTurnId;
+    let codexClientAttachedAt;
+    let consecutiveCodexDisconnects = 0;
     const switchDetachedSessions = new WeakSet();
     let activationId;
     let conversationRecoverability = "unknown";
@@ -46,6 +52,27 @@ export async function runAgentHost(input) {
         authorityHolderId: authority.holderId
     };
     const handleTerminal = (terminal) => {
+        if (!terminal.clientOwned) {
+            const busyPayload = sessionPayload;
+            if (busyPayload === undefined
+                || session === undefined
+                || terminal.conversationId !== session.conversationId)
+                return;
+            // Another ordinary client completed a Turn. It never enters Yui's Run
+            // observation path; it only removes backpressure from retained work.
+            if (snapshot.state === "busy") {
+                updateSnapshot(hostSnapshot("idle", {
+                    launchId: busyPayload.launchId,
+                    adapterId: session.adapterId,
+                    processInstanceId: session.processInstanceId,
+                    nativeSessionId: session.nativeSessionId,
+                    conversationId: session.conversationId,
+                    ...authorityFields()
+                }));
+            }
+            signalRoleMailbox(input.home, busyPayload);
+            return;
+        }
         const terminalPayload = activeTurnPayload;
         if (terminalPayload === undefined)
             return;
@@ -74,10 +101,12 @@ export async function runAgentHost(input) {
                 if (activeTurnPayload !== terminalPayload)
                     return;
                 activeTurnPayload = undefined;
+                activeTurnAttemptId = undefined;
+                activeNativeTurnId = undefined;
                 if (session === undefined)
                     return;
                 const currentPayload = sessionPayload ?? terminalPayload;
-                updateSnapshot(hostSnapshot("idle", {
+                updateSnapshot(hostSnapshot(session.activeTurnId === undefined ? "idle" : "busy", {
                     launchId: currentPayload.launchId,
                     adapterId: currentPayload.providerControl.adapterId,
                     processInstanceId: session.processInstanceId,
@@ -101,6 +130,92 @@ export async function runAgentHost(input) {
             }
         }).catch(() => { });
     };
+    const reconnectCodexClient = async (disconnectedSession, currentPayload) => {
+        const previousControl = currentPayload.providerControl;
+        if (previousControl?.adapterId !== "codex" || authority === undefined) {
+            throw new Error("Codex client reconnect lost its Provider control identity.");
+        }
+        const ownedTurn = activeTurnPayload === undefined
+            || activeTurnAttemptId === undefined
+            || activeNativeTurnId === undefined
+            ? undefined
+            : { attemptId: activeTurnAttemptId, turnId: activeNativeTurnId };
+        const reconnectPayload = {
+            ...currentPayload,
+            environment: activeTurnPayload?.environment ?? currentPayload.environment,
+            providerControl: {
+                schemaVersion: 1,
+                adapterId: "codex",
+                transport: "codex-app-server-proxy",
+                kind: "ensure",
+                mode: "resume",
+                nativeSessionId: disconnectedSession.nativeSessionId,
+                ...(previousControl.sessionTitle === undefined
+                    ? {}
+                    : { sessionTitle: previousControl.sessionTitle }),
+                codexThread: previousControl.codexThread,
+                codexDaemonStartArgs: previousControl.codexDaemonStartArgs,
+                ...(ownedTurn === undefined ? {} : { ownedTurn }),
+                authority
+            }
+        };
+        const delays = [0, 250, 1_000];
+        let lastError;
+        for (const delayMs of delays) {
+            if (hostStopRequested)
+                return;
+            if (delayMs !== 0)
+                await delay(delayMs);
+            if (hostStopRequested)
+                return;
+            try {
+                const started = await startStructuredProviderSession(reconnectPayload, {
+                    onTerminal: handleTerminal
+                });
+                session = started.session;
+                sessionPayload = currentPayload;
+                conversationRecoverability = "recoverable";
+                codexClientAttachedAt = Date.now();
+                observeExit(started.session, currentPayload);
+                const reconnectState = activeTurnPayload !== undefined
+                    ? ownedTurn === undefined ? "delivery-unknown" : "ready"
+                    : started.session.activeTurnId === undefined ? "idle" : "busy";
+                updateSnapshot(hostSnapshot(reconnectState, {
+                    launchId: currentPayload.launchId,
+                    adapterId: "codex",
+                    processInstanceId: started.session.processInstanceId,
+                    nativeSessionId: started.session.nativeSessionId,
+                    conversationId: started.session.conversationId,
+                    ...(activeTurnAttemptId === undefined ? {} : { attemptId: activeTurnAttemptId }),
+                    ...(activeNativeTurnId === undefined ? {} : { nativeTurnId: activeNativeTurnId }),
+                    ...authorityFields(),
+                    ...(ownedTurn !== undefined || activeTurnPayload === undefined
+                        ? {}
+                        : {
+                            detail: "Codex client reattached, but the in-flight Turn has no exact native identity."
+                        })
+                }));
+                if (started.recoveredTerminal !== undefined) {
+                    handleTerminal(started.recoveredTerminal);
+                }
+                return;
+            }
+            catch (error) {
+                lastError = error;
+            }
+        }
+        updateSnapshot(hostSnapshot("failed", {
+            launchId: currentPayload.launchId,
+            adapterId: "codex",
+            processInstanceId: disconnectedSession.processInstanceId,
+            nativeSessionId: disconnectedSession.nativeSessionId,
+            conversationId: disconnectedSession.conversationId,
+            ...(activeTurnAttemptId === undefined ? {} : { attemptId: activeTurnAttemptId }),
+            ...(activeNativeTurnId === undefined ? {} : { nativeTurnId: activeNativeTurnId }),
+            ...authorityFields(),
+            detail: `Codex client could not reattach after bounded retries: ${errorText(lastError)}`
+        }));
+    };
     const observeExit = (providerSession, launched) => {
         void providerSession.waitForExit().then((result) => enqueueSerialized(async () => {
             const ownsCurrentSession = session === providerSession;
@@ -109,6 +224,47 @@ export async function runAgentHost(input) {
                 ? activationId ?? launched.launchId
                 : launched.launchId;
             const exitAuthority = authorityFields();
+            const stopReceipt = readRuntimeStopReceipt(input.home, currentPayload.launchId);
+            const reconnectableCodexClient = ownsCurrentSession
+                && providerSession.adapterId === "codex"
+                && !hostStopRequested
+                && stopReceipt === null
+                && !switchDetachedSessions.has(providerSession);
+            if (reconnectableCodexClient) {
+                session = undefined;
+                if (codexClientAttachedAt !== undefined
+                    && Date.now() - codexClientAttachedAt >= CODEX_CLIENT_STABLE_MS) {
+                    consecutiveCodexDisconnects = 0;
+                }
+                consecutiveCodexDisconnects += 1;
+                if (consecutiveCodexDisconnects > MAX_CONSECUTIVE_CODEX_DISCONNECTS) {
+                    updateSnapshot(hostSnapshot("failed", {
+                        launchId: currentPayload.launchId,
+                        adapterId: "codex",
+                        processInstanceId: result.processInstanceId,
+                        nativeSessionId: providerSession.nativeSessionId,
+                        conversationId: providerSession.conversationId,
+                        ...(activeTurnAttemptId === undefined ? {} : { attemptId: activeTurnAttemptId }),
+                        ...(activeNativeTurnId === undefined ? {} : { nativeTurnId: activeNativeTurnId }),
+                        ...exitAuthority,
+                        detail: "Codex client repeatedly disconnected before reaching a stable attachment."
+                    }));
+                    return;
+                }
+                updateSnapshot(hostSnapshot("starting", {
+                    launchId: currentPayload.launchId,
+                    adapterId: "codex",
+                    processInstanceId: result.processInstanceId,
+                    nativeSessionId: providerSession.nativeSessionId,
+                    conversationId: providerSession.conversationId,
+                    ...(activeTurnAttemptId === undefined ? {} : { attemptId: activeTurnAttemptId }),
+                    ...(activeNativeTurnId === undefined ? {} : { nativeTurnId: activeNativeTurnId }),
+                    ...exitAuthority,
+                    detail: "Codex client disconnected; reattaching to the shared daemon."
+                }));
+                await reconnectCodexClient(providerSession, currentPayload);
+                return;
+            }
             if (ownsCurrentSession) {
                 session = undefined;
                 activationId = undefined;
@@ -116,7 +272,6 @@ export async function runAgentHost(input) {
                 authority = undefined;
             }
             hostSequence += 1;
-            const stopReceipt = readRuntimeStopReceipt(input.home, currentPayload.launchId);
             const observedAt = new Date().toISOString();
             const failures = [];
             if (!switchDetachedSessions.has(providerSession)) {
@@ -275,10 +430,22 @@ export async function runAgentHost(input) {
                 conversationRecoverability = providerControl.adapterId === "codex"
                     ? "recoverable"
                     : "unknown";
+                if (providerControl.kind === "ensure" && providerControl.ownedTurn !== undefined) {
+                    activeTurnPayload = next;
+                    activeTurnAttemptId = providerControl.ownedTurn.attemptId;
+                    activeNativeTurnId = providerControl.ownedTurn.turnId;
+                }
                 const started = await startStructuredProviderSession(next, { onTerminal: handleTerminal });
                 session = started.session;
                 sessionPayload = next;
+                if (started.session.adapterId === "codex") {
+                    codexClientAttachedAt = Date.now();
+                    consecutiveCodexDisconnects = 0;
+                }
                 observeExit(started.session, next);
+                if (started.recoveredTerminal !== undefined) {
+                    handleTerminal(started.recoveredTerminal);
+                }
             }
             await publishStructuredProviderOpened({
                 home: input.home,
@@ -294,9 +461,12 @@ export async function runAgentHost(input) {
                 durableInitialTurn = hostTurnControlParams(next, session.nativeSessionId, requestedAuthority, providerControl.initialTurn.attemptId);
                 await beginDurableProviderTurn(input.home, durableInitialTurn);
                 activeTurnPayload = next;
+                activeTurnAttemptId = providerControl.initialTurn.attemptId;
+                activeNativeTurnId = undefined;
                 try {
                     receipt = await session.submitTurn(providerControl.initialTurn);
                     providerAcceptedAttemptId = receipt.attemptId;
+                    activeNativeTurnId = receipt.nativeTurnId;
                 }
                 catch (error) {
                     await resolveProviderTurnSubmission(input.home, durableInitialTurn, error);
@@ -318,16 +488,26 @@ export async function runAgentHost(input) {
                     throw error;
                 }
             }
-            updateSnapshot(hostSnapshot(receipt === undefined ? "idle" : "ready", {
+            const ensuredOwnedTurn = providerControl.kind === "ensure"
+                ? providerControl.ownedTurn
+                : undefined;
+            const providerState = receipt !== undefined || ensuredOwnedTurn !== undefined
+                ? "ready"
+                : session.activeTurnId === undefined ? "idle" : "busy";
+            updateSnapshot(hostSnapshot(providerState, {
                 launchId: next.launchId,
                 adapterId: providerControl.adapterId,
                 processInstanceId: session.processInstanceId,
                 nativeSessionId: receipt?.nativeSessionId ?? session.nativeSessionId,
                 conversationId: receipt?.conversationId ?? session.conversationId,
-                ...(receipt === undefined ? {} : {
-                    attemptId: receipt.attemptId,
-                    nativeTurnId: receipt.nativeTurnId
-                }),
+                ...(receipt !== undefined
+                    ? { attemptId: receipt.attemptId, nativeTurnId: receipt.nativeTurnId }
+                    : ensuredOwnedTurn === undefined
+                        ? {}
+                        : {
+                            attemptId: ensuredOwnedTurn.attemptId,
+                            nativeTurnId: ensuredOwnedTurn.turnId
+                        }),
                 ...authorityFields()
             }));
             return snapshot;
@@ -352,7 +532,9 @@ export async function runAgentHost(input) {
                 || providerAcceptedAttemptId !== undefined;
             const state = deliveryUnknown
                 ? "delivery-unknown"
-                : error instanceof ProviderTurnRejectedError ? "rejected" : "failed";
+                : error instanceof ProviderTurnBusyError
+                    ? "busy"
+                    : error instanceof ProviderTurnRejectedError ? "rejected" : "failed";
             updateSnapshot(hostSnapshot(state, {
                 launchId: next.launchId,
                 adapterId: providerControl.adapterId,
@@ -365,8 +547,11 @@ export async function runAgentHost(input) {
                 ...authorityFields(),
                 detail: errorText(error)
             }));
-            if (state !== "delivery-unknown")
+            if (state !== "delivery-unknown") {
                 activeTurnPayload = undefined;
+                activeTurnAttemptId = undefined;
+                activeNativeTurnId = undefined;
+            }
             if (deliveryUnknown && !(error instanceof ProviderDeliveryUnknownError)) {
                 throw new ProviderDeliveryUnknownError(`Provider accepted input but its durable acknowledgement could not be confirmed: ${errorText(error)}`, providerAcceptedAttemptId);
             }
@@ -394,6 +579,8 @@ export async function runAgentHost(input) {
             throw new Error("Agent Host still owns an unsettled Provider Turn.");
         }
         activeTurnPayload = sessionPayload;
+        activeTurnAttemptId = request.turn.attemptId;
+        activeNativeTurnId = undefined;
         updateSnapshot(hostSnapshot("starting", {
             launchId: request.launchId,
             adapterId: session.adapterId,
@@ -407,6 +594,7 @@ export async function runAgentHost(input) {
         try {
             const receipt = await session.submitTurn(request.turn);
             providerAccepted = true;
+            activeNativeTurnId = receipt.nativeTurnId;
             await publishStructuredProviderAccepted({
                 home: input.home,
                 environment: sessionPayload.environment,
@@ -429,7 +617,9 @@ export async function runAgentHost(input) {
             const deliveryUnknown = error instanceof ProviderDeliveryUnknownError || providerAccepted;
             const state = deliveryUnknown
                 ? "delivery-unknown"
-                : error instanceof ProviderTurnRejectedError ? "rejected" : "failed";
+                : error instanceof ProviderTurnBusyError
+                    ? "busy"
+                    : error instanceof ProviderTurnRejectedError ? "rejected" : "failed";
             updateSnapshot(hostSnapshot(state, {
                 launchId: request.launchId,
                 adapterId: session.adapterId,
@@ -440,8 +630,11 @@ export async function runAgentHost(input) {
                 ...authorityFields(),
                 detail: errorText(error)
             }));
-            if (state !== "delivery-unknown")
+            if (state !== "delivery-unknown") {
                 activeTurnPayload = undefined;
+                activeTurnAttemptId = undefined;
+                activeNativeTurnId = undefined;
+            }
             if (deliveryUnknown && !(error instanceof ProviderDeliveryUnknownError)) {
                 throw new ProviderDeliveryUnknownError(`Provider accepted input but its durable acknowledgement could not be confirmed: ${errorText(error)}`, request.turn.attemptId);
             }
@@ -634,7 +827,9 @@ export async function waitForAgentHostLaunchAck(input) {
                 if (snapshot.state === "ready"
                     || (input.requireTurnAck !== true && snapshot.state === "idle"))
                     return snapshot;
-                if (snapshot.state === "delivery-unknown" || snapshot.state === "rejected") {
+                if (snapshot.state === "delivery-unknown"
+                    || snapshot.state === "busy"
+                    || snapshot.state === "rejected") {
                     return snapshot;
                 }
                 if (snapshot.state === "failed" || snapshot.state === "exited") {
@@ -843,7 +1038,7 @@ function validateControlResult(result) {
 }
 function validateSnapshot(snapshot) {
     if (snapshot.schemaVersion !== 1
-        || !["idle", "starting", "ready", "settling", "delivery-unknown", "rejected", "failed", "exited"]
+        || !["idle", "starting", "ready", "settling", "delivery-unknown", "busy", "rejected", "failed", "exited"]
             .includes(snapshot.state)) {
         throw new Error("Agent Host snapshot is invalid.");
     }
@@ -884,6 +1079,23 @@ function definedFields(value) {
 function errorText(error) {
     return error instanceof Error ? error.message : String(error ?? "unknown error");
 }
+function signalRoleMailbox(home, payload) {
+    const taskId = payload.environment.YUI_TASK_ID;
+    const roleName = payload.environment.YUI_ROLE;
+    if (taskId === undefined || roleName === undefined)
+        return;
+    const key = `role:${encodeURIComponent(taskId)}/${encodeURIComponent(roleName)}`;
+    void callController(home, "scheduler.signal", { key }).catch(() => {
+        // This is a low-latency hint. Durable mailbox state and periodic
+        // reconciliation remain the recovery path across a Controller handover.
+    });
+}
+async function delay(milliseconds) {
+    await new Promise((resolvePromise) => {
+        const timer = setTimeout(resolvePromise, milliseconds);
+        timer.unref();
+    });
+}
 function hostTurnControlParams(payload, nativeSessionId, authority, attemptId) {
     const environment = payload.environment;
     return Object.freeze({

package/dist/runtime/builtinAgentDrivers.js

@@ -118,6 +118,15 @@ export const BUILTIN_AGENT_DRIVERS = Object.freeze([
                 lineage: "partial",
                 detachedQuery: "partial",
                 resultRouting: "partial"
+            }),
+            observation: Object.freeze({
+                ...STRUCTURED_CLI_CAPABILITIES.observation,
+                // Managed Codex uses the ordinary shared App Server event stream.
+                // Turn lifecycle is exact; Yui does not install per-thread Hooks merely
+                // to manufacture tool/wait/usage observations.
+                operations: Object.freeze([]),
+                waiting: Object.freeze([]),
+                usage: "unavailable"
             })
         }),
         runtime: Object.freeze({

package/dist/runtime/codexAppServerRuntime.js

@@ -22,21 +22,17 @@ export class CodexAppServerRuntime {
     async openConversation(input) {
         const result = await this.transport.request("thread/start", {
             cwd: text(input.cwd, "Codex thread cwd"),
-            ...(input.model === undefined ? {} : { model: input.model }),
-            ...(input.approvalPolicy === undefined ? {} : { approvalPolicy: input.approvalPolicy }),
-            ...(input.sandbox === undefined ? {} : { sandbox: input.sandbox }),
-            ...(input.developerInstructions === undefined
-                ? {}
-                : { developerInstructions: input.developerInstructions }),
-            ...(input.runtimeWorkspaceRoots === undefined
-                ? {}
-                : { runtimeWorkspaceRoots: [...input.runtimeWorkspaceRoots] })
+            ...threadOptions(input)
         });
         return { conversationId: threadId(result) };
     }
-    async resumeConversation(conversationId) {
+    async resumeConversation(conversationId, options = {}) {
         const id = text(conversationId, "Codex thread id");
-        const result = await this.transport.request("thread/resume", { threadId: id });
+        const result = await this.transport.request("thread/resume", {
+            threadId: id,
+            ...(options.cwd === undefined ? {} : { cwd: text(options.cwd, "Codex thread cwd") }),
+            ...threadOptions(options)
+        });
         return parseThreadSnapshot(result, id, true);
     }
     async setConversationName(input) {
@@ -85,7 +81,11 @@ export class CodexAppServerRuntime {
             const snapshot = await this.readConversation(requestedThreadId);
             threadId = snapshot.threadId;
             if (input.expectedNoActiveTurn && snapshot.activeTurnId !== undefined) {
-                return { status: "not-accepted", reason: `active-turn:${snapshot.activeTurnId}` };
+                return {
+                    status: "busy",
+                    activeTurnId: snapshot.activeTurnId,
+                    reason: `active-turn:${snapshot.activeTurnId}`
+                };
             }
         }
         catch (error) {
@@ -249,12 +249,25 @@ function parseThreadSnapshot(result, expectedThreadId, loaded) {
     const turns = arrayMember(thread, "turns").map(object).filter((entry) => (entry !== null));
     const active = [...turns].reverse().find((turn) => (["inProgress", "in_progress", "running", "active"].includes(String(turn.status))));
     const latestStatus = optionalTurnStatus(turns.at(-1)?.status);
+    const turnSnapshots = turns.flatMap((turn) => {
+        const turnId = optionalId(turn.id);
+        if (turnId === undefined)
+            return [];
+        const status = optionalTurnStatus(turn.status);
+        const error = providerError(turn.error);
+        return [{
+                turnId,
+                ...(status === undefined ? {} : { status }),
+                ...(error === undefined ? {} : { error })
+            }];
+    });
     return {
         threadId: id,
         loaded,
         status: threadStatus(thread.status),
         ...(optionalId(active?.id) === undefined ? {} : { activeTurnId: optionalId(active?.id) }),
         ...(latestStatus === undefined ? {} : { latestTurnStatus: latestStatus }),
+        turns: Object.freeze(turnSnapshots),
         ...(optionalId(thread.parentThreadId) === undefined
             ? {}
             : { parentThreadId: optionalId(thread.parentThreadId) }),
@@ -262,6 +275,17 @@ function parseThreadSnapshot(result, expectedThreadId, loaded) {
         raw: result
     };
 }
+function providerError(value) {
+    if (typeof value === "string" && value.trim().length > 0)
+        return value.trim();
+    const record = object(value);
+    if (record === null)
+        return undefined;
+    if (typeof record.message === "string" && record.message.trim().length > 0) {
+        return record.message.trim();
+    }
+    return JSON.stringify(record);
+}
 function codexContinuationState(snapshot) {
     if (snapshot.status === "active" || snapshot.latestTurnStatus === "inProgress") {
         return {
@@ -317,12 +341,19 @@ function optionalTurnStatus(value) {
 }
 function classifyMutationError(error) {
     if (error instanceof CodexAppServerRequestError) {
+        if (codexAppServerErrorIsBusy(error)) {
+            return { status: "busy", reason: error.message };
+        }
         if (["INVALID_PARAMS", "NOT_FOUND", "TURN_NOT_ACTIVE", -32602].includes(error.code)) {
             return { status: "not-accepted", reason: error.message };
         }
     }
     return { status: "unknown", reason: error instanceof Error ? error.message : String(error) };
 }
+function codexAppServerErrorIsBusy(error) {
+    return /\b(active turn|turn (?:is )?(?:already )?(?:active|in progress|running)|already has an active)\b/iu
+        .test(error.message);
+}
 function isNotLoaded(error) {
     return error instanceof CodexAppServerRequestError
         && (String(error.code).toLowerCase().includes("not_loaded")
@@ -366,3 +397,23 @@ function text(value, label) {
     }
     return value.trim();
 }
+function threadOptions(input) {
+    return {
+        ...(input.model === undefined ? {} : { model: text(input.model, "Codex model") }),
+        ...(input.approvalPolicy === undefined
+            ? {}
+            : { approvalPolicy: text(input.approvalPolicy, "Codex approval policy") }),
+        ...(input.sandbox === undefined ? {} : { sandbox: text(input.sandbox, "Codex sandbox") }),
+        ...(input.developerInstructions === undefined
+            ? {}
+            : {
+                developerInstructions: text(input.developerInstructions, "Codex developer instructions")
+            }),
+        ...(input.runtimeWorkspaceRoots === undefined
+            ? {}
+            : {
+                runtimeWorkspaceRoots: input.runtimeWorkspaceRoots.map((root) => (text(root, "Codex runtime workspace root")))
+            }),
+        ...(input.config === undefined ? {} : { config: { ...input.config } })
+    };
+}

package/dist/runtime/launchBroker.js

@@ -86,10 +86,25 @@ function validateProviderControl(control) {
     if (control.adapterId !== "codex" && control.adapterId !== "claude") {
         throw new Error("Agent Host Provider control adapter is invalid.");
     }
-    if ((control.adapterId === "codex" && control.transport !== "codex-app-server-stdio")
+    if ((control.adapterId === "codex" && control.transport !== "codex-app-server-proxy")
         || (control.adapterId === "claude" && control.transport !== "claude-stream-json")) {
         throw new Error("Agent Host Provider control transport does not match its adapter.");
     }
+    if ((control.adapterId === "codex") !== (control.codexThread !== undefined)) {
+        throw new Error("Agent Host Provider thread settings do not match its adapter.");
+    }
+    if ((control.adapterId === "codex") !== (control.codexDaemonStartArgs !== undefined)) {
+        throw new Error("Agent Host Provider daemon bootstrap does not match its adapter.");
+    }
+    if (control.codexThread !== undefined)
+        validateCodexThreadOptions(control.codexThread);
+    if (control.codexDaemonStartArgs !== undefined) {
+        if (!Array.isArray(control.codexDaemonStartArgs)
+            || control.codexDaemonStartArgs.length === 0) {
+            throw new Error("Agent Host Codex daemon bootstrap args are invalid.");
+        }
+        control.codexDaemonStartArgs.forEach((value) => text(value, "Codex daemon argument"));
+    }
     if (control.mode !== "new" && control.mode !== "resume") {
         throw new Error("Agent Host Provider control mode is invalid.");
     }
@@ -105,6 +120,16 @@ function validateProviderControl(control) {
     if (control.kind === "ensure" && control.initialTurn !== undefined) {
         throw new Error("Managed Provider ensure launch cannot carry a new Turn.");
     }
+    if (control.kind !== "ensure" && "ownedTurn" in control) {
+        throw new Error("Only a managed Provider ensure launch can recover an owned Turn.");
+    }
+    if (control.kind === "ensure" && control.ownedTurn !== undefined) {
+        if (control.adapterId !== "codex") {
+            throw new Error("Only Managed Codex can recover an owned Turn across client attachment.");
+        }
+        text(control.ownedTurn.attemptId, "owned Provider input attemptId");
+        text(control.ownedTurn.turnId, "owned Provider Turn id");
+    }
     const requiresNativeSessionId = control.mode === "resume" || control.adapterId === "claude";
     if (requiresNativeSessionId !== (control.nativeSessionId !== undefined)) {
         throw new Error("Agent Host Provider resume identity is inconsistent.");
@@ -129,6 +154,31 @@ function validateProviderControl(control) {
         }
     }
 }
+function validateCodexThreadOptions(options) {
+    if (options === null || typeof options !== "object" || Array.isArray(options)) {
+        throw new Error("Agent Host Codex thread settings are invalid.");
+    }
+    for (const [value, label] of [
+        [options.model, "model"],
+        [options.approvalPolicy, "approval policy"],
+        [options.sandbox, "sandbox"],
+        [options.developerInstructions, "developer instructions"]
+    ]) {
+        if (value !== undefined)
+            text(value, `Codex thread ${label}`);
+    }
+    if (options.runtimeWorkspaceRoots !== undefined) {
+        if (!Array.isArray(options.runtimeWorkspaceRoots)) {
+            throw new Error("Agent Host Codex runtime workspace roots are invalid.");
+        }
+        options.runtimeWorkspaceRoots.forEach((root) => text(root, "Codex runtime workspace root"));
+    }
+    if (options.config !== undefined
+        && (options.config === null || typeof options.config !== "object"
+            || Array.isArray(options.config))) {
+        throw new Error("Agent Host Codex thread config is invalid.");
+    }
+}
 function text(value, label) {
     if (typeof value !== "string" || value.length === 0 || value.includes("\0")) {
         throw new Error(`Agent Host ${label} is invalid.`);

package/dist/runtime/runtimeBinding.js

@@ -14,7 +14,15 @@ export function createRuntimeBinding(input) {
     const initialTurnRejectedRunId = input.initialTurnRejectedRunId === undefined
         ? undefined
         : requireSafeIdentity(input.initialTurnRejectedRunId, "Rejected initial Turn Run id");
-    if ([initialTurnRunId, initialTurnDeliveryUnknownRunId, initialTurnRejectedRunId]
+    const initialTurnBusyRunId = input.initialTurnBusyRunId === undefined
+        ? undefined
+        : requireSafeIdentity(input.initialTurnBusyRunId, "Busy initial Turn Run id");
+    if ([
+        initialTurnRunId,
+        initialTurnDeliveryUnknownRunId,
+        initialTurnBusyRunId,
+        initialTurnRejectedRunId
+    ]
         .filter((value) => value !== undefined).length > 1) {
         throw new TypeError("Runtime binding must report at most one initial Turn outcome.");
     }
@@ -30,6 +38,7 @@ export function createRuntimeBinding(input) {
         ...(initialTurnDeliveryUnknownRunId === undefined
             ? {}
             : { initialTurnDeliveryUnknownRunId }),
+        ...(initialTurnBusyRunId === undefined ? {} : { initialTurnBusyRunId }),
         ...(initialTurnRejectedRunId === undefined ? {} : { initialTurnRejectedRunId }),
         ...(input.nativeSessionId === undefined
             ? {}