@zq-silk/yui 0.13.4 → 0.13.6

package/dist/repository/taskWorkspaceCoordinator.js

@@ -1,7 +1,6 @@
 import { isDeepStrictEqual } from "node:util";
 import { retireConfirmedAbsentInactiveTaskRolePlaceholders } from "../executor/agentExecutor.js";
 import { hasRuntimeLifecycleWork, runtimeLifecycleTarget } from "../runtime/lifecycleReservation.js";
-import { blockingProviderContinuations } from "../runtime/runtimeContinuationProjection.js";
 import { managedWorkspaceKey } from "../worktree/managedWorkspace.js";
 import { acquireProjectMaintenanceLocks } from "./projectMaintenanceLock.js";
 import { WorkspaceCleanupBlockedError } from "./taskWorkspacePreparer.js";
@@ -159,7 +158,6 @@ export class TaskWorkspaceCoordinator {
             if (task.status !== "completed" && task.status !== "retired") {
                 throw new Error(`Task must be completed or retired before archive cleanup: ${task.id}.`);
             }
-            this.#assertNoProviderContinuationWriters(task.id);
             const managedWorkspaces = [...this.store.listManagedWorkspaces(task.id)]
                 .sort((left, right) => managedWorkspaceKey(left.owner)
                 .localeCompare(managedWorkspaceKey(right.owner)));
@@ -326,13 +324,6 @@ export class TaskWorkspaceCoordinator {
         if (current === null || !isDeepStrictEqual(current, expected)) {
             throw new WorkspaceCleanupBlockedError("task-changed", `task:${expected.id}`, true, `Task changed during archive cleanup: ${expected.id}.`);
         }
-        this.#assertNoProviderContinuationWriters(expected.id);
-    }
-    #assertNoProviderContinuationWriters(taskId) {
-        const blockers = blockingProviderContinuations(this.store.listEvents(taskId));
-        if (blockers.length > 0) {
-            throw new WorkspaceCleanupBlockedError("active-run", `task:${taskId}`, true, `Task has Provider continuations that may still write its Workspace: ${taskId}.`);
-        }
     }
     #assertWorkItemRuntimeQuiescent(item) {
         const activeRun = this.store.listAgentRuns(item.taskId)

package/dist/runtime/agentHost.js

@@ -14,7 +14,7 @@ import { ProviderDeliveryUnknownError, ProviderConversationMissingError, Provide
 import { sameProviderAuthorityFence, validateProviderAuthorityFence } from "./providerAuthorityFence.js";
 import { validateRuntimeProcessExitObservation } from "./processExitObservation.js";
 import { persistRuntimeProcessExitObservation, replayRuntimeProcessExitOutbox } from "./processExitOutbox.js";
-import { readRuntimeStopReceipt, removeRuntimeStopReceipt, writeRuntimeStopReceipt } from "./runtimeStopReceipt.js";
+import { readRuntimeStopReceipt, removeRuntimeStopReceipt } from "./runtimeStopReceipt.js";
 import { AGENT_HOST_CONTROL_TIMEOUT_MS, AGENT_HOST_READY_TIMEOUT_MS } from "./runtimeDeadlines.js";
 export const AGENT_HOST_CONTROL_PROTOCOL = "yui-agent-host/v2";
 const HOST_CONTROL_MAX_BYTES = 32 * 1024;
@@ -34,7 +34,6 @@ export async function runAgentHost(input) {
     let activeNativeTurnId;
     let codexClientAttachedAt;
     let consecutiveCodexDisconnects = 0;
-    const switchDetachedSessions = new WeakSet();
     let activationId;
     let conversationRecoverability = "unknown";
     let authority;
@@ -146,7 +145,7 @@ export async function runAgentHost(input) {
             providerControl: {
                 schemaVersion: 1,
                 adapterId: "codex",
-                transport: "codex-app-server-proxy",
+                transport: "codex-app-server",
                 kind: "ensure",
                 mode: "resume",
                 nativeSessionId: disconnectedSession.nativeSessionId,
@@ -154,7 +153,6 @@ export async function runAgentHost(input) {
                     ? {}
                     : { sessionTitle: previousControl.sessionTitle }),
                 codexThread: previousControl.codexThread,
-                codexDaemonStartArgs: previousControl.codexDaemonStartArgs,
                 ...(ownedTurn === undefined ? {} : { ownedTurn }),
                 authority
             }
@@ -228,8 +226,7 @@ export async function runAgentHost(input) {
             const reconnectableCodexClient = ownsCurrentSession
                 && providerSession.adapterId === "codex"
                 && !hostStopRequested
-                && stopReceipt === null
-                && !switchDetachedSessions.has(providerSession);
+                && stopReceipt === null;
             if (reconnectableCodexClient) {
                 session = undefined;
                 if (codexClientAttachedAt !== undefined
@@ -260,7 +257,7 @@ export async function runAgentHost(input) {
                     ...(activeTurnAttemptId === undefined ? {} : { attemptId: activeTurnAttemptId }),
                     ...(activeNativeTurnId === undefined ? {} : { nativeTurnId: activeNativeTurnId }),
                     ...exitAuthority,
-                    detail: "Codex client disconnected; reattaching to the shared daemon."
+                    detail: "Codex App Server disconnected; starting a replacement process."
                 }));
                 await reconnectCodexClient(providerSession, currentPayload);
                 return;
@@ -274,21 +271,19 @@ export async function runAgentHost(input) {
             hostSequence += 1;
             const observedAt = new Date().toISOString();
             const failures = [];
-            if (!switchDetachedSessions.has(providerSession)) {
-                try {
-                    await publishStructuredProviderActivationTerminal({
-                        home: input.home,
-                        environment: currentPayload.environment,
-                        conversationId: providerSession.conversationId,
-                        nativeSessionId: providerSession.nativeSessionId,
-                        activationId: currentActivationId,
-                        status: stopReceipt !== null || hostStopRequested ? "ended" : "failed",
-                        observedAt
-                    });
-                }
-                catch (error) {
-                    failures.push(`activation terminal: ${errorText(error)}`);
-                }
+            try {
+                await publishStructuredProviderActivationTerminal({
+                    home: input.home,
+                    environment: currentPayload.environment,
+                    conversationId: providerSession.conversationId,
+                    nativeSessionId: providerSession.nativeSessionId,
+                    activationId: currentActivationId,
+                    status: stopReceipt !== null || hostStopRequested ? "ended" : "failed",
+                    observedAt
+                });
+            }
+            catch (error) {
+                failures.push(`activation terminal: ${errorText(error)}`);
             }
             let exitPersisted = false;
             try {
@@ -357,10 +352,12 @@ export async function runAgentHost(input) {
         }
         const requestedAuthority = validateProviderAuthorityFence(providerControl.authority);
         const replacesCurrentConversation = session !== undefined && providerControl.kind === "new";
-        if (!replacesCurrentConversation && authority === undefined)
+        if (replacesCurrentConversation) {
+            throw new Error("Agent Host cannot replace a live Provider Session; stop it before starting a fresh Session.");
+        }
+        if (authority === undefined)
             authority = requestedAuthority;
-        else if (!replacesCurrentConversation
-            && authority !== undefined
+        else if (authority !== undefined
             && !sameProviderAuthorityFence(authority, requestedAuthority)) {
             throw new Error("Agent Host launch carries a stale Provider authority fence.");
         }
@@ -380,43 +377,6 @@ export async function runAgentHost(input) {
         let providerAcceptedAttemptId;
         let durableInitialTurn;
         try {
-            if (replacesCurrentConversation) {
-                const previousSession = session;
-                const previousPayload = sessionPayload;
-                const previousActivationId = activationId ?? previousPayload?.launchId;
-                if (previousPayload === undefined || previousActivationId === undefined
-                    || authority?.owner !== "controller") {
-                    throw new Error("Agent Host cannot detach an inexact Provider Activation.");
-                }
-                await detachDurableProviderForConversationSwitch(input.home, {
-                    taskId: requiredEnvironment(next.environment.YUI_TASK_ID, "Task id"),
-                    roleName: requiredEnvironment(next.environment.YUI_ROLE, "Role name"),
-                    runId: requiredEnvironment(next.environment.YUI_RUN_ID, "Run id"),
-                    agentId: requiredEnvironment(next.environment.YUI_AGENT_ID, "Agent id"),
-                    launchId: next.launchId,
-                    previousConversationId: previousSession.conversationId,
-                    previousNativeSessionId: previousSession.nativeSessionId,
-                    previousActivationId,
-                    nextAuthorityEpoch: requestedAuthority.epoch,
-                    nextAuthorityHolderId: requestedAuthority.holderId,
-                    observedAt: new Date().toISOString()
-                });
-                switchDetachedSessions.add(previousSession);
-                // The persistent Provider child belongs to the Activation that first
-                // created it, not to the most recent resume Run payload. The exit
-                // observer carries that Activation launch id, so the stop receipt must
-                // use the same identity or the expected switch detach is misclassified
-                // as an abnormal child exit and generic cleanup can kill the Host.
-                writeRuntimeStopReceipt(input.home, previousActivationId, new Date());
-                authority = undefined;
-                await terminateProviderSessionForConversationSwitch(previousSession);
-                if (session === previousSession)
-                    session = undefined;
-                sessionPayload = undefined;
-                activationId = undefined;
-                conversationRecoverability = "unknown";
-                authority = requestedAuthority;
-            }
             if (session !== undefined) {
                 if (session.adapterId !== providerControl.adapterId
                     || providerControl.mode !== "resume"
@@ -1123,9 +1083,6 @@ async function beginDurableProviderTurn(home, durableTurn) {
         throw error;
     }
 }
-async function detachDurableProviderForConversationSwitch(home, request) {
-    await callControllerIdempotently(home, "runtime.conversation-switch-detach", request);
-}
 async function callControllerIdempotently(home, method, request) {
     try {
         await callAgentController(home, method, request);
@@ -1152,24 +1109,6 @@ async function callControllerIdempotently(home, method, request) {
 class ControllerAcknowledgementUnknownError extends Error {
     name = "ControllerAcknowledgementUnknownError";
 }
-async function terminateProviderSessionForConversationSwitch(providerSession) {
-    providerSession.terminate("SIGTERM");
-    const forceKill = setTimeout(() => providerSession.terminate("SIGKILL"), 3_000);
-    forceKill.unref();
-    let hardTimeout;
-    const timeout = new Promise((_resolve, reject) => {
-        hardTimeout = setTimeout(() => reject(new Error("Old Provider Activation did not exit after its switch authority was revoked.")), 8_000);
-        hardTimeout.unref();
-    });
-    try {
-        await Promise.race([providerSession.waitForExit(), timeout]);
-    }
-    finally {
-        clearTimeout(forceKill);
-        if (hardTimeout !== undefined)
-            clearTimeout(hardTimeout);
-    }
-}
 async function resolveProviderTurnSubmission(home, durableTurn, error) {
     const attemptId = durableTurn.attemptId;
     if (typeof attemptId !== "string") {

package/dist/runtime/builtinAgentDrivers.js

@@ -121,7 +121,7 @@ export const BUILTIN_AGENT_DRIVERS = Object.freeze([
             }),
             observation: Object.freeze({
                 ...STRUCTURED_CLI_CAPABILITIES.observation,
-                // Managed Codex uses the ordinary shared App Server event stream.
+                // Managed Codex uses its Yui-owned App Server event stream.
                 // Turn lifecycle is exact; Yui does not install per-thread Hooks merely
                 // to manufacture tool/wait/usage observations.
                 operations: Object.freeze([]),

package/dist/runtime/exactControlPlane.js

@@ -268,7 +268,9 @@ export function assertExactTaskRuntimeEnvironment(runtimeSource, environment, ex
 /** Fences a descriptor to the one currently active durable Task runtime. */
 export function assertExactTaskRuntimeState(runtime, store, options = {}) {
     const task = store.getTask(runtime.taskId);
-    if (task === null || task.status !== "active") {
+    if (task === null
+        || task.status !== "active"
+        || task.executionGate.state !== "enabled") {
         throw new Error("Exact Task runtime Task is not current and active.");
     }
     const role = store.getRole(runtime.taskId, runtime.roleName);
@@ -304,17 +306,21 @@ export function assertExactTaskRuntimeState(runtime, store, options = {}) {
         && session?.launchId === runtime.launchId;
     const executionRef = lifecycleMailbox?.processing?.executionRef;
     const preallocated = options.preallocatedDriverSessionReservation;
-    const exactPreallocatedReservation = preallocated !== undefined
-        && runtime.adapterId === preallocated.adapterId
-        && runtime.runId !== undefined
+    const exactRunLaunchReservation = runtime.runId !== undefined
         && runtime.launchId !== undefined
-        && runtime.nativeSessionId !== undefined
-        && session === undefined
         && reservation
         && !hasRuntimeCleanupObligation(lifecycleMailbox)
         && executionRef?.type === "run"
         && executionRef.taskId === runtime.taskId
-        && executionRef.id === runtime.runId
+        && executionRef.id === runtime.runId;
+    const terminalSessionReplacementReservation = exactRunLaunchReservation
+        && session !== undefined
+        && (session.status === "stopped" || session.status === "broken");
+    const exactPreallocatedReservation = preallocated !== undefined
+        && runtime.adapterId === preallocated.adapterId
+        && exactRunLaunchReservation
+        && runtime.nativeSessionId !== undefined
+        && (session === undefined || terminalSessionReplacementReservation)
         && runtime.nativeSessionId === nativeSessionIdForLaunch(preallocated.yuiHome, runtime.launchId, runtime.agentId, runtime.adapterId);
     const preallocatedBeforeInFlightProjection = exactPreallocatedReservation
         && (sessions?.inFlight === null || sessions?.inFlight === undefined);
@@ -327,11 +333,11 @@ export function assertExactTaskRuntimeState(runtime, store, options = {}) {
         throw new Error("Exact Task runtime launch fence is not current.");
     }
     if (runtime.nativeSessionId === undefined) {
-        if (session !== undefined) {
+        if (session !== undefined && !terminalSessionReplacementReservation) {
             throw new Error("Exact Task runtime native Session fence is missing.");
         }
     }
-    else if (session === undefined) {
+    else if (session === undefined || terminalSessionReplacementReservation) {
         if (!exactPreallocatedReservation) {
             throw new Error("Exact Task runtime native Session fence is not current.");
         }

package/dist/runtime/launchBroker.js

@@ -86,25 +86,15 @@ function validateProviderControl(control) {
     if (control.adapterId !== "codex" && control.adapterId !== "claude") {
         throw new Error("Agent Host Provider control adapter is invalid.");
     }
-    if ((control.adapterId === "codex" && control.transport !== "codex-app-server-proxy")
+    if ((control.adapterId === "codex" && control.transport !== "codex-app-server")
         || (control.adapterId === "claude" && control.transport !== "claude-stream-json")) {
         throw new Error("Agent Host Provider control transport does not match its adapter.");
     }
     if ((control.adapterId === "codex") !== (control.codexThread !== undefined)) {
         throw new Error("Agent Host Provider thread settings do not match its adapter.");
     }
-    if ((control.adapterId === "codex") !== (control.codexDaemonStartArgs !== undefined)) {
-        throw new Error("Agent Host Provider daemon bootstrap does not match its adapter.");
-    }
     if (control.codexThread !== undefined)
         validateCodexThreadOptions(control.codexThread);
-    if (control.codexDaemonStartArgs !== undefined) {
-        if (!Array.isArray(control.codexDaemonStartArgs)
-            || control.codexDaemonStartArgs.length === 0) {
-            throw new Error("Agent Host Codex daemon bootstrap args are invalid.");
-        }
-        control.codexDaemonStartArgs.forEach((value) => text(value, "Codex daemon argument"));
-    }
     if (control.mode !== "new" && control.mode !== "resume") {
         throw new Error("Agent Host Provider control mode is invalid.");
     }

package/dist/runtime/providerContinuationReconciliationService.js

@@ -20,7 +20,7 @@ export class ProviderContinuationReconciliationService {
     }
     async reconcile(now) {
         const changedTaskIds = new Set();
-        for (const task of this.store.listTasks().filter((entry) => entry.status === "active")) {
+        for (const task of this.store.listTasks().filter((entry) => (entry.status === "active" && entry.executionGate.state === "enabled"))) {
             const events = this.store.listEvents(task.id);
             const groups = groupDetachedContinuations(projectProviderContinuations(events), events.map(runtimeObservationFromTaskEvent)
                 .filter((entry) => entry !== null));

package/dist/runtime/providerRecoveryDecision.js

@@ -47,7 +47,7 @@ export function decideProviderRecovery(input) {
             reason: "Provider Conversation is missing but its Activation writer has not ended."
         };
     }
-    return { action: "replace", conversationId: conversation.conversationId };
+    return { action: "restart-run", conversationId: conversation.conversationId };
 }
 function providerTurnIsUnsettled(binding) {
     return binding.turn !== null

package/dist/runtime/providerRuntimeIdentity.js

@@ -294,21 +294,30 @@ export function updateProviderConversationRecoverability(raw, recoverability) {
 export function supersedeProviderConversation(raw, input) {
     const binding = validateProviderRuntimeBinding(raw);
     const current = currentProviderConversation(binding);
-    const basis = input.basis ?? "exact-unrecoverable";
-    if (basis !== "actor-request" && basis !== "exact-unrecoverable") {
-        throw new Error("Provider Conversation switch basis is invalid.");
+    const basis = input.basis;
+    if (basis !== "terminal-session") {
+        throw new Error("Provider Conversation replacement basis is invalid.");
     }
-    if (basis === "exact-unrecoverable" && current.recoverability !== "unrecoverable") {
-        throw new Error("Current Provider Conversation is not exactly unrecoverable.");
-    }
-    if (!input.noUnsettledInputDelivery) {
-        throw new Error("Cannot replace a Provider Conversation with unsettled input delivery.");
-    }
-    if (binding.authority.owner !== "none" || currentProviderActivation(binding) !== null) {
-        throw new Error("Cannot replace a Provider Conversation while its writer umbrella is owned.");
-    }
-    const switchedAt = timestamp(input.switchedAt, "Provider Conversation switch timestamp");
+    const switchedAt = timestamp(input.switchedAt, "Provider Conversation replacement timestamp");
     const epoch = current.epoch + 1;
+    const terminalReason = "terminal-session-replaced";
+    const activations = binding.activations.map((entry) => entry.status === "active"
+        ? {
+            ...entry,
+            status: "failed",
+            endedAt: switchedAt,
+            terminalReason
+        }
+        : entry);
+    const turn = binding.turn !== null
+        && ["submitting", "accepted", "running", "delivery-unknown"].includes(binding.turn.status)
+        ? {
+            ...binding.turn,
+            status: binding.turn.turnId === undefined ? "rejected" : "failed",
+            updatedAt: switchedAt,
+            terminalReason
+        }
+        : binding.turn;
     return validateProviderRuntimeBinding({
         ...binding,
         currentConversationEpoch: epoch,
@@ -324,7 +333,7 @@ export function supersedeProviderConversation(raw, input) {
                 createdAt: switchedAt
             }
         ],
-        activations: [...binding.activations, {
+        activations: [...activations, {
                 activationId: identity(input.activationId, "Provider Activation id"),
                 conversationId: input.conversationId,
                 generation: 1,
@@ -336,7 +345,8 @@ export function supersedeProviderConversation(raw, input) {
             owner: "controller",
             holderId: input.activationId,
             changedAt: switchedAt
-        }
+        },
+        turn
     });
 }
 export function validateProviderRuntimeBinding(value) {

package/dist/runtime/structuredProviderHost.js

@@ -4,8 +4,6 @@ import { CodexAppServerRequestError, CodexAppServerRuntime, codexAppServerErrorI
 import { PROVIDER_ACCEPT_TIMEOUT_MS } from "./runtimeDeadlines.js";
 import { YUI_VERSION } from "../version.js";
 const PROVIDER_MESSAGE_MAX_BYTES = 16 * 1024 * 1024;
-const CODEX_DAEMON_START_TIMEOUT_MS = 10_000;
-const CODEX_DAEMON_OUTPUT_MAX_BYTES = 64 * 1024;
 export class ProviderDeliveryUnknownError extends Error {
     attemptId;
     name = "ProviderDeliveryUnknownError";
@@ -46,9 +44,6 @@ export async function startStructuredProviderSession(payload, input = {}) {
     if (control === undefined) {
         throw new Error("Managed Agent Host launch requires Provider control metadata.");
     }
-    if (control.adapterId === "codex") {
-        await ensureCodexAppServerDaemon(payload, control);
-    }
     const child = spawn(payload.command, [...payload.args], {
         cwd: payload.cwd,
         env: { ...payload.environment },
@@ -78,58 +73,6 @@ export async function startStructuredProviderSession(payload, input = {}) {
         throw error;
     }
 }
-async function ensureCodexAppServerDaemon(payload, control) {
-    if (payload.args.at(-2) !== "app-server" || payload.args.at(-1) !== "proxy")
-        return;
-    if (control.adapterId !== "codex")
-        return;
-    const environment = Object.fromEntries(Object.entries(payload.environment).filter(([key]) => (!key.startsWith("YUI_")
-        && key !== "CODEX_INTERNAL_ORIGINATOR_OVERRIDE"
-        && !["TMPDIR", "XDG_CACHE_HOME", "XDG_DATA_HOME", "XDG_STATE_HOME", "XDG_RUNTIME_DIR"]
-            .includes(key))));
-    const child = spawn(payload.command, [...control.codexDaemonStartArgs], {
-        cwd: payload.cwd,
-        env: environment,
-        stdio: ["ignore", "pipe", "pipe"]
-    });
-    await new Promise((resolvePromise, reject) => {
-        let output = "";
-        let settled = false;
-        let timer;
-        const settle = (error) => {
-            if (settled)
-                return;
-            settled = true;
-            if (timer !== undefined)
-                clearTimeout(timer);
-            if (error === undefined)
-                resolvePromise();
-            else
-                reject(error);
-        };
-        const capture = (chunk) => {
-            output += String(chunk);
-            if (Buffer.byteLength(output, "utf8") <= CODEX_DAEMON_OUTPUT_MAX_BYTES)
-                return;
-            child.kill("SIGTERM");
-            settle(new Error("Codex App Server daemon start output exceeded its bound."));
-        };
-        child.stdout.on("data", capture);
-        child.stderr.on("data", capture);
-        child.once("error", (error) => settle(error));
-        child.once("close", (code, signal) => {
-            if (code === 0)
-                settle();
-            else
-                settle(new Error(`Codex App Server daemon start failed (${code ?? signal ?? "unknown"})${output.trim().length === 0 ? "" : `: ${output.trim()}`}`));
-        });
-        timer = setTimeout(() => {
-            child.kill("SIGTERM");
-            settle(new Error("Codex App Server daemon start timed out."));
-        }, CODEX_DAEMON_START_TIMEOUT_MS);
-        timer.unref();
-    });
-}
 class JsonLineChannel {
     child;
     mirror;

package/dist/scheduler/activeRoleRunDelivery.js

@@ -8,7 +8,7 @@ import { RuntimeLaunchFailure } from "../runtime/launchDiagnostics.js";
 import { mailboxHasWork, nextPendingBatch } from "../coordination/workMailbox.js";
 import { runtimeObservationFromTaskEvent } from "../runtime/runtimeObservation.js";
 import { projectProviderContinuations } from "../runtime/runtimeContinuationProjection.js";
-import { hasRuntimeLifecycleWork, RuntimeLifecycleBusyError, runtimeLifecycleTarget } from "../runtime/lifecycleReservation.js";
+import { RuntimeLifecycleBusyError } from "../runtime/lifecycleReservation.js";
 /**
  * Delivers durable Work AgentRuns before liveness reconciliation. Task command
  * handlers only record intent; this Controller path is the sole automated
@@ -48,24 +48,6 @@ export async function processActiveRoleRunDeliveries(store, delivery, now, selec
                 });
                 continue;
             }
-            // Single-flight: a Role runtime lifecycle lane that already holds a
-            // launch reservation or cleanup obligation must not be entered by a
-            // second delivery. The Run stays active-unpushed and is retried after
-            // the lane settles; the contention is never terminalized as a failure.
-            if (hasRuntimeLifecycleWork(store.getWorkMailbox(runtimeLifecycleTarget({
-                scope: "task",
-                taskId: task.id,
-                roleName: role.name
-            })))) {
-                results.push({
-                    taskId: task.id,
-                    roleName: role.name,
-                    runId: run.id,
-                    status: "skipped",
-                    reason: "runtime-unavailable"
-                });
-                continue;
-            }
             const existingSession = store.getRoleSession(task.id, role.name, run.effective.agentId);
             const receiptId = agentRunDeliveryReceiptId(run);
             const target = { kind: "role", taskId: task.id, roleName: role.name };

package/dist/scheduler/leaderWakeupProcessor.js

@@ -2,11 +2,11 @@ import { createAgentRun } from "../run/agentRun.js";
 import { createRunAssignment } from "../context/runContextContract.js";
 import { formatAgentRunReceiptId } from "../task/taskRecordReference.js";
 import { effectiveLaunchSnapshotsCompatible, effectiveLaunchSnapshotsCompatibleForTaskSession } from "../executor/effectiveLaunch.js";
-import { hasRuntimeLifecycleWork, RuntimeLifecycleBusyError, runtimeLifecycleTarget } from "../runtime/lifecycleReservation.js";
+import { roleAgentSessionResumeMode } from "../executor/agentExecutor.js";
+import { RuntimeLifecycleBusyError } from "../runtime/lifecycleReservation.js";
 import { recordLeaderFailure } from "./leaderFailure.js";
 import { isSchedulerTaskWorkspaceReady } from "./ports.js";
 import { RuntimeLaunchError } from "../runtime/ports.js";
-import { roleSessionDispatchModeWithConversationSwitch } from "../runtime/conversationSwitch.js";
 export async function processLeaderWakeups(store, delivery, now, selection) {
     const results = [];
     const wakeups = selection === undefined || selection.full
@@ -20,7 +20,10 @@ export async function processLeaderWakeups(store, delivery, now, selection) {
     for (const wakeup of wakeups) {
         const task = store.getTask(wakeup.taskId);
         const role = store.getRole(wakeup.taskId, "leader");
-        if (task === null || task.status !== "active" || role === null) {
+        if (task === null
+            || task.status !== "active"
+            || task.executionGate.state !== "enabled"
+            || role === null) {
             results.push({ taskId: wakeup.taskId, status: "skipped", reason: "unavailable" });
             continue;
         }
@@ -29,10 +32,6 @@ export async function processLeaderWakeups(store, delivery, now, selection) {
             results.push({ taskId: task.id, status: "skipped", reason: "workspace-not-ready" });
             continue;
         }
-        if (store.getLeaderFailure(task.id) !== null) {
-            results.push({ taskId: task.id, status: "skipped", reason: "recovery-blocked" });
-            continue;
-        }
         if (store.hasOpenInputRequest(task.id)) {
             results.push({ taskId: task.id, status: "skipped", reason: "waiting-input" });
             continue;
@@ -48,20 +47,6 @@ export async function processLeaderWakeups(store, delivery, now, selection) {
             results.push({ taskId: task.id, status: "skipped", reason: "busy" });
             continue;
         }
-        // Single-flight: a Role runtime lifecycle lane that already holds a
-        // launch reservation or cleanup obligation must not be entered by a
-        // second wake. The wake stays durable (pendingWakeup is not consumed) and
-        // is retried after the lane settles; the suppression is recorded for the
-        // audit instead of manufacturing a failed Run.
-        if (hasRuntimeLifecycleWork(store.getWorkMailbox(runtimeLifecycleTarget({
-            scope: "task",
-            taskId: task.id,
-            roleName: role.name
-        })))) {
-            store.recordWakeSuppression?.(task.id, "lifecycle-busy", now);
-            results.push({ taskId: task.id, status: "skipped", reason: "recovery-blocked" });
-            continue;
-        }
         const reopening = wakeup.reasons.includes("task-reopened");
         let existingSession = store.getRoleSession(task.id, role.name, reopening ? undefined : role.effective.agentId);
         let effectiveSession = existingSession;
@@ -71,43 +56,6 @@ export async function processLeaderWakeups(store, delivery, now, selection) {
         let prepared;
         let preStartFencePersisted = false;
         try {
-            if (existingSession !== null && !hasNativeSession(existingSession)) {
-                const sessionIsTerminal = existingSession.status === "stopped"
-                    || existingSession.status === "broken";
-                if (!sessionIsTerminal) {
-                    // An opaque live Session has no provider identity that can be safely
-                    // rebound. A host absence observation is not a verified stop; keep
-                    // the wake durable until an explicit exact cleanup/reset settles it.
-                    if (existingSession.launchId !== undefined) {
-                        await delivery.inspectRole({
-                            taskId: task.id,
-                            roleName: role.name,
-                            agentId: existingSession.agentId,
-                            adapterId: existingSession.adapterId
-                        });
-                    }
-                    results.push({
-                        taskId: task.id,
-                        status: "skipped",
-                        reason: "recovery-blocked"
-                    });
-                    continue;
-                }
-                if (hasRuntimeLifecycleWork(store.getWorkMailbox(runtimeLifecycleTarget({
-                    scope: "task",
-                    taskId: task.id,
-                    roleName: role.name
-                })))) {
-                    // A stopped/broken Session is eligible for a fresh mode only after
-                    // its exact runtime cleanup/reservation lane has settled.
-                    results.push({
-                        taskId: task.id,
-                        status: "skipped",
-                        reason: "recovery-blocked"
-                    });
-                    continue;
-                }
-            }
             const compatibleSession = existingSession !== null
                 && (reopening
                     ? effectiveLaunchSnapshotsCompatible(existingSession.effective, role.effective)
@@ -123,15 +71,14 @@ export async function processLeaderWakeups(store, delivery, now, selection) {
             const resumableSession = hasNativeSession(existingSession)
                 && existingSession.status !== "stopped"
                 && existingSession.status !== "broken";
-            // A failed or quiet Run is not proof that its Provider Conversation is
-            // unusable. Keep resuming the same identity unless an explicit switch
-            // request (or exact terminal/missing evidence) authorizes a fresh one.
+            // Reuse a healthy Session. A terminal Session is disposable and the next
+            // Run starts fresh without consulting historical recovery records.
             const sessionSet = store.getTaskRoleSessionSet?.(task.id, role.name) ?? null;
             const mode = reopenIdentityDrift
                 ? "new"
                 : sessionSet === null
                     ? resumableSession && compatibleSession ? "resume" : "new"
-                    : roleSessionDispatchModeWithConversationSwitch(sessionSet, store.listEvents?.(task.id) ?? [], store.getWorkMailbox({ kind: "role", taskId: task.id, roleName: role.name }), role.name, role.effective.agentId, role.effective);
+                    : roleAgentSessionResumeMode(sessionSet, role.effective.agentId, role.effective);
             const runId = store.peekNextAgentRunId(task.id);
             const wakeEnvelope = resolveLeaderWakeEnvelope(store, task.id);
             const contextSnapshot = store.freezeLeaderContextSnapshot?.(task.id, role.name, now);
@@ -226,7 +173,9 @@ export async function processLeaderWakeups(store, delivery, now, selection) {
                 || ready.prepared.turnAcceptedDuringLaunch === true
                 || ready.prepared.turnDeliveryUnknownDuringLaunch === true;
             const latestTask = store.getTask(task.id);
-            if (latestTask === null || latestTask.status !== "active") {
+            if (latestTask === null
+                || latestTask.status !== "active"
+                || latestTask.executionGate.state !== "enabled") {
                 delivery.forgetPrepared?.({
                     taskId: task.id,
                     roleName: role.name,