@zq-silk/yui 0.15.7 → 0.15.8

package/dist/runtime/taskRuntimeIsolation.js

@@ -1,5 +1,5 @@
 import { createHash, randomBytes } from "node:crypto";
-import { lstatSync, mkdirSync, readFileSync, readdirSync, renameSync, rmdirSync, rmSync, writeFileSync } from "node:fs";
+import { lstatSync, mkdirSync, readFileSync, renameSync, rmdirSync, rmSync, writeFileSync } from "node:fs";
 import { dirname, isAbsolute, join, relative, resolve } from "node:path";
 import { validateManagedWorkspace } from "../worktree/managedWorkspace.js";
 import { ResourceRegistrar } from "../resources/resourceRegistrar.js";
@@ -8,7 +8,7 @@ export const YUI_TASK_RUNTIME_SERVICE_NAMESPACE = "YUI_TASK_RUNTIME_SERVICE_NAME
 const MARKER_FILE = ".yui-task-runtime-owner.json";
 /**
  * One project-neutral implementation owns descriptor construction, preflight,
- * exact generation activation, and exact generation cleanup. It never scans by
+ * exact runtime activation, and exact runtime cleanup. It never scans by
  * process name, Role, PID, age, or an ambient Home.
  */
 export class FileTaskRuntimeIsolation {
@@ -40,7 +40,7 @@ export class FileTaskRuntimeIsolation {
             pathLayout: this.#pathLayout,
             controlPlane: this.#controlPlane,
             resources: [
-                ...inspectGenerationRoot(descriptor, fingerprint),
+                ...inspectRuntimeRoot(descriptor, fingerprint),
                 ...(this.#inspectResources?.(descriptor) ?? [])
             ],
             allowExactActive: input.allowExactActive === true
@@ -53,13 +53,13 @@ export class FileTaskRuntimeIsolation {
     }
     activate(preparation) {
         const { descriptor, fingerprint } = validatePreparation(preparation);
-        const root = descriptor.roots.generation;
-        const existing = inspectGenerationRoot(descriptor, fingerprint);
+        const root = descriptor.roots.runtime;
+        const existing = inspectRuntimeRoot(descriptor, fingerprint);
         if (existing.length > 0) {
             const [resource] = existing;
             if (resource?.ownership !== "owned"
                 || resource.descriptorFingerprint !== fingerprint) {
-                throw new Error(`Task runtime generation is not exactly owned: ${root}.`);
+                throw new Error(`Task runtime workspace is not exactly owned: ${root}.`);
             }
             ensureOwnedDirectories(descriptor);
             this.#resourceRegistrar().registerTaskRuntimeIsolation(descriptor);
@@ -82,7 +82,7 @@ export class FileTaskRuntimeIsolation {
             this.#resourceRegistrar().registerTaskRuntimeIsolation(descriptor);
         }
         catch (error) {
-            const current = inspectGenerationRoot(descriptor, fingerprint);
+            const current = inspectRuntimeRoot(descriptor, fingerprint);
             if (current[0]?.ownership === "owned")
                 throw error;
             // The directory was created by this exact activation but never acquired
@@ -96,21 +96,21 @@ export class FileTaskRuntimeIsolation {
         requireCleanupReason(reason);
         const { descriptor, fingerprint } = validatePreparation(preparation);
         const resources = [
-            ...inspectGenerationRoot(descriptor, fingerprint),
+            ...inspectRuntimeRoot(descriptor, fingerprint),
             ...(this.#inspectResources?.(descriptor) ?? [])
         ];
         if (resources.length === 0)
             return;
         planTaskRuntimeCleanup(descriptor, reason, resources);
         // Re-read the sole durable marker immediately before deletion. A missing,
-        // replaced, symlinked, or mismatched generation is never cleanup authority.
-        const current = inspectGenerationRoot(descriptor, fingerprint);
+        // replaced, symlinked, or mismatched runtime is never cleanup authority.
+        const current = inspectRuntimeRoot(descriptor, fingerprint);
         if (current.length !== 1
             || current[0]?.ownership !== "owned"
             || current[0].descriptorFingerprint !== fingerprint) {
             throw new Error("Task runtime resources changed since cleanup preflight.");
         }
-        const root = descriptor.roots.generation;
+        const root = descriptor.roots.runtime;
         const claimed = `${root}.cleanup-${randomBytes(16).toString("hex")}`;
         renameSync(root, claimed);
         try {
@@ -121,7 +121,7 @@ export class FileTaskRuntimeIsolation {
             }
             rmSync(claimed, { recursive: true });
             this.#resourceRegistrar().markPathsDeleted([
-                descriptor.roots.generation,
+                descriptor.roots.runtime,
                 descriptor.roots.data,
                 descriptor.roots.cache,
                 descriptor.roots.temporary
@@ -129,7 +129,7 @@ export class FileTaskRuntimeIsolation {
         }
         catch (error) {
             // Preserve a claimed-but-unverified resource. Restore its exact path only
-            // when no concurrent generation has appeared there; never delete it.
+            // when no concurrent runtime has appeared there; never delete it.
             try {
                 renameSync(claimed, root);
             }
@@ -139,84 +139,14 @@ export class FileTaskRuntimeIsolation {
             throw error;
         }
     }
-    cleanupTaskLaunch(input) {
-        const taskId = requireIdentity(input.taskId, "Task id");
-        const runtimeGenerationId = requireIdentity(input.runtimeGenerationId, "Runtime generation id");
-        requireCleanupReason(input.reason);
-        const taskRoot = taskRuntimeInventoryRoot(this.#runtimeRoot, taskId, this.#pathLayout);
-        let entries;
-        try {
-            const metadata = lstatSync(taskRoot);
-            if (!metadata.isDirectory() || metadata.isSymbolicLink()) {
-                throw new Error("Task runtime Task root is ambiguous.");
-            }
-            entries = readdirSync(taskRoot, { withFileTypes: true });
-        }
-        catch (error) {
-            if (isNodeCode(error, "ENOENT"))
-                return "absent";
-            throw error;
-        }
-        const launchDigest = taskRuntimeLaunchDigest(taskId, runtimeGenerationId, this.#pathLayout);
-        const matches = [];
-        for (const entry of entries) {
-            if (!entry.isDirectory() || entry.isSymbolicLink()) {
-                throw new Error("Task runtime owner inventory is ambiguous.");
-            }
-            const generationRoot = join(taskRoot, entry.name, launchDigest);
-            let metadata;
-            try {
-                metadata = lstatSync(generationRoot);
-            }
-            catch (error) {
-                if (isNodeCode(error, "ENOENT"))
-                    continue;
-                throw new Error("Task runtime generation inventory is ambiguous.", { cause: error });
-            }
-            if (!metadata.isDirectory() || metadata.isSymbolicLink()) {
-                throw new Error("Task runtime generation inventory is ambiguous.");
-            }
-            let marker;
-            try {
-                marker = parseMarker(readFileSync(join(generationRoot, MARKER_FILE), "utf8"));
-            }
-            catch (error) {
-                throw new Error("Task runtime generation is unmarked or invalid.", {
-                    cause: error
-                });
-            }
-            const descriptor = marker.descriptor;
-            const fingerprint = taskRuntimeIsolationFingerprint(descriptor);
-            if (marker.fingerprint !== fingerprint
-                || descriptor.taskId !== taskId
-                || descriptor.generation.runtimeGenerationId !== runtimeGenerationId
-                || descriptor.roots.generation !== generationRoot) {
-                throw new Error("Task runtime generation ownership is mismatched.");
-            }
-            matches.push({
-                descriptor,
-                fingerprint,
-                environment: taskRuntimeIsolationEnvironment(descriptor)
-            });
-        }
-        if (matches.length === 0)
-            return "absent";
-        if (matches.length !== 1) {
-            throw new Error("Task runtime generation ownership is ambiguous.");
-        }
-        this.cleanup(matches[0], input.reason);
-        return "cleaned";
-    }
 }
 export function createTaskRuntimeIsolationDescriptor(input) {
     const workspace = validateManagedWorkspace(input.workspace);
     const owner = taskRuntimeWorkspaceOwner(workspace.owner);
     const taskId = requireIdentity(owner.taskId, "Task id");
-    const runtimeGenerationId = requireIdentity(input.runtimeGenerationId, "Runtime generation id");
-    const generationId = requireIdentity(input.generationId, "Generation id");
     const runtimeRoot = canonicalPath(input.runtimeRoot, "Task runtime root");
     const pathLayout = taskRuntimePathLayout(input.pathLayout);
-    const generation = taskRuntimeGenerationRoot(runtimeRoot, taskId, owner, runtimeGenerationId, pathLayout);
+    const runtime = taskRuntimeWorkspaceRoot(runtimeRoot, taskId, owner, pathLayout);
     const declared = capabilities(input.policy?.declaredExternalCapabilities ?? [], "Declared external capability");
     const requested = capabilities(input.policy?.requestedExternalCapabilities ?? [], "Requested external capability");
     const portPreference = ports(input.policy?.portPreference ?? [], "Port preference");
@@ -227,19 +157,15 @@ export function createTaskRuntimeIsolationDescriptor(input) {
         taskId,
         workspace: Object.freeze({ owner, root: canonicalPath(workspace.root, "Workspace root") }),
         roots: Object.freeze({
-            generation,
-            data: join(generation, "data"),
-            cache: join(generation, "cache"),
-            temporary: join(generation, "tmp")
+            runtime,
+            data: join(runtime, "data"),
+            cache: join(runtime, "cache"),
+            temporary: join(runtime, "tmp")
         }),
-        serviceNamespace: taskRuntimeServiceNamespace(taskId, owner, runtimeGenerationId, generationId),
+        serviceNamespace: taskRuntimeServiceNamespace(taskId, owner, runtime),
         portPreference,
         portAllocations,
         externalCapabilities: Object.freeze({ declared, requested }),
-        generation: Object.freeze({
-            runtimeGenerationId,
-            generationId
-        })
     });
 }
 export function parseTaskRuntimeIsolationDescriptor(serialized) {
@@ -258,7 +184,6 @@ export function parseTaskRuntimeIsolationDescriptor(serialized) {
     }
     const workspace = requireRecord(value.workspace, "Task runtime workspace");
     const roots = requireRecord(value.roots, "Task runtime roots");
-    const generation = requireRecord(value.generation, "Task runtime generation");
     const external = requireRecord(value.externalCapabilities, "Task runtime external capabilities");
     const owner = taskRuntimeWorkspaceOwner(requireRecord(workspace.owner, "Task runtime workspace owner"));
     const descriptor = {
@@ -270,7 +195,7 @@ export function parseTaskRuntimeIsolationDescriptor(serialized) {
             root: canonicalPath(workspace.root, "Workspace root")
         },
         roots: {
-            generation: canonicalPath(roots.generation, "Task runtime generation root"),
+            runtime: canonicalPath(roots.runtime, "Task runtime workspace root"),
             data: canonicalPath(roots.data, "Task runtime data root"),
             cache: canonicalPath(roots.cache, "Task runtime cache root"),
             temporary: canonicalPath(roots.temporary, "Task runtime temporary root")
@@ -282,10 +207,6 @@ export function parseTaskRuntimeIsolationDescriptor(serialized) {
             declared: capabilities(external.declared, "Declared external capability"),
             requested: capabilities(external.requested, "Requested external capability")
         },
-        generation: {
-            runtimeGenerationId: requireIdentity(generation.runtimeGenerationId, "Runtime generation id"),
-            generationId: requireIdentity(generation.generationId, "Generation id")
-        }
     };
     return Object.freeze(descriptor);
 }
@@ -315,22 +236,22 @@ export function assertTaskRuntimeIsolationPreflight(input) {
     }
     const runtimeRoot = canonicalPath(input.runtimeRoot, "Task runtime root");
     const pathLayout = taskRuntimePathLayout(input.pathLayout);
-    const expectedGeneration = taskRuntimeGenerationRoot(runtimeRoot, descriptor.taskId, expectedOwner, descriptor.generation.runtimeGenerationId, pathLayout);
-    if (descriptor.roots.generation !== expectedGeneration
-        || descriptor.roots.data !== join(expectedGeneration, "data")
-        || descriptor.roots.cache !== join(expectedGeneration, "cache")
-        || descriptor.roots.temporary !== join(expectedGeneration, "tmp")) {
-        throw new Error("Task runtime roots do not match the exact Task, owner, and runtime generation identity.");
+    const expectedRuntimeRoot = taskRuntimeWorkspaceRoot(runtimeRoot, descriptor.taskId, expectedOwner, pathLayout);
+    if (descriptor.roots.runtime !== expectedRuntimeRoot
+        || descriptor.roots.data !== join(expectedRuntimeRoot, "data")
+        || descriptor.roots.cache !== join(expectedRuntimeRoot, "cache")
+        || descriptor.roots.temporary !== join(expectedRuntimeRoot, "tmp")) {
+        throw new Error("Task runtime roots do not match the exact Task, owner, and runtime workspace identity.");
     }
-    if (descriptor.serviceNamespace !== taskRuntimeServiceNamespace(descriptor.taskId, expectedOwner, descriptor.generation.runtimeGenerationId, descriptor.generation.generationId)) {
-        throw new Error("Task runtime service namespace does not match its exact Task runtime generation.");
+    if (descriptor.serviceNamespace !== taskRuntimeServiceNamespace(descriptor.taskId, expectedOwner, descriptor.roots.runtime)) {
+        throw new Error("Task runtime service namespace does not match its exact Task runtime workspace.");
     }
-    if (!isWithin(runtimeRoot, descriptor.roots.generation)) {
-        throw new Error("Task runtime generation is outside its runtime root.");
+    if (!isWithin(runtimeRoot, descriptor.roots.runtime)) {
+        throw new Error("Task runtime workspace is outside its runtime root.");
     }
     for (const [name, root] of Object.entries(descriptor.roots)) {
-        if (name !== "generation" && !isWithin(descriptor.roots.generation, root)) {
-            throw new Error(`Task runtime ${name} root is outside its exact generation.`);
+        if (name !== "runtime" && !isWithin(descriptor.roots.runtime, root)) {
+            throw new Error(`Task runtime ${name} root is outside its exact runtime.`);
         }
     }
     const control = normalizeControlBoundary(input.controlPlane);
@@ -394,8 +315,8 @@ export function planTaskRuntimeCleanup(descriptor, reason, resources) {
     }
     return Object.freeze([...ids].sort());
 }
-function inspectGenerationRoot(descriptor, expectedFingerprint) {
-    const root = descriptor.roots.generation;
+function inspectRuntimeRoot(descriptor, expectedFingerprint) {
+    const root = descriptor.roots.runtime;
     let metadata;
     try {
         metadata = lstatSync(root);
@@ -453,7 +374,7 @@ function ensureOwnedDirectories(descriptor) {
         join(descriptor.roots.data, "state"),
         join(descriptor.roots.temporary, "runtime")
     ]) {
-        ensureDirectoryChain(descriptor.roots.generation, path);
+        ensureDirectoryChain(descriptor.roots.runtime, path);
     }
 }
 function ensureDirectoryChain(boundary, target) {
@@ -494,8 +415,8 @@ function validatePreparation(preparation) {
 function taskRuntimeWorkspaceOwner(owner) {
     return owner;
 }
-function taskRuntimeGenerationRoot(runtimeRoot, taskId, owner, runtimeGenerationId, pathLayout = "hierarchical") {
-    return join(taskRuntimeInventoryRoot(runtimeRoot, taskId, pathLayout), taskRuntimeOwnerDigest(taskId, owner, pathLayout), taskRuntimeLaunchDigest(taskId, runtimeGenerationId, pathLayout));
+function taskRuntimeWorkspaceRoot(runtimeRoot, taskId, owner, pathLayout = "hierarchical") {
+    return join(taskRuntimeInventoryRoot(runtimeRoot, taskId, pathLayout), taskRuntimeOwnerDigest(taskId, owner, pathLayout), "runtime");
 }
 function taskRuntimeInventoryRoot(runtimeRoot, taskId, pathLayout) {
     return pathLayout === "compact" ? runtimeRoot : join(runtimeRoot, taskId);
@@ -505,9 +426,6 @@ function taskRuntimeOwnerDigest(taskId, owner, pathLayout) {
         ? digest(JSON.stringify([taskId, owner])).slice(0, 20)
         : digest(JSON.stringify(owner)).slice(0, 24);
 }
-function taskRuntimeLaunchDigest(taskId, runtimeGenerationId, pathLayout) {
-    return digest(JSON.stringify([taskId, runtimeGenerationId])).slice(0, pathLayout === "compact" ? 20 : 24);
-}
 function taskRuntimePathLayout(value) {
     const pathLayout = value ?? "hierarchical";
     if (pathLayout !== "hierarchical" && pathLayout !== "compact") {
@@ -515,12 +433,11 @@ function taskRuntimePathLayout(value) {
     }
     return pathLayout;
 }
-function taskRuntimeServiceNamespace(taskId, owner, runtimeGenerationId, generationId) {
+function taskRuntimeServiceNamespace(taskId, owner, runtimeRoot) {
     return `yui-task-${digest(JSON.stringify([
         taskId,
         owner,
-        runtimeGenerationId,
-        generationId
+        runtimeRoot
     ])).slice(0, 24)}`;
 }
 function normalizeControlBoundary(value) {

package/dist/runtime/tmuxAdapters.js

@@ -3,12 +3,12 @@ import { fileURLToPath } from "node:url";
 import { resolve } from "node:path";
 import { createRuntimeBinding } from "./runtimeBinding.js";
 import { normalizeRuntimeOwner } from "./runtimeOwner.js";
-import { RuntimeGenerationMismatchError, RuntimeHostContentionError, RuntimeHostUnavailableError, promptPushOutcome } from "./ports.js";
+import { RuntimeHostContentionError, RuntimeHostUnavailableError, promptPushOutcome } from "./ports.js";
 import { providerDeliveryFailureFrom } from "./agentError.js";
 import { toRuntimeLaunchFailure } from "./launchDiagnostics.js";
 import { requireSafeIdentity } from "./validation.js";
 import { launchBrokerForHome } from "./launchBroker.js";
-import { AGENT_HOST_CONTROL_PROTOCOL, sendAgentHostLaunchControl, sendAgentHostTurnControl, sendAgentHostSteerControl, waitForAgentHostLaunchAck } from "./agentHost.js";
+import { AGENT_HOST_CONTROL_PROTOCOL, sendAgentHostLaunchControl, sendAgentHostRunControl, sendAgentHostSteerControl, waitForAgentHostLaunchAck } from "./agentHost.js";
 const DEFAULT_INACTIVITY_TIMEOUT_MS = 300_000;
 /**
  * Runtime lifecycle adapter for the current tmux host. The returned hostRef is
@@ -143,8 +143,8 @@ export class TmuxSessionHost {
         const key = hostId;
         const previous = this.#launchTails.get(key) ?? Promise.resolve();
         let release;
-        const turn = new Promise((resolve) => { release = resolve; });
-        const tail = previous.then(() => turn);
+        const run = new Promise((resolve) => { release = resolve; });
+        const tail = previous.then(() => run);
         this.#launchTails.set(key, tail);
         await previous;
         try {
@@ -160,7 +160,7 @@ export class TmuxSessionHost {
         // Validate generated identity before starting an external process.
         const bindingId = requireSafeIdentity(this.#createBindingId(), "Runtime binding id");
         const writableHumanAttached = request.owner.scope === "task"
-            && request.turnId !== undefined
+            && request.runId !== undefined
             && (this.tmux.hasWritableClientAsync !== undefined
                 ? await this.tmux.hasWritableClientAsync(hostId, request.owner.roleName)
                 : this.tmux.hasWritableClient?.(hostId, request.owner.roleName) === true);
@@ -172,9 +172,8 @@ export class TmuxSessionHost {
             agentId: request.agentId,
             adapterId: request.adapterId,
             effective: request.effective,
-            runtimeGenerationId: request.runtimeGenerationId,
             mode: request.mode,
-            ...(request.turnId === undefined ? {} : { turnId: request.turnId }),
+            ...(request.runId === undefined ? {} : { runId: request.runId }),
             ...(request.runtimeIsolation === undefined
                 ? {}
                 : { runtimeIsolation: request.runtimeIsolation }),
@@ -237,8 +236,7 @@ export class TmuxSessionHost {
             ?? (request.mode === "resume" ? request.nativeSessionId : undefined);
         beforeHostStart?.({
             owner: request.owner,
-            runtimeGenerationId: request.runtimeGenerationId,
-            ...(request.turnId === undefined ? {} : { turnId: request.turnId }),
+            ...(request.runId === undefined ? {} : { runId: request.runId }),
             agentId: request.agentId,
             adapterId: request.adapterId,
             effective: request.effective,
@@ -256,8 +254,8 @@ export class TmuxSessionHost {
             || (!interactiveCodex && (yuiHome === undefined
                 || childLifecycle === undefined
                 || planned.launch.providerControl === undefined))) {
-            if (request.owner.scope === "task" && request.turnId !== undefined) {
-                throw new Error("Managed Task Turn is missing its structured Agent Host contract.");
+            if (request.owner.scope === "task" && request.runId !== undefined) {
+                throw new Error("Managed Task AgentRun is missing its structured Agent Host contract.");
             }
             let hostCreated;
             try {
@@ -271,7 +269,6 @@ export class TmuxSessionHost {
             }
             let binding = createRuntimeBinding({
                 id: bindingId,
-                runtimeGenerationId: request.runtimeGenerationId,
                 owner: request.owner,
                 agentId: request.agentId,
                 adapterId: request.adapterId,
@@ -290,7 +287,7 @@ export class TmuxSessionHost {
                 }
                 if (request.mode === "new"
                     && request.owner.scope === "task"
-                    && request.turnId !== undefined
+                    && request.runId !== undefined
                     && this.#waitForNativeSession !== undefined) {
                     binding = createRuntimeBinding({
                         ...binding,
@@ -307,22 +304,27 @@ export class TmuxSessionHost {
         }
         const broker = launchBrokerForHome(yuiHome);
         const sessionManifest = planned.launch.env.YUI_SESSION_MANIFEST;
-        if (request.owner.scope === "task" && request.turnId !== undefined
+        if (request.owner.scope === "task" && request.runId !== undefined
             && sessionManifest === undefined) {
             throw new Error("Managed Task Agent Host launch is missing its Session Manifest.");
         }
         const reservation = broker.reserve(Object.freeze({
             schemaVersion: 2,
-            runtimeGenerationId: request.runtimeGenerationId,
             command: planned.launch.command,
             args: [...planned.launch.args],
             environment: { ...planned.launch.env },
             cwd: planned.role.cwd ?? planned.role.workspace,
+            ...(planned.launch.executionEnvironment === undefined ? {} : {
+                executionEnvironment: structuredClone(planned.launch.executionEnvironment)
+            }),
             childLifecycle,
             startMode: planned.launch.deferProviderStart === true ? "idle" : "provider",
             ...(planned.launch.providerControl === undefined
                 ? {}
-                : { providerControl: planned.launch.providerControl })
+                : { providerControl: planned.launch.providerControl }),
+            ...(planned.launch.interactiveCodexThread === undefined
+                ? {}
+                : { interactiveCodexThread: planned.launch.interactiveCodexThread })
         }));
         const hostLaunch = {
             command: process.execPath,
@@ -330,7 +332,6 @@ export class TmuxSessionHost {
                 fileURLToPath(new URL("../cli.js", import.meta.url)),
                 "internal",
                 "agent-host",
-                reservation.runtimeGenerationId,
                 reservation.ticket
             ],
             env: {
@@ -338,7 +339,6 @@ export class TmuxSessionHost {
                 YUI_SESSION_SCOPE: request.owner.scope,
                 ...(request.owner.scope === "task" ? { YUI_TASK_ID: request.owner.taskId } : {}),
                 YUI_ROLE: request.owner.roleName,
-                YUI_RUNTIME_GENERATION_ID: request.runtimeGenerationId,
                 ...(planned.launch.env.YUI_AGENT_ID === undefined
                     ? {}
                     : { YUI_AGENT_ID: planned.launch.env.YUI_AGENT_ID }),
@@ -354,7 +354,6 @@ export class TmuxSessionHost {
             }
         };
         let hostCreated = false;
-        let providerDispatchObserved = false;
         let providerSnapshot;
         try {
             hostCreated = await ensureRoleWindow(this.tmux, hostId, planned.role, hostLaunch);
@@ -372,8 +371,7 @@ export class TmuxSessionHost {
                     scope: request.owner.scope,
                     ...(request.owner.scope === "task" ? { taskId: request.owner.taskId } : {}),
                     roleName: request.owner.roleName,
-                    runtimeGenerationId: reservation.runtimeGenerationId,
-                    requireTurnAck: false,
+                    requireRunAck: false,
                     ...(interactiveCodex ? { assertHostRunning: assertInteractivePane } : {})
                 });
                 if (interactiveCodex) {
@@ -383,7 +381,6 @@ export class TmuxSessionHost {
                     requireSafeIdentity(providerSnapshot.nativeSessionId, "Codex Thread identity");
                     await assertInteractivePane();
                 }
-                providerDispatchObserved = true;
             }
             if (!hostCreated) {
                 if (interactiveCodex) {
@@ -397,74 +394,32 @@ export class TmuxSessionHost {
                     control: {
                         protocol: AGENT_HOST_CONTROL_PROTOCOL,
                         type: "launch",
-                        runtimeGenerationId: reservation.runtimeGenerationId,
                         ticket: reservation.ticket
                     }
                 });
-                if (controlResult.outcome === "active-other-generation") {
-                    broker.revoke(request.runtimeGenerationId);
+                if (controlResult.outcome === "busy") {
+                    broker.revoke(reservation.ticket);
                     throw new RuntimeHostContentionError("provider-child-active", `The persistent Agent Host for ${request.owner.roleName} still owns another Provider Turn.`);
                 }
-                if (controlResult.outcome === "active-same-generation") {
-                    broker.revoke(request.runtimeGenerationId);
-                }
-                // Identity and readiness are separate facts. Only a genuinely
-                // different generation is a conflict that must fail closed, not
-                // permission to stop the Host; a matching unsettled generation is this
-                // exact activation still coming up, and stopping it would destroy a
-                // healthy Session (and any Turn it is carrying).
-                const observedGeneration = controlResult.snapshot.runtimeGenerationId;
-                if (observedGeneration !== reservation.runtimeGenerationId) {
-                    broker.revoke(request.runtimeGenerationId);
-                    throw new RuntimeGenerationMismatchError(reservation.runtimeGenerationId, observedGeneration, controlResult.snapshot.state, `Agent Host acknowledgement generation mismatch for ${reservation.runtimeGenerationId}; observed=${observedGeneration ?? "none"}; `
-                        + `state=${controlResult.snapshot.state}${describeHostFailure(controlResult)}.`);
-                }
                 if (!["idle", "ready", "busy"].includes(controlResult.snapshot.state)) {
-                    broker.revoke(request.runtimeGenerationId);
+                    broker.revoke(reservation.ticket);
                     if (["starting", "settling", "delivery-unknown"].includes(controlResult.snapshot.state)) {
-                        // The right generation is present but not yet deliverable. This
-                        // is transient backpressure, so leave the Host running and let
-                        // the caller retry rather than terminalizing the Turn.
-                        throw new RuntimeHostContentionError("provider-child-active", `The Agent Host for ${request.owner.roleName} is still ${controlResult.snapshot.state} on this exact generation${describeHostFailure(controlResult)}.`);
+                        // A temporarily unavailable Session preserves the pending input.
+                        throw new RuntimeHostContentionError("provider-child-active", `The Agent Host for ${request.owner.roleName} is still ${controlResult.snapshot.state}${describeHostFailure(controlResult)}.`);
                     }
                     // This launch is unusable. It did not create this Host, so failure
                     // is not authority to clean its resources or unknown execution.
-                    throw new RuntimeHostUnavailableError(reservation.runtimeGenerationId, controlResult.snapshot.state, `Agent Host reached ${controlResult.snapshot.state} for ${reservation.runtimeGenerationId}${describeHostFailure(controlResult)}.`, { cause: controlResult.failure ?? controlResult.snapshot });
+                    throw new RuntimeHostUnavailableError(controlResult.snapshot.state, `Agent Host reached ${controlResult.snapshot.state}${describeHostFailure(controlResult)}.`, { cause: controlResult.failure ?? controlResult.snapshot });
                 }
                 providerSnapshot = controlResult.snapshot;
-                providerDispatchObserved = true;
             }
         }
         catch (error) {
-            broker.revoke(request.runtimeGenerationId);
-            if (hostCreated && !providerDispatchObserved) {
-                try {
-                    await stopExactRole(this.tmux, hostId, request.owner.roleName);
-                }
-                catch (stopError) {
-                    throw new Error(`Managed Provider launch failed and its disposable Agent Host could not be stopped: ${stopError instanceof Error ? stopError.message : String(stopError)}`, { cause: stopError });
-                }
-            }
+            broker.revoke(reservation.ticket);
             throw error;
         }
-        if (providerDispatchObserved
-            // A fresh Host always starts a Provider process. mode=new also starts
-            // one inside a reused Host by replacing (or creating) the native
-            // Conversation. Same-Conversation resume must retain its inherited key.
-            && (hostCreated || request.mode === "new")
-            && request.owner.scope === "task"
-            && planned.launch.env.YUI_JOB_CALLER_KEY !== undefined
-            && this.planner.commitTaskCallerKey !== undefined) {
-            this.planner.commitTaskCallerKey({
-                taskId: request.owner.taskId,
-                roleName: request.owner.roleName,
-                agentId: request.agentId,
-                callerKey: planned.launch.env.YUI_JOB_CALLER_KEY
-            });
-        }
         const binding = createRuntimeBinding({
             id: bindingId,
-            runtimeGenerationId: request.runtimeGenerationId,
             owner: request.owner,
             agentId: request.agentId,
             adapterId: request.adapterId,
@@ -519,12 +474,7 @@ export class TmuxSessionHost {
             return await Promise.race([discovery, monitor]);
         }
         catch (error) {
-            try {
-                await stopExactRole(this.tmux, hostId, request.owner.roleName);
-            }
-            catch {
-                // Preserve the discovery failure; durable cleanup owns later retries.
-            }
+            // Missing discovery is not evidence that the running process is unwanted.
             throw toRuntimeLaunchFailure(error, "native-session-discovery", context);
         }
         finally {
@@ -565,7 +515,7 @@ function describeHostFailure(result) {
     const detail = result.failure?.detail ?? result.snapshot.detail;
     return detail === undefined ? "" : `; detail=${detail}`;
 }
-/** Structured managed-Turn input; tmux remains presentation/liveness only. */
+/** Structured managed-AgentRun input; tmux remains presentation/liveness only. */
 export class AgentHostPromptPushAdapter {
     home;
     constructor(home) {
@@ -579,7 +529,7 @@ export class AgentHostPromptPushAdapter {
             return promptPushOutcome("unavailable");
         }
         try {
-            const result = await sendAgentHostTurnControl({
+            const result = await sendAgentHostRunControl({
                 home: this.home,
                 scope: "task",
                 taskId: ref.hostId,
@@ -587,11 +537,11 @@ export class AgentHostPromptPushAdapter {
                 control: {
                     protocol: AGENT_HOST_CONTROL_PROTOCOL,
                     type: "submit-turn",
-                    runtimeGenerationId: request.binding.runtimeGenerationId,
                     nativeSessionId: request.binding.nativeSessionId,
-                    turnId: request.envelope.source.localId,
+                    ...(request.envelope.source.kind === "notification"
+                        ? {} : { runId: request.envelope.source.localId }),
                     authority: request.binding.providerAuthority,
-                    turn: {
+                    run: {
                         attemptId: request.envelope.id,
                         boundedText: request.envelope.text
                     }
@@ -599,6 +549,8 @@ export class AgentHostPromptPushAdapter {
             });
             // The Host attaches its own structured cause to every non-delivery.
             const failure = result.failure;
+            if (result.outcome === "pending")
+                return promptPushOutcome("pending");
             if (result.snapshot.state === "delivery-unknown") {
                 return promptPushOutcome("delivery-unknown", failure);
             }
@@ -612,7 +564,7 @@ export class AgentHostPromptPushAdapter {
                     : promptPushOutcome("unavailable", failure);
             }
             if (result.snapshot.state === "ready")
-                return promptPushOutcome("delivered");
+                return promptPushOutcome(result.snapshot.inputAcceptance === "provider" ? "delivered" : "pending");
             return result.snapshot.state === "starting" || result.snapshot.state === "settling"
                 ? promptPushOutcome("busy", failure)
                 : promptPushOutcome("unavailable", failure);
@@ -631,20 +583,21 @@ export class AgentHostPromptPushAdapter {
                 control: {
                     protocol: AGENT_HOST_CONTROL_PROTOCOL,
                     type: "steer-turn",
-                    runtimeGenerationId: request.runtimeGenerationId,
                     nativeSessionId: request.nativeSessionId,
                     nativeTurnId: request.nativeTurnId,
                     authority: request.providerAuthority,
-                    turn: {
+                    run: {
                         attemptId: request.envelope.id,
                         boundedText: request.envelope.text
                     }
                 }
             });
+            if (result.outcome === "pending")
+                return promptPushOutcome("pending");
             if (result.outcome === "accepted")
                 return promptPushOutcome("delivered");
             const failure = result.failure;
-            if (result.snapshot.state === "delivery-unknown") {
+            if (failure?.inputDisposition === "unknown" || result.snapshot.state === "delivery-unknown") {
                 return promptPushOutcome("delivery-unknown", failure);
             }
             if (result.snapshot.state === "busy")