@zq-silk/yui 0.2.0 → 0.4.2

package/dist/controller/controller.js

@@ -1,33 +1,535 @@
 import { reconciliationIntervalMilliseconds } from "../config/yuiConfig.js";
 import { processLeaderWakeups } from "../scheduler/leaderWakeupProcessor.js";
 import { processActiveRoleRunDeliveries } from "../scheduler/activeRoleRunDelivery.js";
-import { stopArchivedTaskRuntimes } from "../scheduler/archivedTaskRuntime.js";
+import { selectedSchedulerRoles, selectedSchedulerTasks } from "../scheduler/ports.js";
 import { reconcileExitedRoleRuns } from "../scheduler/roleRunLiveness.js";
+import { DEFAULT_STALL_WINDOW_MS, reconcileStalledRoleRuns } from "../scheduler/roleRunStall.js";
+import { repairOrphanedActiveTasks } from "../scheduler/activeTaskProgress.js";
 import { processOperatorInputNotifications } from "../scheduler/operatorInputNotificationProcessor.js";
 import { startControllerServer } from "../core/controllerServer.js";
+import { MailboxScheduler } from "../coordination/mailboxScheduler.js";
+import { nearestDeadlineBatch } from "../coordination/deadlineScheduler.js";
+import { hasRuntimeCleanupObligation, isRuntimeLaunchReservation, runtimeLifecycleTarget } from "../runtime/lifecycleReservation.js";
+import { formatTaskRecordReference } from "../task/taskRecordReference.js";
 const DEFAULT_RECONCILIATION_INTERVAL_MS = reconciliationIntervalMilliseconds();
+const DEFAULT_SIGNAL_WINDOW_MS = 100;
+const DEFAULT_DELIVERY_RETRY_MS = 250;
+const DEFAULT_DELIVERY_RETRY_LIMIT = 60;
+const RUNTIME_RESERVATION_RECOVERY_AGE_MS = 120_000;
+const MAX_TIMER_DELAY_MS = 2_147_483_647;
+class RuntimeEventApplyError extends AggregateError {
+}
 /**
- * Runs one lean scheduler pass. Liveness always precedes wakeup processing so
- * an exited busy Leader is cleared and reconsidered in the same pass.
+ * 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) {
-    await workspacePreparer?.prepareActiveTaskWorkspaces();
-    const stoppedArchivedTaskIds = await stopArchivedTaskRuntimes(store, delivery, now);
-    await workspacePreparer?.cleanupArchivedTaskWorkspaces();
-    const activeRunDeliveries = await processActiveRoleRunDeliveries(store, delivery, now);
-    const failedRunIds = await reconcileExitedRoleRuns(store, delivery, now);
-    const autoResolvedInputs = store.resolveExpiredInputRecommendations(now);
-    const wakeups = await processLeaderWakeups(store, delivery, now);
-    const inputNotifications = await processOperatorInputNotifications(store, delivery);
+export async function runControllerSchedulerPass(store, delivery, now, workspacePreparer, scope = { kind: "full" }, includeOperator = true, runtimeCleanupOutcomes = [], lifecycleHost, stallWindowMs = DEFAULT_STALL_WINDOW_MS, resourceSuppressionKeys = new Set()) {
+    const compiledSelection = compileReconcileSelection(scope);
+    const selection = includeOperator
+        ? compiledSelection
+        : { ...compiledSelection, operator: false };
+    queueSelectedCompletedTaskRuntimeCleanups(store, selection, now);
+    const failedCleanupRoles = await processSelectedRoleRuntimeCleanups(store, delivery, lifecycleHost, scope, now, runtimeCleanupOutcomes);
+    const roleSelection = selectionWithoutFailedCleanupRoles(store, selection, failedCleanupRoles);
+    const wakeupSelection = selectionWithoutFailedLeaderCleanupTasks(store, selection, failedCleanupRoles);
+    if (selection.full)
+        repairOrphanedActiveTasks(store, now, selection);
+    const claimedTaskMailboxes = claimSelectedTaskMailboxes(store, selection, now);
+    try {
+        const failedTaskMailboxes = await prepareActiveWorkspaces(store, workspacePreparer, selection);
+        const activeRunDeliveries = await processActiveRoleRunDeliveries(store, delivery, now, roleSelection);
+        const unsettledRunRefs = new Set(activeRunDeliveries.flatMap((result) => (result.reason === "delivery-uncertain" || result.terminalFailure !== undefined
+            ? [formatTaskRecordReference(result.taskId, result.runId, "agentRun")]
+            : [])));
+        resolveDueRuntimeTurnCompletions(store, delivery, selection, now);
+        const liveStatuses = new Map();
+        const resourceEvidence = new Map();
+        const failedRunRefs = await reconcileExitedRoleRuns(store, delivery, now, roleSelection, unsettledRunRefs, liveStatuses, resourceEvidence);
+        await reconcileStalledRoleRuns(store, delivery, now, roleSelection, stallWindowMs, liveStatuses, resourceEvidence, resourceSuppressionKeys);
+        await reconcileDormantRuntimeOwners(store, delivery, lifecycleHost, scope, now);
+        const autoResolvedInputs = selection.full
+            ? store.resolveExpiredInputRecommendations(now)
+            : selection.taskIds.size === 0
+                ? []
+                : store.resolveExpiredInputRecommendations(now, selection.taskIds);
+        const wakeups = await processLeaderWakeups(store, delivery, now, wakeupSelection);
+        const inputNotifications = includeOperator
+            ? await processOperatorInputNotifications(store, delivery, selection, now)
+            : [];
+        for (const claim of claimedTaskMailboxes) {
+            if (failedTaskMailboxes.has(claim.target.taskId)) {
+                store.releaseWorkMailbox(claim.target, claim.processing.batchId);
+            }
+            else {
+                store.completeWorkMailbox(claim.target, claim.processing.batchId);
+            }
+        }
+        return {
+            activeRunDeliveries,
+            failedRunRefs,
+            wakeups,
+            inputNotifications,
+            autoResolvedInputs
+        };
+    }
+    catch (error) {
+        for (const claim of claimedTaskMailboxes) {
+            store.releaseWorkMailbox(claim.target, claim.processing.batchId);
+        }
+        throw error;
+    }
+}
+function queueSelectedCompletedTaskRuntimeCleanups(store, selection, now) {
+    if (store.enqueueRuntimeCleanup === undefined)
+        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 === "stopped" || session.status === "broken") {
+        return false;
+    }
+    return session.status === "running" || session.launchId !== undefined;
+}
+async function processSelectedRoleRuntimeCleanups(store, delivery, lifecycleHost, scope, now, outcomes) {
+    const targets = selectedRuntimeLifecycleTargets(store, scope);
+    const failedRoles = new Set();
+    for (const target of targets) {
+        const mailbox = store.getWorkMailbox(target);
+        if (mailbox === null)
+            continue;
+        const owner = runtimeOwner(target);
+        const batchId = runtimeLifecycleBatchIdentity(target, mailbox);
+        if (hasRuntimeCleanupObligation(mailbox)) {
+            try {
+                if (lifecycleHost === undefined) {
+                    throw new Error("Role runtime cleanup host is unavailable.");
+                }
+                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 reservedLaunchId = isRuntimeLaunchReservation(mailbox.processing)
+                        ? mailbox.processing.batchId
+                        : undefined;
+                    if (reservedLaunchId !== undefined
+                        && session?.launchId !== undefined
+                        && reservedLaunchId !== session.launchId) {
+                        throw new Error(`Task runtime cleanup launch identity is ambiguous: ${target.taskId}.`);
+                    }
+                    const launchId = reservedLaunchId ?? session?.launchId;
+                    if (launchId !== undefined
+                        && lifecycleHost.cleanupTaskLaunch !== undefined) {
+                        const task = store.getTask(target.taskId);
+                        const reason = task?.status === "completed"
+                            ? "completion"
+                            : "interruption";
+                        lifecycleHost.cleanupTaskLaunch({
+                            taskId: target.taskId,
+                            launchId,
+                            reason
+                        });
+                    }
+                }
+                if (store.completeRuntimeCleanup === undefined
+                    || !store.completeRuntimeCleanup(target, now)) {
+                    throw new Error(`Role runtime cleanup 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 });
+            }
+            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) {
+    if (scope.kind !== "full"
+        || lifecycleHost === undefined
+        || store.listDormantRuntimeOwners === undefined
+        || store.markRuntimeOwnerStopped === undefined) {
+        return;
+    }
+    const candidates = store.listDormantRuntimeOwners();
+    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.owner.scope === "task"
+                && candidate.launchId !== undefined) {
+                // The exact launch-owned resources must settle through the durable
+                // cleanup lane before its Session fact becomes stopped. The candidate
+                // is passed back as the CAS fence so a concurrent Hook/launch cannot
+                // redirect cleanup to a newer generation.
+                store.enqueueRuntimeCleanup?.(candidate.owner, now, candidate);
+                continue;
+            }
+            if (store.markRuntimeOwnerStopped(candidate, now)) {
+                forgetPreparedRuntimeOwner(delivery, candidate.owner);
+            }
+        }
+    }
+}
+function forgetPreparedRuntimeOwner(delivery, owner) {
+    if (owner.scope !== "task")
+        return;
+    delivery.forgetPrepared?.({
+        taskId: owner.taskId,
+        roleName: owner.roleName
+    });
+}
+function runtimeOwnerIdentity(owner) {
+    return owner.scope === "task"
+        ? `task\0${owner.taskId}\0${owner.roleName}`
+        : `global\0${owner.roleName}`;
+}
+function resolveDueRuntimeTurnCompletions(store, delivery, selection, now) {
+    if (typeof store.resolveDueRuntimeTurnCompletions !== "function")
+        return;
+    const selectedTaskIds = selection.full ? undefined : selection.taskIds;
+    if (selectedTaskIds?.size === 0)
+        return;
+    const candidates = store.listPendingRuntimeTurnCompletions().filter((completion) => (selectedTaskIds === undefined
+        || selectedTaskIds.has(completion.taskId)));
+    const finalized = new Set(store.resolveDueRuntimeTurnCompletions(now, selectedTaskIds));
+    if (finalized.size === 0)
+        return;
+    for (const completion of candidates) {
+        if (!finalized.has(formatTaskRecordReference(completion.taskId, completion.runId, "agentRun")))
+            continue;
+        delivery.forgetPrepared?.({
+            taskId: completion.taskId,
+            roleName: completion.roleName,
+            runId: completion.runId
+        });
+    }
+}
+function selectedRuntimeLifecycleTargets(store, scope) {
+    if (scope.kind === "full") {
+        return store.listWorkMailboxes().flatMap((mailbox) => (mailbox.target.kind === "role-runtime"
+            || mailbox.target.kind === "global-role-runtime"
+            ? [mailbox.target]
+            : []));
+    }
+    const targets = new Map();
+    for (const key of scope.keys) {
+        const parsed = parseMailboxKey(key);
+        if (parsed.kind === "task") {
+            for (const role of store.listRoles(parsed.taskId)) {
+                const target = {
+                    kind: "role-runtime",
+                    taskId: parsed.taskId,
+                    roleName: role.name
+                };
+                targets.set(runtimeTargetIdentity(target), target);
+            }
+        }
+        else if (parsed.kind === "role") {
+            const target = {
+                kind: "role-runtime",
+                taskId: parsed.taskId,
+                roleName: parsed.roleName
+            };
+            targets.set(runtimeTargetIdentity(target), target);
+        }
+        else if (parsed.kind === "global-role") {
+            const target = {
+                kind: "global-role-runtime",
+                roleName: parsed.roleName
+            };
+            targets.set(runtimeTargetIdentity(target), target);
+        }
+    }
+    return [...targets.values()];
+}
+function runtimeOwner(target) {
+    return target.kind === "role-runtime"
+        ? {
+            scope: "task",
+            taskId: target.taskId,
+            roleName: target.roleName
+        }
+        : { scope: "global", roleName: target.roleName };
+}
+function runtimeOwnerLabel(owner) {
+    return owner.scope === "task"
+        ? `${owner.taskId}/${owner.roleName}`
+        : `global/${owner.roleName}`;
+}
+function runtimeTargetIdentity(target) {
+    return target.kind === "role-runtime"
+        ? `task\0${target.taskId}\0${target.roleName}`
+        : `global\0${target.roleName}`;
+}
+function runtimeCleanupMailboxKey(target) {
+    return target.kind === "role-runtime"
+        ? `role:${encodeURIComponent(target.taskId)}/${encodeURIComponent(target.roleName)}`
+        : `global-role:${encodeURIComponent(target.roleName)}`;
+}
+function runtimeLifecycleBatchIdentity(target, mailbox) {
+    if (mailbox.processing !== null)
+        return mailbox.processing.batchId;
+    const pending = mailbox.pending;
+    return pending === null
+        ? runtimeTargetIdentity(target)
+        : `${runtimeTargetIdentity(target)}:${pending.fromSequence}-${pending.toSequence}`;
+}
+function markFailedRuntimeTarget(failedRoles, target) {
+    if (target.kind === "role-runtime") {
+        failedRoles.add(roleIdentity(target.taskId, target.roleName));
+    }
+}
+function selectionWithoutFailedCleanupRoles(store, selection, failedRoles) {
+    if (failedRoles.size === 0)
+        return selection;
+    const taskIds = selection.full
+        ? new Set(store.listTasks().map((task) => task.id))
+        : new Set(selection.taskIds);
+    const rolesByTask = new Map();
+    for (const taskId of taskIds) {
+        const roleNames = selection.full || selection.allRoleTaskIds.has(taskId)
+            ? store.listRoles(taskId).map((role) => role.name)
+            : [...(selection.rolesByTask.get(taskId) ?? [])];
+        rolesByTask.set(taskId, new Set(roleNames.filter((roleName) => (!failedRoles.has(roleIdentity(taskId, roleName))))));
+    }
+    return {
+        full: false,
+        taskIds,
+        allRoleTaskIds: new Set(),
+        rolesByTask,
+        operator: selection.operator
+    };
+}
+function selectionWithoutFailedLeaderCleanupTasks(store, selection, failedRoles) {
+    if (![...failedRoles].some((identity) => identity.endsWith("\0leader"))) {
+        return selection;
+    }
+    const taskIds = selection.full
+        ? new Set(store.listTasks().map((task) => task.id))
+        : new Set(selection.taskIds);
+    for (const taskId of taskIds) {
+        if (failedRoles.has(roleIdentity(taskId, "leader")))
+            taskIds.delete(taskId);
+    }
+    return {
+        full: false,
+        taskIds,
+        allRoleTaskIds: new Set(),
+        rolesByTask: new Map(),
+        operator: selection.operator
+    };
+}
+function roleIdentity(taskId, roleName) {
+    return `${taskId}\0${roleName}`;
+}
+function claimSelectedTaskMailboxes(store, selection, now) {
+    const targets = selection.full
+        ? store.listWorkMailboxes().flatMap((mailbox) => (mailbox.target.kind === "task" ? [mailbox.target] : []))
+        : [...selection.allRoleTaskIds].map((taskId) => ({ kind: "task", taskId }));
+    const claims = [];
+    for (const target of targets) {
+        const mailbox = store.getWorkMailbox(target);
+        if (mailbox === null || (mailbox.processing === null && mailbox.pending === null))
+            continue;
+        const batchId = mailbox.processing?.batchId
+            ?? `task:${encodeURIComponent(target.taskId)}:${mailbox.pending.fromSequence}-${mailbox.pending.toSequence}`;
+        const claim = store.claimWorkMailbox({
+            target,
+            batchId,
+            owner: "controller",
+            now
+        });
+        if (claim.status !== "empty")
+            claims.push({ target, processing: claim.processing });
+    }
+    return claims;
+}
+export function compileReconcileSelection(scope) {
+    if (scope.kind === "full") {
+        return {
+            full: true,
+            taskIds: new Set(),
+            allRoleTaskIds: new Set(),
+            rolesByTask: new Map(),
+            operator: true
+        };
+    }
+    const taskIds = new Set();
+    const allRoleTaskIds = new Set();
+    const mutableRoles = new Map();
+    let operator = false;
+    for (const key of scope.keys) {
+        const target = parseMailboxKey(key);
+        if (target.kind === "operator") {
+            operator = true;
+        }
+        else if (target.kind === "task") {
+            taskIds.add(target.taskId);
+            allRoleTaskIds.add(target.taskId);
+        }
+        else if (target.kind === "role") {
+            taskIds.add(target.taskId);
+            const roles = mutableRoles.get(target.taskId) ?? new Set();
+            roles.add(target.roleName);
+            mutableRoles.set(target.taskId, roles);
+        }
+    }
     return {
-        stoppedArchivedTaskIds,
-        activeRunDeliveries,
-        failedRunIds,
-        wakeups,
-        inputNotifications,
-        autoResolvedInputs
+        full: false,
+        taskIds,
+        allRoleTaskIds,
+        rolesByTask: mutableRoles,
+        operator
     };
 }
+async function prepareActiveWorkspaces(store, workspace, selection) {
+    if (workspace === undefined)
+        return new Set();
+    const taskIds = selection.full
+        ? new Set(store.listTasks()
+            .filter((task) => task.status === "active")
+            .map((task) => task.id))
+        : new Set([...selection.taskIds, ...selection.allRoleTaskIds]);
+    const failed = new Set();
+    for (const taskId of taskIds) {
+        if (store.getTask(taskId)?.status === "active") {
+            try {
+                const result = await workspace.prepareTaskWorkspace(taskId);
+                if (result.status === "failed")
+                    failed.add(taskId);
+            }
+            catch {
+                failed.add(taskId);
+            }
+        }
+    }
+    return failed;
+}
+function parseMailboxKey(key) {
+    if (key === "operator")
+        return { kind: "operator" };
+    if (key.startsWith("task:")) {
+        return { kind: "task", taskId: mailboxPart(key.slice("task:".length), key) };
+    }
+    if (key.startsWith("global-role:")) {
+        return {
+            kind: "global-role",
+            roleName: mailboxPart(key.slice("global-role:".length), key)
+        };
+    }
+    if (key.startsWith("role:")) {
+        const value = key.slice("role:".length);
+        const separator = value.indexOf("/");
+        if (separator > 0 && separator < value.length - 1 && value.indexOf("/", separator + 1) < 0) {
+            return {
+                kind: "role",
+                taskId: mailboxPart(value.slice(0, separator), key),
+                roleName: mailboxPart(value.slice(separator + 1), key)
+            };
+        }
+    }
+    throw new TypeError(`Controller mailbox key is invalid: ${key}.`);
+}
+function mailboxPart(value, key) {
+    if (value.length === 0 || value.trim() !== value || value.includes("\0")) {
+        throw new TypeError(`Controller mailbox key is invalid: ${key}.`);
+    }
+    try {
+        const decoded = decodeURIComponent(value);
+        if (decoded.length === 0 || decoded.includes("\0") || encodeURIComponent(decoded) !== value) {
+            throw new Error("not canonical");
+        }
+        return decoded;
+    }
+    catch {
+        throw new TypeError(`Controller mailbox key is invalid: ${key}.`);
+    }
+}
 /**
  * Single-owner periodic runtime for FileTaskStore-backed scheduling. Concurrent
  * pump requests coalesce into one follow-up pass; scheduler effects never
@@ -40,9 +542,30 @@ export class FileTaskController {
     #now;
     #onError;
     #workspacePreparer;
+    #deliveryRetryMs;
+    #deliveryRetryLimit;
+    #stallWindowMs;
+    /** Narrow-port fallback; FileSchedulerStoreAdapter durably records these keys. */
+    #resourceSuppressionKeys = new Set();
+    #runtimeEventProcessor;
+    #lifecycleHost;
+    #deliveryRetryAttempts = new Map();
+    #deliveryRetryTimers = new Map();
+    #passRetryTimer;
+    #passRetryAttempt = 0;
     #timer;
+    #deadlineTimer;
+    #signalScheduler;
+    #operatorSignalScheduler;
+    #configuration;
+    #resourceReaper;
+    #onExpiredEphemeralDomain;
     #current;
-    #rerunRequested = false;
+    #operatorCurrent;
+    #pendingFull = false;
+    #pendingKeys = new Set();
+    #operatorStartupRetryArmed = false;
+    #lastOperatorSignalIdentity;
     #stopped = false;
     constructor(store, delivery, options = {}) {
         this.store = store;
@@ -51,33 +574,151 @@ export class FileTaskController {
         this.#now = options.now ?? (() => new Date());
         this.#onError = options.onError ?? (() => { });
         this.#workspacePreparer = options.workspacePreparer;
+        this.#deliveryRetryMs = positiveInteger(options.deliveryRetryMs, DEFAULT_DELIVERY_RETRY_MS, "Controller delivery retry delay");
+        this.#deliveryRetryLimit = positiveInteger(options.deliveryRetryLimit, DEFAULT_DELIVERY_RETRY_LIMIT, "Controller delivery retry limit");
+        this.#stallWindowMs = positiveInteger(options.stallWindowMs, DEFAULT_STALL_WINDOW_MS, "Controller Run stall window");
+        this.#runtimeEventProcessor = options.runtimeEventProcessor;
+        this.#lifecycleHost = options.lifecycleHost;
+        this.#configuration = options.configuration;
+        this.#resourceReaper = options.resourceReaper;
+        this.#onExpiredEphemeralDomain = options.onExpiredEphemeralDomain;
+        this.#signalScheduler = new MailboxScheduler(async (keys) => { await this.#requestPass({ kind: "dirty", keys }); }, {
+            windowMs: options.signalWindowMs ?? DEFAULT_SIGNAL_WINDOW_MS,
+            onError: this.#onError,
+            setTimer: (callback, delayMs) => {
+                const timer = setTimeout(callback, delayMs);
+                timer.unref();
+                return timer;
+            }
+        });
+        this.#operatorSignalScheduler = new MailboxScheduler(async () => {
+            const running = this.#runOperatorPass();
+            this.#operatorCurrent = running;
+            try {
+                await running;
+            }
+            finally {
+                if (this.#operatorCurrent === running)
+                    this.#operatorCurrent = undefined;
+            }
+        }, {
+            windowMs: options.signalWindowMs ?? DEFAULT_SIGNAL_WINDOW_MS,
+            onError: this.#onError,
+            setTimer: (callback, delayMs) => {
+                const timer = setTimeout(callback, delayMs);
+                timer.unref();
+                return timer;
+            }
+        });
     }
     get reconciliationIntervalMs() {
         return this.#intervalMs;
     }
+    updateReconciliationInterval(intervalMs) {
+        const next = positiveInteger(intervalMs, DEFAULT_RECONCILIATION_INTERVAL_MS, "Controller reconciliation interval");
+        if (this.#stopped)
+            throw new Error("Controller runtime is stopped.");
+        if (next === this.#intervalMs)
+            return;
+        this.#intervalMs = next;
+        if (this.#timer !== undefined) {
+            clearInterval(this.#timer);
+            this.#timer = setInterval(() => {
+                this.#requestBackgroundPump();
+            }, this.#intervalMs);
+            this.#timer.unref();
+        }
+    }
+    reloadReconciliationInterval() {
+        if (this.#configuration !== undefined) {
+            this.updateReconciliationInterval(this.#configuration.reconciliationIntervalMs());
+        }
+        return this.#intervalMs;
+    }
     start() {
         if (this.#timer !== undefined)
             return;
-        this.#stopped = false;
-        void this.pump().catch(this.#onError);
+        if (this.#stopped)
+            throw new Error("Controller runtime is stopped.");
+        this.#requestBackgroundPump();
+        // Arm the Operator lane once for work that was already pending when the
+        // Controller started. Subsequent main-lane passes signal it only when a
+        // new Operator batch is durably queued; an unchanged pending batch must
+        // not keep an unavailable Operator lane in a zero-delay drain loop.
+        this.#signalOperatorMailbox();
         this.#timer = setInterval(() => {
-            void this.pump().catch(this.#onError);
+            this.#requestBackgroundPump();
         }, this.#intervalMs);
         this.#timer.unref();
     }
     stop() {
         this.#stopped = true;
+        this.#signalScheduler.stop();
+        this.#operatorSignalScheduler.stop();
+        if (this.#deadlineTimer !== undefined) {
+            clearTimeout(this.#deadlineTimer);
+            this.#deadlineTimer = undefined;
+        }
         if (this.#timer !== undefined) {
             clearInterval(this.#timer);
             this.#timer = undefined;
         }
+        for (const timer of this.#deliveryRetryTimers.values())
+            clearTimeout(timer);
+        this.#deliveryRetryTimers.clear();
+        this.#deliveryRetryAttempts.clear();
+        if (this.#passRetryTimer !== undefined) {
+            clearTimeout(this.#passRetryTimer);
+            this.#passRetryTimer = undefined;
+        }
+    }
+    async shutdownAndDrain() {
+        this.stop();
+        await Promise.allSettled([
+            this.#current ?? Promise.resolve(),
+            this.#operatorCurrent ?? Promise.resolve()
+        ]);
+    }
+    /** Adds one dirty Task key to the fixed-window wake queue and returns immediately. */
+    signal(key) {
+        if (this.#stopped)
+            throw new Error("Controller runtime is stopped.");
+        parseMailboxKey(key);
+        if (key === "operator") {
+            // Main lane owns durable Hook folding; the Operator lane is the sole
+            // consumer of the Operator delivery mailbox.
+            this.#signalScheduler.signal("operator");
+            this.#operatorSignalScheduler.signal("operator");
+        }
+        else
+            this.#signalScheduler.signal(key);
     }
     pump() {
+        return this.#requestPass({ kind: "full" });
+    }
+    armOperatorStartupRetry() {
+        if (this.#stopped)
+            return;
+        const mailbox = this.store.getWorkMailbox({ kind: "operator" });
+        const shouldArm = mailbox !== null
+            && (mailbox.pending !== null || mailbox.processing !== null);
+        if (shouldArm)
+            this.#clearDeliveryRetry("operator");
+        this.#operatorStartupRetryArmed = shouldArm;
+    }
+    #requestPass(scope) {
         if (this.#stopped) {
             return Promise.reject(new Error("Controller runtime is stopped."));
         }
+        if (scope.kind === "full") {
+            this.#pendingFull = true;
+            this.#pendingKeys.clear();
+        }
+        else if (!this.#pendingFull) {
+            for (const key of scope.keys)
+                this.#pendingKeys.add(key);
+        }
         if (this.#current !== undefined) {
-            this.#rerunRequested = true;
             return this.#current;
         }
         const running = this.#runCoalesced();
@@ -88,43 +729,410 @@ export class FileTaskController {
         }).catch(() => { });
         return running;
     }
+    #requestBackgroundPump() {
+        void this.pump().catch(this.#onError);
+    }
     async #runCoalesced() {
         let result = {
-            stoppedArchivedTaskIds: [],
             activeRunDeliveries: [],
-            failedRunIds: [],
+            failedRunRefs: [],
             wakeups: [],
             inputNotifications: [],
             autoResolvedInputs: []
         };
-        do {
-            this.#rerunRequested = false;
-            result = await runControllerSchedulerPass(this.store, this.delivery, this.#now(), this.#workspacePreparer);
-        } while (this.#rerunRequested && !this.#stopped);
+        try {
+            while (this.#pendingFull || this.#pendingKeys.size > 0) {
+                const scope = this.#pendingFull
+                    ? { kind: "full" }
+                    : { kind: "dirty", keys: [...this.#pendingKeys] };
+                const runtimeCleanupOutcomes = [];
+                this.#pendingFull = false;
+                this.#pendingKeys.clear();
+                try {
+                    if (scope.kind === "full")
+                        this.reloadReconciliationInterval();
+                    if (scope.kind === "full" && this.#resourceReaper !== undefined) {
+                        const reap = await this.#resourceReaper();
+                        for (const failure of reap.failed) {
+                            this.#onError(new Error(`Ephemeral runtime reap failed for ${failure.id}: ${failure.message}`));
+                        }
+                        // The reaper owns the exact resource fences. Once a whole expired
+                        // domain converges, let the detached Controller close itself on a
+                        // later turn; never close while this reconciliation pass is still
+                        // the in-flight server request.
+                        if (reap.failed.length === 0 && (reap.expiredDomains?.length ?? 0) > 0) {
+                            for (const domain of reap.expiredDomains ?? []) {
+                                queueMicrotask(() => {
+                                    this.#onExpiredEphemeralDomain?.(domain);
+                                });
+                            }
+                        }
+                    }
+                    const firstRuntimeDrain = this.#drainRuntimeEvents();
+                    result = await runControllerSchedulerPass(this.store, this.delivery, this.#now(), this.#workspacePreparer, scope, false, runtimeCleanupOutcomes, this.#lifecycleHost, this.#stallWindowMs, this.#resourceSuppressionKeys);
+                    const secondRuntimeDrain = this.#drainRuntimeEvents();
+                    this.#clearPassRetry();
+                    this.#scheduleRuntimeCleanupRetries(runtimeCleanupOutcomes);
+                    this.#scheduleDeliveryRetries(result);
+                    this.#scheduleTaskMailboxRetries(scope);
+                    if (scope.kind === "full"
+                        || scope.keys.some((key) => key !== "operator")
+                        || (firstRuntimeDrain?.acknowledgedEventIds.length ?? 0) > 0
+                        || (secondRuntimeDrain?.acknowledgedEventIds.length ?? 0) > 0) {
+                        this.#signalOperatorMailbox();
+                    }
+                }
+                catch (error) {
+                    if (scope.kind === "full") {
+                        this.#pendingFull = true;
+                        this.#pendingKeys.clear();
+                    }
+                    else if (!this.#pendingFull) {
+                        for (const key of scope.keys)
+                            this.#pendingKeys.add(key);
+                    }
+                    this.#schedulePassRetry();
+                    throw error;
+                }
+                if (this.#stopped)
+                    break;
+            }
+            return result;
+        }
+        finally {
+            this.#scheduleNextInputDeadline();
+        }
+    }
+    async #runOperatorPass() {
+        const result = await runControllerSchedulerPass(this.store, this.delivery, this.#now(), undefined, { kind: "dirty", keys: ["operator"] });
+        if (this.#operatorStartupRetryArmed && result.inputNotifications.length === 0) {
+            const mailbox = this.store.getWorkMailbox({ kind: "operator" });
+            if (mailbox === null
+                || (mailbox.pending === null && mailbox.processing === null)) {
+                this.#operatorStartupRetryArmed = false;
+            }
+        }
+        this.#scheduleDeliveryRetries(result);
+        this.#clearEmptyOperatorRetry();
+        this.#scheduleNextInputDeadline();
+    }
+    #signalOperatorMailbox() {
+        if (this.#stopped)
+            return;
+        const mailbox = this.store.getWorkMailbox({ kind: "operator" });
+        const identity = operatorMailboxBatchIdentity(mailbox);
+        if (identity === null) {
+            this.#lastOperatorSignalIdentity = undefined;
+            return;
+        }
+        if (identity !== this.#lastOperatorSignalIdentity) {
+            this.#operatorSignalScheduler.signal("operator");
+            this.#lastOperatorSignalIdentity = identity;
+        }
+    }
+    #drainRuntimeEvents() {
+        const result = this.#runtimeEventProcessor?.drain(this.#now());
+        if (result !== undefined && result.failed.length > 0) {
+            throw new RuntimeEventApplyError(result.failed.map((failure) => failure.error), "One or more native Turn events could not be applied.");
+        }
         return result;
     }
+    #schedulePassRetry() {
+        if (this.#stopped
+            || this.#passRetryTimer !== undefined
+            || this.#passRetryAttempt >= this.#deliveryRetryLimit)
+            return;
+        const delayMs = Math.min(2_000, this.#deliveryRetryMs * (2 ** Math.min(this.#passRetryAttempt, 3)));
+        this.#passRetryAttempt += 1;
+        this.#passRetryTimer = setTimeout(() => {
+            this.#passRetryTimer = undefined;
+            if (this.#stopped)
+                return;
+            void this.#requestPass({ kind: "dirty", keys: [] }).catch(this.#onError);
+        }, delayMs);
+        this.#passRetryTimer.unref();
+    }
+    #clearPassRetry() {
+        if (this.#passRetryTimer !== undefined)
+            clearTimeout(this.#passRetryTimer);
+        this.#passRetryTimer = undefined;
+        this.#passRetryAttempt = 0;
+    }
+    #scheduleNextInputDeadline() {
+        if (this.#deadlineTimer !== undefined) {
+            clearTimeout(this.#deadlineTimer);
+            this.#deadlineTimer = undefined;
+        }
+        if (this.#stopped)
+            return;
+        const deadlines = [
+            ...this.store.listOpenInputRequests()
+                .flatMap((request) => request.policy.kind === "recommended"
+                ? [{
+                        key: `task:${encodeURIComponent(request.taskId)}`,
+                        at: Date.parse(request.policy.timeoutAt)
+                    }]
+                : []),
+            ...(typeof this.store.listPendingRuntimeTurnCompletions === "function"
+                ? this.store.listPendingRuntimeTurnCompletions()
+                : []).map((completion) => ({
+                key: `role:${encodeURIComponent(completion.taskId)}/${encodeURIComponent(completion.roleName)}`,
+                at: Date.parse(completion.dueAt)
+            }))
+        ];
+        const nearest = nearestDeadlineBatch(deadlines);
+        if (nearest === null)
+            return;
+        const now = this.#now().getTime();
+        // Preserve an upcoming semantic deadline even while another pass backs
+        // off. Once that deadline has fired, the bounded pass retry owns failures
+        // so an overdue record cannot create a zero-delay hot loop.
+        if (nearest.at <= now && this.#passRetryAttempt > 0)
+            return;
+        const delayMs = Math.min(MAX_TIMER_DELAY_MS, Math.max(0, nearest.at - now));
+        this.#deadlineTimer = setTimeout(() => {
+            this.#deadlineTimer = undefined;
+            for (const key of nearest.keys)
+                this.#signalScheduler.signal(key);
+            void this.#signalScheduler.drain().catch(this.#onError);
+        }, delayMs);
+        this.#deadlineTimer.unref();
+    }
+    #scheduleDeliveryRetries(result) {
+        const retry = new Map();
+        const settled = new Set();
+        const resignal = new Set();
+        for (const delivery of result.activeRunDeliveries) {
+            const key = `role:${encodeURIComponent(delivery.taskId)}/${encodeURIComponent(delivery.roleName)}`;
+            if (delivery.terminalized === true) {
+                settled.add(key);
+                resignal.add(key);
+            }
+            else if (delivery.reason === "not-ready"
+                || delivery.reason === "runtime-unavailable"
+                || delivery.reason === "delivery-uncertain") {
+                retry.set(key, {
+                    identity: delivery.runId,
+                    ...(delivery.terminalFailure === undefined
+                        ? {}
+                        : { terminalFailure: delivery.terminalFailure })
+                });
+            }
+            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.reason === "not-ready"
+                || wakeup.reason === "delivery-uncertain") {
+                retry.set(key, { identity: wakeup.runId ?? key });
+            }
+            else if (wakeup.status === "dispatched")
+                settled.add(key);
+        }
+        const operatorRetries = result.inputNotifications.filter((notification) => notification.reason === "operator-not-ready"
+            || (notification.reason === "operator-unavailable"
+                && this.#operatorStartupRetryArmed));
+        if (operatorRetries.length > 0) {
+            retry.set("operator", {
+                identity: operatorRetries.map((notification) => ("inputRequestId" in notification
+                    ? `input:${notification.inputRequestId}`
+                    : "recoveryTaskId" in notification
+                        ? `recovery:${notification.recoveryTaskId}`
+                        : "stallTaskId" in notification
+                            ? `stall:${notification.stallTaskId}`
+                            : `terminal:${notification.terminalTaskId}`)).join("|")
+            });
+        }
+        else if (result.inputNotifications.some((notification) => notification.status === "sent"
+            || notification.status === "already-sent")) {
+            this.#operatorStartupRetryArmed = false;
+            settled.add("operator");
+        }
+        for (const key of settled)
+            this.#clearDeliveryRetry(key);
+        for (const key of resignal)
+            this.signal(key);
+        for (const [key, candidate] of retry) {
+            this.#scheduleDeliveryRetry(key, candidate.identity, candidate.terminalFailure);
+        }
+    }
+    #scheduleRuntimeCleanupRetries(outcomes) {
+        for (const outcome of outcomes) {
+            const key = runtimeCleanupMailboxKey(outcome.target);
+            const identity = `runtime-cleanup:${outcome.batchId}`;
+            if (outcome.status === "failed") {
+                if (outcome.error !== undefined)
+                    this.#onError(outcome.error);
+                this.#scheduleDeliveryRetry(key, identity);
+                continue;
+            }
+            if (this.#deliveryRetryAttempts.get(key)?.identity === identity) {
+                this.#clearDeliveryRetry(key);
+            }
+        }
+    }
+    #scheduleTaskMailboxRetries(scope) {
+        const selection = compileReconcileSelection(scope);
+        const targets = selection.full
+            ? this.store.listWorkMailboxes().flatMap((mailbox) => (mailbox.target.kind === "task" ? [mailbox.target] : []))
+            : [...selection.allRoleTaskIds].map((taskId) => ({ kind: "task", taskId }));
+        for (const target of targets) {
+            const key = `task:${encodeURIComponent(target.taskId)}`;
+            const mailbox = this.store.getWorkMailbox(target);
+            const batch = mailbox?.pending ?? mailbox?.processing?.batch;
+            if (batch === undefined || batch === null) {
+                this.#clearDeliveryRetry(key);
+                continue;
+            }
+            this.#scheduleDeliveryRetry(key, `${batch.fromSequence}-${batch.toSequence}`);
+        }
+    }
+    #scheduleDeliveryRetry(key, identity, terminalFailure) {
+        let previous = this.#deliveryRetryAttempts.get(key);
+        if (previous !== undefined && previous.identity !== identity) {
+            this.#clearDeliveryRetry(key);
+            previous = undefined;
+        }
+        const stableTerminalFailure = previous?.terminalFailure ?? terminalFailure;
+        if (this.#deliveryRetryTimers.has(key)) {
+            if (previous !== undefined && stableTerminalFailure !== previous.terminalFailure) {
+                this.#deliveryRetryAttempts.set(key, {
+                    ...previous,
+                    terminalFailure: stableTerminalFailure
+                });
+            }
+            return;
+        }
+        const attempts = previous?.attempts ?? 0;
+        if (attempts >= this.#deliveryRetryLimit) {
+            if (key === "operator")
+                this.#operatorStartupRetryArmed = false;
+            this.#terminalizePreparedAfterRetryExhaustion(key, identity, stableTerminalFailure);
+            return;
+        }
+        this.#deliveryRetryAttempts.set(key, {
+            identity,
+            attempts: attempts + 1,
+            ...(stableTerminalFailure === undefined
+                ? {}
+                : { terminalFailure: stableTerminalFailure })
+        });
+        const delayMs = Math.min(2_000, this.#deliveryRetryMs * (2 ** Math.min(attempts, 3)));
+        const timer = setTimeout(() => {
+            this.#deliveryRetryTimers.delete(key);
+            if (!this.#stopped)
+                this.signal(key);
+        }, delayMs);
+        timer.unref();
+        this.#deliveryRetryTimers.set(key, timer);
+    }
+    #terminalizePreparedAfterRetryExhaustion(key, runId, failure) {
+        if (!key.startsWith("role:")
+            || runId.startsWith("runtime-cleanup:")
+            || failure === undefined) {
+            return;
+        }
+        const target = parseMailboxKey(key);
+        if (target.kind !== "role")
+            return;
+        if (target.taskId !== failure.taskId
+            || target.roleName !== failure.roleName
+            || runId !== failure.runId) {
+            throw new Error(`Role delivery retry identity changed: ${key}/${runId}.`);
+        }
+        const result = this.store.saveRoleRunDeliveryFailure({
+            ...failure,
+            now: this.#now()
+        });
+        this.#clearDeliveryRetry(key);
+        if (result !== "failed")
+            return;
+        this.delivery.forgetPrepared?.({
+            taskId: failure.taskId,
+            roleName: failure.roleName,
+            runId: failure.runId,
+            ...(failure.launchId === undefined
+                ? {}
+                : { launchId: failure.launchId })
+        });
+        if (!this.#stopped)
+            this.signal(key);
+    }
+    #clearEmptyOperatorRetry() {
+        if (!this.#operatorStartupRetryArmed
+            && !this.#deliveryRetryAttempts.has("operator"))
+            return;
+        const mailbox = this.store.getWorkMailbox({ kind: "operator" });
+        if (mailbox === null
+            || (mailbox.pending === null && mailbox.processing === null)) {
+            this.#operatorStartupRetryArmed = false;
+            this.#clearDeliveryRetry("operator");
+        }
+    }
+    #clearDeliveryRetry(key) {
+        const timer = this.#deliveryRetryTimers.get(key);
+        if (timer !== undefined)
+            clearTimeout(timer);
+        this.#deliveryRetryTimers.delete(key);
+        this.#deliveryRetryAttempts.delete(key);
+    }
 }
 /**
  * Starts the single private Unix-socket Controller for one YUI_HOME. The
  * shared server owns status/stop and rejects a second live instance; this
- * layer adds only scheduler.scan plus an optional command dispatcher.
+ * layer adds scheduler.signal/scheduler.scan plus an optional command dispatcher.
  */
 export async function startFileTaskController(home, store, delivery, dispatcher, options = {}) {
     const runtime = new FileTaskController(store, delivery, options);
+    let stopping = false;
+    const lifecycleRequests = new Set();
     const server = await startControllerServer(home, async (method, params) => {
+        if (stopping) {
+            throw controllerApplicationError("METHOD_NOT_FOUND", "Controller is stopping.");
+        }
+        if (method === "scheduler.signal") {
+            runtime.signal(signalMailboxKey(params));
+            return { accepted: true };
+        }
         if (method === "scheduler.scan") {
             if (!isEmptyJsonObject(params)) {
                 throw controllerApplicationError("INVALID_PARAMS", "scheduler.scan params are invalid.");
             }
             return schedulerResultJson(await runtime.pump());
         }
+        if (method === "scheduler.configure") {
+            requireEmptySchedulerConfigureParams(params);
+            const intervalMs = runtime.reloadReconciliationInterval();
+            return { configured: true, reconciliationIntervalMs: intervalMs };
+        }
         if (dispatcher === undefined) {
             throw controllerApplicationError("METHOD_NOT_FOUND", "Controller method was not found.");
         }
-        return dispatcher(method, params);
+        const request = Promise.resolve(dispatcher(method, params));
+        lifecycleRequests.add(request);
+        try {
+            const result = await request;
+            if (method === "runtime.ensure-role-session"
+                && isGlobalOperatorSessionRequest(params)
+                && isStartedRuntimeSessionResult(result)) {
+                runtime.armOperatorStartupRetry();
+            }
+            return result;
+        }
+        finally {
+            lifecycleRequests.delete(request);
+        }
+    }, async () => {
+        stopping = true;
+        runtime.stop();
+        await Promise.allSettled([...lifecycleRequests]);
+        await runtime.shutdownAndDrain();
+    }, {
+        domainIdentity: options.domainIdentity
     });
     runtime.start();
-    const closed = server.closed.finally(() => runtime.stop());
+    const closed = server.closed;
     return {
         runtime,
         server,
@@ -132,9 +1140,34 @@ export async function startFileTaskController(home, store, delivery, dispatcher,
         close: async () => {
             runtime.stop();
             await server.close();
+            await runtime.shutdownAndDrain();
         }
     };
 }
+function signalMailboxKey(value) {
+    if (typeof value !== "object"
+        || value === null
+        || Array.isArray(value)) {
+        throw controllerApplicationError("INVALID_PARAMS", "scheduler.signal params are invalid.");
+    }
+    const record = value;
+    if (Object.keys(record).length !== 1
+        || typeof record.key !== "string") {
+        throw controllerApplicationError("INVALID_PARAMS", "scheduler.signal params are invalid.");
+    }
+    try {
+        parseMailboxKey(record.key);
+        return record.key;
+    }
+    catch {
+        throw controllerApplicationError("INVALID_PARAMS", "scheduler.signal params are invalid.");
+    }
+}
+function requireEmptySchedulerConfigureParams(value) {
+    if (!isEmptyJsonObject(value)) {
+        throw controllerApplicationError("INVALID_PARAMS", "scheduler.configure params are invalid.");
+    }
+}
 function positiveInteger(value, fallback, label) {
     const resolved = value ?? fallback;
     if (!Number.isSafeInteger(resolved) || resolved <= 0) {
@@ -142,6 +1175,17 @@ function positiveInteger(value, fallback, label) {
     }
     return resolved;
 }
+function operatorMailboxBatchIdentity(mailbox) {
+    const batch = mailbox?.pending ?? mailbox?.processing?.batch;
+    if (batch === null || batch === undefined)
+        return null;
+    return [
+        batch.fromSequence,
+        batch.toSequence,
+        batch.firstQueuedAt,
+        batch.lastQueuedAt
+    ].join(":");
+}
 function schedulerResultJson(result) {
     return JSON.parse(JSON.stringify(result));
 }
@@ -151,6 +1195,19 @@ function isEmptyJsonObject(value) {
         && !Array.isArray(value)
         && Object.keys(value).length === 0;
 }
+function isGlobalOperatorSessionRequest(value) {
+    return typeof value === "object"
+        && value !== null
+        && !Array.isArray(value)
+        && value.scope === "global"
+        && value.roleName === "operator";
+}
+function isStartedRuntimeSessionResult(value) {
+    return typeof value === "object"
+        && value !== null
+        && !Array.isArray(value)
+        && value.sessionStarted === true;
+}
 function controllerApplicationError(code, message) {
     const error = Object.assign(new Error(message), { code });
     error.name = "CoreApplicationError";