@zq-silk/yui 0.13.2 → 0.13.4

package/dist/executor/fileRoleLaunchPlanner.js

@@ -292,7 +292,7 @@ export class FileRoleLaunchPlanner {
         const adapter = resolveAgentAdapter(binding.adapterId);
         const effectiveWorkspace = effective.workspace.root;
         const agentWorkspace = nativeAgentWorkspace(effective.workspace);
-        if (adapter.id === "codex") {
+        if (adapter.id === "codex" && (owner.scope !== "task" || input.runId === undefined)) {
             const codexConfig = inspectCodexLaunchConfig({
                 environment: launchEnvironment,
                 workspace: agentWorkspace,
@@ -301,9 +301,7 @@ export class FileRoleLaunchPlanner {
                     : undefined,
                 trustWorkspace: true
             });
-            assertCodexLaunchOverridesAvailable(codexConfig, owner.scope !== "task" || input.runId === undefined
-                ? ["developerInstructions", "notify"]
-                : ["developerInstructions"]);
+            assertCodexLaunchOverridesAvailable(codexConfig, ["developerInstructions", "notify"]);
         }
         const runtimeIsolation = input.runtimeIsolation === undefined
             ? undefined
@@ -424,20 +422,17 @@ export class FileRoleLaunchPlanner {
         }
         if (binding.adapterId === "codex") {
             // Global/interactive Codex sessions still use notify for presentation.
-            // Managed Runs use the structured Driver Hook as their sole lifecycle
-            // authority, avoiding two terminal channels for the same Turn.
+            // Managed Runs receive lifecycle facts through their ordinary App Server
+            // subscription, avoiding a second Hook channel for the same Turn.
             if (owner.scope !== "task" || input.runId === undefined) {
                 args = addCodexSessionNotify(args, launchMode, this.#cliPath);
             }
-            // Managed Codex runs use App Server lifecycle hooks and structured Turn
-            // submission. No Run prompt is placed in argv or written as terminal input.
+            // Managed Codex Runs are ordinary shared-daemon threads. Their Session
+            // Manifest points at the Yui Skills; no Yui Hook config is installed.
             if (owner.scope === "task" && input.runId !== undefined) {
                 if (managedRun === null || managedRun.status !== "active") {
                     throw new Error(`Managed Codex Run is no longer active: ${input.runId}.`);
                 }
-                args = managedControl
-                    ? addCodexManagedLifecycleHooks(args, this.#cliPath)
-                    : addCodexLifecycleHooks(args, launchMode, this.#cliPath);
             }
             session = launchMode === "resume"
                 ? readySession(input.agentId, binding.adapterId, resumeNativeSessionId, effective)
@@ -502,13 +497,16 @@ export class FileRoleLaunchPlanner {
         const providerAuthority = managedControl
             ? this.#providerAuthorityForLaunch(owner.taskId, role.name, input.launchId, input.mode)
             : undefined;
+        const providerOwnedTurn = managedControl && !carriesInitialTurn
+            ? this.#providerOwnedTurnForLaunch(owner.taskId, role.name, input.runId)
+            : undefined;
         const providerNativeSessionId = binding.adapterId === "claude"
             ? preallocatedNativeSessionId
             : resumeNativeSessionId;
         const initialTurn = carriesInitialTurn
             ? {
                 attemptId: agentRunDeliveryReceiptId(managedRun),
-                boundedText: managedRunLaunchEnvelope(managedRun, input.mode, sessionTitle)
+                boundedText: managedRunLaunchEnvelope(managedRun, input.mode, sessionContext.sessionManifestPath, sessionTitle)
             }
             : undefined;
         const providerControl = !managedControl
@@ -522,6 +520,13 @@ export class FileRoleLaunchPlanner {
                     mode: "resume",
                     nativeSessionId: requireText(providerNativeSessionId, "Managed Provider ensure native session id"),
                     ...(sessionTitle === undefined ? {} : { sessionTitle }),
+                    ...(managedCompiled.codexThread === undefined
+                        ? {}
+                        : { codexThread: managedCompiled.codexThread }),
+                    ...(managedCompiled.codexDaemonStartArgs === undefined
+                        ? {}
+                        : { codexDaemonStartArgs: managedCompiled.codexDaemonStartArgs }),
+                    ...(providerOwnedTurn === undefined ? {} : { ownedTurn: providerOwnedTurn }),
                     authority: providerAuthority
                 }
                 : resumeNativeSessionId === undefined
@@ -535,6 +540,12 @@ export class FileRoleLaunchPlanner {
                             ? {}
                             : { nativeSessionId: providerNativeSessionId }),
                         ...(sessionTitle === undefined ? {} : { sessionTitle }),
+                        ...(managedCompiled.codexThread === undefined
+                            ? {}
+                            : { codexThread: managedCompiled.codexThread }),
+                        ...(managedCompiled.codexDaemonStartArgs === undefined
+                            ? {}
+                            : { codexDaemonStartArgs: managedCompiled.codexDaemonStartArgs }),
                         authority: providerAuthority,
                         initialTurn
                     }
@@ -546,6 +557,12 @@ export class FileRoleLaunchPlanner {
                         mode: "resume",
                         nativeSessionId: requireText(providerNativeSessionId, "Managed Provider resume native session id"),
                         ...(sessionTitle === undefined ? {} : { sessionTitle }),
+                        ...(managedCompiled.codexThread === undefined
+                            ? {}
+                            : { codexThread: managedCompiled.codexThread }),
+                        ...(managedCompiled.codexDaemonStartArgs === undefined
+                            ? {}
+                            : { codexDaemonStartArgs: managedCompiled.codexDaemonStartArgs }),
                         authority: providerAuthority,
                         initialTurn
                     };
@@ -601,6 +618,7 @@ export class FileRoleLaunchPlanner {
         const scopedLaunch = owner.scope === "task"
             ? this.#applyWorkspaceScope(owner.taskId, role, launch, workspaceOverride)
             : launch;
+        const ordinaryConversationLaunch = withCodexThreadEnvironment(scopedLaunch);
         return {
             role: {
                 name: role.name,
@@ -608,7 +626,7 @@ export class FileRoleLaunchPlanner {
                 ...(agentWorkspace === effectiveWorkspace ? {} : { cwd: agentWorkspace }),
                 ...(owner.scope === "task" ? { status: role.status } : {})
             },
-            launch: scopedLaunch,
+            launch: ordinaryConversationLaunch,
             session,
             ...(sessionTitle === undefined ? {} : { sessionTitle }),
             ...(carriesInitialTurn && input.runId !== undefined
@@ -654,6 +672,18 @@ export class FileRoleLaunchPlanner {
         }
         throw new Error(`Provider writer authority is unknown: ${taskId}/${roleName}.`);
     }
+    #providerOwnedTurnForLaunch(taskId, roleName, runId) {
+        const binding = this.store.getTaskRoleSessionSet(taskId, roleName)?.providerBinding;
+        if (binding === null || binding === undefined || binding.runId !== runId)
+            return undefined;
+        const turn = binding.turn;
+        if (turn === null || !["accepted", "running"].includes(turn.status))
+            return undefined;
+        if (turn.turnId === undefined) {
+            throw new Error(`Active Provider Turn has no native identity: ${taskId}/${roleName}.`);
+        }
+        return { attemptId: turn.attemptId, turnId: turn.turnId };
+    }
     #applyWorkspaceScope(taskId, role, launch, workspaceOverride) {
         const workspace = workspaceOverride
             ?? (role.name === "leader"
@@ -691,7 +721,7 @@ export class FileRoleLaunchPlanner {
         return selectEnvironment(source, names);
     }
 }
-function managedRunLaunchEnvelope(run, mode, title) {
+function managedRunLaunchEnvelope(run, mode, sessionManifestPath, title) {
     const body = run.providerRetry?.state === "dispatching"
         ? serializeProviderRetryEnvelope({
             taskId: run.taskId,
@@ -709,9 +739,14 @@ function managedRunLaunchEnvelope(run, mode, title) {
             : mode === "resume" && run.pushedAt !== undefined
                 ? serializeRunHostRecoveryEnvelope(run.bootstrapEnvelope)
                 : serializeRunBootstrapEnvelope(run.bootstrapEnvelope);
+    const guided = [
+        `Yui Session Manifest: ${sessionManifestPath}`,
+        "Read the manifest and its matching Role Skill before using the yui CLI for this Task.",
+        body
+    ].join("\n");
     return title === undefined
-        ? body
-        : prefixYuiTitleInput(body, title);
+        ? guided
+        : prefixYuiTitleInput(guided, title);
 }
 export function nativeAgentWorkspace(workspace) {
     return workspace.entries.length === 1
@@ -916,17 +951,26 @@ function addCodexLifecycleHooks(args, mode, cliPath) {
     }
     return [...args.slice(0, -2), ...managed, ...args.slice(-2)];
 }
-function addCodexManagedLifecycleHooks(args, cliPath) {
-    if (args.length < 2 || args.at(-2) !== "app-server" || args.at(-1) !== "--stdio") {
-        throw new Error("Managed Codex App Server launch shape is invalid.");
-    }
-    return [
-        ...args.slice(0, -2),
-        "--enable", "hooks",
-        "--config", codexLifecycleHooksConfig(cliPath),
-        "--dangerously-bypass-hook-trust",
-        ...args.slice(-2)
-    ];
+function withCodexThreadEnvironment(launch) {
+    const control = launch.providerControl;
+    if (control?.adapterId !== "codex" || control.codexThread === undefined)
+        return launch;
+    const set = Object.fromEntries(Object.entries(launch.env).filter(([key]) => (key.startsWith("YUI_")
+        || ["TMPDIR", "XDG_CACHE_HOME", "XDG_DATA_HOME", "XDG_STATE_HOME", "XDG_RUNTIME_DIR"]
+            .includes(key))));
+    return {
+        ...launch,
+        providerControl: {
+            ...control,
+            codexThread: {
+                ...control.codexThread,
+                config: {
+                    ...(control.codexThread.config ?? {}),
+                    shell_environment_policy: { set }
+                }
+            }
+        }
+    };
 }
 function readySession(agentId, adapterId, nativeSessionId, effective) {
     return {

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({