@zq-silk/yui 0.15.7 → 0.15.8

package/dist/runtime/agentHost.js

@@ -1,24 +1,32 @@
 import { createHash, randomUUID } from "node:crypto";
 import { chmodSync, mkdirSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
+import { tmpdir, homedir } from "node:os";
 import { dirname, join, resolve } from "node:path";
 import { createConnection, createServer } from "node:net";
 import { createInterface } from "node:readline";
+import { assertAgentExecutionEnvironment } from "./executionEnvironment.js";
+import { withSessionContextPointer } from "../context/sessionBootstrapManifest.js";
 import { callController, controllerCallMayHaveApplied, ControllerClientError } from "../core/controllerClient.js";
 import { readHomeFilesystemId } from "../core/homeFilesystemIdentity.js";
 import { callFileTaskController } from "../controller/clientRuntime.js";
 import { isForeignHandoverLockHeld } from "../release/runtimeRelease.js";
-import { publishStructuredProviderAccepted, publishStructuredProviderActivationTerminal, publishStructuredProviderGoal, publishStructuredConversationRecoverability, publishStructuredProviderOpened, publishStructuredProviderStarted, publishStructuredProviderTerminal } from "../controller/structuredProviderObservation.js";
+import { publishStructuredProviderAccepted, publishStructuredProviderAttachmentExit, publishStructuredProviderActivity, publishStructuredProviderInputSettlement, publishStructuredProviderInputObserved, publishStructuredProviderGoal, publishStructuredConversationRecoverability, publishStructuredProviderOpened, publishStructuredProviderStarted, publishStructuredProviderTerminal } from "../controller/structuredProviderObservation.js";
 import { validateAgentHostLaunchPayload } from "./launchBroker.js";
-import { ProviderDeliveryUnknownError, ProviderConversationMissingError, ProviderTurnBusyError, ProviderTurnRejectedError, startStructuredProviderSession } from "./structuredProviderHost.js";
+import { ProviderDeliveryUnknownError, ProviderConversationMissingError, ProviderTurnBusyError, ProviderTurnRejectedError } from "./structuredProviderHost.js";
+import { createAgentEndpointOwner } from "./agentEndpointOwnership.js";
 import { sameProviderAuthorityFence, validateProviderAuthorityFence } from "./providerAuthorityFence.js";
 import { validateRuntimeProcessExitObservation } from "./processExitObservation.js";
 import { persistRuntimeProcessExitObservation, replayRuntimeProcessExitOutbox } from "./processExitOutbox.js";
-import { readRuntimeStopReceipt, removeRuntimeStopReceipt } from "./runtimeStopReceipt.js";
-import { AGENT_HOST_CONTROL_TIMEOUT_MS, AGENT_HOST_READY_TIMEOUT_MS } from "./runtimeDeadlines.js";
+import { AGENT_HOST_CLIENT_EXIT_GRACE_MS, AGENT_HOST_CONTROL_TIMEOUT_MS, AGENT_HOST_READY_TIMEOUT_MS, ENDPOINT_DRAIN_TIMEOUT_MS, PROVIDER_ACCEPT_TIMEOUT_MS } from "./runtimeDeadlines.js";
 import { providerDeliveryFailure, providerDeliveryFailureFrom, redactAgentErrorText, serializeAgentErrorRaw } from "./agentError.js";
 import { runCodexInteractiveHost } from "./codexInteractiveHost.js";
-export const AGENT_HOST_CONTROL_PROTOCOL = "yui-agent-host/v4";
+import { readAgentRunConfigurationObservation, unknownAgentRunConfiguration } from "./agentRunConfiguration.js";
+import { openCurrentTaskStore } from "../storage/currentTaskStore.js";
+import { createSessionOwnerIdentity, readLinuxProcessIdentity } from "./sessionOwnerIdentity.js";
+import { yuiTmuxServerName, yuiTmuxSessionName } from "../tmux/tmuxManager.js";
+import { tmuxSocketDirectory } from "../tmux/tmuxSocketEndpoint.js";
+import { createTaskEvent } from "../event/taskEvent.js";
+export const AGENT_HOST_CONTROL_PROTOCOL = "yui-agent-host/v5";
 const HOST_CONTROL_MAX_BYTES = 32 * 1024;
 const CODEX_CLIENT_STABLE_MS = 5_000;
 const MAX_CONSECUTIVE_CODEX_DISCONNECTS = 3;
@@ -28,20 +36,29 @@ export function serializeAgentHostLaunchControl(control) {
 export async function runAgentHost(input) {
     const hostInstanceId = randomUUID();
     let hostSequence = 0;
-    let payload = await redeem(input.home, input.runtimeGenerationId, input.ticket);
+    let payload = await redeem(input.home, input.ticket);
     if (payload.environment.YUI_SESSION_SCOPE === "global"
         && payload.environment.YUI_ADAPTER_ID === "codex"
         && payload.providerControl === undefined) {
         return runCodexInteractiveHost(input.home, payload);
     }
     let session;
+    // This process really holds the Endpoint code its Session runs on. The lease
+    // spans the Session's Turns, so installing a newer generation does not change
+    // the implementation under a Session that is still using this one.
+    const endpointOwner = createAgentEndpointOwner();
+    let endpointLease;
+    /** The adapter this process actually pinned, so the drain below reports the
+     * implementation genuinely held rather than whichever one a later payload names. */
+    let endpointAdapterId;
     let sessionPayload;
-    let activeTurnPayload;
-    let activeTurnAttemptId;
+    let activeRunPayload;
+    let lastTerminalPayload;
+    let lastTerminal;
+    let activeRunAttemptId;
     let activeNativeTurnId;
     let codexClientAttachedAt;
     let consecutiveCodexDisconnects = 0;
-    let activationId;
     let conversationRecoverability = "unknown";
     let authority;
     let hostStopRequested = false;
@@ -53,16 +70,55 @@ export async function runAgentHost(input) {
     const updateSnapshot = (next) => {
         snapshot = validateSnapshot(next);
     };
-    const authorityFields = () => authority === undefined ? {} : {
-        authorityEpoch: authority.epoch,
-        authorityOwner: authority.owner,
-        authorityHolderId: authority.holderId
+    const authorityFields = () => ({
+        ...(session === undefined ? {} : { endpointImplementation: session.configuration.implementation }),
+        ...(authority === undefined ? {} : {
+            authorityEpoch: authority.epoch,
+            authorityOwner: authority.owner,
+            authorityHolderId: authority.holderId
+        })
+    });
+    const handleAccepted = (receipt) => {
+        const observedPayload = activeRunPayload;
+        if (observedPayload === undefined || receipt.acceptance !== "provider"
+            || receipt.attemptId !== activeRunAttemptId
+            || receipt.nativeSessionId !== session?.nativeSessionId)
+            return;
+        void enqueueSerialized(async () => {
+            if (activeRunPayload !== observedPayload || activeRunAttemptId !== receipt.attemptId
+                || snapshot.attemptId === receipt.attemptId && snapshot.inputAcceptance === "provider")
+                return;
+            await publishStructuredProviderAccepted({
+                home: input.home, environment: observedPayload.environment, receipt
+            });
+            updateSnapshot(hostSnapshot("ready", {
+                adapterId: session.adapterId,
+                processInstanceId: session.processInstanceId,
+                nativeSessionId: receipt.nativeSessionId,
+                conversationId: receipt.conversationId,
+                attemptId: receipt.attemptId,
+                nativeTurnId: receipt.nativeTurnId,
+                inputAcceptance: "provider",
+                ...authorityFields()
+            }));
+            signalRoleMailbox(input.home, observedPayload);
+        }).catch(() => { });
+    };
+    const handleActivity = (activity) => {
+        const observedPayload = activeRunPayload;
+        if (observedPayload === undefined || activity.attemptId !== activeRunAttemptId
+            || activity.nativeSessionId !== session?.nativeSessionId)
+            return;
+        void enqueueSerialized(async () => {
+            if (activeRunPayload !== observedPayload || activity.attemptId !== activeRunAttemptId)
+                return;
+            await publishStructuredProviderActivity({ home: input.home, environment: observedPayload.environment, activity });
+        }).catch(() => { });
     };
     const handleStarted = (started, observedPayload = sessionPayload) => {
         if (started.clientOwned || observedPayload === undefined)
             return;
         updateSnapshot(hostSnapshot("busy", {
-            runtimeGenerationId: observedPayload.runtimeGenerationId,
             adapterId: observedPayload.providerControl?.adapterId,
             processInstanceId: session?.processInstanceId,
             nativeSessionId: started.nativeSessionId,
@@ -70,12 +126,10 @@ export async function runAgentHost(input) {
             nativeTurnId: started.nativeTurnId,
             ...authorityFields()
         }));
-        const directActivationId = activationId ?? observedPayload.runtimeGenerationId;
         void enqueueSerialized(async () => {
             await publishStructuredProviderStarted({
                 home: input.home,
                 environment: observedPayload.environment,
-                activationId: directActivationId,
                 started
             });
             signalRoleMailbox(input.home, observedPayload);
@@ -89,19 +143,16 @@ export async function runAgentHost(input) {
                 || terminal.conversationId !== session.conversationId)
                 return;
             // A direct Provider client shares the Session but still produces a Yui
-            // Turn audit record. It has no WorkItem ownership and no managed input
+            // AgentRun audit record. It has no WorkItem ownership and no managed input
             // fence; the runtime observer records only visible input/output.
-            const directActivationId = activationId ?? busyPayload.runtimeGenerationId;
             void enqueueSerialized(async () => {
                 await publishStructuredProviderTerminal({
                     home: input.home,
                     environment: busyPayload.environment,
-                    activationId: directActivationId,
                     terminal
                 });
                 if (session !== undefined && terminal.conversationId === session.conversationId) {
-                    updateSnapshot(hostSnapshot(session.activeTurnId === undefined ? "idle" : "busy", {
-                        runtimeGenerationId: busyPayload.runtimeGenerationId,
+                    updateSnapshot(hostSnapshot(session.inspect().activeNativeTurnId === undefined ? "idle" : "busy", {
                         adapterId: session.adapterId,
                         processInstanceId: session.processInstanceId,
                         nativeSessionId: session.nativeSessionId,
@@ -113,18 +164,17 @@ export async function runAgentHost(input) {
             }).catch(() => { });
             return;
         }
-        const terminalPayload = activeTurnPayload;
-        if (terminal.attemptId !== undefined && terminal.attemptId !== activeTurnAttemptId
+        const terminalPayload = activeRunPayload;
+        if (terminal.attemptId !== undefined && terminal.attemptId !== activeRunAttemptId
             && sessionPayload !== undefined && terminal.nativeSessionId === session?.nativeSessionId) {
             // A duplicate/late terminal retains the Driver's exact old attempt.
             // The durable observer validates that binding; it must not alter the
-            // current Host occupancy or inherit the successor's managed Turn.
+            // current Host occupancy or inherit the successor's managed AgentRun.
             const observedPayload = sessionPayload;
             void enqueueSerialized(async () => {
                 await publishStructuredProviderTerminal({
                     home: input.home,
                     environment: observedPayload.environment,
-                    activationId: activationId ?? observedPayload.runtimeGenerationId,
                     terminal
                 });
                 signalRoleMailbox(input.home, observedPayload);
@@ -132,20 +182,20 @@ export async function runAgentHost(input) {
             return;
         }
         if (terminalPayload === undefined
-            || terminal.attemptId !== activeTurnAttemptId
+            || terminal.attemptId !== activeRunAttemptId
             || terminal.nativeSessionId !== session?.nativeSessionId
             || (terminal.nativeTurnId !== undefined && activeNativeTurnId !== undefined
                 && terminal.nativeTurnId !== activeNativeTurnId))
             return;
         const terminalAttemptId = terminal.attemptId;
-        const terminalActivationId = activationId ?? terminalPayload.runtimeGenerationId;
+        lastTerminalPayload = terminalPayload;
+        lastTerminal = terminal;
         void enqueueSerialized(async () => {
-            if (activeTurnPayload !== terminalPayload
-                || activeTurnAttemptId !== terminalAttemptId)
+            if (activeRunPayload !== terminalPayload
+                || activeRunAttemptId !== terminalAttemptId)
                 return;
             if (session !== undefined) {
                 updateSnapshot(hostSnapshot("settling", {
-                    runtimeGenerationId: terminalPayload.runtimeGenerationId,
                     adapterId: terminalPayload.providerControl.adapterId,
                     processInstanceId: session.processInstanceId,
                     nativeSessionId: terminal.nativeSessionId,
@@ -159,19 +209,17 @@ export async function runAgentHost(input) {
                 await publishStructuredProviderTerminal({
                     home: input.home,
                     environment: terminalPayload.environment,
-                    activationId: terminalActivationId,
                     terminal
                 });
-                if (activeTurnPayload !== terminalPayload)
+                if (activeRunPayload !== terminalPayload)
                     return;
-                activeTurnPayload = undefined;
-                activeTurnAttemptId = undefined;
+                activeRunPayload = undefined;
+                activeRunAttemptId = undefined;
                 activeNativeTurnId = undefined;
                 if (session === undefined)
                     return;
                 const currentPayload = sessionPayload ?? terminalPayload;
-                updateSnapshot(hostSnapshot(session.activeTurnId === undefined ? "idle" : "busy", {
-                    runtimeGenerationId: currentPayload.runtimeGenerationId,
+                updateSnapshot(hostSnapshot(session.inspect().activeNativeTurnId === undefined ? "idle" : "busy", {
                     adapterId: currentPayload.providerControl.adapterId,
                     processInstanceId: session.processInstanceId,
                     nativeSessionId: terminal.nativeSessionId,
@@ -182,7 +230,6 @@ export async function runAgentHost(input) {
             }
             catch (error) {
                 updateSnapshot(hostSnapshot("failed", {
-                    runtimeGenerationId: terminalPayload.runtimeGenerationId,
                     adapterId: terminalPayload.providerControl.adapterId,
                     processInstanceId: session?.processInstanceId,
                     nativeSessionId: terminal.nativeSessionId,
@@ -195,16 +242,14 @@ export async function runAgentHost(input) {
         }).catch(() => { });
     };
     const handleGoal = (goal) => {
-        const currentPayload = activeTurnPayload ?? sessionPayload;
+        const currentPayload = activeRunPayload ?? sessionPayload;
         const currentSession = session;
         if (currentPayload === undefined || currentSession === undefined)
             return;
-        const currentActivationId = activationId ?? currentPayload.runtimeGenerationId;
         void enqueueSerialized(async () => {
             await publishStructuredProviderGoal({
                 home: input.home,
                 environment: currentPayload.environment,
-                activationId: currentActivationId,
                 conversationId: currentSession.conversationId,
                 goal
             });
@@ -216,17 +261,26 @@ export async function runAgentHost(input) {
         if (previousControl?.adapterId !== "codex" || authority === undefined) {
             throw new Error("Codex client reconnect lost its Provider control identity.");
         }
-        const ownedTurn = activeTurnPayload === undefined
-            || activeTurnAttemptId === undefined
+        const ownedTurn = activeRunPayload === undefined
+            || activeRunAttemptId === undefined
             || activeNativeTurnId === undefined
             ? undefined
-            : { attemptId: activeTurnAttemptId, turnId: activeNativeTurnId };
+            : { attemptId: activeRunAttemptId, turnId: activeNativeTurnId };
         const reconnectPayload = {
             ...currentPayload,
-            environment: activeTurnPayload?.environment ?? currentPayload.environment,
+            command: disconnectedSession.configuration.command,
+            args: disconnectedSession.configuration.args,
+            cwd: disconnectedSession.configuration.cwd,
+            environment: activeRunPayload?.environment ?? currentPayload.environment,
             providerControl: {
                 schemaVersion: 1,
                 adapterId: "codex",
+                // Reconnecting reaches the same product the disconnected Session was
+                // pinned to. Rebuilding the control without the component would quietly
+                // drop that identity halfway through a Session's life.
+                ...(previousControl.component === undefined
+                    ? {}
+                    : { component: previousControl.component }),
                 transport: "codex-app-server-proxy",
                 kind: "restore",
                 mode: "resume",
@@ -234,7 +288,8 @@ export async function runAgentHost(input) {
                 ...(previousControl.sessionTitle === undefined
                     ? {}
                     : { sessionTitle: previousControl.sessionTitle }),
-                codexThread: previousControl.codexThread,
+                codexThread: disconnectedSession.configuration.threadOptions,
+                endpointImplementation: disconnectedSession.configuration.implementation,
                 ...(ownedTurn === undefined ? {} : { ownedTurn }),
                 authority
             }
@@ -249,42 +304,61 @@ export async function runAgentHost(input) {
             if (hostStopRequested)
                 return;
             try {
-                const started = await startStructuredProviderSession(reconnectPayload, {
-                    onStarted: (turn) => handleStarted(turn, currentPayload),
-                    onTerminal: handleTerminal,
-                    onGoal: handleGoal
-                });
+                assertAgentExecutionEnvironment(input.home, reconnectPayload);
+                // Reattaching a dropped client continues the same Session on the same
+                // pinned generation; it never re-selects an implementation.
+                if (endpointLease === undefined) {
+                    throw new Error("Codex client reconnect lost its Endpoint implementation lease.");
+                }
+                const started = await endpointLease.resume(reconnectPayload);
                 session = started.session;
                 sessionPayload = currentPayload;
+                started.session.events((event) => {
+                    if (session !== started.session && event.type !== "terminal")
+                        return;
+                    if (event.type === "accepted")
+                        handleAccepted(event.value);
+                    else if (event.type === "activity")
+                        handleActivity(event.value);
+                    else if (event.type === "started")
+                        handleStarted(event.value, currentPayload);
+                    else if (event.type === "terminal")
+                        handleTerminal(event.value);
+                    else if (event.type === "goal")
+                        handleGoal(event.value);
+                    else
+                        void enqueueSerialized(() => publishStructuredProviderInputObserved({
+                            home: input.home, environment: currentPayload.environment, observed: event.value
+                        })).catch(() => { });
+                });
                 conversationRecoverability = "recoverable";
                 codexClientAttachedAt = Date.now();
                 observeExit(started.session, currentPayload);
-                const reconnectState = activeTurnPayload !== undefined
+                const reconnectState = activeRunPayload !== undefined
                     ? ownedTurn === undefined ? "delivery-unknown" : "ready"
-                    : started.session.activeTurnId === undefined ? "idle" : "busy";
+                    : started.session.inspect().activeNativeTurnId === undefined ? "idle" : "busy";
                 updateSnapshot(hostSnapshot(reconnectState, {
-                    runtimeGenerationId: currentPayload.runtimeGenerationId,
                     adapterId: "codex",
                     processInstanceId: started.session.processInstanceId,
                     nativeSessionId: started.session.nativeSessionId,
                     conversationId: started.session.conversationId,
-                    ...(activeTurnAttemptId === undefined ? {} : { attemptId: activeTurnAttemptId }),
+                    ...(activeRunAttemptId === undefined ? {} : { attemptId: activeRunAttemptId }),
                     ...(activeNativeTurnId === undefined ? {} : { nativeTurnId: activeNativeTurnId }),
                     ...authorityFields(),
-                    ...(ownedTurn !== undefined || activeTurnPayload === undefined
+                    ...(ownedTurn !== undefined || activeRunPayload === undefined
                         ? {}
                         : {
-                            detail: "Codex client reattached, but the in-flight Turn has no exact native identity."
+                            detail: "Codex client reattached, but the in-flight AgentRun has no exact native identity."
                         })
                 }));
                 if (started.recoveredTerminal !== undefined) {
                     handleTerminal(started.recoveredTerminal);
                 }
-                if (ownedTurn === undefined && started.session.activeTurnId !== undefined) {
+                if (ownedTurn === undefined && started.session.inspect().activeNativeTurnId !== undefined) {
                     handleStarted({
                         conversationId: started.session.conversationId,
                         nativeSessionId: started.session.nativeSessionId,
-                        nativeTurnId: started.session.activeTurnId,
+                        nativeTurnId: started.session.inspect().activeNativeTurnId,
                         clientOwned: false,
                         observedAt: new Date().toISOString()
                     }, currentPayload);
@@ -298,12 +372,11 @@ export async function runAgentHost(input) {
             }
         }
         updateSnapshot(hostSnapshot("failed", {
-            runtimeGenerationId: currentPayload.runtimeGenerationId,
             adapterId: "codex",
             processInstanceId: disconnectedSession.processInstanceId,
             nativeSessionId: disconnectedSession.nativeSessionId,
             conversationId: disconnectedSession.conversationId,
-            ...(activeTurnAttemptId === undefined ? {} : { attemptId: activeTurnAttemptId }),
+            ...(activeRunAttemptId === undefined ? {} : { attemptId: activeRunAttemptId }),
             ...(activeNativeTurnId === undefined ? {} : { nativeTurnId: activeNativeTurnId }),
             ...authorityFields(),
             detail: `Codex client could not reattach after bounded retries: ${errorText(lastError)}`
@@ -312,16 +385,13 @@ export async function runAgentHost(input) {
     const observeExit = (providerSession, launched) => {
         void providerSession.waitForExit().then((result) => enqueueSerialized(async () => {
             const ownsCurrentSession = session === providerSession;
-            const currentPayload = ownsCurrentSession ? sessionPayload ?? launched : launched;
-            const currentActivationId = ownsCurrentSession
-                ? activationId ?? launched.runtimeGenerationId
-                : launched.runtimeGenerationId;
+            const currentPayload = ownsCurrentSession
+                ? activeRunPayload ?? lastTerminalPayload ?? sessionPayload ?? launched : launched;
             const exitAuthority = authorityFields();
-            const stopReceipt = readRuntimeStopReceipt(input.home, currentPayload.runtimeGenerationId);
+            const stopRequested = hostStopRequested || providerSession.inspect().cancellation === "requested";
             const reconnectableCodexClient = ownsCurrentSession
                 && providerSession.adapterId === "codex"
-                && !hostStopRequested
-                && stopReceipt === null;
+                && !hostStopRequested;
             if (reconnectableCodexClient) {
                 session = undefined;
                 if (codexClientAttachedAt !== undefined
@@ -331,12 +401,11 @@ export async function runAgentHost(input) {
                 consecutiveCodexDisconnects += 1;
                 if (consecutiveCodexDisconnects > MAX_CONSECUTIVE_CODEX_DISCONNECTS) {
                     updateSnapshot(hostSnapshot("failed", {
-                        runtimeGenerationId: currentPayload.runtimeGenerationId,
                         adapterId: "codex",
                         processInstanceId: result.processInstanceId,
                         nativeSessionId: providerSession.nativeSessionId,
                         conversationId: providerSession.conversationId,
-                        ...(activeTurnAttemptId === undefined ? {} : { attemptId: activeTurnAttemptId }),
+                        ...(activeRunAttemptId === undefined ? {} : { attemptId: activeRunAttemptId }),
                         ...(activeNativeTurnId === undefined ? {} : { nativeTurnId: activeNativeTurnId }),
                         ...exitAuthority,
                         detail: "Codex client repeatedly disconnected before reaching a stable attachment."
@@ -344,12 +413,11 @@ export async function runAgentHost(input) {
                     return;
                 }
                 updateSnapshot(hostSnapshot("starting", {
-                    runtimeGenerationId: currentPayload.runtimeGenerationId,
                     adapterId: "codex",
                     processInstanceId: result.processInstanceId,
                     nativeSessionId: providerSession.nativeSessionId,
                     conversationId: providerSession.conversationId,
-                    ...(activeTurnAttemptId === undefined ? {} : { attemptId: activeTurnAttemptId }),
+                    ...(activeRunAttemptId === undefined ? {} : { attemptId: activeRunAttemptId }),
                     ...(activeNativeTurnId === undefined ? {} : { nativeTurnId: activeNativeTurnId }),
                     ...exitAuthority,
                     detail: "Codex App Server proxy disconnected; attaching a replacement client."
@@ -359,28 +427,18 @@ export async function runAgentHost(input) {
             }
             if (ownsCurrentSession) {
                 session = undefined;
-                activationId = undefined;
                 conversationRecoverability = "unknown";
                 authority = undefined;
+                // The client is gone for good, so this Session stops holding the
+                // implementation. Keeping the reference would report work in progress
+                // that no longer exists; a later launch pins again explicitly.
+                const ending = endpointLease;
+                endpointLease = undefined;
+                await ending?.release().catch(() => undefined);
             }
             hostSequence += 1;
             const observedAt = new Date().toISOString();
             const failures = [];
-            try {
-                await publishStructuredProviderActivationTerminal({
-                    home: input.home,
-                    environment: currentPayload.environment,
-                    conversationId: providerSession.conversationId,
-                    nativeSessionId: providerSession.nativeSessionId,
-                    activationId: currentActivationId,
-                    status: stopReceipt !== null || hostStopRequested ? "ended" : "failed",
-                    observedAt
-                });
-            }
-            catch (error) {
-                failures.push(`activation terminal: ${errorText(error)}`);
-            }
-            let exitPersisted = false;
             try {
                 await persistAndSubmitExit(input.home, validateRuntimeProcessExitObservation({
                     schemaVersion: 2,
@@ -392,31 +450,39 @@ export async function runAgentHost(input) {
                         ? {}
                         : { taskId: currentPayload.environment.YUI_TASK_ID }),
                     roleName: currentPayload.environment.YUI_ROLE ?? "unknown-role",
-                    ...(currentPayload.environment.YUI_TURN_ID === undefined
+                    ...(currentPayload.environment.YUI_RUN_ID === undefined
                         ? {}
-                        : { turnId: currentPayload.environment.YUI_TURN_ID }),
-                    runtimeGenerationId: currentPayload.runtimeGenerationId,
+                        : { runId: currentPayload.environment.YUI_RUN_ID }),
                     ...(providerSession.nativeSessionId.length === 0
                         ? {}
                         : { nativeSessionId: providerSession.nativeSessionId }),
                     processKind: "provider-child",
                     ...(result.code === null ? {} : { exitCode: result.code }),
                     ...(result.signal === null ? {} : { signal: result.signal }),
-                    ...(stopReceipt === null ? {} : { stopReceiptId: stopReceipt.receiptId }),
+                    ...(stopRequested ? { stopRequested: true } : {}),
                     observedAt
                 }));
-                exitPersisted = true;
             }
             catch (error) {
                 failures.push(`process exit: ${errorText(error)}`);
             }
-            if (stopReceipt !== null && exitPersisted) {
-                removeRuntimeStopReceipt(input.home, currentPayload.runtimeGenerationId);
+            if (ownsCurrentSession && currentPayload.environment.YUI_SESSION_SCOPE === "task") {
+                try {
+                    await publishStructuredProviderAttachmentExit({
+                        home: input.home, environment: currentPayload.environment,
+                        nativeSessionId: providerSession.nativeSessionId,
+                        attemptId: activeRunAttemptId ?? lastTerminal?.attemptId,
+                        nativeTurnId: activeNativeTurnId ?? lastTerminal?.nativeTurnId,
+                        failed: !stopRequested, observedAt
+                    });
+                }
+                catch (error) {
+                    failures.push(`attachment exit: ${errorText(error)}`);
+                }
             }
             if (hostStopRequested || !ownsCurrentSession)
                 return;
             updateSnapshot(hostSnapshot(failures.length === 0 ? "exited" : "failed", {
-                runtimeGenerationId: currentPayload.runtimeGenerationId,
                 adapterId: currentPayload.providerControl?.adapterId,
                 processInstanceId: result.processInstanceId,
                 nativeSessionId: providerSession.nativeSessionId,
@@ -424,12 +490,11 @@ export async function runAgentHost(input) {
                 ...exitAuthority,
                 ...(failures.length !== 0
                     ? { detail: failures.join("; ") }
-                    : activeTurnPayload === undefined
+                    : activeRunPayload === undefined
                         ? {}
-                        : { detail: "Provider process exited before the active Turn reached a terminal boundary." })
+                        : { detail: "Provider process exited before the active AgentRun reached a terminal boundary." })
             }));
         })).catch((error) => updateSnapshot(hostSnapshot("failed", {
-            runtimeGenerationId: launched.runtimeGenerationId,
             adapterId: launched.providerControl?.adapterId,
             processInstanceId: providerSession.processInstanceId,
             ...authorityFields(),
@@ -441,7 +506,7 @@ export async function runAgentHost(input) {
         if (providerControl === undefined) {
             throw new Error("Agent Host accepts only managed Provider control launches.");
         }
-        if (activeTurnPayload !== undefined
+        if (activeRunPayload !== undefined
             || ["starting", "ready", "settling", "delivery-unknown"].includes(snapshot.state)) {
             throw new Error("Agent Host still owns an unsettled Provider Turn.");
         }
@@ -457,7 +522,6 @@ export async function runAgentHost(input) {
             throw new Error("Agent Host launch carries a stale Provider authority fence.");
         }
         updateSnapshot(hostSnapshot("starting", {
-            runtimeGenerationId: next.runtimeGenerationId,
             adapterId: providerControl.adapterId,
             ...(session === undefined ? {} : {
                 processInstanceId: session.processInstanceId,
@@ -471,28 +535,58 @@ export async function runAgentHost(input) {
             if (session !== undefined) {
                 if (session.adapterId !== providerControl.adapterId
                     || providerControl.mode !== "resume"
-                    || providerControl.nativeSessionId !== session.nativeSessionId) {
+                    || providerControl.nativeSessionId !== session.nativeSessionId
+                    || (providerControl.endpointImplementation !== undefined
+                        && (providerControl.endpointImplementation.id !== session.configuration.implementation.id
+                            || providerControl.endpointImplementation.generation !== session.configuration.implementation.generation))) {
                     throw new Error("Agent Host launch does not match its live Provider Conversation.");
                 }
                 sessionPayload = next;
             }
             else {
-                activationId = next.runtimeGenerationId;
-                conversationRecoverability = providerControl.adapterId === "codex"
-                    ? "recoverable"
-                    : "unknown";
                 if (providerControl.kind === "restore" && providerControl.ownedTurn !== undefined) {
-                    activeTurnPayload = next;
-                    activeTurnAttemptId = providerControl.ownedTurn.attemptId;
+                    activeRunPayload = next;
+                    activeRunAttemptId = providerControl.ownedTurn.attemptId;
                     activeNativeTurnId = providerControl.ownedTurn.turnId;
                 }
-                const started = await startStructuredProviderSession(next, {
-                    onStarted: (turn) => handleStarted(turn, next),
-                    onTerminal: handleTerminal,
-                    onGoal: handleGoal
-                });
+                assertAgentExecutionEnvironment(input.home, next);
+                // Pin before opening: the Session holds this exact generation for every
+                // later Turn. A pinned reference naming code this process is not running
+                // fails here, rather than silently starting on a different generation.
+                endpointLease ??= endpointOwner.pin(providerControl.adapterId, providerControl.endpointImplementation);
+                endpointAdapterId = providerControl.adapterId;
+                const started = await (providerControl.mode === "new"
+                    ? endpointLease.open(next) : endpointLease.resume(next));
                 session = started.session;
                 sessionPayload = next;
+                recordOwnedProviderProcess(input.home, next.environment, started.session);
+                recordNativeConnection(input.home, next, started.session);
+                lastTerminalPayload = undefined;
+                lastTerminal = undefined;
+                // Recoverable means a later process can rebind this Conversation by
+                // its native id. The Endpoint answers that from the Driver capability
+                // or, where the protocol settles it per connection, from what this
+                // Agent actually negotiated — so it is read after the handshake, never
+                // predicted before it.
+                conversationRecoverability = started.session.conversationRecoverability;
+                started.session.events((event) => {
+                    if (session !== started.session && event.type !== "terminal")
+                        return;
+                    if (event.type === "accepted")
+                        handleAccepted(event.value);
+                    else if (event.type === "activity")
+                        handleActivity(event.value);
+                    else if (event.type === "started")
+                        handleStarted(event.value, next);
+                    else if (event.type === "terminal")
+                        handleTerminal(event.value);
+                    else if (event.type === "goal")
+                        handleGoal(event.value);
+                    else
+                        void enqueueSerialized(() => publishStructuredProviderInputObserved({
+                            home: input.home, environment: next.environment, observed: event.value
+                        })).catch(() => { });
+                });
                 recoveredGoal = started.goal;
                 if (started.session.adapterId === "codex") {
                     codexClientAttachedAt = Date.now();
@@ -503,51 +597,49 @@ export async function runAgentHost(input) {
                     handleTerminal(started.recoveredTerminal);
                 }
                 if ((providerControl.kind !== "restore" || providerControl.ownedTurn === undefined)
-                    && started.session.activeTurnId !== undefined) {
+                    && started.session.inspect().activeNativeTurnId !== undefined) {
                     handleStarted({
                         conversationId: started.session.conversationId,
                         nativeSessionId: started.session.nativeSessionId,
-                        nativeTurnId: started.session.activeTurnId,
+                        nativeTurnId: started.session.inspect().activeNativeTurnId,
                         clientOwned: false,
                         observedAt: new Date().toISOString()
                     }, next);
                 }
             }
-            await publishStructuredProviderOpened({
-                home: input.home,
-                environment: next.environment,
-                conversationId: session.conversationId,
-                nativeSessionId: session.nativeSessionId,
-                activationId: activationId ?? next.runtimeGenerationId,
-                recoverability: conversationRecoverability,
-                observedAt: new Date().toISOString()
-            });
-            if (recoveredGoal !== undefined) {
+            if (!providerControl.sessionOnly)
+                await publishStructuredProviderOpened({
+                    home: input.home,
+                    environment: next.environment,
+                    conversationId: session.conversationId,
+                    nativeSessionId: session.nativeSessionId,
+                    recoverability: conversationRecoverability,
+                    observedAt: new Date().toISOString()
+                });
+            if (recoveredGoal !== undefined && !providerControl.sessionOnly) {
                 await publishStructuredProviderGoal({
                     home: input.home,
                     environment: next.environment,
-                    activationId: activationId ?? next.runtimeGenerationId,
                     conversationId: session.conversationId,
                     goal: recoveredGoal
                 });
             }
-            const restoredOwnedTurn = providerControl.kind === "restore"
+            const restoredOwnedRun = providerControl.kind === "restore"
                 ? providerControl.ownedTurn
                 : undefined;
-            const providerState = restoredOwnedTurn !== undefined
+            const providerState = restoredOwnedRun !== undefined
                 ? "ready"
-                : session.activeTurnId === undefined ? "idle" : "busy";
+                : session.inspect().activeNativeTurnId === undefined ? "idle" : "busy";
             updateSnapshot(hostSnapshot(providerState, {
-                runtimeGenerationId: next.runtimeGenerationId,
                 adapterId: providerControl.adapterId,
                 processInstanceId: session.processInstanceId,
                 nativeSessionId: session.nativeSessionId,
                 conversationId: session.conversationId,
-                ...(restoredOwnedTurn === undefined
+                ...(restoredOwnedRun === undefined
                     ? {}
                     : {
-                        attemptId: restoredOwnedTurn.attemptId,
-                        nativeTurnId: restoredOwnedTurn.turnId
+                        attemptId: restoredOwnedRun.attemptId,
+                        nativeTurnId: restoredOwnedRun.turnId
                     }),
                 ...authorityFields()
             }));
@@ -559,13 +651,11 @@ export async function runAgentHost(input) {
                     home: input.home,
                     environment: next.environment,
                     conversationId: error.conversationId,
-                    activationId: activationId ?? next.runtimeGenerationId,
                     recoverability: "unrecoverable",
                     observedAt: new Date().toISOString()
                 }).catch(() => { });
             }
             if (session === undefined) {
-                activationId = undefined;
                 conversationRecoverability = "unknown";
                 authority = undefined;
             }
@@ -573,7 +663,6 @@ export async function runAgentHost(input) {
                 ? "busy"
                 : error instanceof ProviderTurnRejectedError ? "rejected" : "failed";
             updateSnapshot(hostSnapshot(state, {
-                runtimeGenerationId: next.runtimeGenerationId,
                 adapterId: providerControl.adapterId,
                 processInstanceId: session?.processInstanceId,
                 nativeSessionId: session?.nativeSessionId ?? providerControl.nativeSessionId,
@@ -581,8 +670,8 @@ export async function runAgentHost(input) {
                 ...authorityFields(),
                 detail: errorText(error)
             }));
-            activeTurnPayload = undefined;
-            activeTurnAttemptId = undefined;
+            activeRunPayload = undefined;
+            activeRunAttemptId = undefined;
             activeNativeTurnId = undefined;
             throw error;
         }
@@ -593,85 +682,61 @@ export async function runAgentHost(input) {
         return operation;
     };
     const enqueueDispatch = (next) => (enqueueSerialized(() => dispatch(next)));
-    const submitTurn = async (request, operation) => {
+    const submitRun = async (request, operation) => {
         if (session === undefined || sessionPayload === undefined) {
             throw new Error("Agent Host has no live Provider Conversation.");
         }
         if (request.nativeSessionId !== session.nativeSessionId) {
-            throw new Error("Agent Host Turn targets a different Provider Conversation.");
-        }
-        // A superseded generation is a real identity conflict, and the writer
-        // fence does not catch it: a Turn can carry an old generation under a
-        // fence that is still current. Without this the Host registered the stale
-        // Turn, wrote it to the Provider, and adopted the old generation into its
-        // own snapshot. Same generation is contention, which is decided below.
-        if (request.runtimeGenerationId !== sessionPayload.runtimeGenerationId) {
-            operation.failure = providerDeliveryFailure({
-                detail: "Agent Host Turn targets a superseded runtime generation.",
-                errorName: "ProviderGenerationConflictError",
-                phase: "turn-submit",
-                hostState: snapshot.state,
-                expectedRuntimeGenerationId: sessionPayload.runtimeGenerationId,
-                observedRuntimeGenerationId: request.runtimeGenerationId,
-                attemptId: request.turn.attemptId,
-                inputDisposition: "not-accepted",
-                registrationDisposition: "not-committed",
-                // A stale writer does not make the live Session unusable.
-                sessionDisposition: "recoverable"
-            });
-            throw new Error("Agent Host Turn targets a superseded runtime generation: expected "
-                + `${sessionPayload.runtimeGenerationId}, observed ${request.runtimeGenerationId}.`);
+            throw new Error("Agent Host AgentRun targets a different Provider Conversation.");
         }
         if (authority === undefined
             || !sameProviderAuthorityFence(authority, request.authority)) {
             throw new Error("Agent Host rejected a stale Provider writer fence.");
         }
-        if (activeTurnPayload !== undefined || snapshot.state === "settling") {
+        if (activeRunPayload !== undefined || snapshot.state === "settling"
+            || session.inspect().activeNativeTurnId !== undefined) {
             operation.failure = providerDeliveryFailure({
                 detail: "Agent Host still owns an unsettled Provider Turn.",
                 errorName: "ProviderTurnBusyError",
                 phase: "turn-submit",
                 hostState: snapshot.state === "settling" ? "settling" : snapshot.state,
-                expectedRuntimeGenerationId: sessionPayload.runtimeGenerationId,
-                observedRuntimeGenerationId: request.runtimeGenerationId,
-                attemptId: request.turn.attemptId,
+                attemptId: request.run.attemptId,
                 inputDisposition: "not-accepted",
                 registrationDisposition: "not-committed",
                 // Busy is a healthy Session doing work, never a reason to stop it.
                 sessionDisposition: "recoverable"
             });
-            throw new ProviderTurnBusyError("Agent Host still owns an unsettled Provider Turn.", request.turn.attemptId, activeNativeTurnId);
+            throw new ProviderTurnBusyError("Agent Host still owns an unsettled Provider Turn.", request.run.attemptId, activeNativeTurnId);
         }
-        const { YUI_TURN_ID: _launchTurnId, ...baseEnvironment } = sessionPayload.environment;
+        const { YUI_RUN_ID: _launchRunId, ...baseEnvironment } = sessionPayload.environment;
         // Steer attempts belong to the active native Turn. Never evict an unknown
-        // attempt while that Turn remains active, but don't retain another Turn's
+        // attempt while that AgentRun remains active, but don't retain another AgentRun's
         // completed steering history after a new exact submission begins.
         recentSteerAttempts.clear();
-        activeTurnPayload = {
+        activeRunPayload = {
             ...sessionPayload,
             environment: {
                 ...baseEnvironment,
-                ...(request.turnId === undefined ? {} : { YUI_TURN_ID: request.turnId })
+                ...(request.runId === undefined ? {} : { YUI_RUN_ID: request.runId })
             }
         };
-        activeTurnAttemptId = request.turn.attemptId;
+        activeRunAttemptId = request.run.attemptId;
         activeNativeTurnId = undefined;
         updateSnapshot(hostSnapshot("starting", {
-            runtimeGenerationId: request.runtimeGenerationId,
             adapterId: session.adapterId,
             processInstanceId: session.processInstanceId,
             nativeSessionId: session.nativeSessionId,
             conversationId: session.conversationId,
-            attemptId: request.turn.attemptId,
+            attemptId: request.run.attemptId,
             ...authorityFields()
         }));
-        const durableTurn = hostTurnControlParams(sessionPayload, session.nativeSessionId, request.authority, request.turn.attemptId, request.turnId);
+        const durableRun = hostRunControlParams(sessionPayload, session.nativeSessionId, request.authority, request.run.attemptId, request.runId);
         // Registration precedes the Provider write, so its failure modes are not
         // the Provider's. A definite failure means the Provider never saw this
         // input and the occupancy must be released; anything unconfirmed leaves
         // durable state ambiguous and keeps it held.
         try {
-            await beginDurableProviderTurn(input.home, durableTurn);
+            await beginDurableProviderTurn(input.home, durableRun);
         }
         catch (error) {
             // Registration ends in one of three states and they are not
@@ -686,13 +751,13 @@ export async function runAgentHost(input) {
             const registrationUnknown = !registrationSettled
                 && (error instanceof ControllerAcknowledgementUnknownError
                     || error instanceof ProviderDeliveryUnknownError);
-            updateSnapshot(hostSnapshot(registrationUnknown ? "delivery-unknown" : "failed", {
-                runtimeGenerationId: request.runtimeGenerationId,
+            updateSnapshot(hostSnapshot(registrationUnknown ? "delivery-unknown"
+                : error instanceof ProviderTurnBusyError ? "busy" : "failed", {
                 adapterId: session.adapterId,
                 processInstanceId: session.processInstanceId,
                 nativeSessionId: session.nativeSessionId,
                 conversationId: session.conversationId,
-                attemptId: request.turn.attemptId,
+                attemptId: request.run.attemptId,
                 ...authorityFields(),
                 detail: registrationUnknown
                     ? `Provider Turn registration acknowledgement is unconfirmed; the Provider was not sent this input: ${errorText(error)}`
@@ -705,9 +770,7 @@ export async function runAgentHost(input) {
             operation.failure = providerDeliveryFailureFrom(error, {
                 phase: "turn-submit",
                 hostState: snapshot.state,
-                expectedRuntimeGenerationId: sessionPayload.runtimeGenerationId,
-                observedRuntimeGenerationId: request.runtimeGenerationId,
-                attemptId: request.turn.attemptId,
+                attemptId: request.run.attemptId,
                 inputDisposition: "not-accepted",
                 registrationDisposition: registrationUnknown
                     ? "unknown"
@@ -718,8 +781,8 @@ export async function runAgentHost(input) {
                 // The Provider provably holds nothing, and the durable record either
                 // never existed or is settled. Release the Session for the next
                 // attempt instead of stranding it in a false `starting`.
-                activeTurnPayload = undefined;
-                activeTurnAttemptId = undefined;
+                activeRunPayload = undefined;
+                activeRunAttemptId = undefined;
                 activeNativeTurnId = undefined;
             }
             throw error;
@@ -727,34 +790,38 @@ export async function runAgentHost(input) {
         let providerAccepted = false;
         let transportAccepted = false;
         try {
-            const receipt = await session.submitTurn(request.turn);
+            assertAgentExecutionEnvironment(input.home, activeRunPayload);
+            const receipt = endpointReceipt(await session.submit({
+                ...request.run,
+                boundedText: withSessionContextPointer(request.run.boundedText, activeRunPayload.environment),
+                inputRef: request.runId ?? request.run.attemptId
+            }), request.run.attemptId);
             transportAccepted = true;
             providerAccepted = receipt.acceptance === "provider";
             activeNativeTurnId = receipt.nativeTurnId;
             try {
                 await publishStructuredProviderAccepted({
                     home: input.home,
-                    environment: activeTurnPayload.environment,
-                    activationId: activationId ?? sessionPayload.runtimeGenerationId,
+                    environment: activeRunPayload.environment,
                     receipt
                 });
             }
             catch (error) {
-                const unknown = new ProviderDeliveryUnknownError("Input submission returned a receipt but its durable acknowledgement could not be confirmed.", request.turn.attemptId, { cause: error });
+                const unknown = new ProviderDeliveryUnknownError("Input submission returned a receipt but its durable acknowledgement could not be confirmed.", request.run.attemptId, { cause: error });
                 // A resolve failure here must not escape before the snapshot is
                 // written: the Provider has already accepted, and losing that fact
-                // would report a definite non-acceptance for a live Turn.
-                await resolveProviderTurnSubmission(input.home, durableTurn, unknown);
+                // would report a definite non-acceptance for a live AgentRun.
+                await resolveProviderTurnSubmission(input.home, durableRun, unknown);
                 throw unknown;
             }
             updateSnapshot(hostSnapshot("ready", {
-                runtimeGenerationId: request.runtimeGenerationId,
                 adapterId: session.adapterId,
                 processInstanceId: session.processInstanceId,
                 nativeSessionId: receipt.nativeSessionId,
                 conversationId: receipt.conversationId,
                 attemptId: receipt.attemptId,
                 nativeTurnId: receipt.nativeTurnId,
+                inputAcceptance: receipt.acceptance,
                 ...authorityFields()
             }));
             return snapshot;
@@ -764,7 +831,7 @@ export async function runAgentHost(input) {
             let settlementUnknown = false;
             if (!transportAccepted) {
                 try {
-                    await resolveProviderTurnSubmission(input.home, durableTurn, error);
+                    await resolveProviderTurnSubmission(input.home, durableRun, error);
                 }
                 catch (resolutionError) {
                     settlementUnknown = true;
@@ -779,21 +846,18 @@ export async function runAgentHost(input) {
                     ? "busy"
                     : error instanceof ProviderTurnRejectedError ? "rejected" : "failed";
             updateSnapshot(hostSnapshot(state, {
-                runtimeGenerationId: request.runtimeGenerationId,
                 adapterId: session.adapterId,
                 processInstanceId: session.processInstanceId,
                 nativeSessionId: session.nativeSessionId,
                 conversationId: session.conversationId,
-                attemptId: request.turn.attemptId,
+                attemptId: request.run.attemptId,
                 ...authorityFields(),
                 detail: errorText(failureError)
             }));
             operation.failure = providerDeliveryFailureFrom(failureError, {
                 phase: "turn-submit",
                 hostState: state,
-                expectedRuntimeGenerationId: sessionPayload.runtimeGenerationId,
-                observedRuntimeGenerationId: request.runtimeGenerationId,
-                attemptId: request.turn.attemptId,
+                attemptId: request.run.attemptId,
                 // Acceptance is observed, never inferred from the error class.
                 inputDisposition: providerAccepted
                     ? "accepted"
@@ -802,50 +866,28 @@ export async function runAgentHost(input) {
                 sessionDisposition: state === "failed" ? "unknown" : "recoverable"
             });
             if (state !== "delivery-unknown") {
-                activeTurnPayload = undefined;
-                activeTurnAttemptId = undefined;
+                activeRunPayload = undefined;
+                activeRunAttemptId = undefined;
                 activeNativeTurnId = undefined;
             }
             if (deliveryUnknown && !(failureError instanceof ProviderDeliveryUnknownError)) {
-                throw new ProviderDeliveryUnknownError("Provider accepted input but its durable acknowledgement could not be confirmed.", request.turn.attemptId, { cause: failureError });
+                throw new ProviderDeliveryUnknownError("Provider accepted input but its durable acknowledgement could not be confirmed.", request.run.attemptId, { cause: failureError });
             }
             throw failureError;
         }
     };
-    const steerTurn = async (request, operation) => {
-        if (session === undefined || sessionPayload === undefined || activeTurnPayload === undefined) {
+    const steerRun = async (request, operation) => {
+        if (session === undefined || sessionPayload === undefined || activeRunPayload === undefined) {
             operation.failure = providerDeliveryFailure({
                 detail: "Agent Host has no active Provider Turn to steer.",
                 errorName: "ProviderTurnRejectedError",
                 phase: "turn-submit",
                 hostState: snapshot.state,
-                expectedRuntimeGenerationId: sessionPayload?.runtimeGenerationId
-                    ?? snapshot.runtimeGenerationId ?? "none",
-                observedRuntimeGenerationId: request.runtimeGenerationId,
-                attemptId: request.turn.attemptId,
-                inputDisposition: "not-accepted",
-                sessionDisposition: "recoverable"
-            });
-            throw new ProviderTurnRejectedError("Agent Host has no active Provider Turn to steer.", request.turn.attemptId);
-        }
-        // Steer carried no generation check, so a steer issued against a
-        // superseded activation was written into the current Provider Turn. The
-        // native Turn id alone does not catch it: a late steer can arrive while
-        // the id it names is still the active one under a newer generation.
-        if (request.runtimeGenerationId !== sessionPayload.runtimeGenerationId) {
-            operation.failure = providerDeliveryFailure({
-                detail: "Agent Host steer targets a superseded runtime generation.",
-                errorName: "ProviderGenerationConflictError",
-                phase: "turn-submit",
-                hostState: snapshot.state,
-                expectedRuntimeGenerationId: sessionPayload.runtimeGenerationId,
-                observedRuntimeGenerationId: request.runtimeGenerationId,
-                attemptId: request.turn.attemptId,
+                attemptId: request.run.attemptId,
                 inputDisposition: "not-accepted",
                 sessionDisposition: "recoverable"
             });
-            throw new ProviderTurnRejectedError("Agent Host steer targets a superseded runtime generation: expected "
-                + `${sessionPayload.runtimeGenerationId}, observed ${request.runtimeGenerationId}.`, request.turn.attemptId);
+            throw new ProviderTurnRejectedError("Agent Host has no active Provider Turn to steer.", request.run.attemptId);
         }
         if (request.nativeSessionId !== session.nativeSessionId
             || request.nativeTurnId !== activeNativeTurnId) {
@@ -854,44 +896,35 @@ export async function runAgentHost(input) {
                 errorName: "ProviderTurnRejectedError",
                 phase: "turn-submit",
                 hostState: snapshot.state,
-                expectedRuntimeGenerationId: sessionPayload.runtimeGenerationId,
-                observedRuntimeGenerationId: request.runtimeGenerationId,
-                attemptId: request.turn.attemptId,
+                attemptId: request.run.attemptId,
                 inputDisposition: "not-accepted",
                 sessionDisposition: "recoverable"
             });
-            throw new ProviderTurnRejectedError("Agent Host steer targets a different Provider Turn.", request.turn.attemptId);
+            throw new ProviderTurnRejectedError("Agent Host steer targets a different Provider Turn.", request.run.attemptId);
         }
         if (authority === undefined || !sameProviderAuthorityFence(authority, request.authority)) {
             throw new Error("Agent Host rejected a stale Provider writer fence.");
         }
-        if (recentSteerAttempts.has(request.turn.attemptId)) {
-            const previous = recentSteerAttempts.get(request.turn.attemptId);
-            if (previous === undefined)
-                return snapshot;
-            operation.failure = previous;
-            throw new ProviderDeliveryUnknownError(previous.detail, request.turn.attemptId);
-        }
         try {
-            const receipt = await session.steerTurn(request.turn);
+            assertAgentExecutionEnvironment(input.home, sessionPayload);
+            const receipt = endpointReceipt(await session.steer({
+                ...request.run,
+                boundedText: withSessionContextPointer(request.run.boundedText, sessionPayload.environment),
+                inputRef: request.run.attemptId
+            }), request.run.attemptId);
             if (receipt.nativeTurnId !== request.nativeTurnId) {
-                throw new ProviderDeliveryUnknownError("Provider accepted steer against an unexpected native Turn.", request.turn.attemptId);
+                throw new ProviderDeliveryUnknownError("Provider accepted steer against an unexpected native Turn.", request.run.attemptId);
             }
-            recentSteerAttempts.set(request.turn.attemptId, undefined);
         }
         catch (error) {
             const unknown = error instanceof ProviderDeliveryUnknownError;
             operation.failure = providerDeliveryFailureFrom(error, {
                 phase: "turn-submit",
                 hostState: snapshot.state,
-                expectedRuntimeGenerationId: sessionPayload.runtimeGenerationId,
-                observedRuntimeGenerationId: request.runtimeGenerationId,
-                attemptId: request.turn.attemptId,
+                attemptId: request.run.attemptId,
                 inputDisposition: unknown ? "unknown" : "not-accepted",
                 sessionDisposition: "unknown"
             });
-            if (unknown)
-                recentSteerAttempts.set(request.turn.attemptId, operation.failure);
             throw error;
         }
         return snapshot;
@@ -900,9 +933,9 @@ export async function runAgentHost(input) {
         if (session === undefined || request.nativeSessionId !== session.nativeSessionId) {
             throw new Error("Agent Host authority targets a different Provider Conversation.");
         }
-        if (activeTurnPayload !== undefined
+        if (activeRunPayload !== undefined
             || ["starting", "ready", "settling", "delivery-unknown"].includes(snapshot.state)) {
-            throw new Error("Agent Host authority cannot transfer while a Turn is unsettled.");
+            throw new Error("Agent Host authority cannot transfer while a AgentRun is unsettled.");
         }
         const next = validateProviderAuthorityFence(request.authority);
         if (authority !== undefined) {
@@ -914,7 +947,6 @@ export async function runAgentHost(input) {
         }
         authority = next;
         updateSnapshot(hostSnapshot("idle", {
-            runtimeGenerationId: sessionPayload?.runtimeGenerationId ?? snapshot.runtimeGenerationId,
             adapterId: session.adapterId,
             processInstanceId: session.processInstanceId,
             nativeSessionId: session.nativeSessionId,
@@ -926,48 +958,119 @@ export async function runAgentHost(input) {
     };
     const control = await openAgentHostControl(input.home, payload, () => snapshot, async (request) => {
         if (request.type === "status") {
-            return controlResult("status", snapshot);
+            // Read the Agent's configuration at answer time, not from the stored
+            // snapshot. The Agent may have changed it since the last state
+            // transition, and a status request is exactly where a caller expects the
+            // current reading rather than the one that was true at launch. Nothing is
+            // sent to the Agent to obtain it: this reads what the Session has already
+            // been told.
+            return controlResult("status", session === undefined
+                ? snapshot
+                : validateSnapshot({
+                    ...snapshot,
+                    runConfiguration: session.runConfiguration
+                }));
+        }
+        if (request.type === "cancel") {
+            if (session === undefined || request.nativeSessionId !== session.nativeSessionId
+                || request.attemptId !== activeRunAttemptId
+                || authority === undefined || !sameProviderAuthorityFence(authority, request.authority)) {
+                throw new Error("Endpoint cancellation does not match the current Session and authority.");
+            }
+            // Cancellation remains callable while submit is awaiting native ack.
+            // The response never declares the shared native resource stopped.
+            const cancellation = await session.cancel(request.attemptId);
+            return Object.freeze({ ...controlResult("cancel-requested", snapshot), cancellation });
         }
         if (request.type === "submit-turn") {
-            const accepted = await enqueueSerialized(async () => {
+            const submission = enqueueSerialized(async () => {
                 const operation = {};
                 try {
-                    return await submitTurn(request, operation);
+                    return await submitRun(request, operation);
                 }
                 catch (error) {
                     throw new AgentHostOperationError(error, snapshot, operation.failure);
                 }
             });
-            return controlResult("accepted", accepted);
+            return await observePendingHostSubmission(submission, () => snapshot);
         }
         if (request.type === "steer-turn") {
-            const accepted = await enqueueSerialized(async () => {
+            const previous = recentSteerAttempts.get(request.run.attemptId);
+            if (previous !== undefined) {
+                if (previous.request.nativeSessionId !== request.nativeSessionId
+                    || previous.request.nativeTurnId !== request.nativeTurnId
+                    || previous.request.run.boundedText !== request.run.boundedText
+                    || !sameProviderAuthorityFence(previous.request.authority, request.authority)) {
+                    throw new Error("Steer attempt identity cannot name another input or Provider fence.");
+                }
+                return controlResult(previous.outcome.result === "delivered" ? "accepted"
+                    : previous.outcome.result === "pending" ? "pending" : "rejected", snapshot, previous.outcome.failure);
+            }
+            // Reserve before queueing, so inspection is meaningful even while an
+            // earlier Host operation owns the serialized dispatch lane.
+            const attempt = { request, outcome: { result: "pending" } };
+            recentSteerAttempts.set(request.run.attemptId, attempt);
+            const sourcePayload = activeRunPayload ?? sessionPayload ?? payload;
+            const settlement = {
+                home: input.home,
+                environment: sourcePayload.environment,
+                nativeSessionId: request.nativeSessionId,
+                nativeTurnId: request.nativeTurnId,
+                attemptId: request.run.attemptId,
+                boundedText: request.run.boundedText
+            };
+            const submission = enqueueSerialized(async () => {
                 const operation = {};
+                let providerAccepted = false;
                 try {
-                    return await steerTurn(request, operation);
+                    const accepted = await steerRun(request, operation);
+                    providerAccepted = true;
+                    await publishStructuredProviderInputSettlement({ ...settlement, status: "accepted" });
+                    attempt.outcome = { result: "delivered" };
+                    signalRoleMailbox(input.home, sessionPayload ?? payload);
+                    return accepted;
                 }
                 catch (error) {
-                    throw new AgentHostOperationError(error, snapshot, operation.failure);
+                    const unknown = providerAccepted || error instanceof ProviderDeliveryUnknownError;
+                    const failure = operation.failure ?? providerDeliveryFailureFrom(error, {
+                        phase: "turn-submit", attemptId: request.run.attemptId,
+                        inputDisposition: providerAccepted ? "accepted" : unknown ? "unknown" : "not-accepted"
+                    });
+                    attempt.outcome = {
+                        result: unknown ? "delivery-unknown" : "rejected",
+                        failure
+                    };
+                    // Persist a native disposition before replying. Accepted publication
+                    // already enqueued its fact before Controller apply; never replace
+                    // that fact with an "unknown" when only apply acknowledgement failed.
+                    if (!providerAccepted) {
+                        try {
+                            await publishStructuredProviderInputSettlement({
+                                ...settlement, status: unknown ? "unknown" : "rejected", failure
+                            });
+                        }
+                        catch (settlementError) {
+                            throw new AgentHostOperationError(new ProviderDeliveryUnknownError("Steer disposition could not be durably acknowledged.", request.run.attemptId, { cause: new AggregateError([error, settlementError]) }), snapshot, failure);
+                        }
+                    }
+                    signalRoleMailbox(input.home, sessionPayload ?? payload);
+                    throw new AgentHostOperationError(providerAccepted ? new ProviderDeliveryUnknownError("Steer acceptance was observed but its settlement acknowledgement is unknown.", request.run.attemptId, { cause: error }) : error, snapshot, failure);
                 }
             });
-            return controlResult("accepted", accepted);
+            return await observePendingHostSubmission(submission, () => snapshot);
         }
         if (request.type === "set-authority") {
             const accepted = await enqueueSerialized(async () => setAuthority(request));
             return controlResult("accepted", accepted);
         }
-        // Same generation means this exact activation is already live here: the
-        // control request was received and the identity matches. Whether the
-        // Conversation is usable yet is a separate fact the caller reads from
-        // `snapshot.state`; it is never an identity conflict.
-        if (snapshot.runtimeGenerationId === request.runtimeGenerationId
-            && ["starting", "ready", "settling", "delivery-unknown"].includes(snapshot.state)) {
-            return controlResult("active-same-generation", snapshot);
-        }
-        const redeemed = await redeem(input.home, request.runtimeGenerationId, request.ticket);
-        if (activeTurnPayload !== undefined
+        const redeemed = await redeem(input.home, request.ticket);
+        if (activeRunPayload !== undefined
             || ["starting", "ready", "settling", "delivery-unknown"].includes(snapshot.state)) {
-            return controlResult("active-other-generation", snapshot);
+            if (redeemed.providerControl?.mode === "resume"
+                && redeemed.providerControl.nativeSessionId === snapshot.nativeSessionId) {
+                return controlResult("accepted", snapshot);
+            }
+            return controlResult("busy", snapshot);
         }
         const accepted = await enqueueDispatch(redeemed);
         return controlResult("accepted", accepted);
@@ -977,7 +1080,7 @@ export async function runAgentHost(input) {
         : undefined;
     promptHuman = () => {
         if (humanConsole !== undefined && authority?.owner === "human"
-            && activeTurnPayload === undefined
+            && activeRunPayload === undefined
             && ["idle", "rejected", "failed"].includes(snapshot.state)) {
             humanConsole.setPrompt("yui(provider)> ");
             humanConsole.prompt();
@@ -998,19 +1101,18 @@ export async function runAgentHost(input) {
             if (boundedText.length === 0)
                 return;
             const attemptId = `human:${currentAuthority.holderId}:${randomUUID()}`;
-            const turnControl = {
+            const runControl = {
                 protocol: AGENT_HOST_CONTROL_PROTOCOL,
                 type: "submit-turn",
-                runtimeGenerationId: currentPayload.runtimeGenerationId,
                 nativeSessionId: currentSession.nativeSessionId,
                 authority: currentAuthority,
-                turn: {
+                run: {
                     attemptId,
                     boundedText
                 }
             };
-            await submitTurn(turnControl, {});
-            process.stdout.write("Provider accepted the human Turn; waiting for its terminal boundary.\n");
+            await submitRun(runControl, {});
+            process.stdout.write("Provider accepted the human AgentRun; waiting for its terminal boundary.\n");
         }).catch((error) => {
             process.stderr.write(`Provider input failed: ${errorText(error)}\n`);
             promptHuman();
@@ -1029,8 +1131,8 @@ export async function runAgentHost(input) {
             if (hostStopRequested)
                 return;
             hostStopRequested = true;
-            session?.terminate(signal);
-            forceKillTimer = setTimeout(() => session?.terminate("SIGKILL"), 10_000);
+            session?.detach(signal);
+            forceKillTimer = setTimeout(() => session?.detach("SIGKILL"), AGENT_HOST_CLIENT_EXIT_GRACE_MS);
             forceKillTimer.unref();
             stopResolve();
         };
@@ -1050,11 +1152,111 @@ export async function runAgentHost(input) {
         if (forceKillTimer !== undefined)
             clearTimeout(forceKillTimer);
         humanConsole?.close();
-        session?.terminate("SIGTERM");
+        // Ask the client to exit, then hand back the Session's hold. The reference
+        // is only actually returned once the client proves it exited, so the bounded
+        // stop below waits on the real dependency instead of an assumed one.
+        session?.detach();
+        const adapterId = endpointAdapterId;
+        await endpointLease?.release();
+        endpointLease = undefined;
+        if (adapterId !== undefined) {
+            // Stop new acquisition and wait a bounded time for what is already
+            // running. A timeout reports the references and pending effects that are
+            // genuinely still in use; it never escalates to killing a Provider this
+            // Endpoint does not own, and it never reports quiescence it cannot prove.
+            const drain = await endpointOwner.stop(adapterId, ENDPOINT_DRAIN_TIMEOUT_MS);
+            if (!drain.quiescent) {
+                const detail = `Endpoint stop ${drain.timedOut ? "timed out" : "returned"} after ${drain.waitedMs}ms`
+                    + ` (bound ${ENDPOINT_DRAIN_TIMEOUT_MS}ms); ${drain.references} reference(s), `
+                    + `${drain.opening} opening client(s) and `
+                    + `${drain.sessions.reduce((total, held) => total + held.pending.length, 0)} pending effect(s) `
+                    + "may still be in use. Owned client resources are unknown.";
+                updateSnapshot(hostSnapshot(snapshot.state, {
+                    ...definedFields({
+                        adapterId,
+                        nativeSessionId: snapshot.nativeSessionId,
+                        conversationId: snapshot.conversationId
+                    }),
+                    ...authorityFields(),
+                    detail
+                }));
+                // The snapshot is about to stop being reachable, and a stop this process
+                // could not prove quiescent must remain diagnosable afterwards. Written
+                // to the Host's own stream, which its pane and logs retain.
+                process.stderr.write(`${detail}\n`);
+            }
+        }
+        // Final cleanup is bounded on its own deadline. The bounded stop above may
+        // already have given up on a client that never proves exit, and waiting for
+        // that same drain again would leave the control socket open and this function
+        // never returning. Anything still held is reported, not silently released.
+        const remaining = await endpointOwner.close(ENDPOINT_DRAIN_TIMEOUT_MS).catch(() => []);
+        const held = remaining.filter((drain) => !drain.quiescent);
+        if (held.length > 0) {
+            const references = held.reduce((total, drain) => total + drain.references, 0);
+            const opening = held.reduce((total, drain) => total + drain.opening, 0);
+            process.stderr.write(`Endpoint cleanup returned with ${references} reference(s) and ${opening} opening client(s) `
+                + `still held across ${held.length} implementation(s) (bound ${ENDPOINT_DRAIN_TIMEOUT_MS}ms); `
+                + "those implementations stay detached and undisposed. Owned client resources are unknown.\n");
+        }
         await control.close();
         void sessionPayload;
     }
 }
+/** Host-restart-independent OS custody. No secret or launch payload is stored. */
+function recordOwnedProviderProcess(home, environment, endpoint) {
+    if (endpoint.ownedProcessId === undefined || environment.YUI_SESSION_SCOPE !== "task")
+        return;
+    const identity = readLinuxProcessIdentity(endpoint.ownedProcessId);
+    if (identity === undefined)
+        throw new Error("Dedicated Provider process identity was lost before registration.");
+    const taskId = environment.YUI_TASK_ID;
+    const roleName = environment.YUI_ROLE;
+    const store = openCurrentTaskStore(home);
+    try {
+        store.saveSessionOwner(createSessionOwnerIdentity({
+            owner: { scope: "task", taskId, roleName },
+            agentId: environment.YUI_AGENT_ID, adapterId: endpoint.adapterId,
+            nativeSessionId: endpoint.nativeSessionId,
+            tmux: {
+                serverName: yuiTmuxServerName(home),
+                socketPath: join(tmuxSocketDirectory(environment), yuiTmuxServerName(home)),
+                sessionName: yuiTmuxSessionName(home, taskId), windowName: roleName, panePid: process.pid
+            },
+            providerRoot: { pid: identity.pid, startIdentity: identity.startIdentity,
+                processGroupId: identity.processGroupId, processSessionId: identity.processSessionId,
+                attribution: "owned-child" },
+            recordedAt: new Date()
+        }));
+    }
+    finally {
+        store.close();
+    }
+}
+function recordNativeConnection(home, payload, endpoint) {
+    if (endpoint.adapterId !== "codex" || payload.environment.YUI_SESSION_SCOPE !== "task")
+        return;
+    const taskId = payload.environment.YUI_TASK_ID;
+    const store = openCurrentTaskStore(home);
+    try {
+        if (store.listEvents(taskId).some(event => event.type === "runtime.native-connection-bound"
+            && event.payload.nativeSessionId === endpoint.nativeSessionId))
+            return;
+        const userHome = resolve(payload.cwd, payload.environment.HOME ?? homedir());
+        store.saveEvent(taskId, createTaskEvent(store.nextEventId(taskId), taskId, "runtime.native-connection-bound", {
+            roleName: payload.environment.YUI_ROLE, agentId: payload.environment.YUI_AGENT_ID,
+            nativeSessionId: endpoint.nativeSessionId,
+            // Account location is needed after Controller/Host loss. Never retain
+            // resolved credentials or duplicate the full process environment.
+            home: userHome,
+            codexHome: resolve(payload.cwd, payload.environment.CODEX_HOME ?? join(userHome, ".codex")),
+            ...(endpoint.nativeAccountHome === undefined ? {} : { nativeAccountHome: endpoint.nativeAccountHome })
+        }, new Date()));
+    }
+    finally {
+        store.close();
+    }
+}
 export function agentHostControlSocketPath(input) {
     const owner = input.scope === "task" ? input.taskId ?? "missing-task" : "global";
     const homeDigest = createHash("sha256")
@@ -1075,7 +1277,7 @@ export function agentHostControlSocketPath(input) {
 export async function sendAgentHostLaunchControl(input) {
     return await sendAgentHostControl(input);
 }
-export async function sendAgentHostTurnControl(input) {
+export async function sendAgentHostRunControl(input) {
     return await sendAgentHostControl(input);
 }
 export async function sendAgentHostSteerControl(input) {
@@ -1084,6 +1286,9 @@ export async function sendAgentHostSteerControl(input) {
 export async function sendAgentHostAuthorityControl(input) {
     return await sendAgentHostControl(input);
 }
+export async function sendAgentHostCancelControl(input) {
+    return await sendAgentHostControl(input);
+}
 export async function inspectAgentHost(input) {
     const result = await sendAgentHostControl({
         ...input,
@@ -1097,9 +1302,9 @@ export async function waitForAgentHostLaunchAck(input) {
     while (Date.now() < deadline) {
         try {
             const snapshot = await inspectAgentHost(input);
-            if (snapshot.runtimeGenerationId === input.runtimeGenerationId) {
+            {
                 if (snapshot.state === "ready"
-                    || (input.requireTurnAck !== true && snapshot.state === "idle"))
+                    || (input.requireRunAck !== true && snapshot.state === "idle"))
                     return snapshot;
                 if (snapshot.state === "delivery-unknown"
                     || snapshot.state === "busy"
@@ -1120,7 +1325,7 @@ export async function waitForAgentHostLaunchAck(input) {
         }
         await new Promise((resolvePromise) => setTimeout(resolvePromise, 50));
     }
-    throw new Error(`Agent Host did not acknowledge Provider launch ${input.runtimeGenerationId}: ${errorText(lastError)}.`);
+    throw new Error(`Agent Host did not acknowledge Provider launch: ${errorText(lastError)}.`);
 }
 async function sendAgentHostControl(input) {
     const path = agentHostControlSocketPath(input);
@@ -1158,9 +1363,8 @@ async function sendAgentHostControl(input) {
         });
     });
 }
-async function redeem(home, runtimeGenerationId, ticket) {
+async function redeem(home, ticket) {
     const result = await callController(home, "runtime.launch-redeem", {
-        runtimeGenerationId,
         ticket,
         hostPid: process.pid
     });
@@ -1236,15 +1440,12 @@ export async function openAgentHostControl(home, payload, snapshot, dispatch) {
                         || error instanceof ControllerAcknowledgementUnknownError;
                     // The failing operation already recorded the exact facts. Prefer its
                     // record; only synthesize one when the failure came from outside a
-                    // Turn operation (a malformed control, say), where those facts do
+                    // AgentRun operation (a malformed control, say), where those facts do
                     // not exist.
                     const recorded = caught instanceof AgentHostOperationError ? caught.failure : undefined;
                     const failure = recorded ?? providerDeliveryFailureFrom(error, {
                         phase: controlRequestPhase(body),
                         hostState: busy ? "busy" : unknown ? "delivery-unknown" : current.state,
-                        ...(current.runtimeGenerationId === undefined
-                            ? {}
-                            : { observedRuntimeGenerationId: current.runtimeGenerationId }),
                         ...(current.attemptId === undefined
                             ? {}
                             : { attemptId: current.attemptId }),
@@ -1256,7 +1457,7 @@ export async function openAgentHostControl(home, payload, snapshot, dispatch) {
                     // A bare `rejected` here is indistinguishable from the Provider
                     // refusing the input. Carry the real cause and an explicit input
                     // disposition so no consumer has to guess from the message text.
-                    socket.end(`${JSON.stringify(boundControlResponse(controlResult(busy ? "accepted" : "rejected", validateSnapshot({
+                    socket.end(`${JSON.stringify(boundControlResponse(controlResult(busy ? "busy" : "rejected", validateSnapshot({
                         ...current,
                         ...(busy ? { state: "busy" } : {}),
                         ...(unknown ? { state: "delivery-unknown" } : {}),
@@ -1294,7 +1495,10 @@ function boundControlResponse(result) {
     // Every public response, including status and successful controls, crosses
     // the same redaction/size boundary. An earlier failed operation may remain
     // visible through an otherwise successful status request.
-    result = controlResult(result.outcome, validateSnapshot(result.snapshot), result.failure === undefined ? undefined : providerDeliveryFailure(result.failure));
+    result = {
+        ...controlResult(result.outcome, validateSnapshot(result.snapshot), result.failure === undefined ? undefined : providerDeliveryFailure(result.failure)),
+        ...(result.cancellation === undefined ? {} : { cancellation: result.cancellation })
+    };
     if (withinControlBound(result))
         return result;
     const clip = (text, chars) => {
@@ -1303,6 +1507,17 @@ function boundControlResponse(result) {
         const head = Math.floor(chars * 0.75);
         return `${text.slice(0, head)}…[truncated ${text.length - chars} chars: control byte bound]${text.slice(text.length - (chars - head))}`;
     };
+    // Never make an omitted option list look like a complete empty enumeration.
+    if (result.snapshot.runConfiguration?.status === "observed") {
+        result = controlResult(result.outcome, validateSnapshot({
+            ...result.snapshot,
+            runConfiguration: unknownAgentRunConfiguration("The Agent's reported configuration is too large for the Agent Host "
+                + "control response, so it could not be carried in full and none of it "
+                + "is shown rather than part of it.")
+        }), result.failure);
+        if (withinControlBound(result))
+            return result;
+    }
     let bounded = controlResult(result.outcome, {
         ...result.snapshot,
         ...(result.snapshot.detail === undefined ? {} : { detail: clip(result.snapshot.detail, 1200) })
@@ -1349,24 +1564,29 @@ function validateControl(control) {
     }
     if (control.type === "status")
         return Object.freeze({ ...control });
+    if (control.type === "cancel") {
+        validateIdentity(control.nativeSessionId, "native Session id");
+        validateIdentity(control.attemptId, "Provider input attempt id");
+        validateProviderAuthorityFence(control.authority);
+        return Object.freeze({ ...control });
+    }
     if (control.type === "submit-turn" || control.type === "steer-turn") {
-        validateRuntimeGenerationId(control.runtimeGenerationId);
         validateIdentity(control.nativeSessionId, "native Session id");
-        if (control.type === "submit-turn" && control.turnId !== undefined) {
-            validateIdentity(control.turnId, "Turn id");
+        if (control.type === "submit-turn" && control.runId !== undefined) {
+            validateIdentity(control.runId, "AgentRun id");
         }
         if (control.type === "steer-turn")
             validateIdentity(control.nativeTurnId, "native Turn id");
         validateProviderAuthorityFence(control.authority);
-        validateIdentity(control.turn.attemptId, "Provider input attempt id");
-        if (typeof control.turn.boundedText !== "string"
-            || control.turn.boundedText.includes("\0")
-            || Buffer.byteLength(control.turn.boundedText, "utf8") > 32 * 1024) {
+        validateIdentity(control.run.attemptId, "Provider input attempt id");
+        if (typeof control.run.boundedText !== "string"
+            || control.run.boundedText.includes("\0")
+            || Buffer.byteLength(control.run.boundedText, "utf8") > 32 * 1024) {
             throw new Error("Agent Host Provider input is invalid.");
         }
         return Object.freeze({
             ...control,
-            turn: Object.freeze({ ...control.turn })
+            run: Object.freeze({ ...control.run })
         });
     }
     if (control.type === "set-authority") {
@@ -1378,18 +1598,11 @@ function validateControl(control) {
     }
     if (control.type !== "launch")
         throw new Error("Agent Host control type is invalid.");
-    validateRuntimeGenerationId(control.runtimeGenerationId);
     if (typeof control.ticket !== "string" || !/^[a-f0-9]{64}$/u.test(control.ticket)) {
         throw new Error("Agent Host launch control ticket is invalid.");
     }
     return Object.freeze({ ...control });
 }
-function validateRuntimeGenerationId(value) {
-    if (typeof value !== "string" || value.length === 0
-        || value.length > 256 || value.includes("\0")) {
-        throw new Error("Agent Host launch control identity is invalid.");
-    }
-}
 function validateIdentity(value, label) {
     if (typeof value !== "string" || value.trim().length === 0 || value.includes("\0")) {
         throw new Error(`Agent Host ${label} is invalid.`);
@@ -1397,7 +1610,7 @@ function validateIdentity(value, label) {
 }
 function validateControlResult(result) {
     if (result.protocol !== AGENT_HOST_CONTROL_PROTOCOL
-        || !["status", "accepted", "rejected", "active-same-generation", "active-other-generation"].includes(result.outcome)) {
+        || !["status", "accepted", "pending", "cancel-requested", "rejected", "busy"].includes(result.outcome)) {
         throw new Error("Agent Host control response is invalid.");
     }
     return Object.freeze({
@@ -1431,6 +1644,10 @@ function validateSnapshot(snapshot) {
     if (!Number.isFinite(Date.parse(snapshot.updatedAt))) {
         throw new Error("Agent Host snapshot timestamp is invalid.");
     }
+    if (snapshot.inputAcceptance !== undefined
+        && snapshot.inputAcceptance !== "provider" && snapshot.inputAcceptance !== "transport") {
+        throw new Error("Agent Host input acceptance evidence is invalid.");
+    }
     const authorityFields = [
         snapshot.authorityEpoch,
         snapshot.authorityOwner,
@@ -1451,6 +1668,12 @@ function validateSnapshot(snapshot) {
     // to expose the original exception on their normal success paths.
     return Object.freeze({
         ...snapshot,
+        ...(snapshot.runConfiguration === undefined
+            ? {}
+            // Re-read through the same parser the client uses. A shape this build does
+            // not recognize becomes an explicit `unknown` here rather than travelling
+            // as a partial record that renders like a real answer.
+            : { runConfiguration: readAgentRunConfigurationObservation(snapshot.runConfiguration) }),
         ...(snapshot.detail === undefined ? {} : { detail: redactAgentErrorText(snapshot.detail) })
     });
 }
@@ -1480,6 +1703,8 @@ function controlRequestPhase(body) {
         const type = JSON.parse(body.trim()).type;
         if (type === "submit-turn" || type === "steer-turn")
             return "turn-submit";
+        if (type === "cancel")
+            return "host-stop";
         if (type === "launch")
             return "session-restore";
     }
@@ -1494,6 +1719,30 @@ function definedFields(value) {
 function errorText(error) {
     return error instanceof Error ? error.message : String(error ?? "unknown error");
 }
+/** Preserve the existing durable publication/failure path at the Host boundary. */
+function endpointReceipt(result, attemptId) {
+    if (result.status === "accepted")
+        return result.receipt;
+    if (result.status === "pending") {
+        throw result.error ?? new ProviderTurnBusyError("The same Endpoint input is still pending.", attemptId);
+    }
+    throw result.error;
+}
+async function observePendingHostSubmission(submission, snapshot) {
+    let timer;
+    try {
+        return await Promise.race([
+            submission.then((accepted) => controlResult("accepted", accepted)),
+            new Promise((resolvePromise) => {
+                timer = setTimeout(() => resolvePromise(controlResult("pending", snapshot())), PROVIDER_ACCEPT_TIMEOUT_MS);
+            })
+        ]);
+    }
+    finally {
+        if (timer !== undefined)
+            clearTimeout(timer);
+    }
+}
 function signalRoleMailbox(home, payload) {
     const taskId = payload.environment.YUI_TASK_ID;
     const roleName = payload.environment.YUI_ROLE;
@@ -1511,14 +1760,13 @@ async function delay(milliseconds) {
         timer.unref();
     });
 }
-function hostTurnControlParams(payload, nativeSessionId, authority, attemptId, turnId) {
+function hostRunControlParams(payload, nativeSessionId, authority, attemptId, runId) {
     const environment = payload.environment;
     return Object.freeze({
         taskId: requiredEnvironment(environment.YUI_TASK_ID, "Task id"),
         roleName: requiredEnvironment(environment.YUI_ROLE, "Role name"),
-        ...(turnId === undefined ? {} : { turnId: requiredEnvironment(turnId, "Turn id") }),
+        ...(runId === undefined ? {} : { runId: requiredEnvironment(runId, "AgentRun id") }),
         agentId: requiredEnvironment(environment.YUI_AGENT_ID, "Agent id"),
-        runtimeGenerationId: payload.runtimeGenerationId,
         nativeSessionId: requiredEnvironment(nativeSessionId, "native Session id"),
         attemptId,
         authorityEpoch: authority.epoch,
@@ -1527,14 +1775,17 @@ function hostTurnControlParams(payload, nativeSessionId, authority, attemptId, t
         observedAt: new Date().toISOString()
     });
 }
-async function beginDurableProviderTurn(home, durableTurn) {
+async function beginDurableProviderTurn(home, durableRun) {
     try {
-        await callControllerIdempotently(home, "runtime.provider-turn-begin", durableTurn);
+        await callControllerIdempotently(home, "runtime.provider-turn-begin", durableRun);
     }
     catch (error) {
+        if (error instanceof ControllerClientError && error.code === "SESSION_BUSY") {
+            throw new ProviderTurnBusyError(error.message, String(durableRun.attemptId));
+        }
         if (!(error instanceof ControllerAcknowledgementUnknownError))
             throw error;
-        await resolveProviderTurnSubmission(home, durableTurn, new Error(`Provider Turn intent acknowledgement failed before Provider write: ${errorText(error)}`, { cause: error }));
+        await resolveProviderTurnSubmission(home, durableRun, new Error(`Provider Turn intent acknowledgement failed before Provider write: ${errorText(error)}`, { cause: error }));
         // The resolve is fenced on this exact attempt id, so its success proves
         // the registration did commit and is now settled with nothing written to
         // the Provider. That is a known outcome; reporting it as unknown would
@@ -1577,16 +1828,16 @@ class ControllerAcknowledgementUnknownError extends Error {
 class ProviderTurnRegistrationSettledError extends Error {
     name = "ProviderTurnRegistrationSettledError";
 }
-async function resolveProviderTurnSubmission(home, durableTurn, error) {
-    const attemptId = durableTurn.attemptId;
+async function resolveProviderTurnSubmission(home, durableRun, error) {
+    const attemptId = durableRun.attemptId;
     if (typeof attemptId !== "string") {
         throw new Error("Provider Turn resolution has no attempt id.");
     }
     const request = {
-        ...durableTurn,
+        ...durableRun,
         status: error instanceof ProviderDeliveryUnknownError
             ? "delivery-unknown"
-            : "rejected",
+            : error instanceof ProviderTurnBusyError ? "deferred" : "rejected",
         reason: errorText(error),
         raw: serializeAgentErrorRaw(error),
         observedAt: new Date().toISOString()