@zq-silk/yui 0.13.10 → 0.14.1

package/dist/controller/agentRuntimeObserver.js

@@ -5,7 +5,7 @@ const DEFAULT_MAX_CONCURRENT_SAMPLES = 8;
 const MAX_CONCURRENT_SAMPLES = 64;
 /**
  * Controller-owned, provider-independent sampler. Drivers own source parsing;
- * this component owns active-Run discovery, cursor lifetime, canonical event
+ * this component owns active-Turn discovery, cursor lifetime, canonical event
  * creation, and low-latency mailbox wakes.
  */
 export class AgentRuntimeObserver {
@@ -73,7 +73,7 @@ export class AgentRuntimeObserver {
             if (state.usage === undefined) {
                 // Cumulative counters need a lower bound. An exact initial sample
                 // proves the complete Session-generation history even when the
-                // current Run resumed that Session, so preserve every occurrence and
+                // current Turn resumed that Session, so preserve every occurrence and
                 // anchor it at zero. A partial sample cannot prove the omitted request
                 // boundaries; retain its latest total as a partial baseline, plus the
                 // smallest ordered witness if the visible counter already rolled back.
@@ -239,8 +239,8 @@ export class AgentRuntimeObserver {
     activeSources() {
         const result = [];
         const indexedTaskIds = this.store.listActiveTaskIds?.();
-        // FileTaskStore remains a development/compatibility fallback. The normal
-        // Controller store is SQLite and must discover only its indexed hot set.
+        // Stores without the indexed projection remain useful for deterministic
+        // tests. The production SQLite store discovers only its indexed hot set.
         const activeTasks = indexedTaskIds === undefined
             ? this.store.listTasks().filter((task) => (task.status === "active" && task.executionGate.state === "enabled"))
             : [...new Set(indexedTaskIds)]
@@ -251,43 +251,43 @@ export class AgentRuntimeObserver {
                 && task.executionGate.state === "enabled"));
         for (const task of activeTasks) {
             // A Task still incurs one O(E) event projection. Group those observations
-            // by Run and sort each group once so every active Run can reuse the same
+            // by Turn and sort each group once so every active Turn can reuse the same
             // ordered slice instead of repeatedly filtering/sorting all E events.
-            const observationsByRunId = new Map();
+            const observationsByTurnId = new Map();
             const taskObservations = [];
             for (const event of this.store.listEvents(task.id)) {
                 const observation = runtimeObservationFromTaskEvent(event);
-                const runId = observation?.fence.runId;
-                if (observation === null || runId === undefined)
+                const turnId = observation?.fence.turnId;
+                if (observation === null || turnId === undefined)
                     continue;
                 taskObservations.push(observation);
-                const grouped = observationsByRunId.get(runId);
+                const grouped = observationsByTurnId.get(turnId);
                 if (grouped === undefined) {
-                    observationsByRunId.set(runId, [observation]);
+                    observationsByTurnId.set(turnId, [observation]);
                 }
                 else {
                     grouped.push(observation);
                 }
             }
-            for (const observations of observationsByRunId.values()) {
+            for (const observations of observationsByTurnId.values()) {
                 observations.sort(compareObservations);
             }
             taskObservations.sort(compareObservations);
-            for (const run of this.store.listAgentRuns(task.id)) {
+            for (const run of this.store.listTurns(task.id)) {
                 if (run.status !== "active"
-                    || this.store.getActiveAgentRun(task.id, run.roleName)?.id !== run.id)
+                    || this.store.getActiveTurn(task.id, run.roleName)?.id !== run.id)
                     continue;
-                const observations = observationsByRunId.get(run.id) ?? [];
+                const observations = observationsByTurnId.get(run.id) ?? [];
                 const accepted = observations
                     .filter((observation) => observation.kind === "turn.accepted"
-                    && observation.fence.runId === run.id
+                    && observation.fence.turnId === run.id
                     && observation.fence.roleName === run.roleName
                     && observation.fence.agentId === run.effective.agentId
                     && observation.payload.observerSource !== undefined)
                     .at(-1);
                 const source = accepted?.payload.observerSource;
                 if (accepted === undefined || source === undefined
-                    || accepted.fence.taskId === undefined || accepted.fence.runId === undefined)
+                    || accepted.fence.taskId === undefined || accepted.fence.turnId === undefined)
                     continue;
                 try {
                     if (this.drivers.require(accepted.fence.driverId).runtime.observer === undefined)
@@ -313,7 +313,7 @@ export class AgentRuntimeObserver {
                     key: JSON.stringify([
                         fence.taskId,
                         fence.roleName,
-                        fence.runId,
+                        fence.turnId,
                         fence.agentId,
                         fence.driverId,
                         fence.launchId,
@@ -374,7 +374,7 @@ function sampleConcurrency(value) {
     if (!Number.isSafeInteger(resolved)
         || resolved < 1
         || resolved > MAX_CONCURRENT_SAMPLES) {
-        throw new Error(`Agent runtime observer maxConcurrentSamples must be between 1 and ${MAX_CONCURRENT_SAMPLES}.`);
+        throw new Error(`AgentRuntime observer maxConcurrentSamples must be between 1 and ${MAX_CONCURRENT_SAMPLES}.`);
     }
     return resolved;
 }

package/dist/controller/clientRuntime.js

@@ -1,10 +1,10 @@
 import { spawn } from "node:child_process";
 import { fileURLToPath } from "node:url";
-import { callController, ControllerClientError, readControllerDiscovery, stopOrphanedFileTaskController, stopPreviousFileTaskController } from "../core/controllerClient.js";
+import { callController, ControllerClientError, readControllerDiscovery, stopOrphanedFileTaskController } from "../core/controllerClient.js";
 import { controllerSocketPath } from "../core/controllerEndpoint.js";
 import { FILE_TASK_CONTROLLER_PROTOCOL_VERSION } from "../core/protocol.js";
 import { AGENT_OPERATIONAL_ENVIRONMENT_NAMES, nativeAgentEnvironmentNames, operationalAgentEnvironment, selectEnvironment, YUI_MANAGED_RUNTIME_ENVIRONMENT_NAMES } from "../agent/launchEnvironment.js";
-import { openCompatibleFileTaskStore } from "../storage/compatibleTaskStore.js";
+import { openCurrentTaskStore } from "../storage/currentTaskStore.js";
 import { yuiTmuxServerName } from "../tmux/tmuxManager.js";
 import { hasRuntimeLifecycleWork } from "../runtime/lifecycleReservation.js";
 import { assertControllerStatusIdentity } from "../runtime/exactControlPlane.js";
@@ -21,19 +21,15 @@ const ENVIRONMENT_REFRESH_TIMEOUT_MS = 500;
 const CONFIGURATION_REFRESH_TIMEOUT_MS = 500;
 const CONTROLLER_OPERATIONAL_ENVIRONMENT = [
     ...AGENT_OPERATIONAL_ENVIRONMENT_NAMES,
-    // Issue 01: YUI_STORE_BACKEND/YUI_STORE_WORKER are reserved for tests and
-    // explicit recovery commands. A Controller spawned by such a command must
-    // inherit the forced backend; otherwise a layout-7 test Home silently opens
-    // SQLite, creates yui.db, and diverges from the file store the test writes.
-    "YUI_STORE_BACKEND",
+    // The worker toggle changes process placement, not storage authority.
     "YUI_STORE_WORKER",
     // rr13/test: Forward the liveness seam so an integration test's Controller
-    // subprocess does not reap a saved active Leader Run without a real tmux role.
+    // subprocess does not reap a saved active Leader Turn without a real tmux role.
     "YUI_TEST_ROLE_LIVENESS_PRESENT",
     ...EPHEMERAL_DOMAIN_ENVIRONMENT_NAMES
 ];
 /**
- * Direct FileTaskStore writers must not extend state while an older Controller
+ * Direct TaskStore writers must not extend state while an older Controller
  * is still reading the same YUI_HOME.
  */
 export async function assertFileTaskControllerStorageCompatible(home, options = {}) {
@@ -241,11 +237,8 @@ export async function restartFileTaskController(home, options = {}) {
     catch (error) {
         if (options.call !== undefined || !isInvalidDiscovery(error))
             throw error;
-        // Protocol v3 is the immediately previous released Controller. Keep its
-        // parser and transport confined to this explicit replacement operation;
-        // no ordinary request can fall back to it.
-        const previous = await stopPreviousFileTaskController(home, shutdownTimeoutMs);
-        previousPid = previous.pid;
+        // A malformed current discovery record cannot authorize a protocol call.
+        // Exact process identity below may still fence and stop an orphaned owner.
     }
     if (!controllerRunning(current) && options.call === undefined) {
         const orphan = await stopOrphanedFileTaskController(home, shutdownTimeoutMs);
@@ -278,7 +271,7 @@ export async function restartFileTaskController(home, options = {}) {
 function controllerSpawnEnvironment(home, source) {
     const allowed = new Set(CONTROLLER_OPERATIONAL_ENVIRONMENT);
     try {
-        for (const agent of openCompatibleFileTaskStore(home).listConfiguredAgents()) {
+        for (const agent of openCurrentTaskStore(home).listConfiguredAgents()) {
             for (const name of nativeAgentEnvironmentNames(agent.adapterId))
                 allowed.add(name);
             for (const binding of agent.environment)
@@ -291,7 +284,7 @@ function controllerSpawnEnvironment(home, source) {
     }
     // Merge with process.env so a partial source (e.g. a managed-Session env
     // that only carries YUI_SESSION_SCOPE/YUI_TASK_ID) still forwards
-    // operational vars like YUI_STORE_BACKEND and PATH. The source wins on
+    // operational vars like YUI_STORE_WORKER and PATH. The source wins on
     // conflict; the whitelist still gates every forwarded name.
     const effectiveSource = { ...process.env, ...source };
     const environment = {};
@@ -440,8 +433,8 @@ export class FileTaskWorkflowRuntime {
     async stopTaskRoleSessions(taskId, roleNames) {
         const targets = [];
         for (const roleName of [...new Set(roleNames)]) {
-            if (this.store.getActiveAgentRun(taskId, roleName) !== null) {
-                throw new Error(`Role has an active Run: ${taskId}/${roleName}.`);
+            if (this.store.getActiveTurn(taskId, roleName) !== null) {
+                throw new Error(`Role has an active Turn: ${taskId}/${roleName}.`);
             }
             const target = this.schedulerStore.enqueueRuntimeCleanup({
                 scope: "task",
@@ -473,8 +466,8 @@ export class FileTaskWorkflowRuntime {
     }
     /** Stops only the exact idle Session observed by an Agent command. */
     async stopExactTaskRoleSession(input) {
-        if (this.store.getActiveAgentRun(input.taskId, input.roleName) !== null) {
-            throw new Error(`Role has an active Run: ${input.taskId}/${input.roleName}.`);
+        if (this.store.getActiveTurn(input.taskId, input.roleName) !== null) {
+            throw new Error(`Role has an active Turn: ${input.taskId}/${input.roleName}.`);
         }
         const owner = {
             scope: "task",

package/dist/controller/controller.js

@@ -1,11 +1,10 @@
 import { reconciliationIntervalMilliseconds } from "../config/yuiConfig.js";
-import { processLeaderWakeups } from "../scheduler/leaderWakeupProcessor.js";
+import { LEADER_WAKE_AGGREGATION_MS, LEADER_WAKE_FORCE_MS, processLeaderWakeups } from "../scheduler/leaderWakeupProcessor.js";
 import { pendingWakeupsMatch } from "../scheduler/pendingWakeup.js";
-import { processActiveRoleRunDeliveries } from "../scheduler/activeRoleRunDelivery.js";
-import { selectedActiveSchedulerTasks, selectedSchedulerRoles, selectedSchedulerTasks } from "../scheduler/ports.js";
-import { reconcileExitedRoleRuns } from "../scheduler/roleRunLiveness.js";
-import { DEFAULT_STALL_WINDOW_MS, DEFAULT_WORKFLOW_STALL_CANDIDATE_AGE_MS, reconcileStalledRoleRuns } from "../scheduler/roleRunStall.js";
-import { repairOrphanedActiveTasks } from "../scheduler/activeTaskProgress.js";
+import { processActiveRoleTurnDeliveries } from "../scheduler/activeRoleTurnDelivery.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 { processOperatorInputNotifications } from "../scheduler/operatorInputNotificationProcessor.js";
 import { startControllerServer } from "../core/controllerServer.js";
 import { monotonicMilliseconds } from "../core/controllerTelemetry.js";
@@ -15,7 +14,7 @@ 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, runtimeLifecycleTarget } from "../runtime/lifecycleReservation.js";
+import { hasRuntimeCleanupObligation, isRuntimeLaunchReservation } from "../runtime/lifecycleReservation.js";
 import { formatTaskRecordReference } from "../task/taskRecordReference.js";
 import { parseDurableJobAcknowledgeParams, parseDurableJobCancelParams, parseDurableJobRefParams, parseDurableJobStartParams } from "./jobControl.js";
 const DEFAULT_RECONCILIATION_INTERVAL_MS = reconciliationIntervalMilliseconds();
@@ -46,19 +45,18 @@ 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(), inputDeliveryRecoveryCutoff, 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) {
     const compiledSelection = compileReconcileSelection(scope);
     const selection = includeOperator
         ? { ...compiledSelection, blockedTaskIds }
         : { ...compiledSelection, operator: false, blockedTaskIds };
-    queueSelectedCompletedTaskRuntimeCleanups(store, selection, now);
     // A full-state Task projection can be individually bounded yet still starve
     // 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 Run,
+    // 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);
@@ -67,8 +65,6 @@ export async function runControllerSchedulerPass(store, delivery, now, workspace
     const availableWakeupSelection = () => (leaderWakeFence?.() === true
         ? exactTaskSelection(new Set())
         : selectionWithoutFailedLeaderCleanupTasks(store, selection, failedCleanupRoles));
-    if (selection.full)
-        repairOrphanedActiveTasks(store, now, selection);
     const claimedTaskMailboxes = claimSelectedTaskMailboxes(store, selection, now);
     try {
         // Durable Leader work that already has a ready Task workspace belongs to
@@ -81,13 +77,10 @@ export async function runControllerSchedulerPass(store, delivery, now, workspace
         await controlEventLoopTurn();
         const workspacePreparation = await prepareActiveWorkspaces(store, workspacePreparer, selection, maintenanceFence, onMaintenanceFenceDefer);
         await controlEventLoopTurn();
-        // Issue 04: reopen due in-place Provider retries on their original
-        // Sessions before delivery, so the existing delivery path re-pushes the
-        // exact same input in this same pass.
-        const activeRunDeliveries = await processActiveRoleRunDeliveries(store, delivery, now, roleSelection, inputDeliveryRecoveryCutoff);
+        const activeTurnDeliveries = await processActiveRoleTurnDeliveries(store, delivery, now, roleSelection);
         await controlEventLoopTurn();
-        const unsettledRunRefs = new Set(activeRunDeliveries.flatMap((result) => (result.reason === "delivery-uncertain" || result.terminalFailure !== undefined
-            ? [formatTaskRecordReference(result.taskId, result.runId, "agentRun")]
+        const unsettledTurnRefs = new Set(activeTurnDeliveries.flatMap((result) => (result.reason === "delivery-uncertain"
+            ? [formatTaskRecordReference(result.taskId, result.turnId, "turn")]
             : [])));
         // Every successful Task has completed the targeted phases owned by its
         // mailbox at this boundary. Settle that exact claim before advisory
@@ -99,16 +92,16 @@ export async function runControllerSchedulerPass(store, delivery, now, workspace
             }
         }
         const newlyIdleBusyTaskIds = new Set(initialWakeupResults.flatMap((result) => (result.reason === "busy"
-            && store.getActiveAgentRun(result.taskId, "leader") === null
+            && store.getActiveTurn(result.taskId, "leader") === null
             ? [result.taskId]
             : [])));
-        // Phase-one Leader Runs did not exist at the pass's liveness boundary.
-        // Keep every newly claimed Run outside destructive absence decisions until
+        // 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/session generation.
         for (const result of initialWakeupResults) {
-            if (result.runId !== undefined
-                && store.getActiveAgentRun(result.taskId, "leader")?.id === result.runId) {
-                unsettledRunRefs.add(formatTaskRecordReference(result.taskId, result.runId, "agentRun"));
+            if (result.turnId !== undefined
+                && store.getActiveTurn(result.taskId, "leader")?.id === result.turnId) {
+                unsettledTurnRefs.add(formatTaskRecordReference(result.taskId, result.turnId, "turn"));
             }
         }
         // Let socket callbacks queued during the bounded scheduler phases run
@@ -116,9 +109,9 @@ export async function runControllerSchedulerPass(store, delivery, now, workspace
         await controlEventLoopTurn();
         const liveStatuses = new Map();
         const resourceEvidence = new Map();
-        const failedRunRefs = await reconcileExitedRoleRuns(store, delivery, now, roleSelection, unsettledRunRefs, liveStatuses, resourceEvidence, scope.kind === "dirty");
+        const failedTurnRefs = await reconcileExitedRoleTurns(store, delivery, now, roleSelection, unsettledTurnRefs, liveStatuses, resourceEvidence, scope.kind === "dirty");
         await controlEventLoopTurn();
-        await reconcileStalledRoleRuns(store, delivery, now, roleSelection, stallWindowMs, liveStatuses, resourceEvidence, diagnosticAfterMs);
+        await reconcileStalledRoleTurns(store, delivery, now, roleSelection, stallWindowMs, liveStatuses, resourceEvidence, diagnosticAfterMs);
         await controlEventLoopTurn();
         await reconcileDormantRuntimeOwners(store, delivery, lifecycleHost, scope, now, selection.blockedTaskIds);
         const selectedInputTaskIds = selectedTaskIdsForBoundedPass(store, selection);
@@ -155,8 +148,8 @@ export async function runControllerSchedulerPass(store, delivery, now, workspace
             ? await processOperatorInputNotifications(store, delivery, selection, now)
             : [];
         return {
-            activeRunDeliveries,
-            failedRunRefs,
+            activeTurnDeliveries,
+            failedTurnRefs,
             wakeups: mergeWakeupPhaseResults(initialWakeupResults, laterWakeups),
             inputNotifications,
             autoResolvedInputs
@@ -208,60 +201,6 @@ function mergeWakeupPhaseResults(initial, later) {
     }
     return merged;
 }
-function queueSelectedCompletedTaskRuntimeCleanups(store, selection, now) {
-    if (store.enqueueRuntimeCleanup === undefined)
-        return;
-    if (selection.full && store.listRuntimeSessionCandidates !== undefined) {
-        for (const candidate of store.listRuntimeSessionCandidates({
-            cleanupRequiredOnly: true
-        })) {
-            if (candidate.owner.scope !== "task"
-                || !candidate.cleanupRequired
-                || selection.blockedTaskIds?.has(candidate.owner.taskId)) {
-                continue;
-            }
-            const { taskId, roleName } = candidate.owner;
-            if (store.getTask(taskId)?.status !== "completed")
-                continue;
-            if (store.getActiveAgentRun(taskId, roleName) !== null)
-                continue;
-            const target = runtimeLifecycleTarget(candidate.owner);
-            if (hasRuntimeCleanupObligation(store.getWorkMailbox(target)))
-                continue;
-            store.enqueueRuntimeCleanup(candidate.owner, now);
-        }
-        return;
-    }
-    for (const task of selectedSchedulerTasks(store, selection)) {
-        if (task.status !== "completed")
-            continue;
-        for (const role of selectedSchedulerRoles(store, task.id, selection)) {
-            if (store.getActiveAgentRun(task.id, role.name) !== null)
-                continue;
-            const session = store.getRoleSession(task.id, role.name);
-            if (!schedulerSessionRequiresRuntimeCleanup(session))
-                continue;
-            const target = runtimeLifecycleTarget({
-                scope: "task",
-                taskId: task.id,
-                roleName: role.name
-            });
-            if (hasRuntimeCleanupObligation(store.getWorkMailbox(target)))
-                continue;
-            store.enqueueRuntimeCleanup({
-                scope: "task",
-                taskId: task.id,
-                roleName: role.name
-            }, now);
-        }
-    }
-}
-function schedulerSessionRequiresRuntimeCleanup(session) {
-    if (session === null || session.status === "ended") {
-        return false;
-    }
-    return session.launchId !== undefined;
-}
 async function processSelectedRoleRuntimeCleanups(store, delivery, lifecycleHost, scope, now, outcomes, blockedTaskIds = new Set()) {
     const targets = selectedRuntimeLifecycleTargets(store, scope, blockedTaskIds);
     const failedRoles = new Set();
@@ -750,8 +689,8 @@ function partitionDirtyScope(keys) {
 }
 function emptyControllerSchedulerResult() {
     return {
-        activeRunDeliveries: [],
-        failedRunRefs: [],
+        activeTurnDeliveries: [],
+        failedTurnRefs: [],
         wakeups: [],
         inputNotifications: [],
         autoResolvedInputs: []
@@ -768,15 +707,15 @@ function runtimeTaskFailureIds(result) {
 }
 function mergeControllerSchedulerResults(results) {
     return {
-        activeRunDeliveries: results.flatMap((result) => result.activeRunDeliveries),
-        failedRunRefs: results.flatMap((result) => result.failedRunRefs),
+        activeTurnDeliveries: results.flatMap((result) => result.activeTurnDeliveries),
+        failedTurnRefs: results.flatMap((result) => result.failedTurnRefs),
         wakeups: results.flatMap((result) => result.wakeups),
         inputNotifications: results.flatMap((result) => result.inputNotifications),
         autoResolvedInputs: results.flatMap((result) => result.autoResolvedInputs)
     };
 }
 /**
- * Single-owner periodic runtime for FileTaskStore-backed scheduling. Full pump
+ * Single-owner periodic runtime for TaskStore-backed scheduling. Full pump
  * requests remain exclusive, while dirty work is serialized per Task and may
  * progress concurrently across different Tasks up to the configured bound.
  */
@@ -809,6 +748,7 @@ export class FileTaskController {
     #passRetryAttempt = 0;
     #timer;
     #deadlineTimer;
+    #leaderWakeDeadlineTimer;
     #runtimeObserverTimer;
     #signalScheduler;
     #operatorSignalScheduler;
@@ -851,8 +791,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 Run stall window");
-        this.#diagnosticAfterMs = positiveInteger(options.diagnosticAfterMs, DEFAULT_WORKFLOW_STALL_CANDIDATE_AGE_MS, "Controller Run diagnostic threshold");
+        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.#runtimeEventProcessor = options.runtimeEventProcessor;
         this.#runtimeObserver = options.runtimeObserver;
         this.#runtimeObserverIntervalMs = positiveInteger(options.runtimeObserverIntervalMs, DEFAULT_RUNTIME_OBSERVER_INTERVAL_MS, "Controller runtime observer interval");
@@ -969,6 +909,10 @@ export class FileTaskController {
             clearTimeout(this.#deadlineTimer);
             this.#deadlineTimer = undefined;
         }
+        if (this.#leaderWakeDeadlineTimer !== undefined) {
+            clearTimeout(this.#leaderWakeDeadlineTimer);
+            this.#leaderWakeDeadlineTimer = undefined;
+        }
         if (this.#timer !== undefined) {
             clearInterval(this.#timer);
             this.#timer = undefined;
@@ -1115,7 +1059,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.#startedAt, 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);
                     }
                     else {
                         const dirtyPass = await this.#runDirtySchedulerPass(scope, runtimeCleanupOutcomes, runtimeFailedTaskIds);
@@ -1207,6 +1151,7 @@ export class FileTaskController {
         }
         finally {
             this.#scheduleNextInputDeadline();
+            this.#scheduleNextLeaderWakeDeadline();
         }
     }
     async #runDirtySchedulerPass(scope, runtimeCleanupOutcomes, blockedTaskIds = new Set()) {
@@ -1214,7 +1159,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.#startedAt, 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));
         }
         if (taskScopes.length === 0
             || this.#stopped
@@ -1247,7 +1192,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.#startedAt, 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.#clearTaskPassRetry(selected.taskScope.taskId);
                     }
                     catch (error) {
@@ -1302,6 +1247,7 @@ export class FileTaskController {
         this.#scheduleDeliveryRetries(result);
         this.#clearEmptyOperatorRetry();
         this.#scheduleNextInputDeadline();
+        this.#scheduleNextLeaderWakeDeadline();
     }
     #signalOperatorMailbox(retryReady = false) {
         if (this.#stopped)
@@ -1322,7 +1268,7 @@ export class FileTaskController {
         const processor = this.#runtimeEventProcessor;
         if (processor === undefined)
             return undefined;
-        // The worker backend exposes drainAsync; the file backend stays sync.
+        // The persistence worker exposes drainAsync; the in-process store stays sync.
         const result = "drainAsync" in processor
             ? await processor.drainAsync(this.#now())
             : processor.drain(this.#now());
@@ -1459,12 +1405,51 @@ export class FileTaskController {
         }, delayMs);
         this.#deadlineTimer.unref();
     }
+    #scheduleNextLeaderWakeDeadline() {
+        if (this.#leaderWakeDeadlineTimer !== undefined) {
+            clearTimeout(this.#leaderWakeDeadlineTimer);
+            this.#leaderWakeDeadlineTimer = undefined;
+        }
+        if (this.#stopped)
+            return;
+        const now = this.#now().getTime();
+        const deadlines = this.store.listPendingWakeups().flatMap((wakeup) => {
+            const firstRequestedAt = Date.parse(wakeup.firstRequestedAt);
+            if (!Number.isFinite(firstRequestedAt))
+                return [];
+            const aggregationAt = firstRequestedAt + LEADER_WAKE_AGGREGATION_MS;
+            if (aggregationAt > now) {
+                return [{
+                        key: `role:${encodeURIComponent(wakeup.taskId)}/leader`,
+                        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
+                    }]
+                : [];
+        });
+        const nearest = nearestDeadlineBatch(deadlines);
+        if (nearest === null)
+            return;
+        const delayMs = Math.min(MAX_TIMER_DELAY_MS, Math.max(0, nearest.at - now));
+        this.#leaderWakeDeadlineTimer = setTimeout(() => {
+            this.#leaderWakeDeadlineTimer = undefined;
+            for (const key of nearest.keys)
+                this.#signalScheduler.signal(key);
+            void this.#signalScheduler.drain().catch(this.#onError);
+        }, delayMs);
+        this.#leaderWakeDeadlineTimer.unref();
+    }
     #scheduleDeliveryRetries(result) {
         const retry = new Map();
         const settled = new Set();
         const writerBlocked = new Set();
         const resignal = new Set();
-        for (const delivery of result.activeRunDeliveries) {
+        for (const delivery of result.activeTurnDeliveries) {
             const key = `role:${encodeURIComponent(delivery.taskId)}/${encodeURIComponent(delivery.roleName)}`;
             if (delivery.terminalized === true) {
                 settled.add(key);
@@ -1474,28 +1459,16 @@ export class FileTaskController {
                 writerBlocked.add(key);
             else if (delivery.reason === "not-ready"
                 || delivery.reason === "runtime-unavailable") {
-                retry.set(key, {
-                    identity: delivery.runId,
-                    ...(delivery.terminalFailure === undefined
-                        ? {}
-                        : { terminalFailure: delivery.terminalFailure })
-                });
+                retry.set(key, { identity: delivery.turnId });
             }
             else if (delivery.status === "delivered" || delivery.status === "already-delivered")
                 settled.add(key);
         }
         for (const wakeup of result.wakeups) {
             const key = `role:${encodeURIComponent(wakeup.taskId)}/leader`;
-            if (wakeup.terminalized === true) {
-                settled.add(key);
-                resignal.add(key);
-            }
-            else if (wakeup.reason === "writer-attached") {
-                writerBlocked.add(key);
-            }
-            else if (wakeup.reason === "not-ready"
-                || (wakeup.reason === "busy" && wakeup.runId !== undefined)) {
-                retry.set(key, { identity: wakeup.runId ?? key });
+            if (wakeup.reason === "not-ready"
+                || (wakeup.reason === "busy" && wakeup.turnId !== undefined)) {
+                retry.set(key, { identity: wakeup.turnId ?? key });
             }
             else if (wakeup.status === "dispatched")
                 settled.add(key);
@@ -1602,9 +1575,9 @@ export class FileTaskController {
         timer.unref();
         this.#deliveryRetryTimers.set(key, timer);
     }
-    #terminalizePreparedAfterRetryExhaustion(key, runId, failure) {
+    #terminalizePreparedAfterRetryExhaustion(key, turnId, failure) {
         if (!key.startsWith("role:")
-            || runId.startsWith("runtime-cleanup:")
+            || turnId.startsWith("runtime-cleanup:")
             || failure === undefined) {
             return;
         }
@@ -1613,10 +1586,10 @@ export class FileTaskController {
             return;
         if (target.taskId !== failure.taskId
             || target.roleName !== failure.roleName
-            || runId !== failure.runId) {
-            throw new Error(`Role delivery retry identity changed: ${key}/${runId}.`);
+            || turnId !== failure.turnId) {
+            throw new Error(`Role delivery retry identity changed: ${key}/${turnId}.`);
         }
-        const result = this.store.saveRoleRunDeliveryFailure({
+        const result = this.store.saveRoleTurnDeliveryFailure({
             ...failure,
             now: this.#now()
         });
@@ -1626,7 +1599,7 @@ export class FileTaskController {
         this.delivery.forgetPrepared?.({
             taskId: failure.taskId,
             roleName: failure.roleName,
-            runId: failure.runId,
+            turnId: failure.turnId,
             ...(failure.launchId === undefined
                 ? {}
                 : { launchId: failure.launchId })