@zq-silk/yui 0.13.3 → 0.13.5

package/dist/controller/fileSchedulerStoreAdapter.js

@@ -1,8 +1,7 @@
 import { createHash } from "node:crypto";
 import { isDeepStrictEqual } from "node:util";
-import { activeLiveRoleAgentSession, bindTaskRoleProviderRuntime, bindTaskRoleRun, clearTaskRoleRun, createRoleSessionSet, markTaskRoleRunDelivered, markTaskRoleRunPushed, prepareTaskRoleRunRedispatch, recordRoleAgentSession, replaceTaskRoleAgentSessionForConversationSwitch, recordTaskRoleTurnBoundary, rememberRoleAgentCompletedTurn, stopTaskRoleRuntimeAfterPhysicalExit, updateRoleAgentSessionStatus, updateTaskRoleProviderRuntime } from "../executor/agentExecutor.js";
+import { activeLiveRoleAgentSession, bindTaskRoleProviderRuntime, bindTaskRoleRun, clearTaskRoleRun, createRoleSessionSet, markTaskRoleRunDelivered, markTaskRoleRunPushed, prepareTaskRoleRunRedispatch, recordRoleAgentSession, replaceTaskRoleAgentSession, recordTaskRoleTurnBoundary, rememberRoleAgentCompletedTurn, stopTaskRoleRuntimeAfterPhysicalExit, updateRoleAgentSessionStatus, updateTaskRoleProviderRuntime } from "../executor/agentExecutor.js";
 import { acceptProviderTurn, beginProviderTurn, createProviderRuntimeBinding, endProviderActivation, currentProviderActivation, currentProviderConversation, markProviderTurnDeliveryUnknown, rejectProviderTurn, settleProviderTurnSubmission, settleProviderTurn, startProviderActivation, supersedeProviderConversation, updateProviderConversationRecoverability } from "../runtime/providerRuntimeIdentity.js";
-import { CONVERSATION_SWITCH_DETACHED_EVENT, CONVERSATION_SWITCH_RESOLVED_EVENT, conversationDetachmentBasis, conversationReplacementBasis, pendingConversationSwitch, roleSessionDispatchModeWithConversationSwitch } from "../runtime/conversationSwitch.js";
 import { decideProviderRecovery } from "../runtime/providerRecoveryDecision.js";
 import { hasRecentTurnId } from "../executor/turnCompletion.js";
 import { createTaskEvent } from "../event/taskEvent.js";
@@ -29,7 +28,7 @@ import { wakeReason } from "../scheduler/wakeReason.js";
 import { foldRunProgressFacts, latestRunDurableProgressAt, latestRunEventTime, latestStallEvidenceKey, isRoleRunStalled, RUN_PROGRESS_EVENT, RUN_DIAGNOSTIC_FINISHED_EVENT, RUN_RECOVERED_EVENT, RUN_STALLED_EVENT } from "../scheduler/roleRunStall.js";
 import { projectProviderContinuations } from "../runtime/runtimeContinuationProjection.js";
 import { providerContinuationKey } from "../runtime/providerContinuation.js";
-import { currentWorkItemExecutionGroup, updateWorkItemExecutionGroup, updateWorkItemStatus, workItemOwnsUnresolvedExecutionLane } from "../workItem/workItem.js";
+import { currentWorkItemExecutionGroup, updateWorkItemExecutionGroup } from "../workItem/workItem.js";
 import { recordExecutionLaneResult } from "../execution/executionGroup.js";
 import { formatAgentRunReceiptId, formatTaskRecordReference } from "../task/taskRecordReference.js";
 import { bindExecution, claimPending, claimInputDelivery as claimMailboxInputDelivery, completeInputDelivery as completeMailboxInputDelivery, completeProcessing, mailboxHasPending, mailboxHasWork, pendingLane, markInputDeliveryPushed as markMailboxInputDeliveryPushed, markInputDeliveryUnknown as markMailboxInputDeliveryUnknown, releaseInputDelivery as releaseMailboxInputDelivery, resolveInputDeliveryNotAccepted as resolveMailboxInputDeliveryNotAccepted, releaseProcessing } from "../coordination/workMailbox.js";
@@ -387,7 +386,7 @@ export class FileSchedulerStoreAdapter {
                     const message = [
                         `Leader native Session became unavailable while Run ${active.id} remains active.`,
                         "Yui preserved the Run because Session/host termination is not a workflow outcome.",
-                        "Inspect native-child and mailbox facts, then explicitly diagnose, recover the Run, request a Conversation switch, or request user input."
+                        "Retire the disposable Run, or use Task execution stop/start if the current runtime cannot be settled normally."
                     ].join(" ");
                     recordLeaderAttentionRequired(store, {
                         taskId: input.fence.taskId,
@@ -650,7 +649,9 @@ export class FileSchedulerStoreAdapter {
             const resolved = [];
             for (const request of expired) {
                 const task = store.getTask(request.taskId);
-                if (task?.status !== "active" || request.policy.kind !== "recommended")
+                if (task?.status !== "active"
+                    || task.executionGate.state !== "enabled"
+                    || request.policy.kind !== "recommended")
                     continue;
                 const choiceKey = request.policy.recommendedChoiceKey;
                 const answered = answerInputRequest(request, { choiceKey }, "agent-timeout", now);
@@ -723,7 +724,7 @@ export class FileSchedulerStoreAdapter {
         return this.store.transaction((store) => {
             const task = store.getTask(input.taskId);
             const run = store.getActiveAgentRun(input.taskId, input.roleName);
-            if (task === null || task.status !== "active"
+            if (task === null || task.status !== "active" || task.executionGate.state !== "enabled"
                 || run === null || run.id !== input.runId || run.status !== "active") {
                 return "state-changed";
             }
@@ -747,6 +748,7 @@ export class FileSchedulerStoreAdapter {
             const run = store.getActiveAgentRun(input.taskId, input.roleName);
             if (task === null
                 || task.status !== "active"
+                || task.executionGate.state !== "enabled"
                 || role === null
                 || run === null
                 || run.id !== input.runId
@@ -783,6 +785,7 @@ export class FileSchedulerStoreAdapter {
             const run = store.getActiveAgentRun(input.taskId, input.roleName);
             if (task === null
                 || task.status !== "active"
+                || task.executionGate.state !== "enabled"
                 || run === null
                 || run.id !== input.runId
                 || run.status !== "active")
@@ -828,82 +831,6 @@ export class FileSchedulerStoreAdapter {
         const sessions = this.store.getTaskRoleSessionSet(taskId, roleName);
         return sessions !== null && sessions.inFlight !== null;
     }
-    detachAgentHostProviderForConversationSwitch(input) {
-        return this.store.transaction((store) => {
-            const sessions = store.getTaskRoleSessionSet(input.taskId, input.roleName);
-            const run = store.getAgentRun(input.taskId, input.runId);
-            const mailbox = store.getWorkMailbox({
-                kind: "role",
-                taskId: input.taskId,
-                roleName: input.roleName
-            });
-            const binding = sessions?.providerBinding;
-            const session = sessions?.sessions[input.agentId];
-            const task = store.getTask(input.taskId);
-            const role = store.getRole(input.taskId, input.roleName);
-            const activeRun = store.getActiveAgentRun(input.taskId, input.roleName);
-            if (task === null || task.status !== "active"
-                || role === null || role.activeAgentId !== input.agentId
-                || sessions === null || sessions === undefined
-                || run === null || run.status !== "active" || run.mode !== "new"
-                || activeRun?.id !== run.id
-                || run.effective.agentId !== input.agentId
-                || session?.nativeSessionId !== input.previousNativeSessionId
-                || binding === null || binding === undefined
-                || currentProviderConversation(binding).conversationId !== input.previousConversationId
-                || sessions.inFlight?.runId !== input.runId
-                || mailbox?.processing?.batchId !== sessions.inFlight.receiptId
-                || mailbox.processing.owner !== "controller"
-                || mailbox.processing.executionRef?.type !== "run"
-                || mailbox.processing.executionRef.taskId !== input.taskId
-                || mailbox.processing.executionRef.id !== input.runId
-                || mailbox.inputDelivery !== null
-                || pendingConversationSwitch(store.listEvents(input.taskId), input.roleName, sessions) === null
-                || !runtimeHookMatchesReservation(store, { scope: "task", taskId: input.taskId, roleName: input.roleName }, input.launchId)
-                || input.nextAuthorityHolderId !== input.launchId) {
-                throw new Error("Provider Conversation detachment no longer matches the exact switch Run.");
-            }
-            const target = binding.activations.find((entry) => (entry.activationId === input.previousActivationId
-                && entry.conversationId === input.previousConversationId));
-            if (target === undefined) {
-                throw new Error("Provider Conversation detachment targets an unknown Activation.");
-            }
-            if (target.status !== "active") {
-                if (binding.authority.owner !== "none"
-                    || input.nextAuthorityEpoch !== binding.authority.epoch + 1) {
-                    throw new Error("Provider Conversation detachment replay has a stale authority fence.");
-                }
-                return "already-detached";
-            }
-            if (conversationDetachmentBasis({
-                sessions,
-                events: store.listEvents(input.taskId),
-                mailbox,
-                roleName: input.roleName,
-                runId: input.runId,
-                runMode: run.mode
-            }) !== "actor-request"
-                || binding.authority.owner !== "controller"
-                || binding.authority.holderId !== target.activationId
-                || input.nextAuthorityEpoch !== binding.authority.epoch + 2) {
-                throw new Error("Provider Conversation detachment is not authorized at this boundary.");
-            }
-            const detached = endProviderActivation(binding, target.activationId, {
-                status: "ended",
-                endedAt: input.now.toISOString(),
-                reason: "conversation-switch"
-            });
-            store.saveTaskRoleSessionSet(updateTaskRoleProviderRuntime(sessions, detached, input.now));
-            store.saveEvent(input.taskId, createTaskEvent(store.nextEventId(input.taskId), input.taskId, CONVERSATION_SWITCH_DETACHED_EVENT, {
-                runId: input.runId,
-                roleName: input.roleName,
-                launchId: input.launchId,
-                conversationId: input.previousConversationId,
-                activationId: input.previousActivationId
-            }, input.now));
-            return "detached";
-        });
-    }
     beginAgentHostProviderTurn(input) {
         this.store.transaction((store) => {
             const sessions = store.getTaskRoleSessionSet(input.taskId, input.roleName);
@@ -1307,7 +1234,7 @@ export class FileSchedulerStoreAdapter {
     saveLeaderDispatch(input) {
         return this.store.transaction((store) => {
             const task = store.getTask(input.task.id);
-            if (task === null || task.status !== "active") {
+            if (task === null || task.status !== "active" || task.executionGate.state !== "enabled") {
                 return "unavailable";
             }
             const role = requireRole(store, input.task.id, input.role.name);
@@ -1391,7 +1318,7 @@ export class FileSchedulerStoreAdapter {
     saveRoleRunDelivery(input) {
         this.store.transaction((store) => {
             const task = store.getTask(input.task.id);
-            if (task === null || task.status !== "active") {
+            if (task === null || task.status !== "active" || task.executionGate.state !== "enabled") {
                 throw new Error(`Task is not active: ${input.task.id}.`);
             }
             const role = requireRole(store, input.task.id, input.role.name);
@@ -1464,7 +1391,7 @@ export class FileSchedulerStoreAdapter {
     saveRoleRunPrepared(input) {
         this.store.transaction((store) => {
             const task = store.getTask(input.task.id);
-            if (task === null || task.status !== "active") {
+            if (task === null || task.status !== "active" || task.executionGate.state !== "enabled") {
                 throw new Error(`Task is not active: ${input.task.id}.`);
             }
             const role = requireRole(store, input.task.id, input.role.name);
@@ -1475,9 +1402,15 @@ export class FileSchedulerStoreAdapter {
             if (input.session !== null && input.session.nativeSessionId !== undefined) {
                 const existing = store.getRoleSession(input.task.id, input.role.name);
                 matchingPreparedRuntimeReservation(store, input);
+                // A terminal Session is audit history, not the current execution
+                // identity. Preallocated providers must publish the replacement fence
+                // before the new Agent Host starts so its exact-runtime preflight sees
+                // the new launch. Only a still-live conflicting Session is deferred.
                 const defersConversationReplacement = active.mode === "new"
                     && existing !== null
-                    && existing.nativeSessionId !== input.session.nativeSessionId;
+                    && existing.nativeSessionId !== input.session.nativeSessionId
+                    && existing.status !== "stopped"
+                    && existing.status !== "broken";
                 if (!defersConversationReplacement
                     && (existing?.nativeSessionId !== input.session.nativeSessionId
                         || (input.launchId !== undefined && existing.launchId !== input.launchId)
@@ -1510,6 +1443,7 @@ export class FileSchedulerStoreAdapter {
             }));
             if (task === null
                 || task.status !== "active"
+                || task.executionGate.state !== "enabled"
                 || role === null
                 || active === null
                 || active.id !== input.runId
@@ -1556,16 +1490,6 @@ export class FileSchedulerStoreAdapter {
                 outcome: terminal.status
             }, input.now);
             store.saveEvent(input.taskId, deliveryFailureEvent);
-            if (terminal.purpose === "execution" && terminal.workItemId !== undefined) {
-                const item = store.getWorkItem(input.taskId, terminal.workItemId);
-                if (item !== null && ![
-                    "completed", "failed", "retired"
-                ].includes(item.status)) {
-                    if (!workItemOwnsUnresolvedExecutionLane(item, terminal.executionGroupId, terminal.executionLaneId)) {
-                        store.saveWorkItem(input.taskId, updateWorkItemStatus(item, "failed", input.now, summary));
-                    }
-                }
-            }
             if (input.roleName !== "leader") {
                 routeRoleEvent(store, deliveryFailureEvent, input.roleName, terminal.purpose === "review" ? "review-failed" : "role-run-failed", input.now);
             }
@@ -1593,6 +1517,7 @@ export class FileSchedulerStoreAdapter {
             const mailbox = store.getWorkMailbox(target);
             if (task === null
                 || task.status !== "active"
+                || task.executionGate.state !== "enabled"
                 || role === null
                 || active === null
                 || active.id !== input.claimed.run.id
@@ -1606,7 +1531,9 @@ export class FileSchedulerStoreAdapter {
             store.saveAgentRun(failAgentRun(active, input.failure.message, input.now));
             store.clearActiveAgentRun(input.task.id, input.role.name);
             clearTaskRoleRunInFlight(store, role, active, input.now);
-            store.saveWorkMailbox(releaseProcessing(mailbox, mailbox.processing.batchId));
+            // Consume this failed delivery attempt. Releasing it would immediately
+            // redispatch the same wake and manufacture another Leader Session.
+            store.saveWorkMailbox(completeProcessing(mailbox, mailbox.processing.batchId));
             store.saveRole(input.task.id, updateRoleStatus(role, "failed", input.now));
             breakTaskSessionIfPresent(store, input.task.id, role.name, active.effective.agentId, input.now);
             const failure = recordLeaderFailure(input.task.id, input.failure.nativeSessionId, input.failure.message, input.now, store.getLeaderFailure(input.task.id));
@@ -1630,6 +1557,7 @@ export class FileSchedulerStoreAdapter {
             const currentRun = store.getActiveAgentRun(input.task.id, input.role.name);
             if (task === null
                 || task.status !== "active"
+                || task.executionGate.state !== "enabled"
                 || role === null
                 || currentRun === null
                 || currentRun.id !== input.run.id
@@ -1708,17 +1636,12 @@ export class FileSchedulerStoreAdapter {
                         const group = currentWorkItemExecutionGroup(workItem);
                         store.saveWorkItem(task.id, updateWorkItemExecutionGroup(workItem, recordExecutionLaneResult(group, currentRun.executionLaneId, { summary: input.summary }, "failed", input.now), input.now));
                     }
-                    const laneUpdated = store.getWorkItem(task.id, currentRun.workItemId);
-                    if (!workItemOwnsUnresolvedExecutionLane(laneUpdated, currentRun.executionGroupId, currentRun.executionLaneId)) {
-                        store.saveWorkItem(task.id, updateWorkItemStatus(laneUpdated, "failed", input.now, input.summary));
-                    }
                 }
             }
-            const blocksAutomaticLeaderRecovery = role.name === "leader"
-                && input.leaderRecovery === "blocked";
-            store.saveRole(task.id, updateRoleStatus(role, blocksAutomaticLeaderRecovery ? "failed" : "exited", input.now));
+            const leaderFailed = role.name === "leader";
+            store.saveRole(task.id, updateRoleStatus(role, leaderFailed ? "failed" : "exited", input.now));
             stopTaskSessionIfPresent(store, task.id, role.name, currentRun.effective.agentId, input.now);
-            if (blocksAutomaticLeaderRecovery) {
+            if (leaderFailed) {
                 const failure = recordLeaderFailure(task.id, input.session?.nativeSessionId ?? "(unregistered)", input.summary, input.now, store.getLeaderFailure(task.id));
                 store.saveLeaderFailure(failure);
                 recordLeaderAttentionRequired(store, {
@@ -1732,7 +1655,7 @@ export class FileSchedulerStoreAdapter {
                 });
                 return "failed";
             }
-            queueLeaderWakeup(store, task.id, wakeReason(role.name === "leader" ? "leader-run-failed" : "role-run-failed"), input.now);
+            queueLeaderWakeup(store, task.id, wakeReason("role-run-failed"), input.now);
             return "failed";
         });
     }
@@ -1963,7 +1886,7 @@ export class FileSchedulerStoreAdapter {
             const task = store.getTask(input.taskId);
             if (task === null)
                 throw new Error(`Task not found: ${input.taskId}.`);
-            if (task.status !== "active") {
+            if (task.status !== "active" || task.executionGate.state !== "enabled") {
                 throw new Error(`Cannot complete a runtime turn for inactive Task: ${input.taskId}.`);
             }
             const role = requireRole(store, input.taskId, input.roleName);
@@ -2061,7 +1984,7 @@ export class FileSchedulerStoreAdapter {
     }
     classifyRuntimeTurnFailed(input) {
         const task = this.store.getTask(input.taskId);
-        if (task?.status !== "active")
+        if (task?.status !== "active" || task.executionGate.state !== "enabled")
             return "obsolete";
         const role = this.store.getRole(input.taskId, input.roleName);
         if (role === null)
@@ -2122,14 +2045,6 @@ export class FileSchedulerStoreAdapter {
                 roleName: input.roleName
             }), RUNTIME_CLEANUP_REQUIRED_REASON, now, [{ type: "task", id: input.taskId }]);
             const terminal = result.run;
-            if (before.purpose === "execution" && before.workItemId !== undefined) {
-                const item = store.getWorkItem(input.taskId, before.workItemId);
-                if (item !== null && ![
-                    "completed", "failed", "retired"
-                ].includes(item.status) && !workItemOwnsUnresolvedExecutionLane(item, before.executionGroupId, before.executionLaneId)) {
-                    store.saveWorkItem(input.taskId, updateWorkItemStatus(item, "failed", now, summary));
-                }
-            }
             const role = store.getRole(input.taskId, input.roleName);
             if (role !== null) {
                 store.saveRole(input.taskId, updateRoleStatus(role, input.roleName === "leader" ? "failed" : "idle", now));
@@ -2513,8 +2428,6 @@ export class FileSchedulerStoreAdapter {
                 }
                 const sessions = store.getTaskRoleSessionSet(entry.taskId, entry.roleName);
                 const providerBinding = sessions?.providerBinding;
-                let recoveryMode = "resume";
-                let replacementRequired = false;
                 if (providerBinding === null || providerBinding === undefined) {
                     deferUnprovenProviderRecovery(store, run, entry.roleName, "Provider Conversation identity is missing; automatic recovery is fenced.", now);
                     return;
@@ -2554,12 +2467,19 @@ export class FileSchedulerStoreAdapter {
                     }
                     return;
                 }
-                if (recovery.action === "replace") {
-                    if (conversation.recoverability !== "unrecoverable") {
-                        deferUnprovenProviderRecovery(store, run, entry.roleName, "Provider replacement lacks an exact missing-Conversation observation.", now);
-                        return;
+                if (recovery.action === "restart-run") {
+                    const finalized = finalizeProviderRetryDeadline(store, run, "Provider Conversation is unavailable; retry the work with a fresh Run and Session.", "provider-conversation-unavailable", now);
+                    if (finalized) {
+                        const currentSessions = store.getTaskRoleSessionSet(entry.taskId, entry.roleName);
+                        const currentSession = currentSessions?.sessions[run.effective.agentId];
+                        if (currentSessions !== null && currentSessions !== undefined
+                            && currentSession !== undefined
+                            && currentSession.status !== "stopped"
+                            && currentSession.status !== "broken") {
+                            store.saveTaskRoleSessionSet(updateRoleAgentSessionStatus(currentSessions, run.effective.agentId, "broken", now));
+                        }
                     }
-                    replacementRequired = true;
+                    return;
                 }
                 const session = sessions?.sessions[run.effective.agentId];
                 const identityMatches = session !== undefined
@@ -2570,9 +2490,8 @@ export class FileSchedulerStoreAdapter {
                         || session.launchId === run.providerRetry.launchId);
                 if (!identityMatches || session?.nativeSessionId === undefined) {
                     // Local Session projection loss is not native-session-dead evidence.
-                    // Preserve the Run and episode for explicit same-generation recovery;
-                    // only an exact Provider-native resume response may terminalize it as
-                    // unrecoverable.
+                    // Keep the bounded retry episode; if native identity never returns,
+                    // the episode fails and a later Run can continue from Task progress.
                     const deferred = deferProviderRetry(run.providerRetry, now);
                     if (deferred === null) {
                         finalizeProviderRetryDeadline(store, run, "Provider retry safety could not be re-established before the bounded episode deadline; native Session recoverability remains unproven.", "native-resume-unproven", now);
@@ -2606,25 +2525,10 @@ export class FileSchedulerStoreAdapter {
                     store.saveAgentRun(withProviderRetry(run, deferred));
                     return;
                 }
-                if (replacementRequired) {
-                    try {
-                        recoveryMode = roleSessionDispatchModeWithConversationSwitch(sessions, store.listEvents(entry.taskId), roleMailbox, entry.roleName, run.effective.agentId, run.effective);
-                    }
-                    catch (error) {
-                        deferUnprovenProviderRecovery(store, run, entry.roleName, error instanceof Error
-                            ? error.message
-                            : "Independent Conversation-switch evaluation failed closed.", now);
-                        return;
-                    }
-                    if (recoveryMode !== "new") {
-                        deferUnprovenProviderRecovery(store, run, entry.roleName, "Independent Conversation-switch evaluation kept the current Conversation.", now);
-                        return;
-                    }
-                }
                 // Reopen the Run on its original Session: reset transport markers,
                 // switch to resume, and mark the projection in-flight. The delivery
                 // pass re-pushes the exact same input in this same pass.
-                const reopenedRun = reopenRunForProviderRetry(run, `provider-retry-${run.providerRetry.episodeId}-${run.providerRetry.dispatchedRetries + 1}`, now, recoveryMode);
+                const reopenedRun = reopenRunForProviderRetry(run, `provider-retry-${run.providerRetry.episodeId}-${run.providerRetry.dispatchedRetries + 1}`, now, "resume");
                 store.saveAgentRun(reopenedRun);
                 if (sessions !== null && sessions.inFlight !== null) {
                     store.saveTaskRoleSessionSet(prepareTaskRoleRunRedispatch(sessions, {
@@ -2735,22 +2639,17 @@ export class FileSchedulerStoreAdapter {
                             taskId,
                             roleName: input.fence.roleName
                         });
-                        const existingNativeSessionId = sessions.sessions[input.fence.agentId]
-                            ?.nativeSessionId;
+                        const existingSession = sessions.sessions[input.fence.agentId];
+                        const existingNativeSessionId = existingSession?.nativeSessionId;
                         const replacingNativeSession = existingNativeSessionId !== undefined
                             && existingNativeSessionId !== decision.outcome.nativeSessionId;
                         const replacementBasis = replacingNativeSession
-                            ? conversationReplacementBasis({
-                                sessions,
-                                events: store.listEvents(taskId),
-                                mailbox,
-                                roleName: input.fence.roleName,
-                                runId: run.id,
-                                runMode: run.mode
-                            })
+                            && run.mode === "new"
+                            && (existingSession?.status === "stopped" || existingSession?.status === "broken")
+                            ? "terminal-session"
                             : null;
                         if (replacingNativeSession && replacementBasis === null) {
-                            recordCanonicalObservationObsolete(store, input, "conversation-switch-not-authorized", now);
+                            recordCanonicalObservationObsolete(store, input, "session-replacement-not-terminal", now);
                             return "obsolete";
                         }
                         const sessionInput = {
@@ -2764,17 +2663,9 @@ export class FileSchedulerStoreAdapter {
                         };
                         const bound = replacementBasis === null
                             ? recordRoleAgentSession(sessions, sessionInput, now)
-                            : replaceTaskRoleAgentSessionForConversationSwitch(sessions, sessionInput, now);
+                            : replaceTaskRoleAgentSession(sessions, sessionInput, now);
                         const withProvider = bindOrSupersedeProviderRuntime(bound, input, now, replacementBasis ?? undefined);
                         store.saveTaskRoleSessionSet(withProvider);
-                        if (replacementBasis === "actor-request") {
-                            resolveConversationSwitchRequest(store, taskId, input.fence.roleName, sessions, "applied", now, {
-                                conversationId: input.fence.conversationId
-                                    ?? decision.outcome.nativeSessionId,
-                                activationId: input.fence.activationId ?? input.fence.launchId,
-                                launchId: input.fence.launchId
-                            });
-                        }
                         const driver = this.drivers.require(input.fence.driverId);
                         if (driver.capabilities.observation.sessionBootstrap === "discovered"
                             && run.pushedAt === undefined) {
@@ -3111,6 +3002,17 @@ export class FileSchedulerStoreAdapter {
             current = rememberRoleAgentCompletedTurn(current, input.agentId, nativeSessionId, input.turnId, now);
             store.saveGlobalRoleSessionSet(current);
             completeRuntimeHookReservation(store, owner, input.launchId);
+            if (input.roleName === SYSTEM_OPERATOR_ROLE
+                && input.adapterId === "codex"
+                && completedStatus === "ready") {
+                const operatorMailbox = store.getWorkMailbox({ kind: "operator" });
+                // A completed foreground Codex Turn leaves its native TUI attached to
+                // the thread. Stop only that idle Role runtime so Desktop can become
+                // the writer; the durable nativeSessionId remains available to resume.
+                if (operatorMailbox === null || !mailboxHasWork(operatorMailbox)) {
+                    enqueueWork(store, runtimeLifecycleTarget(owner), RUNTIME_CLEANUP_REQUIRED_REASON, now);
+                }
+            }
             return current.sessions[input.agentId];
         });
     }
@@ -3286,6 +3188,7 @@ function preallocatedRuntimeReadyAwaitingProjection(store, observation, drivers)
     const run = store.getActiveAgentRun(taskId, observation.fence.roleName);
     const sessions = store.getTaskRoleSessionSet(taskId, observation.fence.roleName);
     if (task?.status !== "active"
+        || task.executionGate.state !== "enabled"
         || role?.activeAgentId !== observation.fence.agentId
         || run?.id !== runId
         || run.status !== "active"
@@ -3436,14 +3339,6 @@ function finalizeProviderRetryDeadline(store, run, summary, reason, now) {
         elapsedMs: String(Math.max(0, now.getTime() - Date.parse(retry.firstFailureAt)))
     }, now);
     store.saveEvent(run.taskId, exhaustionEvent);
-    if (terminal.purpose === "execution" && terminal.workItemId !== undefined) {
-        const item = store.getWorkItem(run.taskId, terminal.workItemId);
-        if (item !== null
-            && !["completed", "failed", "retired"].includes(item.status)
-            && !workItemOwnsUnresolvedExecutionLane(item, terminal.executionGroupId, terminal.executionLaneId)) {
-            store.saveWorkItem(run.taskId, updateWorkItemStatus(item, "failed", now, summary));
-        }
-    }
     const role = store.getRole(run.taskId, run.roleName);
     if (role !== null) {
         store.saveRole(run.taskId, updateRoleStatus(role, run.roleName === "leader" ? "failed" : "idle", now));
@@ -3511,7 +3406,7 @@ function recordTaskRuntimeNativeSession(store, input, now) {
     if (task.status === "archived") {
         throw new Error(`Cannot register a native session for archived Task: ${input.taskId}.`);
     }
-    if (task.status !== "active") {
+    if (task.status !== "active" || task.executionGate.state !== "enabled") {
         throw new Error(`Cannot register a native session for a Task that is not active: ${input.taskId}.`);
     }
     const role = requireRole(store, input.taskId, input.roleName);
@@ -3979,29 +3874,16 @@ function bindOrSupersedeProviderRuntime(sessions, input, now, replacementBasis)
             startedAt: input.observedAt ?? input.receivedAt
         }), now);
     }
-    const turn = sessions.providerBinding.turn;
-    const noUnsettledInputDelivery = turn === null
-        || ["completed", "failed", "cancelled", "rejected"].includes(turn.status);
+    if (replacementBasis === undefined) {
+        throw new Error("A fresh Provider Conversation requires a terminal prior Session.");
+    }
     return updateTaskRoleProviderRuntime(sessions, supersedeProviderConversation(sessions.providerBinding, {
         conversationId,
         activationId,
         switchedAt: input.observedAt ?? input.receivedAt,
-        noUnsettledInputDelivery,
-        ...(replacementBasis === undefined ? {} : { basis: replacementBasis })
+        basis: replacementBasis
     }), now);
 }
-function resolveConversationSwitchRequest(store, taskId, roleName, previousSessions, status, now, replacement) {
-    const request = pendingConversationSwitch(store.listEvents(taskId), roleName, previousSessions);
-    if (request === null)
-        return;
-    store.saveEvent(taskId, createTaskEvent(store.nextEventId(taskId), taskId, CONVERSATION_SWITCH_RESOLVED_EVENT, {
-        requestId: request.requestId,
-        roleName,
-        generation: request.generation,
-        status,
-        ...(replacement === undefined ? {} : replacement)
-    }, now));
-}
 function rejectSubmittingProviderTurn(store, target, delivery, now, reason) {
     if (target.kind !== "role"
         || delivery.executionRef.type !== "run"

package/dist/controller/jobControl.js

@@ -99,8 +99,9 @@ function validateStartParams(store, params) {
     if (task === null) {
         throw jobDomainError(`Task not found: ${params.taskId}.`);
     }
-    if (task.status !== "active") {
-        throw jobDomainError(`DurableJob requires an active Task; ${params.taskId} is ${task.status}.`);
+    if (task.status !== "active" || task.executionGate.state !== "enabled") {
+        throw jobDomainError(`DurableJob requires enabled Task execution; ${params.taskId} is `
+            + `${task.status}/${task.executionGate.state}.`);
     }
     // The owner record must exist and must not be terminal. A terminal owner
     // cannot run new jobs — its workspace is eligible for cleanup.

package/dist/controller/runtime.js

@@ -584,11 +584,6 @@ export function createRuntimeLifecycleDispatcher(store, schedulerStore, sessionH
             }
             return { recorded: true };
         }
-        if (method === "runtime.conversation-switch-detach") {
-            const value = conversationSwitchDetachParams(params);
-            const outcome = schedulerStore.detachAgentHostProviderForConversationSwitch(value);
-            return { recorded: outcome === "detached", outcome };
-        }
         if (method === "runtime.provider-turn-submission-resolve") {
             const value = providerTurnControlParams(params);
             const status = params.status;
@@ -719,10 +714,11 @@ export function createRuntimeLifecycleDispatcher(store, schedulerStore, sessionH
             const task = request.scope === "task"
                 ? store.getTask(request.taskId)
                 : null;
-            if (request.scope === "task" && task?.status !== "active") {
+            if (request.scope === "task"
+                && (task?.status !== "active" || task.executionGate.state !== "enabled")) {
                 throw applicationError("INVALID_PARAMS", task === null
                     ? `Task not found: ${request.taskId}.`
-                    : `Task is not active: ${request.taskId}.`);
+                    : `Task execution is not enabled: ${request.taskId}.`);
             }
             if (request.scope === "task" && task !== null) {
                 const taskWorkspace = store.getTaskWorkspace(task.id);
@@ -852,7 +848,9 @@ function assertRuntimeLaunchRequestCurrent(store, request) {
     let activeRun = null;
     if (request.owner.scope === "task") {
         const task = store.getTask(request.owner.taskId);
-        if (task === null || task.status !== "active") {
+        if (task === null
+            || task.status !== "active"
+            || task.executionGate.state !== "enabled") {
             throw new Error(`Task is no longer active: ${request.owner.taskId}.`);
         }
         activeRun = store.getActiveAgentRun(request.owner.taskId, request.owner.roleName);
@@ -1135,31 +1133,6 @@ function providerTurnControlParams(params) {
         now: new Date(observedAt)
     };
 }
-function conversationSwitchDetachParams(params) {
-    if (typeof params !== "object" || params === null || Array.isArray(params)) {
-        throw applicationError("INVALID_PARAMS", "Provider Conversation detachment params are invalid.");
-    }
-    const value = params;
-    const nextAuthorityEpoch = value.nextAuthorityEpoch;
-    const observedAt = requiredParam(value.observedAt);
-    if (!Number.isSafeInteger(nextAuthorityEpoch) || nextAuthorityEpoch < 1
-        || !Number.isFinite(Date.parse(observedAt))) {
-        throw applicationError("INVALID_PARAMS", "Provider Conversation detachment fence is invalid.");
-    }
-    return {
-        taskId: requiredParam(value.taskId),
-        roleName: requiredParam(value.roleName),
-        runId: requiredParam(value.runId),
-        agentId: requiredParam(value.agentId),
-        launchId: requiredParam(value.launchId),
-        previousConversationId: requiredParam(value.previousConversationId),
-        previousNativeSessionId: requiredParam(value.previousNativeSessionId),
-        previousActivationId: requiredParam(value.previousActivationId),
-        nextAuthorityEpoch: nextAuthorityEpoch,
-        nextAuthorityHolderId: requiredParam(value.nextAuthorityHolderId),
-        now: new Date(observedAt)
-    };
-}
 function abortableDelay(milliseconds, signal) {
     return new Promise((resolve, reject) => {
         const timer = setTimeout(() => {

package/dist/controller/runtimeEventProcessor.js

@@ -137,7 +137,9 @@ export class FileRuntimeEventProcessor {
         const taskId = event.observation.fence.taskId;
         if (taskId !== undefined) {
             const task = this.observer.getTask(taskId);
-            if (task === null || task.status !== "active")
+            if (task === null
+                || task.status !== "active"
+                || task.executionGate.state !== "enabled")
                 return "obsolete";
         }
         return this.observer.observeRuntimeObservation?.(event.observation, now) ?? "obsolete";
@@ -217,7 +219,7 @@ export class FileRuntimeEventProcessor {
             };
             if (task === null)
                 return "obsolete";
-            if (task.status !== "active") {
+            if (task.status !== "active" || task.executionGate.state !== "enabled") {
                 this.recordObsolete(event, task.status === "archived" ? "task-archived" : "task-retired", now);
                 return "obsolete";
             }
@@ -622,7 +624,9 @@ export class AsyncRuntimeEventProcessor {
         const taskId = event.observation.fence.taskId;
         if (taskId !== undefined) {
             const task = await this.observer.getTask(taskId);
-            if (task === null || task.status !== "active")
+            if (task === null
+                || task.status !== "active"
+                || task.executionGate.state !== "enabled")
                 return "obsolete";
         }
         const outcome = (await this.observer.observeRuntimeObservation?.(event.observation, now))
@@ -662,7 +666,7 @@ export class AsyncRuntimeEventProcessor {
             };
             if (task === null)
                 return "obsolete";
-            if (task.status !== "active") {
+            if (task.status !== "active" || task.executionGate.state !== "enabled") {
                 await this.recordObsolete(event, task.status === "archived" ? "task-archived" : "task-retired", now);
                 return "obsolete";
             }