@zq-silk/yui 0.15.7 → 0.15.9

package/dist/controller/controller.js

@@ -1,10 +1,10 @@
 import { reconciliationIntervalMilliseconds } from "../config/yuiConfig.js";
-import { LEADER_WAKE_AGGREGATION_MS, LEADER_WAKE_FORCE_MS, processLeaderWakeups } from "../scheduler/leaderWakeupProcessor.js";
+import { LEADER_WAKE_AGGREGATION_MS, processLeaderWakeups } from "../scheduler/leaderWakeupProcessor.js";
 import { pendingWakeupsMatch } from "../scheduler/pendingWakeup.js";
-import { processActiveRoleTurnDeliveries } from "../scheduler/activeRoleTurnDelivery.js";
+import { processActiveRoleRunDeliveries } from "../scheduler/activeRoleRunDelivery.js";
 import { selectedActiveSchedulerTasks } from "../scheduler/ports.js";
-import { reconcileExitedRoleTurns } from "../scheduler/roleTurnLiveness.js";
-import { DEFAULT_STALL_WINDOW_MS, DEFAULT_WORKFLOW_STALL_CANDIDATE_AGE_MS, reconcileStalledRoleTurns } from "../scheduler/roleTurnStall.js";
+import { reconcileExitedRoleRuns } from "../scheduler/roleRunLiveness.js";
+import { DEFAULT_STALL_WINDOW_MS, DEFAULT_WORKFLOW_STALL_CANDIDATE_AGE_MS, reconcileStalledRoleRuns } from "../scheduler/roleRunStall.js";
 import { processOperatorInputNotifications } from "../scheduler/operatorInputNotificationProcessor.js";
 import { startControllerServer } from "../core/controllerServer.js";
 import { monotonicMilliseconds } from "../core/controllerTelemetry.js";
@@ -14,8 +14,9 @@ import { KeyedWorkQueue } from "../coordination/keyedWorkQueue.js";
 import { MailboxScheduler } from "../coordination/mailboxScheduler.js";
 import { nearestDeadlineBatch } from "../coordination/deadlineScheduler.js";
 import { mailboxHasWork, nextPendingBatch } from "../coordination/workMailbox.js";
-import { hasRuntimeCleanupObligation, isRuntimeLaunchReservation } from "../runtime/lifecycleReservation.js";
+import { hasRuntimeCleanupObligation } from "../runtime/lifecycleReservation.js";
 import { formatTaskRecordReference } from "../task/taskRecordReference.js";
+import { activationRequestIsControllerAdoptable } from "../task/taskActivation.js";
 import { parseDurableJobAcknowledgeParams, parseDurableJobCancelParams, parseDurableJobRefParams, parseDurableJobStartParams } from "./jobControl.js";
 const DEFAULT_RECONCILIATION_INTERVAL_MS = reconciliationIntervalMilliseconds();
 const DEFAULT_SIGNAL_WINDOW_MS = 100;
@@ -26,7 +27,6 @@ const DEFAULT_DELIVERY_TIMEOUT_MS = 120_000;
 const DEFAULT_TASK_ORCHESTRATION_RETRY_LIMIT = 2;
 const DEFAULT_TASK_CONCURRENCY = 4;
 const MAX_TASK_CONCURRENCY = 32;
-const RUNTIME_RESERVATION_RECOVERY_AGE_MS = 120_000;
 const MAX_TIMER_DELAY_MS = 2_147_483_647;
 const CONTROLLER_LATENCY_BUCKETS_MS = [10, 50, 100, 250, 500, 1_000, 3_000];
 class RuntimeEventApplyError extends AggregateError {
@@ -45,7 +45,7 @@ const ZERO_DRAIN_METRICS = Object.freeze({
  * Runs one lean scheduler pass. Due native Turn completions are folded before
  * liveness, so a valid Hook boundary fences destructive process reconciliation.
  */
-export async function runControllerSchedulerPass(store, delivery, now, workspacePreparer, scope = { kind: "full" }, includeOperator = true, runtimeCleanupOutcomes = [], lifecycleHost, stallWindowMs = DEFAULT_STALL_WINDOW_MS, maintenanceFence, onMaintenanceFenceDefer, blockedTaskIds = new Set(), diagnosticAfterMs = DEFAULT_WORKFLOW_STALL_CANDIDATE_AGE_MS, leaderWakeFence) {
+export async function runControllerSchedulerPass(store, delivery, now, workspacePreparer, scope = { kind: "full" }, includeOperator = true, runtimeCleanupOutcomes = [], lifecycleHost, stallWindowMs = DEFAULT_STALL_WINDOW_MS, maintenanceFence, onMaintenanceFenceDefer, blockedTaskIds = new Set(), diagnosticAfterMs = DEFAULT_WORKFLOW_STALL_CANDIDATE_AGE_MS, leaderWakeFence, onError) {
     const compiledSelection = compileReconcileSelection(scope);
     const selection = includeOperator
         ? { ...compiledSelection, blockedTaskIds }
@@ -54,12 +54,7 @@ export async function runControllerSchedulerPass(store, delivery, now, workspace
     // control sockets when several scheduler phases repeat it in one native
     // event-loop turn. Give already-written requests a poll boundary before the
     // next durable phase; later phases retain their existing CAS fences.
-    await controlEventLoopTurn();
-    // A dormant Session may still name a Host that disappeared after its last
-    // Provider Turn. Detach that disposable Host before claiming the next Turn,
-    // so retained Agent intent restores the same Session instead of first
-    // connecting to a known-dead control socket.
-    await reconcileDormantRuntimeOwners(store, delivery, lifecycleHost, scope, now, blockedTaskIds);
+    await controlEventLoopRun();
     const failedCleanupRoles = await processSelectedRoleRuntimeCleanups(store, delivery, lifecycleHost, scope, now, runtimeCleanupOutcomes, blockedTaskIds);
     const roleSelection = selectionWithoutFailedCleanupRoles(store, selection, failedCleanupRoles);
     const availableWakeupSelection = () => (leaderWakeFence?.() === true
@@ -74,13 +69,18 @@ export async function runControllerSchedulerPass(store, delivery, now, workspace
         const initialWakeupResults = await processLeaderWakeups(store, delivery, now, exactTaskSelection(new Set(initialWakeups.keys())));
         // Preserve ready-Leader-first ordering, then bound the repeated state
         // projections that follow it in this pass.
-        await controlEventLoopTurn();
+        await controlEventLoopRun();
+        // A Task whose deferred activation was just released must become active
+        // before the workspace phase, so its first workspace preparation happens in
+        // this same pass rather than waiting for the next one.
+        await adoptReleasedTaskActivations(store, workspacePreparer, selection, onError);
+        await controlEventLoopRun();
         const workspacePreparation = await prepareActiveWorkspaces(store, workspacePreparer, selection, maintenanceFence, onMaintenanceFenceDefer);
-        await controlEventLoopTurn();
-        const activeTurnDeliveries = await processActiveRoleTurnDeliveries(store, delivery, now, roleSelection);
-        await controlEventLoopTurn();
-        const unsettledTurnRefs = new Set(activeTurnDeliveries.flatMap((result) => (result.reason === "delivery-uncertain"
-            ? [formatTaskRecordReference(result.taskId, result.turnId, "turn")]
+        await controlEventLoopRun();
+        const activeRunDeliveries = await processActiveRoleRunDeliveries(store, delivery, now, roleSelection);
+        await controlEventLoopRun();
+        const unsettledRunRefs = new Set(activeRunDeliveries.flatMap((result) => (result.reason === "delivery-uncertain"
+            ? [formatTaskRecordReference(result.taskId, result.runId, "run")]
             : [])));
         // Every successful Task has completed the targeted phases owned by its
         // mailbox at this boundary. Settle that exact claim before advisory
@@ -92,28 +92,27 @@ export async function runControllerSchedulerPass(store, delivery, now, workspace
             }
         }
         const newlyIdleBusyTaskIds = new Set(initialWakeupResults.flatMap((result) => (result.reason === "busy"
-            && store.getActiveTurn(result.taskId, "leader") === null
+            && store.getActiveRun(result.taskId, "leader") === null
             ? [result.taskId]
             : [])));
-        // Phase-one Leader Turns did not exist at the pass's liveness boundary.
-        // Keep every newly claimed Turn outside destructive absence decisions until
-        // a later pass can observe its stable provider/runtime generation.
+        // Phase-one Leader AgentRuns did not exist at the pass's liveness boundary.
+        // Keep every newly claimed AgentRun outside destructive absence decisions until
+        // a later pass can observe its stable provider/runtime.
         for (const result of initialWakeupResults) {
-            if (result.turnId !== undefined
-                && store.getActiveTurn(result.taskId, "leader")?.id === result.turnId) {
-                unsettledTurnRefs.add(formatTaskRecordReference(result.taskId, result.turnId, "turn"));
+            if (result.runId !== undefined
+                && store.getActiveRun(result.taskId, "leader")?.id === result.runId) {
+                unsettledRunRefs.add(formatTaskRecordReference(result.taskId, result.runId, "run"));
             }
         }
         // Let socket callbacks queued during the bounded scheduler phases run
         // before starting a potentially large liveness inventory.
-        await controlEventLoopTurn();
+        await controlEventLoopRun();
         const liveStatuses = new Map();
         const resourceEvidence = new Map();
-        const failedTurnRefs = await reconcileExitedRoleTurns(store, delivery, now, roleSelection, unsettledTurnRefs, liveStatuses, resourceEvidence, scope.kind === "dirty");
-        await controlEventLoopTurn();
-        await reconcileStalledRoleTurns(store, delivery, now, roleSelection, stallWindowMs, liveStatuses, resourceEvidence, diagnosticAfterMs);
-        await controlEventLoopTurn();
-        await reconcileDormantRuntimeOwners(store, delivery, lifecycleHost, scope, now, selection.blockedTaskIds);
+        const failedRunRefs = await reconcileExitedRoleRuns(store, delivery, now, roleSelection, unsettledRunRefs, liveStatuses, resourceEvidence, scope.kind === "dirty");
+        await controlEventLoopRun();
+        await reconcileStalledRoleRuns(store, delivery, now, roleSelection, stallWindowMs, liveStatuses, resourceEvidence, diagnosticAfterMs);
+        await controlEventLoopRun();
         const selectedInputTaskIds = selectedTaskIdsForBoundedPass(store, selection);
         const autoResolvedInputs = selectedInputTaskIds === undefined
             ? store.resolveExpiredInputRecommendations(now)
@@ -148,8 +147,8 @@ export async function runControllerSchedulerPass(store, delivery, now, workspace
             ? await processOperatorInputNotifications(store, delivery, selection, now)
             : [];
         return {
-            activeTurnDeliveries,
-            failedTurnRefs,
+            activeRunDeliveries,
+            failedRunRefs,
             wakeups: mergeWakeupPhaseResults(initialWakeupResults, laterWakeups),
             inputNotifications,
             autoResolvedInputs
@@ -218,34 +217,6 @@ async function processSelectedRoleRuntimeCleanups(store, delivery, lifecycleHost
                 if (!await lifecycleHost.stopOwner(owner)) {
                     throw new Error(`Role runtime cleanup could not confirm the host stopped: ${runtimeOwnerLabel(owner)}.`);
                 }
-                if (target.kind === "role-runtime") {
-                    const session = store.getRoleSession(target.taskId, target.roleName);
-                    const reservedRuntimeGenerationId = isRuntimeLaunchReservation(mailbox.processing)
-                        ? mailbox.processing.batchId
-                        : undefined;
-                    // A failed fresh-Conversation launch can leave two exact resource
-                    // generations: the detached Session's last committed launch and the
-                    // replacement reservation. They are not competing authorities. The
-                    // owner-wide stop has already proven physical zero, so clean both
-                    // exact launch roots idempotently before settling the mailbox.
-                    const runtimeGenerationIds = new Set([
-                        reservedRuntimeGenerationId,
-                        session?.runtimeGenerationId
-                    ].filter((runtimeGenerationId) => runtimeGenerationId !== undefined));
-                    if (lifecycleHost.cleanupTaskLaunch !== undefined) {
-                        const task = store.getTask(target.taskId);
-                        const reason = task?.status === "completed"
-                            ? "completion"
-                            : "interruption";
-                        for (const runtimeGenerationId of runtimeGenerationIds) {
-                            lifecycleHost.cleanupTaskLaunch({
-                                taskId: target.taskId,
-                                runtimeGenerationId,
-                                reason
-                            });
-                        }
-                    }
-                }
                 if (store.completeRuntimeCleanup === undefined
                     || !store.completeRuntimeCleanup(target, now)) {
                     throw new Error(`Role runtime cleanup mailbox changed: ${runtimeOwnerLabel(owner)}.`);
@@ -259,95 +230,9 @@ async function processSelectedRoleRuntimeCleanups(store, delivery, lifecycleHost
             }
             continue;
         }
-        const reservation = mailbox.processing;
-        if (reservation === null
-            || !isRuntimeLaunchReservation(reservation)
-            || now.getTime() - Date.parse(reservation.startedAt)
-                < RUNTIME_RESERVATION_RECOVERY_AGE_MS) {
-            continue;
-        }
-        try {
-            if (lifecycleHost === undefined) {
-                throw new Error("Role runtime reservation inspection is unavailable.");
-            }
-            const inspection = await lifecycleHost.inspectOwner(owner);
-            if (inspection.state === "running" || inspection.state === "starting") {
-                continue;
-            }
-            if (inspection.state === "unavailable") {
-                throw new Error(`Role runtime reservation could not inspect the host: ${runtimeOwnerLabel(owner)}.`);
-            }
-            const completed = store.completeStoppedRuntimeReservation === undefined
-                ? store.completeWorkMailbox(target, reservation.batchId)
-                : store.completeStoppedRuntimeReservation(target, reservation.batchId, now);
-            if (!completed) {
-                throw new Error(`Role runtime reservation mailbox changed: ${runtimeOwnerLabel(owner)}.`);
-            }
-            forgetPreparedRuntimeOwner(delivery, owner);
-            outcomes.push({ target, batchId, status: "completed" });
-        }
-        catch (error) {
-            markFailedRuntimeTarget(failedRoles, target);
-            outcomes.push({ target, batchId, status: "failed", error });
-        }
     }
     return failedRoles;
 }
-async function reconcileDormantRuntimeOwners(store, delivery, lifecycleHost, scope, now, blockedTaskIds = new Set()) {
-    if (lifecycleHost === undefined
-        || store.listDormantRuntimeOwners === undefined) {
-        return;
-    }
-    const selectedOwners = scope.kind === "full"
-        ? undefined
-        : new Set(selectedRuntimeLifecycleTargets(store, scope, blockedTaskIds)
-            .map((target) => runtimeOwnerIdentity(runtimeOwner(target))));
-    const candidates = store.listDormantRuntimeOwners().filter((candidate) => ((candidate.owner.scope !== "task"
-        || !blockedTaskIds.has(candidate.owner.taskId))
-        && (selectedOwners === undefined
-            || selectedOwners.has(runtimeOwnerIdentity(candidate.owner)))));
-    if (candidates.length === 0)
-        return;
-    const owners = candidates.map((candidate) => candidate.owner);
-    let inspections;
-    try {
-        inspections = lifecycleHost.inspectOwners === undefined
-            ? await Promise.all(owners.map(async (owner) => ({
-                owner,
-                inspection: await lifecycleHost.inspectOwner(owner)
-            })))
-            : await lifecycleHost.inspectOwners(owners);
-    }
-    catch {
-        // Host inventory is an advisory safety scan. Unknown state must never
-        // mutate persisted session facts; the next full pass will retry.
-        return;
-    }
-    const requested = new Set(owners.map(runtimeOwnerIdentity));
-    const byOwner = new Map();
-    for (const result of inspections) {
-        const identity = runtimeOwnerIdentity(result.owner);
-        if (!requested.has(identity)
-            || byOwner.has(identity)) {
-            return;
-        }
-        byOwner.set(identity, result.inspection);
-    }
-    if (byOwner.size !== requested.size)
-        return;
-    for (const candidate of candidates) {
-        if (byOwner.get(runtimeOwnerIdentity(candidate.owner))?.state
-            === "stopped") {
-            if (candidate.runtimeGenerationId !== undefined) {
-                // The exact launch-owned resources must settle through the durable
-                // cleanup lane before its Host fact is detached. The resumable Session
-                // remains active; the candidate is the CAS fence against a concurrent
-                // Hook or replacement launch.
-                store.enqueueRuntimeHostDetach?.(candidate.owner, now, candidate);
-            }
-        }
-    }
-}
 function forgetPreparedRuntimeOwner(delivery, owner) {
     if (owner.scope !== "task")
         return;
@@ -356,11 +241,6 @@ function forgetPreparedRuntimeOwner(delivery, owner) {
         roleName: owner.roleName
     });
 }
-function runtimeOwnerIdentity(owner) {
-    return owner.scope === "task"
-        ? `task\0${owner.taskId}\0${owner.roleName}`
-        : `global\0${owner.roleName}`;
-}
 function selectedTaskIdsForBoundedPass(store, selection) {
     if (!selection.full) {
         if ((selection.blockedTaskIds?.size ?? 0) === 0)
@@ -575,6 +455,67 @@ export function compileReconcileSelection(scope) {
         blockedTaskIds: new Set()
     };
 }
+/**
+ * Adopts activation requests whose deferral has been released.
+ *
+ * The deferral is only ever released by the planning Turn ending, so this phase
+ * re-reads the request instead of trusting the signal that woke it: a request
+ * cancelled, or a Task retired or stopped, while the Turn was still running is
+ * left alone rather than replayed as historical intent. Adoption itself belongs
+ * to the preparer's single activation boundary, so status and environment facts
+ * still commit together, and a failure here leaves a continuable Draft.
+ *
+ * Full reconciliation resolves the candidates from the durable pending-request
+ * projection rather than from dirty keys. A Controller that restarts after the
+ * releasing signal was enqueued has no dirty key for it, and the startup pass
+ * claims and completes that Task's mailbox — so without the projection a
+ * released request would wait for unrelated traffic on the Task.
+ */
+async function adoptReleasedTaskActivations(store, workspace, selection, onError) {
+    if (workspace === undefined)
+        return;
+    const candidates = selection.full
+        ? (store.listPendingActivationRequestTaskIds?.()
+            ?? store.listTasks().flatMap((task) => (task.status === "draft" && task.activationRequest?.disposition === "pending"
+                ? [task.id]
+                : [])))
+        : selection.taskIds;
+    for (const taskId of candidates) {
+        if (selection.blockedTaskIds?.has(taskId))
+            continue;
+        const task = store.getTask(taskId);
+        if (task?.status !== "draft" || task.executionGate.state !== "enabled")
+            continue;
+        const request = task.activationRequest;
+        if (request?.disposition !== "pending")
+            continue;
+        // Continue only requests with a provable source: a released deferral, or an
+        // immediate request carrying a recognised origin (explicit action, or a
+        // develop submission accepted while unplanned). This admits legal
+        // Operator/user immediate requests the old actor filter dropped, while
+        // still refusing origin-less historical requests, which stay behind the
+        // explicit `yui task activate` boundary.
+        if (!activationRequestIsControllerAdoptable(request))
+            continue;
+        // Later Draft discussion is a Session notification, not another AgentRun.
+        // Its durable activation intent is sufficient once the exact native input
+        // is settled. Never create a synthetic Run merely to release that intent.
+        if (store.getActiveRun(taskId, "leader") !== null)
+            continue;
+        const provider = store.getTaskRoleSessionSet?.(taskId, "leader")?.providerBinding;
+        if (provider?.run != null
+            && ["submitting", "accepted", "delivery-unknown"].includes(provider.run.status))
+            continue;
+        try {
+            await workspace.activateTaskWorkspace(taskId);
+        }
+        catch (error) {
+            // Activation failure is durable Task state, not a Controller fault: the
+            // request records it and the Draft stays continuable.
+            onError?.(error);
+        }
+    }
+}
 async function prepareActiveWorkspaces(store, workspace, selection, maintenanceFence, onMaintenanceFenceDefer) {
     if (workspace === undefined)
         return { failed: new Set(), ready: new Set() };
@@ -689,8 +630,8 @@ function partitionDirtyScope(keys) {
 }
 function emptyControllerSchedulerResult() {
     return {
-        activeTurnDeliveries: [],
-        failedTurnRefs: [],
+        activeRunDeliveries: [],
+        failedRunRefs: [],
         wakeups: [],
         inputNotifications: [],
         autoResolvedInputs: []
@@ -707,8 +648,8 @@ function runtimeTaskFailureIds(result) {
 }
 function mergeControllerSchedulerResults(results) {
     return {
-        activeTurnDeliveries: results.flatMap((result) => result.activeTurnDeliveries),
-        failedTurnRefs: results.flatMap((result) => result.failedTurnRefs),
+        activeRunDeliveries: results.flatMap((result) => result.activeRunDeliveries),
+        failedRunRefs: results.flatMap((result) => result.failedRunRefs),
         wakeups: results.flatMap((result) => result.wakeups),
         inputNotifications: results.flatMap((result) => result.inputNotifications),
         autoResolvedInputs: results.flatMap((result) => result.autoResolvedInputs)
@@ -791,8 +732,8 @@ export class FileTaskController {
             : this.#deliveryRetryLimit;
         this.#taskOrchestrationRetryLimit = positiveInteger(options.taskOrchestrationRetryLimit, DEFAULT_TASK_ORCHESTRATION_RETRY_LIMIT, "Controller Task orchestration retry limit");
         this.#taskConcurrency = boundedPositiveInteger(options.taskConcurrency, DEFAULT_TASK_CONCURRENCY, MAX_TASK_CONCURRENCY, "Controller Task concurrency");
-        this.#stallWindowMs = positiveInteger(options.stallWindowMs, DEFAULT_STALL_WINDOW_MS, "Controller Turn stall window");
-        this.#diagnosticAfterMs = positiveInteger(options.diagnosticAfterMs, DEFAULT_WORKFLOW_STALL_CANDIDATE_AGE_MS, "Controller Turn diagnostic threshold");
+        this.#stallWindowMs = positiveInteger(options.stallWindowMs, DEFAULT_STALL_WINDOW_MS, "Controller AgentRun stall window");
+        this.#diagnosticAfterMs = positiveInteger(options.diagnosticAfterMs, DEFAULT_WORKFLOW_STALL_CANDIDATE_AGE_MS, "Controller AgentRun diagnostic threshold");
         this.#runtimeEventProcessor = options.runtimeEventProcessor;
         this.#runtimeObserver = options.runtimeObserver;
         this.#runtimeObserverIntervalMs = positiveInteger(options.runtimeObserverIntervalMs, DEFAULT_RUNTIME_OBSERVER_INTERVAL_MS, "Controller runtime observer interval");
@@ -1050,7 +991,7 @@ export class FileTaskController {
                     }
                     // Detached reconciliation is deliberately confined to the low-rate
                     // full pass. It queries only identities already present in Task
-                    // facts and cannot start a model Turn or scan unknown children.
+                    // facts and cannot start a model AgentRun or scan unknown children.
                     if (scope.kind === "full" && this.#continuationReconciler !== undefined) {
                         await this.#continuationReconciler.reconcile(this.#now());
                     }
@@ -1059,7 +1000,7 @@ export class FileTaskController {
                     // processes Leader wakeups.
                     this.#jobSupervisor?.reconcile(this.#now());
                     if (scope.kind === "full") {
-                        result = await runControllerSchedulerPass(this.store, this.delivery, this.#now(), this.#workspacePreparer, scope, false, runtimeCleanupOutcomes, this.#lifecycleHost, this.#stallWindowMs, this.#maintenanceFence, this.#onMaintenanceFenceDefer, runtimeFailedTaskIds, this.#diagnosticAfterMs, this.#leaderWakeFence);
+                        result = await runControllerSchedulerPass(this.store, this.delivery, this.#now(), this.#workspacePreparer, scope, false, runtimeCleanupOutcomes, this.#lifecycleHost, this.#stallWindowMs, this.#maintenanceFence, this.#onMaintenanceFenceDefer, runtimeFailedTaskIds, this.#diagnosticAfterMs, this.#leaderWakeFence, this.#onError);
                     }
                     else {
                         const dirtyPass = await this.#runDirtySchedulerPass(scope, runtimeCleanupOutcomes, runtimeFailedTaskIds);
@@ -1144,7 +1085,7 @@ export class FileTaskController {
                 if (this.#pendingFull || this.#pendingKeys.size > 0 || pendingRuntimeDrain) {
                     // A continuous Hook signal stream must yield to socket callbacks
                     // between bounded scheduler passes.
-                    await eventLoopTurn();
+                    await eventLoopRun();
                 }
             }
             return result;
@@ -1159,7 +1100,7 @@ export class FileTaskController {
         const taskScopes = partition.taskScopes.filter((taskScope) => (!blockedTaskIds.has(taskScope.taskId)));
         const orderedResults = [];
         if (partition.globalKeys.length > 0) {
-            orderedResults.push(await runControllerSchedulerPass(this.store, this.delivery, this.#now(), this.#workspacePreparer, { kind: "dirty", keys: partition.globalKeys }, false, runtimeCleanupOutcomes, this.#lifecycleHost, this.#stallWindowMs, this.#maintenanceFence, this.#onMaintenanceFenceDefer, blockedTaskIds, this.#diagnosticAfterMs, this.#leaderWakeFence));
+            orderedResults.push(await runControllerSchedulerPass(this.store, this.delivery, this.#now(), this.#workspacePreparer, { kind: "dirty", keys: partition.globalKeys }, false, runtimeCleanupOutcomes, this.#lifecycleHost, this.#stallWindowMs, this.#maintenanceFence, this.#onMaintenanceFenceDefer, blockedTaskIds, this.#diagnosticAfterMs, this.#leaderWakeFence, this.#onError));
         }
         if (taskScopes.length === 0
             || this.#stopped
@@ -1192,7 +1133,7 @@ export class FileTaskController {
                     if (this.#stopped || this.#pendingFull)
                         continue;
                     try {
-                        taskResults[selected.index] = await runControllerSchedulerPass(this.store, this.delivery, this.#now(), this.#workspacePreparer, { kind: "dirty", keys: selected.taskScope.keys }, false, taskCleanupOutcomes[selected.index], this.#lifecycleHost, this.#stallWindowMs, this.#maintenanceFence, this.#onMaintenanceFenceDefer, blockedTaskIds, this.#diagnosticAfterMs, this.#leaderWakeFence);
+                        taskResults[selected.index] = await runControllerSchedulerPass(this.store, this.delivery, this.#now(), this.#workspacePreparer, { kind: "dirty", keys: selected.taskScope.keys }, false, taskCleanupOutcomes[selected.index], this.#lifecycleHost, this.#stallWindowMs, this.#maintenanceFence, this.#onMaintenanceFenceDefer, blockedTaskIds, this.#diagnosticAfterMs, this.#leaderWakeFence, this.#onError);
                         this.#clearTaskPassRetry(selected.taskScope.taskId);
                     }
                     catch (error) {
@@ -1424,13 +1365,7 @@ export class FileTaskController {
                         at: aggregationAt
                     }];
             }
-            const forceAt = firstRequestedAt + LEADER_WAKE_FORCE_MS;
-            return forceAt > now && this.store.getActiveTurn(wakeup.taskId, "leader") !== null
-                ? [{
-                        key: `role:${encodeURIComponent(wakeup.taskId)}/leader`,
-                        at: forceAt
-                    }]
-                : [];
+            return [];
         });
         const nearest = nearestDeadlineBatch(deadlines);
         if (nearest === null)
@@ -1449,7 +1384,7 @@ export class FileTaskController {
         const settled = new Set();
         const writerBlocked = new Set();
         const resignal = new Set();
-        for (const delivery of result.activeTurnDeliveries) {
+        for (const delivery of result.activeRunDeliveries) {
             const key = `role:${encodeURIComponent(delivery.taskId)}/${encodeURIComponent(delivery.roleName)}`;
             if (delivery.terminalized === true) {
                 settled.add(key);
@@ -1459,7 +1394,7 @@ export class FileTaskController {
                 writerBlocked.add(key);
             else if (delivery.reason === "not-ready"
                 || delivery.reason === "runtime-unavailable") {
-                retry.set(key, { identity: delivery.turnId });
+                retry.set(key, { identity: delivery.runId });
             }
             else if (delivery.status === "delivered" || delivery.status === "already-delivered")
                 settled.add(key);
@@ -1467,8 +1402,8 @@ export class FileTaskController {
         for (const wakeup of result.wakeups) {
             const key = `role:${encodeURIComponent(wakeup.taskId)}/leader`;
             if (wakeup.reason === "not-ready"
-                || (wakeup.reason === "busy" && wakeup.turnId !== undefined)) {
-                retry.set(key, { identity: wakeup.turnId ?? key });
+                || (wakeup.reason === "busy" && wakeup.runId !== undefined)) {
+                retry.set(key, { identity: wakeup.runId ?? key });
             }
             else if (wakeup.status === "dispatched")
                 settled.add(key);
@@ -1575,9 +1510,9 @@ export class FileTaskController {
         timer.unref();
         this.#deliveryRetryTimers.set(key, timer);
     }
-    #terminalizePreparedAfterRetryExhaustion(key, turnId, failure) {
+    #terminalizePreparedAfterRetryExhaustion(key, runId, failure) {
         if (!key.startsWith("role:")
-            || turnId.startsWith("runtime-cleanup:")
+            || runId.startsWith("runtime-cleanup:")
             || failure === undefined) {
             return;
         }
@@ -1586,10 +1521,10 @@ export class FileTaskController {
             return;
         if (target.taskId !== failure.taskId
             || target.roleName !== failure.roleName
-            || turnId !== failure.turnId) {
-            throw new Error(`Role delivery retry identity changed: ${key}/${turnId}.`);
+            || runId !== failure.runId) {
+            throw new Error(`Role delivery retry identity changed: ${key}/${runId}.`);
         }
-        const result = this.store.saveRoleTurnDeliveryFailure({
+        const result = this.store.saveRoleRunDeliveryFailure({
             ...failure,
             now: this.#now()
         });
@@ -1599,10 +1534,7 @@ export class FileTaskController {
         this.delivery.forgetPrepared?.({
             taskId: failure.taskId,
             roleName: failure.roleName,
-            turnId: failure.turnId,
-            ...(failure.runtimeGenerationId === undefined
-                ? {}
-                : { runtimeGenerationId: failure.runtimeGenerationId })
+            runId: failure.runId,
         });
         if (!this.#stopped)
             this.signal(key);
@@ -1808,15 +1740,15 @@ class ControllerDispatcherServiceTimeMetrics {
         };
     }
 }
-function eventLoopTurn() {
+function eventLoopRun() {
     return new Promise((resolve) => setImmediate(resolve));
 }
-async function controlEventLoopTurn() {
+async function controlEventLoopRun() {
     // A setImmediate scheduled from the check phase may resume before the next
     // poll phase. Two turns guarantee already-written socket data gets one poll
     // opportunity before another synchronous scheduler projection starts.
-    await eventLoopTurn();
-    await eventLoopTurn();
+    await eventLoopRun();
+    await eventLoopRun();
 }
 function signalMailboxKey(value) {
     if (typeof value !== "object"