@zq-silk/yui 0.14.0 → 0.14.2

package/dist/runtime/taskRuntimeIsolation.js

@@ -141,7 +141,7 @@ export class FileTaskRuntimeIsolation {
     }
     cleanupTaskLaunch(input) {
         const taskId = requireIdentity(input.taskId, "Task id");
-        const launchId = requireIdentity(input.launchId, "Launch id");
+        const runtimeGenerationId = requireIdentity(input.runtimeGenerationId, "Runtime generation id");
         requireCleanupReason(input.reason);
         const taskRoot = taskRuntimeInventoryRoot(this.#runtimeRoot, taskId, this.#pathLayout);
         let entries;
@@ -157,7 +157,7 @@ export class FileTaskRuntimeIsolation {
                 return "absent";
             throw error;
         }
-        const launchDigest = taskRuntimeLaunchDigest(taskId, launchId, this.#pathLayout);
+        const launchDigest = taskRuntimeLaunchDigest(taskId, runtimeGenerationId, this.#pathLayout);
         const matches = [];
         for (const entry of entries) {
             if (!entry.isDirectory() || entry.isSymbolicLink()) {
@@ -181,7 +181,7 @@ export class FileTaskRuntimeIsolation {
                 marker = parseMarker(readFileSync(join(generationRoot, MARKER_FILE), "utf8"));
             }
             catch (error) {
-                throw new Error("Task runtime launch generation is unmarked or invalid.", {
+                throw new Error("Task runtime generation is unmarked or invalid.", {
                     cause: error
                 });
             }
@@ -189,9 +189,9 @@ export class FileTaskRuntimeIsolation {
             const fingerprint = taskRuntimeIsolationFingerprint(descriptor);
             if (marker.fingerprint !== fingerprint
                 || descriptor.taskId !== taskId
-                || descriptor.generation.launchId !== launchId
+                || descriptor.generation.runtimeGenerationId !== runtimeGenerationId
                 || descriptor.roots.generation !== generationRoot) {
-                throw new Error("Task runtime launch generation ownership is mismatched.");
+                throw new Error("Task runtime generation ownership is mismatched.");
             }
             matches.push({
                 descriptor,
@@ -202,7 +202,7 @@ export class FileTaskRuntimeIsolation {
         if (matches.length === 0)
             return "absent";
         if (matches.length !== 1) {
-            throw new Error("Task runtime launch generation ownership is ambiguous.");
+            throw new Error("Task runtime generation ownership is ambiguous.");
         }
         this.cleanup(matches[0], input.reason);
         return "cleaned";
@@ -212,17 +212,17 @@ export function createTaskRuntimeIsolationDescriptor(input) {
     const workspace = validateManagedWorkspace(input.workspace);
     const owner = taskRuntimeWorkspaceOwner(workspace.owner);
     const taskId = requireIdentity(owner.taskId, "Task id");
-    const launchId = requireIdentity(input.launchId, "Launch 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, launchId, pathLayout);
+    const generation = taskRuntimeGenerationRoot(runtimeRoot, taskId, owner, runtimeGenerationId, 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");
     const portAllocations = allocations(input.policy?.portAllocations ?? []);
     return Object.freeze({
-        schemaVersion: 1,
+        schemaVersion: 2,
         kind: "yui-task-runtime-isolation",
         taskId,
         workspace: Object.freeze({ owner, root: canonicalPath(workspace.root, "Workspace root") }),
@@ -232,12 +232,12 @@ export function createTaskRuntimeIsolationDescriptor(input) {
             cache: join(generation, "cache"),
             temporary: join(generation, "tmp")
         }),
-        serviceNamespace: taskRuntimeServiceNamespace(taskId, owner, launchId, generationId),
+        serviceNamespace: taskRuntimeServiceNamespace(taskId, owner, runtimeGenerationId, generationId),
         portPreference,
         portAllocations,
         externalCapabilities: Object.freeze({ declared, requested }),
         generation: Object.freeze({
-            launchId,
+            runtimeGenerationId,
             generationId
         })
     });
@@ -253,7 +253,7 @@ export function parseTaskRuntimeIsolationDescriptor(serialized) {
     if (!isRecord(value) || value.kind !== "yui-task-runtime-isolation") {
         throw new Error(`Expected yui-task-runtime-isolation descriptor; found ${isRecord(value) && typeof value.kind === "string" ? value.kind : "unknown"}.`);
     }
-    if (value.schemaVersion !== 1) {
+    if (value.schemaVersion !== 2) {
         throw new Error("Task runtime isolation descriptor schema version is invalid.");
     }
     const workspace = requireRecord(value.workspace, "Task runtime workspace");
@@ -262,7 +262,7 @@ export function parseTaskRuntimeIsolationDescriptor(serialized) {
     const external = requireRecord(value.externalCapabilities, "Task runtime external capabilities");
     const owner = taskRuntimeWorkspaceOwner(requireRecord(workspace.owner, "Task runtime workspace owner"));
     const descriptor = {
-        schemaVersion: 1,
+        schemaVersion: 2,
         kind: "yui-task-runtime-isolation",
         taskId: requireIdentity(value.taskId, "Task id"),
         workspace: {
@@ -283,7 +283,7 @@ export function parseTaskRuntimeIsolationDescriptor(serialized) {
             requested: capabilities(external.requested, "Requested external capability")
         },
         generation: {
-            launchId: requireIdentity(generation.launchId, "Launch id"),
+            runtimeGenerationId: requireIdentity(generation.runtimeGenerationId, "Runtime generation id"),
             generationId: requireIdentity(generation.generationId, "Generation id")
         }
     };
@@ -315,15 +315,15 @@ 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.launchId, 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 launch identity.");
+        throw new Error("Task runtime roots do not match the exact Task, owner, and runtime generation identity.");
     }
-    if (descriptor.serviceNamespace !== taskRuntimeServiceNamespace(descriptor.taskId, expectedOwner, descriptor.generation.launchId, descriptor.generation.generationId)) {
-        throw new Error("Task runtime service namespace does not match its exact Task launch generation.");
+    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 (!isWithin(runtimeRoot, descriptor.roots.generation)) {
         throw new Error("Task runtime generation is outside its runtime root.");
@@ -494,8 +494,8 @@ function validatePreparation(preparation) {
 function taskRuntimeWorkspaceOwner(owner) {
     return owner;
 }
-function taskRuntimeGenerationRoot(runtimeRoot, taskId, owner, launchId, pathLayout = "hierarchical") {
-    return join(taskRuntimeInventoryRoot(runtimeRoot, taskId, pathLayout), taskRuntimeOwnerDigest(taskId, owner, pathLayout), taskRuntimeLaunchDigest(taskId, launchId, pathLayout));
+function taskRuntimeGenerationRoot(runtimeRoot, taskId, owner, runtimeGenerationId, pathLayout = "hierarchical") {
+    return join(taskRuntimeInventoryRoot(runtimeRoot, taskId, pathLayout), taskRuntimeOwnerDigest(taskId, owner, pathLayout), taskRuntimeLaunchDigest(taskId, runtimeGenerationId, pathLayout));
 }
 function taskRuntimeInventoryRoot(runtimeRoot, taskId, pathLayout) {
     return pathLayout === "compact" ? runtimeRoot : join(runtimeRoot, taskId);
@@ -505,8 +505,8 @@ function taskRuntimeOwnerDigest(taskId, owner, pathLayout) {
         ? digest(JSON.stringify([taskId, owner])).slice(0, 20)
         : digest(JSON.stringify(owner)).slice(0, 24);
 }
-function taskRuntimeLaunchDigest(taskId, launchId, pathLayout) {
-    return digest(JSON.stringify([taskId, launchId])).slice(0, pathLayout === "compact" ? 20 : 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";
@@ -515,11 +515,11 @@ function taskRuntimePathLayout(value) {
     }
     return pathLayout;
 }
-function taskRuntimeServiceNamespace(taskId, owner, launchId, generationId) {
+function taskRuntimeServiceNamespace(taskId, owner, runtimeGenerationId, generationId) {
     return `yui-task-${digest(JSON.stringify([
         taskId,
         owner,
-        launchId,
+        runtimeGenerationId,
         generationId
     ])).slice(0, 24)}`;
 }

package/dist/runtime/tmuxAdapters.js

@@ -3,10 +3,10 @@ import { fileURLToPath } from "node:url";
 import { resolve } from "node:path";
 import { createRuntimeBinding } from "./runtimeBinding.js";
 import { normalizeRuntimeOwner } from "./runtimeOwner.js";
-import { RuntimeHostContentionError } from "./ports.js";
+import { RuntimeGenerationMismatchError, RuntimeHostContentionError } from "./ports.js";
 import { toRuntimeLaunchFailure } from "./launchDiagnostics.js";
 import { requireSafeIdentity } from "./validation.js";
-import { YUI_CONTROL_PLANE_DESCRIPTOR, YUI_TASK_RUNTIME_DESCRIPTOR } from "./exactControlPlane.js";
+import { YUI_CONTROL_PLANE_DESCRIPTOR } from "./exactControlPlane.js";
 import { launchBrokerForHome } from "./launchBroker.js";
 import { AGENT_HOST_CONTROL_PROTOCOL, sendAgentHostLaunchControl, sendAgentHostTurnControl, sendAgentHostSteerControl, waitForAgentHostLaunchAck } from "./agentHost.js";
 const DEFAULT_INACTIVITY_TIMEOUT_MS = 300_000;
@@ -172,7 +172,7 @@ export class TmuxSessionHost {
             agentId: request.agentId,
             adapterId: request.adapterId,
             effective: request.effective,
-            launchId: request.launchId,
+            runtimeGenerationId: request.runtimeGenerationId,
             mode: request.mode,
             ...(request.turnId === undefined ? {} : { turnId: request.turnId }),
             ...(request.runtimeIsolation === undefined
@@ -220,7 +220,7 @@ export class TmuxSessionHost {
             ?? (request.mode === "resume" ? request.nativeSessionId : undefined);
         beforeHostStart?.({
             owner: request.owner,
-            launchId: request.launchId,
+            runtimeGenerationId: request.runtimeGenerationId,
             ...(request.turnId === undefined ? {} : { turnId: request.turnId }),
             agentId: request.agentId,
             adapterId: request.adapterId,
@@ -251,7 +251,7 @@ export class TmuxSessionHost {
             }
             let binding = createRuntimeBinding({
                 id: bindingId,
-                launchId: request.launchId,
+                runtimeGenerationId: request.runtimeGenerationId,
                 owner: request.owner,
                 agentId: request.agentId,
                 adapterId: request.adapterId,
@@ -285,16 +285,14 @@ export class TmuxSessionHost {
         const broker = launchBrokerForHome(yuiHome);
         const sessionManifest = planned.launch.env.YUI_SESSION_MANIFEST;
         const frozenControlPlane = planned.launch.env[YUI_CONTROL_PLANE_DESCRIPTOR];
-        const frozenTaskRuntime = planned.launch.env[YUI_TASK_RUNTIME_DESCRIPTOR];
         if (request.owner.scope === "task" && request.turnId !== undefined
             && (sessionManifest === undefined
-                || frozenControlPlane === undefined
-                || frozenTaskRuntime === undefined)) {
-            throw new Error("Managed Task Agent Host launch is missing its Session Manifest or frozen control descriptors.");
+                || frozenControlPlane === undefined)) {
+            throw new Error("Managed Task Agent Host launch is missing its Session Manifest or frozen control descriptor.");
         }
         const reservation = broker.reserve(Object.freeze({
-            schemaVersion: 1,
-            launchId: request.launchId,
+            schemaVersion: 2,
+            runtimeGenerationId: request.runtimeGenerationId,
             command: planned.launch.command,
             args: [...planned.launch.args],
             environment: { ...planned.launch.env },
@@ -311,7 +309,7 @@ export class TmuxSessionHost {
                 fileURLToPath(new URL("../cli.js", import.meta.url)),
                 "internal",
                 "agent-host",
-                reservation.launchId,
+                reservation.runtimeGenerationId,
                 reservation.ticket
             ],
             env: {
@@ -319,7 +317,7 @@ 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_LAUNCH_ID: request.launchId,
+                YUI_RUNTIME_GENERATION_ID: request.runtimeGenerationId,
                 ...(planned.launch.env.YUI_AGENT_ID === undefined
                     ? {}
                     : { YUI_AGENT_ID: planned.launch.env.YUI_AGENT_ID }),
@@ -334,10 +332,7 @@ export class TmuxSessionHost {
                     : { YUI_SESSION_MANIFEST: sessionManifest }),
                 ...(frozenControlPlane === undefined
                     ? {}
-                    : { [YUI_CONTROL_PLANE_DESCRIPTOR]: frozenControlPlane }),
-                ...(frozenTaskRuntime === undefined
-                    ? {}
-                    : { [YUI_TASK_RUNTIME_DESCRIPTOR]: frozenTaskRuntime })
+                    : { [YUI_CONTROL_PLANE_DESCRIPTOR]: frozenControlPlane })
             }
         };
         let hostCreated = false;
@@ -351,7 +346,7 @@ export class TmuxSessionHost {
                     scope: request.owner.scope,
                     ...(request.owner.scope === "task" ? { taskId: request.owner.taskId } : {}),
                     roleName: request.owner.roleName,
-                    launchId: reservation.launchId,
+                    runtimeGenerationId: reservation.runtimeGenerationId,
                     requireTurnAck: false
                 });
                 providerDispatchObserved = true;
@@ -365,29 +360,36 @@ export class TmuxSessionHost {
                     control: {
                         protocol: AGENT_HOST_CONTROL_PROTOCOL,
                         type: "launch",
-                        launchId: reservation.launchId,
+                        runtimeGenerationId: reservation.runtimeGenerationId,
                         ticket: reservation.ticket
                     }
                 });
-                if (controlResult.outcome === "active-other-launch") {
-                    broker.revoke(request.launchId);
+                if (controlResult.outcome === "active-other-generation") {
+                    broker.revoke(request.runtimeGenerationId);
                     throw new RuntimeHostContentionError("provider-child-active", `The persistent Agent Host for ${request.owner.roleName} still owns another Provider Turn.`);
                 }
-                if (controlResult.outcome === "active-same-launch") {
-                    broker.revoke(request.launchId);
+                if (controlResult.outcome === "active-same-generation") {
+                    broker.revoke(request.runtimeGenerationId);
                 }
                 const acceptableState = ["idle", "ready", "busy"].includes(controlResult.snapshot.state);
                 if (!acceptableState
-                    || controlResult.snapshot.launchId !== reservation.launchId) {
-                    broker.revoke(request.launchId);
-                    throw new Error(`Agent Host did not return an exact Provider acknowledgement for ${reservation.launchId}.`);
+                    || controlResult.snapshot.runtimeGenerationId !== reservation.runtimeGenerationId) {
+                    broker.revoke(request.runtimeGenerationId);
+                    try {
+                        await stopExactRole(this.tmux, hostId, request.owner.roleName);
+                    }
+                    catch {
+                        // The coordinator will enqueue durable owner cleanup.
+                    }
+                    throw new RuntimeGenerationMismatchError(reservation.runtimeGenerationId, controlResult.snapshot.runtimeGenerationId, controlResult.snapshot.state, `Agent Host acknowledgement generation mismatch for ${reservation.runtimeGenerationId}; observed=${controlResult.snapshot.runtimeGenerationId ?? "none"}; `
+                        + `state=${controlResult.snapshot.state}.`);
                 }
                 providerSnapshot = controlResult.snapshot;
                 providerDispatchObserved = true;
             }
         }
         catch (error) {
-            broker.revoke(request.launchId);
+            broker.revoke(request.runtimeGenerationId);
             if (hostCreated && !providerDispatchObserved) {
                 try {
                     await stopExactRole(this.tmux, hostId, request.owner.roleName);
@@ -415,7 +417,7 @@ export class TmuxSessionHost {
         }
         const binding = createRuntimeBinding({
             id: bindingId,
-            launchId: request.launchId,
+            runtimeGenerationId: request.runtimeGenerationId,
             owner: request.owner,
             agentId: request.agentId,
             adapterId: request.adapterId,
@@ -529,7 +531,7 @@ export class AgentHostPromptPushAdapter {
                 control: {
                     protocol: AGENT_HOST_CONTROL_PROTOCOL,
                     type: "submit-turn",
-                    launchId: request.binding.launchId,
+                    runtimeGenerationId: request.binding.runtimeGenerationId,
                     nativeSessionId: request.binding.nativeSessionId,
                     turnId: request.envelope.source.localId,
                     authority: request.binding.providerAuthority,
@@ -573,7 +575,7 @@ export class AgentHostPromptPushAdapter {
                 control: {
                     protocol: AGENT_HOST_CONTROL_PROTOCOL,
                     type: "steer-turn",
-                    launchId: request.launchId,
+                    runtimeGenerationId: request.runtimeGenerationId,
                     nativeSessionId: request.nativeSessionId,
                     nativeTurnId: request.nativeTurnId,
                     authority: request.providerAuthority,

package/dist/scheduler/activeRoleTurnDelivery.js

@@ -7,6 +7,7 @@ import { RuntimeLaunchFailure } from "../runtime/launchDiagnostics.js";
 import { RuntimeLaunchError } from "../runtime/ports.js";
 import { formatTurnReceiptId } from "../task/taskRecordReference.js";
 import { turnInputEnvelope } from "../turn/turn.js";
+import { captureRoleTurnDispatch } from "../coordination/workMailboxQueue.js";
 import { isSchedulerTaskWorkspaceReady, selectedActiveSchedulerTasks, selectedSchedulerRoles } from "./ports.js";
 /**
  * Sole managed Provider write path. A Turn is durable workflow intent;
@@ -31,6 +32,15 @@ async function deliverActiveTurn(store, delivery, task, role, turn, now) {
     if (!isSchedulerTaskWorkspaceReady(task, store.getTaskWorkspace(task.id))) {
         return { ...base, status: "skipped", reason: "workspace-not-ready" };
     }
+    const dispatchToken = captureRoleTurnDispatch(store.getWorkMailbox({
+        kind: "role",
+        taskId: task.id,
+        roleName: role.name
+    }), {
+        taskId: task.id,
+        roleName: role.name,
+        turnId: turn.id
+    });
     const sessionSet = store.getTaskRoleSessionSet?.(task.id, role.name) ?? null;
     const binding = sessionSet?.providerBinding ?? null;
     const observedTurn = binding?.turn ?? null;
@@ -40,8 +50,11 @@ async function deliverActiveTurn(store, delivery, task, role, turn, now) {
         || binding?.authority.owner === "unknown") {
         return { ...base, status: "skipped", reason: "writer-attached" };
     }
-    if (currentProviderTurn !== null
-        && ["submitting", "accepted"].includes(currentProviderTurn.status)) {
+    if (currentProviderTurn?.status === "accepted") {
+        settleAcceptedRoleTurnDispatch(store, turn, dispatchToken);
+        return { ...base, status: "skipped", reason: "not-ready" };
+    }
+    if (currentProviderTurn?.status === "submitting") {
         return { ...base, status: "skipped", reason: "not-ready" };
     }
     if (currentProviderTurn?.status === "delivery-unknown") {
@@ -72,9 +85,9 @@ async function deliverActiveTurn(store, delivery, task, role, turn, now) {
             mode,
             turnId: turn.id,
             ...(nativeSessionId === undefined ? {} : { nativeSessionId }),
-            ...(mode !== "resume" || existingSession?.launchId === undefined
+            ...(mode !== "resume" || existingSession?.runtimeGenerationId === undefined
                 ? {}
-                : { hostActivationId: existingSession.launchId }),
+                : { hostActivationId: existingSession.runtimeGenerationId }),
             beforeHostStart: (preflight) => persistPreStartSession(store, task, role, turn, existingSession, mode, preflight, now)
         });
         const preparedSession = prepared.session === undefined
@@ -85,7 +98,7 @@ async function deliverActiveTurn(store, delivery, task, role, turn, now) {
             role,
             turn,
             session: preparedSession,
-            ...(prepared.launchId === undefined ? {} : { launchId: prepared.launchId }),
+            ...(prepared.runtimeGenerationId === undefined ? {} : { runtimeGenerationId: prepared.runtimeGenerationId }),
             now
         });
         const ready = await delivery.waitUntilReady(prepared);
@@ -95,7 +108,7 @@ async function deliverActiveTurn(store, delivery, task, role, turn, now) {
             role,
             turn,
             session: readySession,
-            ...(ready.prepared.launchId === undefined ? {} : { launchId: ready.prepared.launchId }),
+            ...(ready.prepared.runtimeGenerationId === undefined ? {} : { runtimeGenerationId: ready.prepared.runtimeGenerationId }),
             now
         });
         submitted = true;
@@ -105,7 +118,7 @@ async function deliverActiveTurn(store, delivery, task, role, turn, now) {
             text: serializeTurnInputEnvelope(turnInputEnvelope(turn))
         });
         if (outcome === "busy" || outcome === "unavailable") {
-            forget(delivery, task.id, role.name, turn.id, ready.prepared.launchId);
+            forget(delivery, task.id, role.name, turn.id, ready.prepared.runtimeGenerationId);
             return {
                 ...base,
                 status: "skipped",
@@ -113,12 +126,13 @@ async function deliverActiveTurn(store, delivery, task, role, turn, now) {
             };
         }
         if (outcome === "rejected" || outcome === "delivery-unknown") {
-            forget(delivery, task.id, role.name, turn.id, ready.prepared.launchId);
+            forget(delivery, task.id, role.name, turn.id, ready.prepared.runtimeGenerationId);
             return failTurnDelivery(store, turn, now, outcome === "delivery-unknown" ? "delivery-unknown" : "runtime-failed", outcome === "delivery-unknown"
                 ? "Provider Turn delivery is ambiguous; Yui will not replay it automatically."
                 : "Provider rejected the managed Turn.");
         }
-        forget(delivery, task.id, role.name, turn.id, ready.prepared.launchId);
+        forget(delivery, task.id, role.name, turn.id, ready.prepared.runtimeGenerationId);
+        settleAcceptedRoleTurnDispatch(store, turn, dispatchToken);
         return {
             ...base,
             status: outcome === "sent" ? "delivered" : "already-delivered"
@@ -147,7 +161,7 @@ async function deliverActiveTurn(store, delivery, task, role, turn, now) {
                 error: message
             };
         }
-        forget(delivery, task.id, role.name, turn.id, prepared?.launchId);
+        forget(delivery, task.id, role.name, turn.id, prepared?.runtimeGenerationId);
         return failTurnDelivery(store, turn, now, submitted ? "delivery-unknown" : "startup-failed", message);
     }
 }
@@ -172,19 +186,27 @@ function failTurnDelivery(store, turn, now, failureReason, summary) {
         ...(disposition === "failed" ? { terminalized: true } : {})
     };
 }
+function settleAcceptedRoleTurnDispatch(store, turn, expected) {
+    store.settleRoleTurnDispatch({
+        taskId: turn.taskId,
+        roleName: turn.roleName,
+        turnId: turn.id,
+        ...(expected === undefined ? {} : { expected })
+    });
+}
 function persistPreStartSession(store, task, role, turn, existing, mode, preflight, now) {
     if (preflight.owner.scope !== "task"
         || preflight.owner.taskId !== task.id
         || preflight.owner.roleName !== role.name
         || preflight.turnId !== turn.id
-        || preflight.launchId.trim().length === 0) {
+        || preflight.runtimeGenerationId.trim().length === 0) {
         throw new Error(`Pre-start launch fence changed the active Role Turn: ${task.id}/${role.name}.`);
     }
     const session = preflight.nativeSessionId === undefined ? null : {
         agentId: preflight.agentId,
         adapterId: preflight.adapterId,
         nativeSessionId: preflight.nativeSessionId,
-        launchId: preflight.launchId,
+        runtimeGenerationId: preflight.runtimeGenerationId,
         ...(preflight.sessionTitle === undefined ? {} : { title: preflight.sessionTitle }),
         status: "active",
         effective: preflight.effective
@@ -194,7 +216,7 @@ function persistPreStartSession(store, task, role, turn, existing, mode, preflig
         role,
         turn,
         session: validateRoleSession(role, turn, existing, mode, session),
-        launchId: preflight.launchId,
+        runtimeGenerationId: preflight.runtimeGenerationId,
         now
     });
 }
@@ -232,12 +254,12 @@ function requireResumeSession(role, turn, session) {
     }
     return session.nativeSessionId;
 }
-function forget(delivery, taskId, roleName, turnId, launchId) {
+function forget(delivery, taskId, roleName, turnId, runtimeGenerationId) {
     delivery.forgetPrepared?.({
         taskId,
         roleName,
         turnId,
-        ...(launchId === undefined ? {} : { launchId })
+        ...(runtimeGenerationId === undefined ? {} : { runtimeGenerationId })
     });
 }
 function hasText(value) {

package/dist/scheduler/leaderWakeupProcessor.js

@@ -81,15 +81,18 @@ export async function processLeaderWakeups(store, delivery, now, selection) {
                         : "new"
                     : roleAgentSessionResumeMode(sessionSet, role.effective.agentId, role.effective);
             const turnId = store.peekNextTurnId(task.id);
+            const envelope = store.getTaskWakeEnvelope?.(task.id) ?? null;
             const contextSnapshot = store.freezeLeaderContextSnapshot?.(task.id, role.name, now);
             const input = createTurnInput({
                 source: leaderWakeInputSource(wakeup.reasons),
                 directive: [
                     `Wake reasons: ${wakeup.reasons.join(", ")}.`,
+                    ...(envelope === null ? [] : [envelope.text.trim()]),
                     `Load exact context for ${task.id}/${turnId}.`,
+                    "Read every referenced completed Worker or Reviewer Turn in full before deciding its disposition.",
                     "Before ending this Turn, judge the affected WorkItems and Task; persist any lifecycle or result changes you establish.",
                     "The final Turn response is evidence only and never updates WorkItem or Task state by itself."
-                ].join(" "),
+                ].join("\n"),
                 ...(contextSnapshot === undefined ? {} : { contextSnapshotRef: contextSnapshot.ref }),
                 deltaRefIds: contextSnapshot?.deltaRefIds ?? []
             });
@@ -97,7 +100,6 @@ export async function processLeaderWakeups(store, delivery, now, selection) {
                 ...(role.managedWorkspace === undefined ? {} : { workspace: role.managedWorkspace }),
                 effective: role.effective
             });
-            const envelope = store.getTaskWakeEnvelope?.(task.id) ?? null;
             const claim = store.saveLeaderDispatch({
                 task,
                 role,
@@ -155,65 +157,86 @@ async function forceLeaderSteer(store, delivery, taskId, roleName, active, now)
     if (processing.batchId !== batchId || processing.owner !== owner) {
         return { taskId, turnId: active.id, status: "skipped", reason: "busy" };
     }
-    const sessions = store.getTaskRoleSessionSet?.(taskId, roleName) ?? null;
-    const session = sessions?.sessions[active.effective.agentId];
-    const binding = sessions?.providerBinding;
-    const providerTurn = binding?.turn;
-    const authority = binding?.authority;
-    if (session?.launchId === undefined || session.nativeSessionId === undefined
-        || providerTurn === null || providerTurn === undefined
-        || providerTurn.turnId !== active.id || providerTurn.nativeTurnId === undefined
-        || providerTurn.status !== "accepted"
-        || authority?.owner !== "controller" || authority.holderId === undefined) {
-        store.releaseWorkMailbox(target, batchId);
-        return { taskId, status: "failed", reason: "not-ready", error: "Active Leader Turn has no steerable Provider fence." };
-    }
-    const batch = processing.batch;
-    const directive = [
-        `Aggregated Leader events: ${batch.reasons.join(", ")}.`,
-        `The first event arrived at ${batch.firstQueuedAt} and has waited at least 10 minutes while this Leader Turn remained active.`,
-        "Process these events now and update durable Task or WorkItem facts when needed.",
-        "After the events are handled, continue the work you were doing before this interruption.",
-        `Load the current exact context for ${taskId}/${active.id}; the event batch may have grown while this input was delivered.`
-    ].join(" ");
-    const input = createTurnInput({
-        source: { type: "yui", channel: "leader-forced-wakeup" },
-        directive,
-        deltaRefIds: []
-    });
-    const outcome = await delivery.steerOnce({
-        taskId,
-        roleName,
-        agentId: active.effective.agentId,
-        adapterId: active.effective.adapterId,
-        launchId: session.launchId,
-        nativeSessionId: session.nativeSessionId,
-        nativeTurnId: providerTurn.nativeTurnId,
-        authority: {
-            epoch: authority.epoch,
-            owner: "controller",
-            holderId: authority.holderId
-        },
-        receiptId: `turn-input:${taskId}/${active.id}/${batchId}`,
-        text: directive
-    });
-    if (outcome !== "sent" && outcome !== "already-sent") {
-        if (outcome !== "delivery-unknown")
+    try {
+        const sessions = store.getTaskRoleSessionSet?.(taskId, roleName) ?? null;
+        const session = sessions?.sessions[active.effective.agentId];
+        const binding = sessions?.providerBinding;
+        const providerTurn = binding?.turn;
+        const authority = binding?.authority;
+        if (session?.runtimeGenerationId === undefined || session.nativeSessionId === undefined
+            || providerTurn === null || providerTurn === undefined
+            || providerTurn.turnId !== active.id || providerTurn.nativeTurnId === undefined
+            || providerTurn.status !== "accepted"
+            || authority?.owner !== "controller" || authority.holderId === undefined) {
             store.releaseWorkMailbox(target, batchId);
+            return { taskId, status: "failed", reason: "not-ready", error: "Active Leader Turn has no steerable Provider fence." };
+        }
+        const batch = processing.batch;
+        const envelope = store.getTaskWakeEnvelope?.(taskId) ?? null;
+        const referencedTurnIds = envelope?.referencedTurnIds ?? [];
+        const displayedTurnIds = referencedTurnIds.slice(0, 4);
+        const directive = [
+            `Aggregated Leader events: ${batch.reasons.join(", ")}.`,
+            `The first event arrived at ${batch.firstQueuedAt} and has waited at least 10 minutes while this Leader Turn remained active.`,
+            ...displayedTurnIds.map((turnId) => `Read the complete result: yui task turn show ${taskId}/${turnId}.`),
+            ...(referencedTurnIds.length > displayedTurnIds.length
+                ? [
+                    `${referencedTurnIds.length - displayedTurnIds.length} additional result Turns are listed in yui task wake show ${taskId} ${envelope.wakeId}.`
+                ]
+                : []),
+            "Process these events now and update durable Task or WorkItem facts when needed.",
+            "After the events are handled, continue the work you were doing before this interruption.",
+            `Load the current exact context for ${taskId}/${active.id}; the event batch may have grown while this input was delivered.`
+        ].join("\n");
+        const input = createTurnInput({
+            source: { type: "yui", channel: "leader-forced-wakeup" },
+            directive,
+            deltaRefIds: []
+        });
+        const outcome = await delivery.steerOnce({
+            taskId,
+            roleName,
+            agentId: active.effective.agentId,
+            adapterId: active.effective.adapterId,
+            runtimeGenerationId: session.runtimeGenerationId,
+            nativeSessionId: session.nativeSessionId,
+            nativeTurnId: providerTurn.nativeTurnId,
+            authority: {
+                epoch: authority.epoch,
+                owner: "controller",
+                holderId: authority.holderId
+            },
+            receiptId: `turn-input:${taskId}/${active.id}/${batchId}`,
+            text: directive
+        });
+        if (outcome !== "sent" && outcome !== "already-sent") {
+            if (outcome !== "delivery-unknown")
+                store.releaseWorkMailbox(target, batchId);
+            return {
+                taskId,
+                turnId: active.id,
+                status: outcome === "busy" ? "skipped" : "failed",
+                reason: outcome === "busy" ? "busy" : "not-ready",
+                error: outcome
+            };
+        }
+        const saved = store.saveLeaderSteer({ taskId, turnId: active.id, batchId, input, now });
+        if (saved !== "claimed")
+            store.releaseWorkMailbox(target, batchId);
+        return saved === "claimed"
+            ? { taskId, turnId: active.id, status: "steered" }
+            : { taskId, turnId: active.id, status: "skipped", reason: saved };
+    }
+    catch (error) {
+        store.releaseWorkMailbox(target, batchId);
         return {
             taskId,
             turnId: active.id,
-            status: outcome === "busy" ? "skipped" : "failed",
-            reason: outcome === "busy" ? "busy" : "not-ready",
-            error: outcome
+            status: "failed",
+            reason: "not-ready",
+            error: error instanceof Error ? error.message : String(error)
         };
     }
-    const saved = store.saveLeaderSteer({ taskId, turnId: active.id, batchId, input, now });
-    if (saved !== "claimed")
-        store.releaseWorkMailbox(target, batchId);
-    return saved === "claimed"
-        ? { taskId, turnId: active.id, status: "steered" }
-        : { taskId, turnId: active.id, status: "skipped", reason: saved };
 }
 function hasNativeSession(session) {
     return session !== null