@zq-silk/yui 0.15.7 → 0.15.8

package/dist/controller/fileSchedulerStoreAdapter.js

@@ -1,47 +1,50 @@
-import { createHash } from "node:crypto";
+import { createHash, randomUUID } from "node:crypto";
+import { prepareMessageContinuations } from "../message/messageContinuation.js";
+import { freezeRunContextSnapshot } from "../context/runContextPack.js";
+import { contextSnapshotRef } from "../context/contextSnapshot.js";
 import { isDeepStrictEqual } from "node:util";
-import { activeLiveRoleAgentSession, bindTaskRoleProviderRuntime, createRoleSessionSet, recordRoleAgentSession, replaceTaskRoleAgentSession, recordTaskRoleTurnBoundary, rememberRoleAgentCompletedTurn, detachRoleAgentSessionHost, updateRoleAgentSessionStatus, updateTaskRoleProviderRuntime } from "../executor/agentExecutor.js";
-import { acceptProviderTurn, beginProviderTurn, createProviderRuntimeBinding, endProviderActivation, currentProviderActivation, currentProviderConversation, managedProviderTurnId, clearProviderGoal, providerGoalContinues, settleProviderTurnSubmission, settleProviderTurn, startProviderActivation, supersedeProviderConversation, updateProviderConversationRecoverability, updateProviderGoal } from "../runtime/providerRuntimeIdentity.js";
+import { assertExecutionEnvironmentCurrent } from "../runtime/executionEnvironment.js";
+import { activeLiveRoleAgentSession, bindTaskRoleProviderRuntime, createRoleSessionSet, recordRoleAgentSession, replaceTaskRoleAgentSession, recordTaskRoleNativeTurnBoundary, rememberRoleAgentCompletedTurn, detachRoleAgentSessionHost, updateRoleAgentSessionStatus, updateTaskRoleProviderRuntime, selectNewTaskRoleSession, taskRoleControlTarget } from "../executor/agentExecutor.js";
+import { acceptProviderTurn, cancelQuiescentProviderInput, beginProviderTurn, createProviderRuntimeBinding, currentProviderConversation, managedProviderTurnId, clearProviderGoal, settleProviderTurnSubmission, settleProviderTurn, transferProviderAuthority, supersedeProviderConversation, updateProviderConversationRecoverability, updateProviderGoal } from "../runtime/providerRuntimeIdentity.js";
 import { createTaskEvent } from "../event/taskEvent.js";
 import { operationalTaskRecords } from "../task/taskRecordRetirement.js";
 import { buildTaskWakeEnvelope } from "../context/wakeNotification.js";
-import { createTaskWake, fallbackWakeCursor, latestTaskWake } from "../scheduler/taskWake.js";
+import { createTaskWake, fallbackWakeCursor, latestTaskWake, markTaskWakeConsumed } from "../scheduler/taskWake.js";
 import { answerInputRequest } from "../input/inputRequest.js";
 import { activeRoleAgentBinding } from "../role/role.js";
 import { effectiveLaunchWithTaskMainWorkspace, roleSessionMayContinue, resolveEffectiveLaunch, validateEffectiveLaunchSnapshot } from "../executor/effectiveLaunch.js";
 import { SYSTEM_OPERATOR_ROLE } from "../role/systemRoles.js";
-import { appendTurnInput, createTurn } from "../turn/turn.js";
+import { appendRunInput, createRun, withRunContextSnapshot, runPurposeAdmitsTaskState } from "../agentRun/agentRun.js";
 import { transportAgentResult } from "../domain/agentResultTransport.js";
-import { createTurnInput } from "../context/turnInputContract.js";
+import { createRunInput } from "../context/runInputContract.js";
 import { classifyRuntimeProcessExit, validateRuntimeProcessExitObservation } from "../runtime/processExitObservation.js";
-import { terminalizeExactTaskTurn } from "../lifecycle/exactTurnTerminalization.js";
+import { terminalizeExactTaskRun, cancelQuiescentRoleRuns } from "../lifecycle/exactRunTerminalization.js";
 import { createCanonicalLifecycleEvent, foldCanonicalLifecycleEvent } from "../lifecycle/canonicalLifecycleEvent.js";
 import { recordLeaderFailure } from "../scheduler/leaderFailure.js";
 import { recordLeaderAttentionRequired, routeRoleEvent } from "../scheduler/operatorEvent.js";
-import { pendingWakeupsMatch } from "../scheduler/pendingWakeup.js";
 import { queueLeaderWakeup } from "../scheduler/wakeupQueue.js";
 import { wakeReason } from "../scheduler/wakeReason.js";
-import { foldTurnProgressFacts, latestTurnDurableProgressAt, latestTurnEventTime, latestStallEvidenceKey, isRoleTurnStalled, TURN_PROGRESS_EVENT, TURN_DIAGNOSTIC_FINISHED_EVENT, TURN_RECOVERED_EVENT, TURN_STALLED_EVENT } from "../scheduler/roleTurnStall.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 { pendingWakeupProjection } from "../storage/taskStore.js";
 import { projectProviderContinuations } from "../runtime/runtimeContinuationProjection.js";
 import { providerContinuationKey } from "../runtime/providerContinuation.js";
-import { formatTurnReceiptId } from "../task/taskRecordReference.js";
-import { bindExecution, claimPending, completeProcessing, consumePendingBatch, mailboxHasPending, mailboxHasWork, releaseProcessing } from "../coordination/workMailbox.js";
-import { enqueueWork, settleRoleTurnDispatch as settleRoleTurnDispatchMailbox } from "../coordination/workMailboxQueue.js";
-import { RUNTIME_CLEANUP_REQUIRED_REASON, RUNTIME_HOST_DETACH_REQUIRED_REASON, RUNTIME_LAUNCH_RESERVED_REASON, RUNTIME_LIFECYCLE_OWNER, RuntimeLifecycleBusyError, hasRuntimeCleanupObligation, hasRuntimeLifecycleWork, isRuntimeCleanupReason, isRuntimeLaunchReservation, runtimeCleanupDisposition, runtimeLifecycleTarget } from "../runtime/lifecycleReservation.js";
-import { nativeSessionIdForLaunch } from "../runtime/preallocatedNativeSession.js";
+import { formatRunReceiptId } from "../task/taskRecordReference.js";
+import { bindExecution, claimPending, completeProcessing, mailboxHasWork, releaseProcessing } from "../coordination/workMailbox.js";
+import { enqueueWork, settleRoleRunDispatch as settleRoleRunDispatchMailbox } from "../coordination/workMailboxQueue.js";
+import { RUNTIME_CLEANUP_REQUIRED_REASON, RUNTIME_HOST_DETACH_REQUIRED_REASON, RUNTIME_LIFECYCLE_OWNER, hasRuntimeCleanupObligation, hasRuntimeLifecycleWork, isRuntimeCleanupReason, runtimeCleanupDisposition, runtimeLifecycleTarget } from "../runtime/lifecycleReservation.js";
 import { builtinAgentDriverRegistry } from "../runtime/builtinAgentDrivers.js";
 import { standardAgentError } from "../runtime/agentError.js";
-import { RUNTIME_OBSERVATION_TASK_EVENT, createRuntimeObservation, isRuntimeTokenEvidence, runtimeObservationFenceMatches, runtimeObservationFromTaskEvent, runtimeObservationTurnFenceMatches, runtimeObservationTaskEventPayload } from "../runtime/runtimeObservation.js";
-import { contextSnapshotRef } from "../context/contextSnapshot.js";
+import { RUNTIME_OBSERVATION_TASK_EVENT, createRuntimeObservation, isRuntimeTokenEvidence, runtimeObservationFenceMatches, runtimeObservationFromTaskEvent, runtimeObservationRunFenceMatches, runtimeObservationTaskEventPayload } from "../runtime/runtimeObservation.js";
 import { snapshotExecutionLaneWorkspaceSync } from "../repository/executionLaneGitSnapshot.js";
-import { contextSnapshotDeltaRefIds, freezeTurnContextSnapshot } from "../context/turnContextPack.js";
 export class AgentHostProviderTurnFenceError extends Error {
     constructor(message) {
         super(message);
         this.name = "AgentHostProviderTurnFenceError";
     }
 }
+export class AgentHostProviderSessionBusyError extends AgentHostProviderTurnFenceError {
+    code = "SESSION_BUSY";
+}
 /** Maps authoritative TaskStore records to the scheduler's narrow port. */
 export class FileSchedulerStoreAdapter {
     store;
@@ -55,23 +58,10 @@ export class FileSchedulerStoreAdapter {
         this.drivers = drivers;
         this.snapshotExecutionLaneWorkspace = snapshotExecutionLaneWorkspace;
     }
-    freezeLeaderContextSnapshot(taskId, roleName, now) {
-        return this.store.transaction((tx) => {
-            const snapshot = freezeTurnContextSnapshot(tx, {
-                taskId,
-                roleName,
-                purpose: "execution"
-            }, now);
-            return Object.freeze({
-                ref: contextSnapshotRef(snapshot),
-                deltaRefIds: contextSnapshotDeltaRefIds(tx, snapshot)
-            });
-        });
-    }
     /**
      * Sole provider-independent ingress for structured runtime state. Driver
      * mapping has already happened before this boundary; this method validates
-     * the exact durable Turn/session fence, applies the small workflow-relevant
+     * the exact durable AgentRun/session fence, applies the small workflow-relevant
      * transitions, and retains the canonical observation for status projection.
      */
     observeRuntimeObservation(raw, now = new Date()) {
@@ -86,10 +76,41 @@ export class FileSchedulerStoreAdapter {
         if (adapterId === null) {
             return this.recordObsoleteCanonicalObservation(input, "driver-or-turn-mismatch", now);
         }
+        if (input.kind === "input.accepted" && input.payload.input !== undefined
+            && (input.fence.receiptId?.startsWith("native-input:") === true
+                || input.fence.receiptId?.startsWith("steer:") === true)) {
+            return this.store.transaction((store) => {
+                const run = input.fence.runId === undefined ? null : store.getRun(taskId, input.fence.runId);
+                const sessions = store.getTaskRoleSessionSet(taskId, input.fence.roleName);
+                const native = sessions?.providerBinding?.run;
+                if (run === null || run.roleName !== input.fence.roleName
+                    || run.effective.agentId !== input.fence.agentId || native?.runId !== run.id
+                    || native.nativeTurnId !== input.fence.nativeTurnId
+                    || sessions?.sessions[input.fence.agentId]?.nativeSessionId !== input.fence.nativeSessionId)
+                    return "obsolete";
+                if (!hasPersistedRuntimeObservation(store.listEvents(taskId), input) && run.status === "active") {
+                    const updated = appendRunInput(run, createRunInput({
+                        source: input.fence.receiptId.startsWith("native-input:")
+                            ? { type: "provider", channel: "visible-input" }
+                            : { type: "yui", channel: "input-response" },
+                        directive: input.payload.input, deltaRefIds: []
+                    }), now);
+                    store.saveRun(updated);
+                    store.saveActiveRun(updated);
+                }
+                this.persistRuntimeObservation(input, now);
+                return "applied";
+            });
+        }
+        if ((input.kind === "input.accepted" || input.kind === "input.rejected" || input.kind === "input.delivery-unknown")
+            && input.payload.input !== undefined
+            && input.fence.receiptId?.startsWith("turn-input:") === true) {
+            return this.observeLeaderSteerReceipt(input, now);
+        }
         // Receipt dedupe is not business-result dedupe. Terminal folds revalidate
         // their exact binding and commit result + notification + observation
         // together, including a retry after a previously interrupted fold.
-        if (!isTurnTerminalObservation(input)
+        if (!isRunTerminalObservation(input)
             && input.kind !== "turn.accepted" && input.kind !== "input.accepted"
             && hasPersistedRuntimeObservation(this.store.listEvents(taskId), input))
             return "applied";
@@ -108,8 +129,8 @@ export class FileSchedulerStoreAdapter {
                 break;
             case "turn.failed": {
                 // A Provider Turn is an activation boundary, not a Task outcome.
-                // Keep the Turn and Session identity available for Agent-directed
-                // restore + submit, even when a provider marks its Turn terminal.
+                // Keep the AgentRun and Session identity available for Agent-directed
+                // restore + submit, even when a provider marks its AgentRun terminal.
                 outcome = this.foldProviderTurnBoundary(input, adapterId, "failed", now);
                 break;
             }
@@ -124,16 +145,13 @@ export class FileSchedulerStoreAdapter {
             case "continuation.reported":
             case "continuation.settled":
             case "input.delivery-unknown":
-                outcome = this.validateCanonicalTurnObservation(input, now);
+                outcome = this.validateCanonicalRunObservation(input, now);
                 break;
             case "turn.cancelled": {
                 outcome = this.foldProviderTurnBoundary(input, adapterId, "cancelled", now);
                 break;
             }
             case "conversation.observed":
-            case "activation.started":
-            case "activation.ended":
-            case "activation.failed":
                 outcome = this.observeProviderRuntimeIdentity(input, now);
                 break;
             case "goal.updated":
@@ -150,21 +168,86 @@ export class FileSchedulerStoreAdapter {
             default:
                 outcome = "obsolete";
         }
-        if (outcome === "applied" && !isTurnTerminalObservation(input)) {
+        if (outcome === "applied" && !isRunTerminalObservation(input)) {
             this.persistRuntimeObservation(input, now);
         }
         return outcome;
     }
+    /** A delayed steer receipt settles only its original claimed mailbox batch. */
+    observeLeaderSteerReceipt(input, now) {
+        return this.store.transaction((store) => {
+            const taskId = input.fence.taskId;
+            const run = input.fence.runId === undefined ? null : store.getRun(taskId, input.fence.runId);
+            const sessions = store.getTaskRoleSessionSet(taskId, input.fence.roleName);
+            const session = sessions?.sessions[input.fence.agentId];
+            const binding = sessions?.providerBinding;
+            if (run === null || run.roleName !== "leader" || input.fence.roleName !== "leader"
+                || run.effective.agentId !== input.fence.agentId
+                || session === undefined
+                || session.nativeSessionId !== input.fence.nativeSessionId
+                || binding?.run?.runId !== run.id
+                || binding.run.nativeTurnId !== input.fence.nativeTurnId) {
+                recordCanonicalObservationObsolete(store, input, "steer-receipt-fence-mismatch", now);
+                return "obsolete";
+            }
+            if (hasPersistedRuntimeObservation(store.listEvents(taskId), input))
+                return "applied";
+            const target = { kind: "role", taskId, roleName: "leader" };
+            const mailbox = store.getWorkMailbox(target);
+            const processing = mailbox?.processing;
+            const exactBatch = processing?.owner === `leader-steer:${run.id}`
+                && input.fence.receiptId === `turn-input:${taskId}/${run.id}/${processing.batchId}`;
+            if (exactBatch && mailbox !== null && processing !== null && processing !== undefined) {
+                if (input.kind === "input.accepted") {
+                    // Terminal AgentRuns remain immutable: the canonical receipt still
+                    // retains their late input, without touching a successor pointer.
+                    if (run.status === "active" && store.getActiveRun(taskId, "leader")?.id === run.id) {
+                        const updated = appendRunInput(run, createRunInput({
+                            source: { type: "yui", channel: "leader-forced-wakeup" },
+                            directive: input.payload.input,
+                            deltaRefIds: []
+                        }), now);
+                        store.saveRun(updated);
+                        store.saveActiveRun(updated);
+                    }
+                    store.saveWorkMailbox(completeProcessing(mailbox, processing.batchId));
+                    store.saveEvent(taskId, createTaskEvent(store.nextEventId(taskId), taskId, "run.input-submitted", {
+                        runId: run.id,
+                        batchId: processing.batchId,
+                        attemptId: input.fence.receiptId,
+                        source: "yui/leader-forced-wakeup",
+                        reasons: processing.batch.reasons.join(",")
+                    }, now));
+                }
+                else if (input.payload.failure?.error.inputDisposition === "not-accepted") {
+                    store.saveWorkMailbox(releaseProcessing(mailbox, processing.batchId));
+                }
+            }
+            if (input.kind !== "input.accepted" && input.payload.failure !== undefined) {
+                const error = input.payload.failure.error;
+                this.recordAgentError({
+                    taskId, roleName: run.roleName, runId: run.id,
+                    source: error.source, phase: error.phase,
+                    message: error.message, raw: error.raw,
+                    inputDisposition: error.inputDisposition,
+                    sessionDisposition: error.sessionDisposition,
+                    attemptId: input.fence.receiptId
+                }, now);
+            }
+            this.persistRuntimeObservation(input, now);
+            return "applied";
+        });
+    }
     adapterForRuntimeObservation(input) {
         const taskId = input.fence.taskId;
-        const turnId = input.fence.turnId;
+        const runId = input.fence.runId;
         if (taskId === undefined)
             return null;
-        if (turnId === undefined) {
+        if (runId === undefined) {
             const role = this.store.getRole(taskId, input.fence.roleName);
             const sessions = this.store.getTaskRoleSessionSet(taskId, input.fence.roleName);
             const session = sessions?.sessions[input.fence.agentId];
-            if (role?.activeAgentId !== input.fence.agentId
+            if (role === null || sessions?.activeAgentId !== input.fence.agentId
                 || session?.adapterId === undefined)
                 return null;
             try {
@@ -176,7 +259,7 @@ export class FileSchedulerStoreAdapter {
                 return null;
             }
         }
-        const run = this.store.getTurn(taskId, turnId);
+        const run = this.store.getRun(taskId, runId);
         if (run === null
             || run.roleName !== input.fence.roleName
             || run.effective.agentId !== input.fence.agentId)
@@ -190,32 +273,31 @@ export class FileSchedulerStoreAdapter {
             return null;
         }
     }
-    validateCanonicalTurnObservation(input, now) {
+    validateCanonicalRunObservation(input, now) {
         return this.store.transaction((store) => {
             if (hasPersistedRuntimeObservation(store.listEvents(input.fence.taskId), input)) {
                 return "applied";
             }
-            const run = store.getTurn(input.fence.taskId, input.fence.turnId);
-            const active = store.getActiveTurn(input.fence.taskId, input.fence.roleName);
+            const run = input.fence.runId === undefined ? null : store.getRun(input.fence.taskId, input.fence.runId);
+            const active = store.getActiveRun(input.fence.taskId, input.fence.roleName);
             const sessions = store.getTaskRoleSessionSet(input.fence.taskId, input.fence.roleName);
             const session = sessions?.sessions[input.fence.agentId];
-            const knownContinuation = input.kind.startsWith("continuation.")
-                && projectProviderContinuations(store.listEvents(input.fence.taskId)).some((entry) => (entry.turnId === input.fence.turnId
-                    && entry.identity.providerNamespace === input.fence.driverId
-                    && entry.identity.accountScope === input.fence.agentId
-                    && entry.identity.conversationId === input.fence.conversationId
-                    && entry.identity.activationId === input.fence.activationId
-                    && entry.identity.continuationId === input.fence.continuationId
-                    && entry.identity.generation === input.fence.continuationGeneration));
+            if (input.fence.runId === undefined
+                && ["operation.started", "operation.completed", "operation.failed", "activity.observed"].includes(input.kind)) {
+                const native = sessions?.providerBinding?.run;
+                return native?.runId === undefined && input.fence.receiptId !== undefined
+                    && native?.attemptId === input.fence.receiptId && native.status === "accepted"
+                    && session?.nativeSessionId === input.fence.nativeSessionId
+                    && (native.nativeTurnId === undefined || native.nativeTurnId === input.fence.nativeTurnId)
+                    ? "applied" : "obsolete";
+            }
+            const knownContinuation = input.kind.startsWith("continuation.") && projectProviderContinuations(store.listEvents(input.fence.taskId)).some((entry) => (entry.runId === input.fence.runId
+                && entry.identity.providerNamespace === input.fence.driverId
+                && entry.identity.accountScope === input.fence.agentId
+                && entry.identity.conversationId === input.fence.conversationId
+                && entry.identity.continuationId === input.fence.continuationId));
             const requiresCurrentRuntime = input.kind !== "turn.cancelled" && !knownContinuation;
-            const valid = run !== null
-                && (!requiresCurrentRuntime || (run.status === "active" && active?.id === run.id))
-                && run.roleName === input.fence.roleName
-                && run.effective.agentId === input.fence.agentId
-                && this.drivers.requireByAdapterId(run.effective.adapterId).id === input.fence.driverId
-                && (knownContinuation || (session?.runtimeGenerationId === input.fence.runtimeGenerationId
-                    && session.nativeSessionId === input.fence.nativeSessionId))
-                && runtimeReceiptBelongsToTurn(store, input);
+            const valid = run !== null && (!requiresCurrentRuntime || (run.status === "active" && active?.id === run.id)) && run.roleName === input.fence.roleName && run.effective.agentId === input.fence.agentId && this.drivers.requireByAdapterId(run.effective.adapterId).id === input.fence.driverId && (knownContinuation || (session !== undefined && session.nativeSessionId === input.fence.nativeSessionId)) && runtimeReceiptBelongsToRun(store, input);
             if (!valid) {
                 recordCanonicalObservationObsolete(store, input, "runtime-fence-not-current", now);
                 return "obsolete";
@@ -234,9 +316,12 @@ export class FileSchedulerStoreAdapter {
                 }
             : {
                 status: "failed",
+                ...(typeof input.payload.output === "string"
+                    && transportAgentResult(input.payload.output).status === "completed"
+                    ? { output: input.payload.output } : {}),
                 diagnostic: providerStatus === "cancelled"
-                    ? "Provider cancelled the Agent Turn."
-                    : `Provider Agent Turn failed: ${input.payload.failure?.error.message ?? "unknown provider failure"}`,
+                    ? "Provider cancelled the Agent AgentRun."
+                    : `Provider Agent AgentRun failed: ${input.payload.failure?.error.message ?? "unknown provider failure"}`,
                 failureReason: providerStatus === "cancelled"
                     ? "cancelled"
                     : "runtime-failed"
@@ -246,57 +331,44 @@ export class FileSchedulerStoreAdapter {
             roleName: input.fence.roleName,
             agentId: input.fence.agentId,
             adapterId,
-            runtimeGenerationId: input.fence.runtimeGenerationId,
-            activationId: input.fence.activationId,
             conversationId: input.fence.conversationId,
             nativeSessionId: input.fence.nativeSessionId,
             nativeTurnId: input.fence.nativeTurnId,
             attemptId: input.fence.receiptId,
-            turnId: input.fence.turnId,
+            runId: input.fence.runId,
             ...(input.payload.input === undefined ? {} : { input: input.payload.input }),
             providerStatus,
             outcome,
             observation: input
         };
-        const classification = this.classifyRuntimeTurnTerminal(completed);
+        const classification = this.classifyRuntimeRunTerminal(completed);
         if (classification !== "apply")
             return classification;
-        const result = this.observeRuntimeTurnTerminal(completed, now);
+        const result = this.observeRuntimeRunTerminal(completed, now);
         return result.disposition === "obsolete" ? "obsolete" : "applied";
     }
     validateCanonicalSessionObservation(input, now) {
         return this.store.transaction((store) => {
-            const run = store.getTurn(input.fence.taskId, input.fence.turnId);
+            const run = input.fence.runId === undefined ? null : store.getRun(input.fence.taskId, input.fence.runId);
             const sessions = store.getTaskRoleSessionSet(input.fence.taskId, input.fence.roleName);
             const session = sessions?.sessions[input.fence.agentId];
-            if (run === null
-                || run.roleName !== input.fence.roleName
-                || run.effective.agentId !== input.fence.agentId
-                || this.drivers.requireByAdapterId(run.effective.adapterId).id !== input.fence.driverId
-                || session?.runtimeGenerationId !== input.fence.runtimeGenerationId
-                || session.nativeSessionId !== input.fence.nativeSessionId) {
+            const native = sessions?.providerBinding?.run;
+            const exactInput = input.fence.receiptId !== undefined && native?.attemptId === input.fence.receiptId;
+            const validRun = input.fence.runId === undefined ? exactInput
+                : run !== null && run.roleName === input.fence.roleName && run.effective.agentId === input.fence.agentId
+                    && this.drivers.requireByAdapterId(run.effective.adapterId).id === input.fence.driverId;
+            if (!validRun || session === undefined || session.nativeSessionId !== input.fence.nativeSessionId
+                || (input.fence.receiptId !== undefined && (!exactInput
+                    || (native?.nativeTurnId !== undefined && native.nativeTurnId !== input.fence.nativeTurnId)))) {
                 recordCanonicalObservationObsolete(store, input, "runtime-session-not-current", now);
                 return "obsolete";
             }
             const status = "ended";
             let updatedSessions = updateRoleAgentSessionStatus(sessions, input.fence.agentId, status, now, input.kind === "session.failed" ? "failed" : "stopped");
-            if (updatedSessions.providerBinding !== null) {
-                const activationId = input.fence.activationId ?? input.fence.runtimeGenerationId;
-                updatedSessions = updateTaskRoleProviderRuntime(updatedSessions, endProviderActivation(updatedSessions.providerBinding, activationId, {
-                    status: input.kind === "session.failed" ? "failed" : "ended",
-                    endedAt: input.observedAt ?? input.receivedAt,
-                    reason: input.kind
-                }), now);
-            }
             store.saveTaskRoleSessionSet(updatedSessions);
             for (const continuation of projectProviderContinuations(store.listEvents(input.fence.taskId))) {
-                if (continuation.turnId !== input.fence.turnId
-                    || continuation.identity.conversationId
-                        !== (input.fence.conversationId ?? input.fence.nativeSessionId)
-                    || continuation.identity.activationId
-                        !== (input.fence.activationId ?? input.fence.runtimeGenerationId)
-                    || continuation.execution === "quiescent"
-                    || continuation.attachment === "detached")
+                if (continuation.runId !== input.fence.runId || continuation.identity.conversationId
+                    !== (input.fence.conversationId ?? input.fence.nativeSessionId) || continuation.execution === "quiescent" || continuation.attachment === "detached")
                     continue;
                 const key = providerContinuationKey(continuation.identity);
                 const identityDigest = createHash("sha256").update(key).digest("hex");
@@ -311,9 +383,7 @@ export class FileSchedulerStoreAdapter {
                     fence: {
                         ...input.fence,
                         conversationId: continuation.identity.conversationId,
-                        activationId: continuation.identity.activationId,
                         continuationId: continuation.identity.continuationId,
-                        continuationGeneration: continuation.identity.generation,
                         ...(continuation.parentContinuationId === undefined
                             ? {}
                             : { parentContinuationId: continuation.parentContinuationId })
@@ -334,23 +404,23 @@ export class FileSchedulerStoreAdapter {
                 store.saveEvent(input.fence.taskId, detachedEvent);
                 routeContinuationResult(store, detached, detachedEvent, "provider-continuation-detached", now);
             }
-            const active = store.getActiveTurn(input.fence.taskId, input.fence.roleName);
+            const active = store.getActiveRun(input.fence.taskId, input.fence.roleName);
             const role = store.getRole(input.fence.taskId, input.fence.roleName);
             if ((input.kind === "session.ended" || input.kind === "session.failed")
                 && active !== null
-                && active.id === input.fence.turnId
+                && active.id === input.fence.runId
                 && active.status === "active"
                 && role !== null) {
                 if (role.name === "leader") {
                     const message = [
-                        `Leader native Session became unavailable while Turn ${active.id} remains active.`,
-                        "Yui preserved the Turn because Session/host termination is not a Task outcome.",
-                        "Retire the disposable Turn, or use Task execution stop/start if the current runtime cannot be settled normally."
+                        `Leader native Session became unavailable while AgentRun ${active.id} remains active.`,
+                        "Yui preserved the AgentRun because Session/host termination is not a Task outcome.",
+                        "Retire the disposable AgentRun, or use Task execution stop/start if the current runtime cannot be settled normally."
                     ].join(" ");
                     recordLeaderAttentionRequired(store, {
                         taskId: input.fence.taskId,
                         reason: "leader-runtime-detached",
-                        payload: { message, turnId: active.id },
+                        payload: { message, runId: active.id },
                         now
                     });
                 }
@@ -360,7 +430,7 @@ export class FileSchedulerStoreAdapter {
                         taskId: input.fence.taskId,
                         roleName: "leader"
                     }, "role-runtime-detached", now, [
-                        { type: "turn", taskId: input.fence.taskId, id: active.id }
+                        { type: "run", taskId: input.fence.taskId, id: active.id }
                     ]);
                 }
             }
@@ -385,10 +455,7 @@ export class FileSchedulerStoreAdapter {
                 && input.payload.snapshotComplete === true
                 && input.payload.observationQuality === "exact") {
                 for (const continuation of projectProviderContinuations(events)) {
-                    if (continuation.turnId !== input.fence.turnId
-                        || continuation.identity.conversationId !== input.fence.conversationId
-                        || continuation.identity.activationId !== input.fence.activationId
-                        || continuation.execution === "quiescent")
+                    if (continuation.runId !== input.fence.runId || continuation.identity.conversationId !== input.fence.conversationId || continuation.execution === "quiescent")
                         continue;
                     const identityKey = providerContinuationKey(continuation.identity);
                     const digest = createHash("sha256")
@@ -405,7 +472,6 @@ export class FileSchedulerStoreAdapter {
                         fence: {
                             ...input.fence,
                             continuationId: continuation.identity.continuationId,
-                            continuationGeneration: continuation.identity.generation,
                             ...(continuation.parentContinuationId === undefined
                                 ? {}
                                 : { parentContinuationId: continuation.parentContinuationId })
@@ -443,18 +509,17 @@ export class FileSchedulerStoreAdapter {
             if (input.kind === "turn.failed" && input.payload.failure !== undefined) {
                 const failure = input.payload.failure;
                 const error = failure.error;
-                const run = input.fence.turnId === undefined
+                const run = input.fence.runId === undefined
                     ? null
-                    : store.getTurn(taskId, input.fence.turnId);
+                    : store.getRun(taskId, input.fence.runId);
                 const errorEvent = createTaskEvent(store.nextEventId(taskId), taskId, "runtime.agent-error", {
                     sourceEventId: input.eventId,
                     observationEventId,
-                    turnId: input.fence.turnId ?? "",
+                    runId: input.fence.runId ?? "",
                     roleName: input.fence.roleName,
                     agentId: input.fence.agentId,
                     adapterId: run?.effective.adapterId ?? "unknown",
                     driverId: input.fence.driverId,
-                    runtimeGenerationId: input.fence.runtimeGenerationId,
                     nativeSessionId: input.fence.nativeSessionId ?? "",
                     nativeTurnId: input.fence.nativeTurnId ?? "",
                     source: error.source,
@@ -471,17 +536,7 @@ export class FileSchedulerStoreAdapter {
                     ...(failure.lastOutput === undefined ? {} : { lastOutput: failure.lastOutput })
                 }, now);
                 store.saveEvent(taskId, errorEvent);
-                enqueueWork(store, { kind: "role", taskId, roleName: "leader" }, wakeReason("agent-error", errorEvent.id), now, [{ type: "event", taskId, id: errorEvent.id }], {
-                    source: input.fence.driverId,
-                    dedupeKey: `agent-error:${taskId}:${input.eventId}`
-                });
-                if (input.fence.roleName === "leader"
-                    && error.sessionDisposition === "unrecoverable") {
-                    enqueueWork(store, { kind: "operator" }, "leader-session-unrecoverable", now, [{ type: "event", taskId, id: errorEvent.id }], {
-                        source: input.fence.driverId,
-                        dedupeKey: `leader-session-unrecoverable:${taskId}:${input.eventId}`
-                    });
-                }
+                routeRoleEvent(store, errorEvent, input.fence.roleName, wakeReason("agent-error", errorEvent.id), now);
             }
             if ((input.kind === "operation.completed" || input.kind === "operation.failed")
                 && input.payload.operation === "subagent") {
@@ -495,14 +550,14 @@ export class FileSchedulerStoreAdapter {
                 }
             }
         });
-        if (this.telemetry !== null && input.fence.turnId !== undefined) {
+        if (this.telemetry !== null && input.fence.runId !== undefined) {
             try {
                 const entry = runtimeObservationTelemetryEntry(input);
                 this.telemetry.sink.observe(entry);
-                const run = this.store.getTurn(entry.taskId, input.fence.turnId);
+                const run = this.store.getRun(entry.taskId, input.fence.runId);
                 if (run !== null && run.status !== "active") {
                     void this.telemetry.retention.flush().then(() => {
-                        this.telemetry?.retention.pruneGeneration(entry.taskId, entry.roleName, entry.turnId, entry.generation);
+                        this.telemetry?.retention.pruneRun(entry.taskId, entry.roleName, entry.runId);
                     }).catch(() => undefined);
                 }
             }
@@ -539,8 +594,8 @@ export class FileSchedulerStoreAdapter {
             const events = this.store.listEvents(taskId);
             task = {
                 events,
-                turnFacts: foldTurnProgressFacts(events),
-                turns: this.store.listTurns(taskId),
+                runFacts: foldRunProgressFacts(events),
+                runs: this.store.listRuns(taskId),
                 workItems: this.store.listWorkItems(taskId),
                 reviewRounds: this.store.listReviewRounds(taskId),
                 changeSets: this.store.listChangeSets(taskId),
@@ -560,6 +615,12 @@ export class FileSchedulerStoreAdapter {
     listActiveTaskIds() {
         return [...this.store.listActiveTaskIds()].sort((left, right) => (left.localeCompare(right, undefined, { numeric: true })));
     }
+    listPlanningDraftTaskIds() {
+        return [...this.store.listPlanningDraftTaskIds()].sort((left, right) => (left.localeCompare(right, undefined, { numeric: true })));
+    }
+    listPendingActivationRequestTaskIds() {
+        return [...this.store.listPendingActivationRequestTaskIds()].sort((left, right) => (left.localeCompare(right, undefined, { numeric: true })));
+    }
     getTask(taskId) { return this.store.getTask(taskId); }
     getTaskWorkspace(taskId) { return this.store.getTaskWorkspace(taskId); }
     getTaskBrief(taskId) { return this.store.getTaskBrief(taskId); }
@@ -576,7 +637,7 @@ export class FileSchedulerStoreAdapter {
             const latest = latestTaskWake(reader.listTaskWakes(taskId));
             const fromCursor = latest?.toCursor ?? fallbackWakeCursor({
                 taskCreatedAt: task.createdAt,
-                leaderTurnCreatedAt: operationalTaskRecords(reader.listTurns(taskId), reader.listEvents(taskId), "turn")
+                leaderRunCreatedAt: operationalTaskRecords(reader.listRuns(taskId), reader.listEvents(taskId), "run")
                     .filter((run) => run.roleName === "leader")
                     .at(-1)?.createdAt
             });
@@ -595,8 +656,8 @@ export class FileSchedulerStoreAdapter {
         const role = this.store.getRole(taskId, roleName);
         return role === null ? null : mapRole(this.store, role);
     }
-    getActiveTurn(taskId, roleName) {
-        return this.store.getActiveTurn(taskId, roleName);
+    getActiveRun(taskId, roleName) {
+        return this.store.getActiveRun(taskId, roleName);
     }
     hasOpenInputRequest(taskId) {
         return this.store.listOpenInputRequests([taskId]).length > 0;
@@ -620,7 +681,7 @@ export class FileSchedulerStoreAdapter {
             adapterId: effectiveSession.effective.adapterId
         };
     }
-    markOperatorTurnStarted(now) {
+    markOperatorRunStarted(now) {
         void now;
     }
     resolveExpiredInputRecommendations(now, taskIds) {
@@ -660,8 +721,8 @@ export class FileSchedulerStoreAdapter {
     listEvents(taskId) {
         return this.#taskReadProjection(taskId).events;
     }
-    listTurns(taskId) {
-        return this.#taskReadProjection(taskId).turns;
+    listRuns(taskId) {
+        return this.#taskReadProjection(taskId).runs;
     }
     listWorkItems(taskId) {
         return this.#taskReadProjection(taskId).workItems;
@@ -681,17 +742,17 @@ export class FileSchedulerStoreAdapter {
     listMessages(taskId) {
         return this.#taskReadProjection(taskId).messages;
     }
-    getTurnProgressFacts(taskId, turnId) {
-        return this.#taskReadProjection(taskId).turnFacts.get(turnId);
+    getRunProgressFacts(taskId, runId) {
+        return this.#taskReadProjection(taskId).runFacts.get(runId);
     }
-    getTurnDurableProgress(taskId, roleName, turnId) {
+    getRunDurableProgress(taskId, roleName, runId) {
         const projected = this.#taskReadProjection(taskId);
         // Serve the related-record fold from the same revision's projection: the
         // event history and the WorkItem/Review/ChangeSet/Integration/Input lists
-        // are read once per Task per revision, and the per-Turn checkpoint/activity
+        // are read once per Task per revision, and the per-AgentRun checkpoint/activity
         // facts come from the one-pass fold instead of per-candidate scans.
         const view = {
-            getTurn: (id, turnId) => this.store.getTurn(id, turnId),
+            getRun: (id, runId) => this.store.getRun(id, runId),
             listEvents: () => projected.events,
             getWorkItem: (id, workItemId) => this.store.getWorkItem(id, workItemId),
             listReviewRounds: () => projected.reviewRounds,
@@ -702,22 +763,22 @@ export class FileSchedulerStoreAdapter {
         // A missing fold entry is an authoritative empty fold, not a signal to
         // re-scan the whole history. Pass {} so latestTurnDurableProgressAt treats
         // the fold as present and skips the per-candidate fallback scans.
-        return latestTurnDurableProgressAt(view, taskId, roleName, turnId, projected.turnFacts.get(turnId) ?? {});
+        return latestRunDurableProgressAt(view, taskId, roleName, runId, projected.runFacts.get(runId) ?? {});
     }
-    recordRoleTurnDiagnostic(input) {
+    recordRoleRunDiagnostic(input) {
         return this.store.transaction((store) => {
             const task = store.getTask(input.taskId);
-            const run = store.getActiveTurn(input.taskId, input.roleName);
-            if (task === null || task.status !== "active" || task.executionGate.state !== "enabled"
-                || run === null || run.id !== input.turnId || run.status !== "active") {
+            const run = store.getActiveRun(input.taskId, input.roleName);
+            if (task === null || run === null || !runPurposeAdmitsTaskState(run.purpose, task)
+                || run.id !== input.runId || run.status !== "active") {
                 return "state-changed";
             }
-            const latest = latestTurnEventTime(store.listEvents(input.taskId), TURN_DIAGNOSTIC_FINISHED_EVENT, input.turnId);
+            const latest = latestRunEventTime(store.listEvents(input.taskId), RUN_DIAGNOSTIC_FINISHED_EVENT, input.runId);
             if (latest !== undefined && Date.parse(latest) >= Date.parse(input.startedAt)) {
                 return "already-recorded";
             }
-            store.saveEvent(input.taskId, createTaskEvent(store.nextEventId(input.taskId), input.taskId, TURN_DIAGNOSTIC_FINISHED_EVENT, {
-                turnId: input.turnId,
+            store.saveEvent(input.taskId, createTaskEvent(store.nextEventId(input.taskId), input.taskId, RUN_DIAGNOSTIC_FINISHED_EVENT, {
+                runId: input.runId,
                 roleName: input.roleName,
                 outcome: input.outcome,
                 startedAt: input.startedAt
@@ -725,22 +786,21 @@ export class FileSchedulerStoreAdapter {
             return "recorded";
         });
     }
-    recordRoleTurnStall(input) {
+    recordRoleRunStall(input) {
         return this.store.transaction((store) => {
             const task = store.getTask(input.taskId);
             const role = store.getRole(input.taskId, input.roleName);
-            const run = store.getActiveTurn(input.taskId, input.roleName);
+            const run = store.getActiveRun(input.taskId, input.roleName);
             if (task === null
-                || task.status !== "active"
-                || task.executionGate.state !== "enabled"
                 || role === null
                 || run === null
-                || run.id !== input.turnId
+                || !runPurposeAdmitsTaskState(run.purpose, task)
+                || run.id !== input.runId
                 || run.status !== "active"
                 || run.effective.agentId !== input.agentId
                 || run.effective.adapterId !== input.adapterId)
                 return "state-changed";
-            const progress = latestTurnDurableProgressAt(store, input.taskId, input.roleName, input.turnId);
+            const progress = latestRunDurableProgressAt(store, input.taskId, input.roleName, input.runId);
             if (progress?.progressAt !== input.progressAt)
                 return "state-changed";
             const session = store.getRoleSession(input.taskId, input.roleName);
@@ -749,8 +809,8 @@ export class FileSchedulerStoreAdapter {
             const existing = latestStallEvidenceKey(store.listEvents(task.id), run.id);
             if (existing?.progressAt === input.progressAt)
                 return "already-raised";
-            const event = createTaskEvent(store.nextEventId(task.id), task.id, TURN_STALLED_EVENT, {
-                turnId: run.id,
+            const event = createTaskEvent(store.nextEventId(task.id), task.id, RUN_STALLED_EVENT, {
+                runId: run.id,
                 roleName: role.name,
                 kind: input.kind,
                 classification: input.classification,
@@ -763,15 +823,14 @@ export class FileSchedulerStoreAdapter {
             return "raised";
         });
     }
-    recordRoleTurnProgress(input) {
+    recordRoleRunProgress(input) {
         return this.store.transaction((store) => {
             const task = store.getTask(input.taskId);
-            const run = store.getActiveTurn(input.taskId, input.roleName);
+            const run = store.getActiveRun(input.taskId, input.roleName);
             if (task === null
-                || task.status !== "active"
-                || task.executionGate.state !== "enabled"
                 || run === null
-                || run.id !== input.turnId
+                || !runPurposeAdmitsTaskState(run.purpose, task)
+                || run.id !== input.runId
                 || run.status !== "active")
                 return "state-changed";
             const events = store.listEvents(task.id);
@@ -782,18 +841,18 @@ export class FileSchedulerStoreAdapter {
                 && Date.parse(input.progressAt) <= Date.parse(previousStall.progressAt)) {
                 return "already-recorded";
             }
-            const existing = events.some((event) => (event.type === TURN_PROGRESS_EVENT
-                && event.payload.turnId === run.id
+            const existing = events.some((event) => (event.type === RUN_PROGRESS_EVENT
+                && event.payload.runId === run.id
                 && (event.payload.progressAt === input.progressAt
                     || (typeof event.payload.progressAt === "string"
                         && Number.isFinite(Date.parse(event.payload.progressAt))
                         && Date.parse(event.payload.progressAt) >= Date.parse(input.progressAt)))));
             // Advisory 30-minute diagnostics are intentionally not lifecycle
             // episodes and therefore must never synthesize turn.recovered.
-            const recovered = isRoleTurnStalled(events, run.id);
+            const recovered = isRoleRunStalled(events, run.id);
             if (!existing) {
-                store.saveEvent(task.id, createTaskEvent(store.nextEventId(task.id), task.id, TURN_PROGRESS_EVENT, {
-                    turnId: run.id,
+                store.saveEvent(task.id, createTaskEvent(store.nextEventId(task.id), task.id, RUN_PROGRESS_EVENT, {
+                    runId: run.id,
                     roleName: input.roleName,
                     kind: "durable-fold",
                     progressAt: input.progressAt,
@@ -801,8 +860,8 @@ export class FileSchedulerStoreAdapter {
                 }, input.now));
             }
             if (recovered) {
-                store.saveEvent(task.id, createTaskEvent(store.nextEventId(task.id), task.id, TURN_RECOVERED_EVENT, {
-                    turnId: run.id,
+                store.saveEvent(task.id, createTaskEvent(store.nextEventId(task.id), task.id, RUN_RECOVERED_EVENT, {
+                    runId: run.id,
                     roleName: input.roleName,
                     progressAt: input.progressAt,
                     kind: "durable-progress"
@@ -813,35 +872,44 @@ export class FileSchedulerStoreAdapter {
     }
     beginAgentHostProviderTurn(input) {
         this.store.transaction((store) => {
+            const task = store.getTask(input.taskId);
+            if (task === null || !["active", "draft"].includes(task.status) || task.executionGate.state !== "enabled"
+                || hasRuntimeCleanupObligation(store.getWorkMailbox(runtimeLifecycleTarget({
+                    scope: "task", taskId: input.taskId, roleName: input.roleName
+                })))) {
+                throw new AgentHostProviderTurnFenceError("Session execution admission is stopped or being replaced.");
+            }
             const sessions = store.getTaskRoleSessionSet(input.taskId, input.roleName);
             const session = sessions?.sessions[input.agentId];
             const binding = sessions?.providerBinding;
-            const active = store.getActiveTurn(input.taskId, input.roleName);
-            if (sessions === null || sessions === undefined
-                || binding === null || binding === undefined
-                || (input.turnId !== undefined
-                    && (active?.id !== input.turnId || active.effective.agentId !== input.agentId))
-                || session?.runtimeGenerationId !== input.runtimeGenerationId
-                || session.nativeSessionId !== input.nativeSessionId
-                || currentProviderConversation(binding).conversationId !== input.nativeSessionId
-                || binding.authority.owner !== input.authorityOwner
-                || binding.authority.epoch !== input.authorityEpoch
-                || binding.authority.holderId !== input.holderId) {
+            const active = store.getActiveRun(input.taskId, input.roleName);
+            if (sessions === null || sessions === undefined || binding === null || binding === undefined || (input.runId !== undefined && (active?.id !== input.runId || active.effective.agentId !== input.agentId)) || session === undefined || session.nativeSessionId !== input.nativeSessionId || currentProviderConversation(binding).conversationId !== input.nativeSessionId || binding.authority.owner !== input.authorityOwner || binding.authority.epoch !== input.authorityEpoch || binding.authority.holderId !== input.holderId) {
                 throw new AgentHostProviderTurnFenceError("Agent Host Provider Turn carries a stale durable writer fence. Release and reacquire Provider authority before retrying input.");
             }
-            const currentTurn = binding.turn;
-            const exactReplay = currentTurn !== null
-                && currentTurn.turnId === input.turnId
-                && currentTurn.attemptId === input.attemptId
-                && currentTurn.authorityEpoch === input.authorityEpoch
-                && currentTurn.status === "submitting";
-            if (!exactReplay && binding.turn !== null
+            const currentRun = binding.run;
+            if (session.effective.executionEnvironment !== undefined) {
+                assertExecutionEnvironmentCurrent(store, input.taskId, session.effective.executionEnvironment);
+            }
+            if (input.runId !== undefined
+                && !isDeepStrictEqual(active?.effective.executionEnvironment, session.effective.executionEnvironment)) {
+                throw new AgentHostProviderTurnFenceError("AgentRun and native Session execution environments differ; start a new Session.");
+            }
+            if (input.runId !== undefined
+                && active?.effective.executionAuthority !== session.effective.executionAuthority) {
+                throw new AgentHostProviderTurnFenceError("Execution authority differs from the fixed native Session.");
+            }
+            const exactReplay = currentRun !== null
+                && currentRun.runId === input.runId
+                && currentRun.attemptId === input.attemptId
+                && currentRun.authorityEpoch === input.authorityEpoch
+                && currentRun.status === "submitting";
+            if (!exactReplay && binding.run !== null
                 && ["submitting", "accepted", "delivery-unknown"]
-                    .includes(binding.turn.status)) {
-                throw new AgentHostProviderTurnFenceError("Provider Conversation already has an unsettled Turn.");
+                    .includes(binding.run.status)) {
+                throw new AgentHostProviderSessionBusyError("Provider Conversation already has an unsettled AgentRun.");
             }
             store.saveTaskRoleSessionSet(updateTaskRoleProviderRuntime(sessions, beginProviderTurn(binding, {
-                ...(input.turnId === undefined ? {} : { turnId: input.turnId }),
+                ...(input.runId === undefined ? {} : { runId: input.runId }),
                 attemptId: input.attemptId,
                 authorityEpoch: input.authorityEpoch,
                 submittedAt: input.now.toISOString()
@@ -854,8 +922,8 @@ export class FileSchedulerStoreAdapter {
             const binding = sessions?.providerBinding;
             if (sessions === null || sessions === undefined
                 || binding === null || binding === undefined
-                || binding.turn?.turnId !== input.turnId
-                || binding.turn?.attemptId !== input.attemptId) {
+                || binding.run?.runId !== input.runId
+                || binding.run?.attemptId !== input.attemptId) {
                 throw new Error("Agent Host Provider Turn submission is no longer current.");
             }
             const updated = settleProviderTurnSubmission(binding, {
@@ -865,9 +933,9 @@ export class FileSchedulerStoreAdapter {
                 resolvedAt: input.now.toISOString()
             });
             store.saveTaskRoleSessionSet(updateTaskRoleProviderRuntime(sessions, updated, input.now));
-            if (input.turnId === undefined)
+            if (input.runId === undefined)
                 return;
-            const run = store.getTurn(input.taskId, input.turnId);
+            const run = store.getRun(input.taskId, input.runId);
             const session = sessions.sessions[sessions.activeAgentId];
             const driver = run === null
                 ? null
@@ -881,11 +949,11 @@ export class FileSchedulerStoreAdapter {
                 }),
                 message: input.reason,
                 raw: input.raw,
-                inputDisposition: input.status === "rejected" ? "not-accepted" : "unknown"
+                inputDisposition: input.status === "delivery-unknown" ? "unknown" : "not-accepted"
             });
             const errorEvent = createTaskEvent(store.nextEventId(input.taskId), input.taskId, "runtime.agent-error", {
                 sourceEventId: input.attemptId,
-                turnId: input.turnId,
+                runId: input.runId,
                 roleName: input.roleName,
                 agentId: run?.effective.agentId ?? sessions.activeAgentId,
                 adapterId: run?.effective.adapterId ?? session?.adapterId ?? "unknown",
@@ -895,7 +963,6 @@ export class FileSchedulerStoreAdapter {
                 // string reads back as a real value and cannot be told apart from
                 // one the Provider genuinely reported.
                 ...optionalEventFields({
-                    runtimeGenerationId: session?.runtimeGenerationId,
                     nativeSessionId: session?.nativeSessionId
                 }),
                 source: error.source,
@@ -908,6 +975,8 @@ export class FileSchedulerStoreAdapter {
                 sessionDisposition: error.sessionDisposition
             }, input.now);
             store.saveEvent(input.taskId, errorEvent);
+            if (input.status === "deferred")
+                return;
             const route = input.roleName === "leader"
                 ? { kind: "operator" }
                 : { kind: "role", taskId: input.taskId, roleName: "leader" };
@@ -923,22 +992,15 @@ export class FileSchedulerStoreAdapter {
         const sessions = this.store.getTaskRoleSessionSet(input.taskId, input.roleName);
         const session = sessions?.sessions[input.agentId];
         const binding = sessions?.providerBinding;
-        if (binding === null || binding === undefined
-            || session?.runtimeGenerationId !== input.runtimeGenerationId
-            || session.nativeSessionId !== input.nativeSessionId
-            || currentProviderConversation(binding).conversationId !== input.nativeSessionId)
-            return null;
-        const activation = currentProviderActivation(binding);
-        if (activation === null)
+        if (binding === null || binding === undefined || session === undefined || session.nativeSessionId !== input.nativeSessionId || currentProviderConversation(binding).conversationId !== input.nativeSessionId)
             return null;
         return {
             conversationId: currentProviderConversation(binding).conversationId,
-            activationId: activation.activationId,
             ...binding.authority
         };
     }
-    peekNextTurnId(taskId) {
-        return this.store.peekNextTurnId(taskId);
+    peekNextRunId(taskId) {
+        return this.store.peekNextRunId(taskId);
     }
     getWorkMailbox(target) { return this.store.getWorkMailbox(target); }
     listWorkMailboxes() { return this.store.listWorkMailboxes(); }
@@ -961,7 +1023,7 @@ export class FileSchedulerStoreAdapter {
     }
     recordAgentError(input, now) {
         return this.store.transaction((store) => {
-            const run = store.getTurn(input.taskId, input.turnId);
+            const run = store.getRun(input.taskId, input.runId);
             const sessionSet = store.getTaskRoleSessionSet(input.taskId, input.roleName);
             const sessionAgentId = run?.effective.agentId ?? sessionSet?.activeAgentId;
             const session = sessionAgentId === undefined
@@ -987,7 +1049,7 @@ export class FileSchedulerStoreAdapter {
                     : { sessionDisposition: input.sessionDisposition })
             });
             const duplicate = [...store.listEvents(input.taskId)].reverse().find((event) => (event.type === "runtime.agent-error"
-                && event.payload.turnId === input.turnId
+                && event.payload.runId === input.runId
                 && event.payload.roleName === input.roleName
                 && event.payload.phase === input.phase
                 && event.payload.attemptId === input.attemptId
@@ -996,8 +1058,6 @@ export class FileSchedulerStoreAdapter {
                 && event.payload.sessionDisposition === error.sessionDisposition
                 && event.payload.registrationDisposition === input.registrationDisposition
                 && event.payload.hostState === input.hostState
-                && event.payload.expectedRuntimeGenerationId === input.expectedRuntimeGenerationId
-                && event.payload.observedRuntimeGenerationId === input.observedRuntimeGenerationId
                 && (input.attemptId === undefined
                     ? event.payload.raw === error.raw
                     : event.payload.message === error.message
@@ -1009,8 +1069,8 @@ export class FileSchedulerStoreAdapter {
             if (duplicate !== undefined)
                 return duplicate.id;
             const event = createTaskEvent(store.nextEventId(input.taskId), input.taskId, "runtime.agent-error", {
-                sourceEventId: `${input.turnId}:${input.phase}${input.attemptId === undefined ? "" : `:${input.attemptId}`}`,
-                turnId: input.turnId,
+                sourceEventId: `${input.runId}:${input.phase}${input.attemptId === undefined ? "" : `:${input.attemptId}`}`,
+                runId: input.runId,
                 roleName: input.roleName,
                 agentId: run?.effective.agentId ?? session?.agentId ?? "unknown",
                 adapterId: run?.effective.adapterId ?? session?.adapterId ?? "unknown",
@@ -1028,32 +1088,40 @@ export class FileSchedulerStoreAdapter {
                 // "the Host did not report this" from "the Host reported nothing".
                 // The Session identities follow the same rule: this failure can
                 // happen before any Session record exists, and there is no native
-                // Turn to name at all.
+                // AgentRun to name at all.
                 ...optionalEventFields({
-                    runtimeGenerationId: session?.runtimeGenerationId,
                     nativeSessionId: session?.nativeSessionId,
                     errorName: input.errorName,
                     causeName: input.causeName,
                     hostState: input.hostState,
-                    expectedRuntimeGenerationId: input.expectedRuntimeGenerationId,
-                    observedRuntimeGenerationId: input.observedRuntimeGenerationId,
                     attemptId: input.attemptId,
                     registrationDisposition: input.registrationDisposition
                 })
             }, now);
             store.saveEvent(input.taskId, event);
+            if (input.phase === "turn-submit" && error.inputDisposition === "unknown"
+                && input.attemptId !== undefined && sessionSet?.providerBinding?.run?.attemptId === input.attemptId
+                && sessionSet.providerBinding.run.status === "submitting") {
+                // A pass clock can precede the asynchronous Host registration.
+                const observedAt = new Date(Math.max(now.getTime(), Date.parse(sessionSet.providerBinding.run.updatedAt)));
+                store.saveTaskRoleSessionSet(updateTaskRoleProviderRuntime(sessionSet, settleProviderTurnSubmission(sessionSet.providerBinding, { attemptId: input.attemptId,
+                    status: "delivery-unknown", reason: error.message, resolvedAt: observedAt.toISOString()
+                }), observedAt));
+            }
+            if (input.errorName === "ProviderTurnBusyError" && error.inputDisposition === "not-accepted")
+                return event.id;
             const leaderCannotReceive = input.roleName === "leader"
                 && ["host-start", "session-start", "session-restore", "turn-submit"].includes(input.phase);
             if (!leaderCannotReceive) {
                 enqueueWork(store, { kind: "role", taskId: input.taskId, roleName: "leader" }, wakeReason("agent-error", event.id), now, [{ type: "event", taskId: input.taskId, id: event.id }], {
                     source: driver?.id ?? input.source,
-                    dedupeKey: `agent-error:${input.taskId}:${input.turnId}:${input.phase}:${event.id}`
+                    dedupeKey: `agent-error:${input.taskId}:${input.runId}:${input.phase}:${event.id}`
                 });
             }
             if (leaderCannotReceive) {
                 enqueueWork(store, { kind: "operator" }, "leader-agent-error", now, [{ type: "event", taskId: input.taskId, id: event.id }], {
                     source: driver?.id ?? input.source,
-                    dedupeKey: `leader-agent-error:${input.taskId}:${input.turnId}:${event.id}`
+                    dedupeKey: `leader-agent-error:${input.taskId}:${input.runId}:${event.id}`
                 });
             }
             return event.id;
@@ -1063,7 +1131,7 @@ export class FileSchedulerStoreAdapter {
      * Records that a Leader wake was suppressed by scheduler single-flight
      * (the Role runtime lifecycle lane was busy). The wake stays durable and
      * is retried after the lane settles; this event is the audit trail that
-     * separates scheduler backpressure from real Turn failures.
+     * separates scheduler backpressure from real AgentRun failures.
      */
     recordWakeSuppression(taskId, reason, now) {
         this.store.transaction((store) => {
@@ -1130,8 +1198,8 @@ export class FileSchedulerStoreAdapter {
             return { status: "claimed", processing: claimed.processing };
         });
     }
-    settleRoleTurnDispatch(input) {
-        return this.store.transaction((store) => (settleRoleTurnDispatchMailbox(store, input, input.expected)));
+    settleRoleRunDispatch(input) {
+        return this.store.transaction((store) => (settleRoleRunDispatchMailbox(store, input, input.expected)));
     }
     completeWorkMailbox(target, batchId) {
         return this.store.transaction((store) => {
@@ -1165,16 +1233,15 @@ export class FileSchedulerStoreAdapter {
             if (mailbox === null || disposition === null)
                 return false;
             if (mailbox.processing !== null) {
-                if (!isRuntimeLaunchReservation(mailbox.processing)
-                    && !mailbox.processing.batch.reasons.every(isRuntimeCleanupReason)) {
+                if (disposition !== "replace-session" && !mailbox.processing.batch.reasons.every(isRuntimeCleanupReason)) {
                     return false;
                 }
                 mailbox = completeProcessing(mailbox, mailbox.processing.batchId);
             }
             const pending = mailbox.pending;
             if (pending !== null) {
-                if (pending.reasons.length === 0
-                    || !pending.reasons.every(isRuntimeCleanupReason)) {
+                if (disposition !== "replace-session" && (pending.reasons.length === 0
+                    || !pending.reasons.every(isRuntimeCleanupReason))) {
                     return false;
                 }
                 const batchId = `runtime-cleanup-complete:${pending.fromSequence}-${pending.toSequence}`;
@@ -1185,9 +1252,46 @@ export class FileSchedulerStoreAdapter {
                 }), batchId);
             }
             const owner = runtimeOwnerFromTarget(target);
-            if (disposition === "end-session") {
+            if (disposition !== "detach-host" && owner.scope === "task") {
+                // Physical quiescence was proven by stopOwner. Runs are engineering
+                // attempts: cancel only this Role, never Task intent or other workers.
+                cancelQuiescentRoleRuns(store, owner.taskId, owner.roleName, "Session execution stopped on request; durable Task context and workspace progress were preserved.", now);
+                let set = store.getTaskRoleSessionSet(owner.taskId, owner.roleName);
+                if (set !== null) {
+                    // Late observations cannot resurrect engineering occupancy after
+                    // the exact native/process stop just completed.
+                    if (set.providerBinding !== null) {
+                        let binding = set.providerBinding;
+                        if (binding.run !== null)
+                            binding = cancelQuiescentProviderInput(binding, {
+                                attemptId: binding.run.attemptId, cancelledAt: now.toISOString(),
+                                reason: "Session replacement after verified resource stop."
+                            });
+                        set = updateTaskRoleProviderRuntime(set, clearProviderGoal(binding), now);
+                    }
+                    store.saveTaskRoleSessionSet(set);
+                }
                 endRuntimeOwnerSession(store, owner, now);
             }
+            if (disposition === "replace-session" && owner.scope === "task") {
+                const set = store.getTaskRoleSessionSet(owner.taskId, owner.roleName);
+                if (set !== null)
+                    store.saveTaskRoleSessionSet(selectNewTaskRoleSession(set, set.activeAgentId, now));
+                const event = createTaskEvent(store.nextEventId(owner.taskId), owner.taskId, "runtime.session-replaced", { roleName: owner.roleName }, now);
+                store.saveEvent(owner.taskId, event);
+                // Accepted notification batches are already consumed; unresolved old
+                // claims belong to the discarded runtime, not to its successor.
+                const leaderTarget = { kind: "role", taskId: owner.taskId, roleName: "leader" };
+                const leaderMailbox = store.getWorkMailbox(leaderTarget);
+                if (owner.roleName === "leader" && leaderMailbox?.processing?.owner.startsWith("leader-notification:")) {
+                    store.saveWorkMailbox(releaseProcessing(leaderMailbox, leaderMailbox.processing.batchId));
+                }
+                enqueueWork(store, leaderTarget, "session-replaced", now, [{ type: "event", taskId: owner.taskId, id: event.id }]);
+            }
+            else if (disposition === "end-session") {
+                if (owner.scope === "global")
+                    endRuntimeOwnerSession(store, owner, now);
+            }
             else {
                 detachRuntimeOwnerHost(store, owner, now);
             }
@@ -1195,22 +1299,11 @@ export class FileSchedulerStoreAdapter {
             return true;
         });
     }
-    completeStoppedRuntimeReservation(target, batchId, now) {
-        return this.store.transaction((store) => {
-            const mailbox = store.getWorkMailbox(target);
-            if (!isRuntimeLaunchReservation(mailbox?.processing, batchId)) {
-                return false;
-            }
-            endRuntimeOwnerSession(store, runtimeOwnerFromTarget(target), now);
-            saveRuntimeLifecycleMailbox(store, completeProcessing(mailbox, batchId));
-            return true;
-        });
-    }
     listDormantRuntimeOwners() {
         return this.listRuntimeSessionCandidates().flatMap((candidate) => {
             if (hasRuntimeLifecycleWork(this.store.getWorkMailbox(runtimeLifecycleTarget(candidate.owner)))
                 || (candidate.owner.scope === "task"
-                    && this.store.getActiveTurn(candidate.owner.taskId, candidate.owner.roleName) !== null)) {
+                    && this.store.getActiveRun(candidate.owner.taskId, candidate.owner.roleName) !== null)) {
                 return [];
             }
             return [{
@@ -1218,7 +1311,6 @@ export class FileSchedulerStoreAdapter {
                     agentId: candidate.agentId,
                     adapterId: candidate.adapterId,
                     nativeSessionId: candidate.nativeSessionId,
-                    ...(candidate.runtimeGenerationId === undefined ? {} : { runtimeGenerationId: candidate.runtimeGenerationId }),
                     sessionUpdatedAt: candidate.sessionUpdatedAt
                 }];
         });
@@ -1226,11 +1318,11 @@ export class FileSchedulerStoreAdapter {
     listRuntimeSessionCandidates(query = {}) {
         return this.store.listRuntimeSessionCandidates(query);
     }
-    enqueueRuntimeCleanup(owner, now = new Date(), expectedDormantCandidate) {
+    enqueueRuntimeCleanup(owner, now = new Date(), expectedDormantCandidate, allowActiveRun = false) {
         return this.store.transaction((store) => {
             if (expectedDormantCandidate !== undefined
                 && (!sameRuntimeOwner(owner, expectedDormantCandidate.owner)
-                    || !dormantRuntimeCandidateIsCurrent(store, expectedDormantCandidate))) {
+                    || !dormantRuntimeCandidateIsCurrent(store, expectedDormantCandidate, allowActiveRun))) {
                 return null;
             }
             if (owner.scope === "task" && store.getTask(owner.taskId) === null) {
@@ -1263,122 +1355,169 @@ export class FileSchedulerStoreAdapter {
     }
     clearPendingWakeup(taskId) { this.store.clearPendingWakeup(taskId); }
     getLeaderFailure(taskId) { return this.store.getLeaderFailure(taskId); }
-    saveLeaderDispatch(input) {
-        return this.store.transaction((store) => {
-            const task = store.getTask(input.task.id);
-            if (task === null || task.status !== "active" || task.executionGate.state !== "enabled") {
-                return "unavailable";
-            }
-            const role = requireRole(store, input.task.id, input.role.name);
-            const binding = activeRoleAgentBinding(role);
-            if (role.activeAgentId !== input.role.activeAgentId
-                || binding.adapterId !== input.role.adapterId
-                || binding.config.model !== input.role.model
-                || binding.config.effort !== input.role.effort
-                || role.workspace !== input.role.workspace) {
-                return "state-changed";
-            }
-            if (!isDeepStrictEqual(input.turn.effective, input.role.effective)) {
-                return "state-changed";
-            }
-            if (store.getTurn(input.task.id, input.turn.id) !== null)
-                return "state-changed";
-            if (store.getActiveTurn(input.task.id, input.role.name) !== null)
-                return "busy";
-            const pending = store.getPendingWakeup(input.task.id);
-            if (pending === null || !pendingWakeupsMatch(pending, input.wakeup)) {
-                return "state-changed";
+    prepareMessageContinuations(taskId, now) {
+        const roles = new Set(this.store.listMessages(taskId).flatMap((message) => message.recipient?.ownerRunId !== undefined && message.continuation?.runId === undefined ? [message.recipient.roleName] : []));
+        for (const roleName of roles) {
+            try {
+                this.store.transaction((store) => prepareMessageContinuations(store, taskId, now, roleName));
+            }
+            catch (error) {
+                const reason = `preparation-failed: ${error instanceof Error ? error.message : String(error)}`.slice(0, 1000);
+                this.store.transaction((store) => {
+                    for (const message of store.listMessages(taskId)) {
+                        if (message.recipient?.roleName === roleName && message.recipient.ownerRunId !== undefined && message.continuation?.runId === undefined
+                            && message.continuation?.notDeliveredReason !== reason) {
+                            store.updateMessage(taskId, { ...message, continuation: { notDeliveredReason: reason } });
+                        }
+                    }
+                });
             }
-            const target = { kind: "role", taskId: input.task.id, roleName: input.role.name };
+        }
+    }
+    /** The first Draft conversation is an explicit planning execution. Later
+     * messages use the same notification path as direct Leader collaboration. */
+    prepareDraftPlanning(taskId, now) {
+        return this.store.transaction((store) => {
+            const task = store.getTask(taskId);
+            if (task?.status !== "draft" || task.executionGate.state !== "enabled")
+                return false;
+            if (store.getActiveRun(taskId, "leader") !== null)
+                return true;
+            if (store.listRuns(taskId).some(run => run.roleName === "leader" && run.purpose === "planning"))
+                return false;
+            const sessions = store.getTaskRoleSessionSet(taskId, "leader");
+            if (activeLiveRoleAgentSession(sessions) !== null)
+                return false;
+            const role = requireRole(store, taskId, "leader");
+            const target = { kind: "role", taskId, roleName: "leader" };
             const mailbox = store.getWorkMailbox(target);
-            if (mailbox === null || !mailboxHasPending(mailbox))
-                return "state-changed";
-            if (store.peekNextTurnId(input.task.id) !== input.turn.id) {
-                return "state-changed";
-            }
-            const allocatedTurnId = store.nextTurnId(input.task.id);
-            if (allocatedTurnId !== input.turn.id) {
-                throw new Error(`Leader Turn allocation changed unexpectedly: ${input.task.id}.`);
-            }
-            // The durable Turn row and its active pointer are separate projections;
-            // keep both writes in the same storage transaction.
-            store.saveTurn(input.turn);
-            store.saveActiveTurn(input.turn);
-            store.saveWorkMailbox(consumePendingBatch(mailbox));
-            store.clearPendingWakeup(input.task.id);
-            store.saveEvent(input.task.id, createTaskEvent(store.nextEventId(input.task.id), input.task.id, "turn.dispatched", turnLaunchEventPayload(input.turn), input.now));
-            if (input.wakeId !== undefined && input.wakeFromCursor !== undefined) {
-                if (store.peekNextTaskWakeId(input.task.id) !== input.wakeId) {
-                    return "state-changed";
-                }
-                const allocatedWakeId = store.nextTaskWakeId(input.task.id);
-                if (allocatedWakeId !== input.wakeId) {
-                    throw new Error(`Leader TaskWake allocation changed unexpectedly: ${input.task.id}.`);
-                }
-                store.saveTaskWake(input.task.id, createTaskWake({
-                    id: allocatedWakeId,
-                    taskId: input.task.id,
-                    reasons: input.wakeup.reasons,
-                    fromCursor: input.wakeFromCursor,
-                    toCursor: input.now.toISOString(),
-                    turnId: input.turn.id,
-                    now: input.now
-                }));
-            }
-            if (input.turn.mode !== "new"
-                && input.session !== null
-                && input.session.nativeSessionId !== undefined) {
-                saveTaskSession(store, role, {
-                    ...input.session,
-                    nativeSessionId: input.session.nativeSessionId
-                }, "active", input.now);
-            }
-            store.clearLeaderFailure(input.task.id);
-            return "claimed";
+            if (mailbox?.pending == null || mailbox.processing !== null)
+                return false;
+            const run = createRun(store.nextRunId(taskId), taskId, "leader", "new", createRunInput({ source: { type: "yui", channel: "task-dispatch" },
+                directive: `Plan Task ${taskId} with the user. Persist requirements and decisions. Request activation explicitly; planning grants no delivery authority.`,
+                deltaRefIds: [] }), now, {
+                purpose: "planning", effective: resolveEffectiveLaunch({ role, purpose: "planning" })
+            });
+            const snapshot = freezeRunContextSnapshot(store, run, now);
+            const frozen = withRunContextSnapshot(run, contextSnapshotRef(snapshot));
+            store.saveRun(frozen);
+            store.saveActiveRun(frozen);
+            // Freeze the initial notification prefix against this planning Run.
+            // Later messages remain pending; acceptance or an exact terminal settles
+            // only this batch, so a failed initial launch cannot replay it forever.
+            const batchId = formatRunReceiptId(taskId, run.id);
+            store.saveWorkMailbox(bindExecution(claimPending(mailbox, {
+                batchId, owner: `planning:${run.id}`, startedAt: now.toISOString()
+            }), batchId, { type: "run", taskId, id: run.id }));
+            return true;
         });
     }
-    saveLeaderSteer(input) {
+    claimLeaderNotification(taskId, now) {
         return this.store.transaction((store) => {
-            const task = store.getTask(input.taskId);
-            const active = store.getActiveTurn(input.taskId, "leader");
-            if (task === null || task.status !== "active" || task.executionGate.state !== "enabled") {
-                return "unavailable";
+            const task = store.getTask(taskId);
+            if (task == null || !["active", "draft"].includes(task.status) || task.executionGate.state !== "enabled")
+                return null;
+            const target = { kind: "role", taskId, roleName: "leader" };
+            let mailbox = store.getWorkMailbox(target);
+            if (mailbox === null)
+                return null;
+            const provider = store.getTaskRoleSessionSet(taskId, "leader")?.providerBinding?.run;
+            const processing = mailbox.processing;
+            if (processing !== null) {
+                if (!processing.owner.startsWith("leader-notification:"))
+                    return null;
+                const wakeId = processing.owner.slice("leader-notification:".length);
+                const attemptId = processing.batchId;
+                const previous = store.listEvents(taskId).filter((event) => event.type === "notification.delivery" && event.payload.attemptId === attemptId).at(-1);
+                const native = provider?.attemptId === attemptId ? provider : undefined;
+                const accepted = store.listEvents(taskId).some((event) => {
+                    const observation = runtimeObservationFromTaskEvent(event);
+                    return observation?.fence.roleName === "leader"
+                        && observation.fence.receiptId === attemptId
+                        && ((observation.kind === "turn.accepted" && observation.authority !== "transport")
+                            || isRunTerminalObservation(observation));
+                });
+                if (accepted || native?.status === "accepted" || previous?.payload.outcome === "accepted") {
+                    this.settleLeaderNotification(taskId, attemptId, "accepted", now);
+                    return null;
+                }
+                if (native?.status === "rejected" || previous?.payload.outcome === "rejected") {
+                    this.settleLeaderNotification(taskId, attemptId, "rejected", now);
+                    return null;
+                }
+                if (native?.status === "submitting")
+                    return { wakeId, attemptId, disposition: "pending" };
+                if (native?.status !== "deferred" && previous?.payload.outcome !== "deferred") {
+                    this.settleLeaderNotification(taskId, attemptId, "unknown", now, "Acceptance could not be recovered. Preserve the fixed wake; no automatic replay.");
+                    return { wakeId, attemptId, disposition: "unknown" };
+                }
+                if (provider !== null && provider !== undefined && provider.attemptId !== attemptId
+                    && ["submitting", "accepted", "delivery-unknown"].includes(provider.status)) {
+                    return { wakeId, attemptId, disposition: "pending" };
+                }
+                const nextAttempt = `notification:${taskId}/${wakeId}/${randomUUID()}`;
+                store.saveWorkMailbox({ ...mailbox, processing: { ...processing, batchId: nextAttempt } });
+                return { wakeId, attemptId: nextAttempt, disposition: "submit" };
             }
-            if (active === null || active.id !== input.turnId || active.status !== "active")
-                return "busy";
-            const target = { kind: "role", taskId: input.taskId, roleName: "leader" };
+            if (mailbox.pending === null || (provider !== null && provider !== undefined
+                && ["submitting", "accepted", "delivery-unknown"].includes(provider.status)))
+                return null;
+            const latest = latestTaskWake(store.listTaskWakes(taskId));
+            const wakeId = store.nextTaskWakeId(taskId);
+            const wake = createTaskWake({
+                id: wakeId, taskId, reasons: mailbox.pending.reasons,
+                refs: mailbox.pending.refs,
+                fromCursor: latest?.toCursor ?? task.createdAt,
+                toCursor: new Date(Math.max(now.getTime(), Date.parse(mailbox.pending.lastQueuedAt))).toISOString(), now
+            });
+            const attemptId = `notification:${taskId}/${wakeId}/${randomUUID()}`;
+            mailbox = claimPending(mailbox, { batchId: attemptId,
+                owner: `leader-notification:${wakeId}`, startedAt: now.toISOString() });
+            store.saveTaskWake(taskId, wake);
+            store.saveWorkMailbox(mailbox);
+            return { wakeId, attemptId, disposition: "submit" };
+        });
+    }
+    settleLeaderNotification(taskId, attemptId, outcome, now, detail) {
+        this.store.transaction((store) => {
+            const target = { kind: "role", taskId, roleName: "leader" };
             const mailbox = store.getWorkMailbox(target);
             const processing = mailbox?.processing;
-            if (mailbox === null
-                || processing?.batchId !== input.batchId
-                || processing.owner !== `leader-steer:${input.turnId}`)
-                return "state-changed";
-            const updated = appendTurnInput(active, input.input, input.now);
-            store.saveTurn(updated);
-            store.saveActiveTurn(updated);
-            store.saveWorkMailbox(completeProcessing(mailbox, input.batchId));
-            store.saveEvent(input.taskId, createTaskEvent(store.nextEventId(input.taskId), input.taskId, "turn.input-submitted", {
-                turnId: active.id,
-                sequence: String(updated.inputs.length),
-                source: `${input.input.source.type}/${input.input.source.channel}`,
-                reasons: processing.batch.reasons.join(",")
-            }, input.now));
-            return "claimed";
+            if (mailbox == null || processing == null || processing.batchId !== attemptId
+                || !processing.owner.startsWith("leader-notification:"))
+                return;
+            if (!store.listEvents(taskId).some((event) => event.type === "notification.delivery"
+                && event.payload.attemptId === attemptId && event.payload.outcome === outcome)) {
+                store.saveEvent(taskId, createTaskEvent(store.nextEventId(taskId), taskId, "notification.delivery", { attemptId, outcome, ...(detail === undefined ? {} : { detail }) }, now));
+            }
+            if (outcome !== "accepted" && outcome !== "rejected")
+                return;
+            store.saveWorkMailbox(completeProcessing(mailbox, attemptId));
+            if (outcome === "accepted") {
+                const wakeId = processing.owner.slice("leader-notification:".length);
+                const wake = store.listTaskWakes(taskId).find((entry) => entry.id === wakeId);
+                if (wake !== undefined)
+                    store.saveTaskWake(taskId, markTaskWakeConsumed(wake, now));
+            }
         });
     }
-    saveRoleTurnPrepared(input) {
+    saveRoleRunPrepared(input) {
         this.store.transaction((store) => {
             const task = store.getTask(input.task.id);
-            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);
-            const active = store.getActiveTurn(input.task.id, input.role.name);
-            if (active === null || active.id !== input.turn.id) {
-                throw new Error(`Active Turn changed before preparation was persisted: ${input.turn.id}.`);
+            const active = store.getActiveRun(input.task.id, input.role.name);
+            if (active === null || active.id !== input.run.id) {
+                throw new Error(`Active AgentRun changed before preparation was persisted: ${input.run.id}.`);
+            }
+            // The Turn's own purpose decides which Task lifecycle admits it, so a
+            // planning Turn on a Draft persists its Session while every other purpose
+            // still requires an active Task. Read the durable active Turn, never the
+            // caller's copy, so admission cannot be widened by a stale input.
+            if (task === null || !runPurposeAdmitsTaskState(active.purpose, task)) {
+                throw new Error(`Task is not active: ${input.task.id}.`);
             }
             if (store.getTaskRoleSessionSet(input.task.id, input.role.name) === null) {
-                store.saveTaskRoleSessionSet(createRoleSessionSet({ scope: "task", taskId: input.task.id, roleName: input.role.name }, input.turn.effective.agentId, input.now));
+                store.saveTaskRoleSessionSet(createRoleSessionSet({ scope: "task", taskId: input.task.id, roleName: input.role.name }, input.run.effective.agentId, input.now));
             }
             if (input.session !== null && input.session.nativeSessionId !== undefined) {
                 const existing = store.getRoleSession(input.task.id, input.role.name);
@@ -1390,63 +1529,61 @@ export class FileSchedulerStoreAdapter {
                     && existing !== null
                     && existing.nativeSessionId !== input.session.nativeSessionId
                     && existing.status === "active";
-                if (!defersConversationReplacement
-                    && (existing?.nativeSessionId !== input.session.nativeSessionId
-                        || (input.runtimeGenerationId !== undefined && existing.runtimeGenerationId !== input.runtimeGenerationId)
-                        || existing.status !== "active")) {
+                if (!defersConversationReplacement && (existing?.nativeSessionId !== input.session.nativeSessionId || existing.status !== "active")) {
                     saveTaskSession(store, role, {
                         ...input.session,
                         nativeSessionId: input.session.nativeSessionId
-                    }, "active", input.now, input.runtimeGenerationId);
+                    }, "active", input.now);
+                }
+                if (!defersConversationReplacement && !store.listEvents(input.task.id).some((event) => event.type === "run.session-prepared" && event.payload.runId === input.run.id
+                    && event.payload.nativeSessionId === input.session.nativeSessionId)) {
+                    store.saveEvent(input.task.id, createTaskEvent(store.nextEventId(input.task.id), input.task.id, "run.session-prepared", { runId: input.run.id, roleName: role.name,
+                        nativeSessionId: input.session.nativeSessionId }, input.now));
                 }
             }
         });
     }
-    saveRoleTurnDeliveryFailure(input) {
+    saveRoleRunDeliveryFailure(input) {
         return this.store.transaction((store) => {
             const task = store.getTask(input.taskId);
             const role = store.getRole(input.taskId, input.roleName);
-            const active = store.getActiveTurn(input.taskId, input.roleName);
+            const active = store.getActiveRun(input.taskId, input.roleName);
             const sessions = store.getTaskRoleSessionSet(input.taskId, input.roleName);
             const session = sessions?.sessions[input.agentId];
             if (task === null
-                || task.status !== "active"
-                || task.executionGate.state !== "enabled"
-                || role === null
                 || active === null
-                || active.id !== input.turnId
+                || !runPurposeAdmitsTaskState(active.purpose, task)
+                || role === null
+                || active.id !== input.runId
                 || active.status !== "active"
                 || active.effective.agentId !== input.agentId
                 || active.effective.adapterId !== input.adapterId) {
                 return "state-changed";
             }
             const summary = input.summary
-                ?? `Role delivery failed conclusively before exact Turn input acceptance: ${input.turnId}.`;
-            const result = terminalizeExactTaskTurn(store, {
+                ?? `Role delivery failed conclusively before exact AgentRun input acceptance: ${input.runId}.`;
+            const result = terminalizeExactTaskRun(store, {
                 taskId: input.taskId,
                 roleName: input.roleName,
                 agentId: input.agentId,
-                turnId: input.turnId,
+                runId: input.runId,
                 ...(session?.nativeSessionId === undefined
                     ? {}
                     : { nativeSessionId: session.nativeSessionId }),
-                ...(input.runtimeGenerationId === undefined ? {} : { runtimeGenerationId: input.runtimeGenerationId }),
                 outcome: { status: "failed", diagnostic: summary, failureReason: input.failureReason }
             }, input.now);
-            if (result.disposition !== "applied" || result.turn === null) {
+            if (result.disposition !== "applied" || result.run === null) {
                 return "state-changed";
             }
-            const terminal = result.turn;
+            const terminal = result.run;
             const deliveryFailureEvent = createTaskEvent(store.nextEventId(input.taskId), input.taskId, "runtime.role-delivery-failed", {
-                turnId: terminal.id,
+                runId: terminal.id,
                 roleName: input.roleName,
                 outcome: terminal.status
             }, input.now);
             store.saveEvent(input.taskId, deliveryFailureEvent);
-            if (input.roleName !== "leader") {
-                routeRoleEvent(store, deliveryFailureEvent, input.roleName, terminal.purpose === "review" ? "review-failed" : "role-turn-failed", input.now);
-            }
-            else {
+            routeRoleEvent(store, deliveryFailureEvent, input.roleName, terminal.purpose === "review" ? "review-failed" : "role-turn-failed", input.now);
+            if (input.roleName === "leader") {
                 store.saveLeaderFailure(recordLeaderFailure(input.taskId, session?.nativeSessionId ?? "(unregistered)", summary, input.now, store.getLeaderFailure(input.taskId)));
             }
             return "failed";
@@ -1456,73 +1593,9 @@ export class FileSchedulerStoreAdapter {
     recordRuntimeNativeSession(input, now = new Date()) {
         return this.store.transaction((store) => (recordTaskRuntimeNativeSession(store, input, now)));
     }
-    reserveRuntimeLaunch(input, assertCurrent, now = new Date()) {
+    recordLaunchedRuntimeNativeSession(input, assertCurrent, now = new Date()) {
         return this.store.transaction((store) => {
             assertCurrent();
-            const target = runtimeLifecycleTarget(input.owner);
-            const existing = store.getWorkMailbox(target);
-            if (isRuntimeLaunchReservation(existing?.processing)) {
-                if (hasRuntimeCleanupObligation(existing)) {
-                    throw new Error("Runtime cleanup is still pending.");
-                }
-                return {
-                    status: "existing",
-                    runtimeGenerationId: existing.processing.batchId
-                };
-            }
-            if (hasRuntimeLifecycleWork(existing)) {
-                throw new RuntimeLifecycleBusyError("Runtime lifecycle work is already pending.");
-            }
-            enqueueWork(store, target, RUNTIME_LAUNCH_RESERVED_REASON, now, input.owner.scope === "task"
-                ? [{ type: "task", id: input.owner.taskId }]
-                : []);
-            const queued = store.getWorkMailbox(target);
-            if (queued === null
-                || queued.pending === null
-                || queued.processing !== null) {
-                throw new Error("Runtime launch reservation could not be queued.");
-            }
-            const claimed = claimPending(queued, {
-                batchId: input.runtimeGenerationId,
-                owner: RUNTIME_LIFECYCLE_OWNER,
-                startedAt: now.toISOString()
-            });
-            store.saveWorkMailbox(claimed);
-            return {
-                status: "reserved",
-                runtimeGenerationId: input.runtimeGenerationId
-            };
-        });
-    }
-    confirmRuntimeLaunchReservation(input, assertCurrent) {
-        return this.store.transaction((store) => {
-            assertCurrent();
-            const mailbox = store.getWorkMailbox(runtimeLifecycleTarget(input.owner));
-            if (isRuntimeLaunchReservation(mailbox?.processing, input.runtimeGenerationId)) {
-                return "reserved";
-            }
-            if (hasRuntimeCleanupObligation(mailbox)) {
-                throw new Error("Runtime cleanup is still pending.");
-            }
-            // A synchronous Driver Hook may bind a fresh native Session
-            // and complete the reservation while the host start call is still
-            // unwinding. Preserve that exact hook-won generation instead of treating
-            // the already-settled reservation as a launch failure.
-            const sessions = runtimeOwnerSessionSet(store, input.owner);
-            const active = sessions?.sessions[sessions.activeAgentId];
-            if (active?.status === "active"
-                && active.runtimeGenerationId === input.runtimeGenerationId)
-                return "provider-bound";
-            throw new Error("Runtime launch reservation no longer matches the launch.");
-        });
-    }
-    recordReservedRuntimeNativeSession(input, assertCurrent, now = new Date()) {
-        return this.store.transaction((store) => {
-            assertCurrent();
-            const mailbox = requireRuntimeLaunchReservation(store, input.owner, input.runtimeGenerationId);
-            if (hasRuntimeCleanupObligation(mailbox)) {
-                throw new Error("Runtime cleanup is still pending.");
-            }
             const session = input.owner.scope === "task"
                 ? recordTaskRuntimeNativeSession(store, {
                     taskId: input.owner.taskId,
@@ -1530,7 +1603,6 @@ export class FileSchedulerStoreAdapter {
                     agentId: input.agentId,
                     adapterId: input.adapterId,
                     nativeSessionId: input.nativeSessionId,
-                    runtimeGenerationId: input.runtimeGenerationId,
                     effective: input.effective
                 }, now)
                 : recordGlobalRuntimeNativeSession(store, {
@@ -1538,61 +1610,39 @@ export class FileSchedulerStoreAdapter {
                     agentId: input.agentId,
                     adapterId: input.adapterId,
                     nativeSessionId: input.nativeSessionId,
-                    runtimeGenerationId: input.runtimeGenerationId,
                     effective: input.effective
                 }, now);
-            saveRuntimeLifecycleMailbox(store, completeProcessing(mailbox, input.runtimeGenerationId));
-            return session;
-        });
-    }
-    completeRuntimeLaunchReservation(owner, runtimeGenerationId, beforeComplete) {
-        return this.store.transaction((store) => {
-            const target = runtimeLifecycleTarget(owner);
-            const mailbox = store.getWorkMailbox(target);
-            if (!isRuntimeLaunchReservation(mailbox?.processing, runtimeGenerationId))
-                return false;
-            beforeComplete?.();
-            saveRuntimeLifecycleMailbox(store, completeProcessing(mailbox, runtimeGenerationId));
-            return true;
-        });
-    }
-    /**
-     * Atomically settles a launch whose host is confirmed absent.
-     *
-     * The exact reservation is authoritative. If its matching Hook won the
-     * transaction race and already cleared that reservation, the session
-     * fallback is permitted only while the same Agent/native identity remains
-     * current and no later lifecycle work or Task Turn exists.
-     */
-    settleStoppedRuntimeLaunch(input, now = new Date()) {
-        return this.store.transaction((store) => {
-            const target = runtimeLifecycleTarget(input.owner);
-            const mailbox = store.getWorkMailbox(target);
-            if (isRuntimeLaunchReservation(mailbox?.processing, input.runtimeGenerationId)) {
-                const sessions = runtimeOwnerSessionSet(store, input.owner);
-                const active = sessions?.sessions[sessions.activeAgentId];
-                if (runtimeSessionMatchesSettledLaunch(active, input)) {
-                    endRuntimeOwnerSession(store, input.owner, now);
+            if (input.owner.scope === "task") {
+                let sessions = store.getTaskRoleSessionSet(input.owner.taskId, input.owner.roleName);
+                if (sessions !== null && sessions.providerBinding === null) {
+                    sessions = bindTaskRoleProviderRuntime(sessions, createProviderRuntimeBinding({
+                        providerNamespace: this.drivers.requireByAdapterId(input.adapterId).id,
+                        accountScope: input.agentId, conversationId: input.nativeSessionId,
+                        startedAt: now.toISOString()
+                    }), now);
+                    store.saveTaskRoleSessionSet(sessions);
+                }
+                else if (sessions?.providerBinding != null
+                    && currentProviderConversation(sessions.providerBinding).conversationId !== input.nativeSessionId) {
+                    sessions = updateTaskRoleProviderRuntime(sessions, supersedeProviderConversation(sessions.providerBinding, {
+                        conversationId: input.nativeSessionId, switchedAt: now.toISOString(), basis: "terminal-session"
+                    }), now);
+                    store.saveTaskRoleSessionSet(sessions);
+                }
+                const binding = sessions?.providerBinding;
+                if (sessions !== null && binding !== null && binding !== undefined
+                    && binding.authority.owner === "none"
+                    && currentProviderConversation(binding).conversationId === input.nativeSessionId) {
+                    store.saveTaskRoleSessionSet(updateTaskRoleProviderRuntime(sessions, transferProviderAuthority(binding, {
+                        expectedEpoch: binding.authority.epoch,
+                        expectedOwner: "none",
+                        owner: "controller",
+                        holderId: "controller",
+                        changedAt: now.toISOString()
+                    }), now));
                 }
-                saveRuntimeLifecycleMailbox(store, completeProcessing(mailbox, input.runtimeGenerationId));
-                return true;
-            }
-            if (hasRuntimeLifecycleWork(mailbox))
-                return false;
-            if (input.owner.scope === "task"
-                && store.getActiveTurn(input.owner.taskId, input.owner.roleName) !== null) {
-                return false;
-            }
-            const sessions = runtimeOwnerSessionSet(store, input.owner);
-            if (sessions === null)
-                return true;
-            const active = sessions.sessions[sessions.activeAgentId];
-            if (!runtimeSessionMatchesSettledLaunch(active, input))
-                return false;
-            if (active.status !== "ended") {
-                endRuntimeOwnerSession(store, input.owner, now);
             }
-            return true;
+            return session;
         });
     }
     /**
@@ -1600,66 +1650,66 @@ export class FileSchedulerStoreAdapter {
      * retained as an intermediate child wait or recorded as a ready boundary
      * for later mailbox input. It never performs tmux, workspace, or Controller I/O.
      */
-    classifyRuntimeTurnTerminal(input) {
+    classifyRuntimeRunTerminal(input) {
         return resolveTerminalExecution(this.store, input) === null ? "obsolete" : "apply";
     }
-    observeRuntimeTurnTerminal(input, now = new Date()) {
+    observeRuntimeRunTerminal(input, now = new Date()) {
         // Resource inspection is bounded but external to SQLite. Revalidate the
-        // immutable Turn workspace after acquiring the write transaction.
-        const preparedTurn = resolveTerminalExecution(this.store, input)?.turn;
-        const workspace = preparedTurn?.status === "active"
-            && preparedTurn.executionGroupId !== undefined
-            && preparedTurn.executionLaneId !== undefined
-            && preparedTurn.workspace !== undefined
+        // immutable AgentRun workspace after acquiring the write transaction.
+        const preparedRun = resolveTerminalExecution(this.store, input)?.run;
+        const workspace = preparedRun?.status === "active"
+            && preparedRun.executionGroupId !== undefined
+            && preparedRun.executionLaneId !== undefined
+            && preparedRun.workspace !== undefined
             && input.outcome.status === "completed"
-            ? this.snapshotExecutionLaneWorkspace(this.store, preparedTurn.workspace)
+            ? this.snapshotExecutionLaneWorkspace(this.store, preparedRun.workspace)
             : undefined;
         return this.store.transaction((store) => {
             const task = store.getTask(input.taskId);
             if (task === null)
                 throw new Error(`Task not found: ${input.taskId}.`);
             if (task.status === "archived") {
-                throw new Error(`Cannot complete a runtime turn for unavailable Task: ${input.taskId}.`);
+                throw new Error(`Cannot complete a runtime run for unavailable Task: ${input.taskId}.`);
             }
             const resolved = resolveTerminalExecution(store, input);
             if (resolved === null)
                 throw new Error("Runtime terminal has no exact execution binding.");
-            const { turn: observedTurn, current: recordedProviderTurn, attemptId } = resolved;
-            if (!isDeepStrictEqual(preparedTurn?.workspace, observedTurn?.workspace)) {
+            const { run: observedRun, current: recordedProviderTurn, attemptId } = resolved;
+            if (!isDeepStrictEqual(preparedRun?.workspace, observedRun?.workspace)) {
                 throw new Error("Runtime terminal workspace changed during result preparation.");
             }
-            if (workspace !== undefined && observedTurn?.workspace !== undefined
-                && !isDeepStrictEqual(store.getManagedWorkspace(observedTurn.workspace.owner), observedTurn.workspace)) {
+            if (workspace !== undefined && observedRun?.workspace !== undefined
+                && !isDeepStrictEqual(store.getManagedWorkspace(observedRun.workspace.owner), observedRun.workspace)) {
                 throw new Error("Runtime terminal workspace ownership changed during result preparation.");
             }
             let sessions = store.getTaskRoleSessionSet(input.taskId, input.roleName)
                 ?? createRoleSessionSet({ scope: "task", taskId: input.taskId, roleName: input.roleName }, input.agentId, now);
-            const canonicalTurnId = input.nativeTurnId ?? resolved.nativeTurnId;
+            const canonicalRunId = input.nativeTurnId ?? resolved.nativeTurnId;
             const existing = sessions.sessions[input.agentId];
             const owner = {
                 scope: "task",
                 taskId: input.taskId,
                 roleName: input.roleName
             };
-            assertConsistentTerminal(store, input, observedTurn);
+            assertConsistentTerminal(store, input, observedRun);
             // A historical operation failure stays failed. The immutable terminal
             // observation retains the late report for explicit Leader adoption.
             // Never touch a successor Session, active pointer, mailbox or Review.
-            if (!recordedProviderTurn || (observedTurn !== null && observedTurn.status !== "active")) {
+            if (!recordedProviderTurn || (observedRun !== null && observedRun.status !== "active")) {
                 // A failed operation and a subsequently confirmed Provider outcome are
                 // distinct facts. Settle only the still-owned original attempt, never
                 // rewriting the historical Task result or a successor's binding.
-                if (recordedProviderTurn && sessions.providerBinding?.turn !== null
-                    && sessions.providerBinding?.turn !== undefined
-                    && ["submitting", "accepted", "delivery-unknown"].includes(sessions.providerBinding.turn.status)) {
-                    if (sessions.providerBinding.turn.status !== "accepted") {
+                if (recordedProviderTurn && sessions.providerBinding?.run !== null
+                    && sessions.providerBinding?.run !== undefined
+                    && ["submitting", "accepted", "delivery-unknown"].includes(sessions.providerBinding.run.status)) {
+                    if (sessions.providerBinding.run.status !== "accepted") {
                         sessions = updateTaskRoleProviderRuntime(sessions, acceptProviderTurn(sessions.providerBinding, {
                             attemptId,
-                            ...(canonicalTurnId === undefined ? {} : { nativeTurnId: canonicalTurnId }),
+                            ...(canonicalRunId === undefined ? {} : { nativeTurnId: canonicalRunId }),
                             acceptedAt: now.toISOString()
                         }), now);
                     }
-                    sessions = settleStructuredProviderTurn(sessions, canonicalTurnId, input.providerStatus, now, attemptId);
+                    sessions = settleStructuredProviderTurn(sessions, canonicalRunId, input.providerStatus, now, attemptId);
                     store.saveTaskRoleSessionSet(sessions);
                 }
                 if (input.observation !== undefined)
@@ -1668,41 +1718,40 @@ export class FileSchedulerStoreAdapter {
                     ...(sessions.sessions[input.agentId] === undefined
                         ? {} : { session: sessions.sessions[input.agentId] }),
                     duplicate: true,
-                    ...(observedTurn === null ? {} : { turn: observedTurn })
+                    ...(observedRun === null ? {} : { run: observedRun })
                 };
             }
             const pending = sessions.providerBinding;
-            if (pending.turn?.status === "submitting" || pending.turn?.status === "delivery-unknown") {
+            if (pending.run?.status === "submitting" || pending.run?.status === "delivery-unknown") {
                 sessions = updateTaskRoleProviderRuntime(sessions, acceptProviderTurn(pending, {
                     attemptId,
-                    ...(canonicalTurnId === undefined ? {} : { nativeTurnId: canonicalTurnId }),
+                    ...(canonicalRunId === undefined ? {} : { nativeTurnId: canonicalRunId }),
                     acceptedAt: now.toISOString()
                 }), now);
             }
-            sessions = settleStructuredProviderTurn(sessions, canonicalTurnId, input.providerStatus, now, attemptId);
-            if (canonicalTurnId !== undefined)
-                sessions = recordTaskRoleTurnBoundary(sessions, {
+            sessions = settleStructuredProviderTurn(sessions, canonicalRunId, input.providerStatus, now, attemptId);
+            if (canonicalRunId !== undefined)
+                sessions = recordTaskRoleNativeTurnBoundary(sessions, {
                     agentId: input.agentId,
                     nativeSessionId: input.nativeSessionId,
-                    turnId: canonicalTurnId
+                    turnId: canonicalRunId
                 }, now);
+            if (input.observation?.payload.failure?.error.sessionDisposition === "unrecoverable"
+                && sessions.providerBinding !== null) {
+                sessions = updateTaskRoleProviderRuntime(sessions, updateProviderConversationRecoverability(sessions.providerBinding, "unrecoverable"), now);
+            }
             store.saveTaskRoleSessionSet(sessions);
-            completeRuntimeHookReservation(store, owner, input.runtimeGenerationId);
-            let terminalTurn;
-            if (recordedProviderTurn && observedTurn?.status === "active") {
+            let terminalRun;
+            if (recordedProviderTurn && observedRun?.status === "active") {
                 const binding = sessions.providerBinding;
                 const conversation = binding.conversations.find((entry) => entry.conversationId === input.nativeSessionId);
-                const activation = binding.activations.find((entry) => (entry.activationId === resolved.activationId));
-                if (activation === undefined) {
-                    throw new Error("Provider Turn result has no matching Activation.");
-                }
                 const providerStatus = input.providerStatus;
                 let systemEvidence;
                 let workspaceFailure;
-                if ((observedTurn.purpose === "execution" || observedTurn.purpose === "review")
-                    && observedTurn.executionGroupId !== undefined
-                    && observedTurn.executionLaneId !== undefined
-                    && observedTurn.workspace !== undefined
+                if ((observedRun.purpose === "execution" || observedRun.purpose === "review")
+                    && observedRun.executionGroupId !== undefined
+                    && observedRun.executionLaneId !== undefined
+                    && observedRun.workspace !== undefined
                     && input.outcome.status === "completed") {
                     const gitSnapshot = workspace;
                     if (gitSnapshot.status === "captured") {
@@ -1719,21 +1768,19 @@ export class FileSchedulerStoreAdapter {
                         };
                     }
                 }
-                const terminalized = terminalizeExactTaskTurn(store, {
+                const terminalized = terminalizeExactTaskRun(store, {
                     taskId: input.taskId,
                     roleName: input.roleName,
                     agentId: input.agentId,
-                    turnId: observedTurn.id,
+                    runId: observedRun.id,
                     nativeSessionId: input.nativeSessionId,
-                    ...(input.runtimeGenerationId === undefined ? {} : { runtimeGenerationId: input.runtimeGenerationId }),
                     outcome: {
                         ...input.outcome,
                         provider: {
                             providerNamespace: binding.providerNamespace,
                             accountScope: binding.accountScope,
                             conversationId: conversation.conversationId,
-                            activationId: activation.activationId,
-                            ...(canonicalTurnId === undefined ? {} : { nativeTurnId: canonicalTurnId }),
+                            ...(canonicalRunId === undefined ? {} : { nativeTurnId: canonicalRunId }),
                             attemptId,
                             status: providerStatus
                         }
@@ -1741,20 +1788,24 @@ export class FileSchedulerStoreAdapter {
                     ...(systemEvidence === undefined ? {} : { systemEvidence }),
                     ...(workspaceFailure === undefined ? {} : { workspaceFailure })
                 }, now);
-                if (terminalized.disposition !== "applied" || terminalized.turn === null) {
-                    throw new Error(`Provider Turn terminal could not complete its exact Turn: ${terminalized.reason ?? "obsolete"}.`);
+                if (terminalized.disposition !== "applied" || terminalized.run === null) {
+                    throw new Error(`Provider AgentRun terminal could not complete its exact AgentRun: ${terminalized.reason ?? "obsolete"}.`);
                 }
-                terminalTurn = terminalized.turn;
-                const event = createTaskEvent(store.nextEventId(input.taskId), input.taskId, terminalTurn.status === "completed" ? "turn.completed" : "turn.failed", {
-                    turnId: terminalTurn.id,
-                    roleName: terminalTurn.roleName,
-                    ...(canonicalTurnId === undefined ? {} : { providerTurnId: canonicalTurnId }),
+                terminalRun = terminalized.run;
+                const event = createTaskEvent(store.nextEventId(input.taskId), input.taskId, terminalRun.status === "completed" ? "run.completed" : "run.failed", {
+                    runId: terminalRun.id,
+                    roleName: terminalRun.roleName,
+                    ...(canonicalRunId === undefined ? {} : { providerTurnId: canonicalRunId }),
                     providerStatus
                 }, now);
                 store.saveEvent(input.taskId, event);
-                if (terminalTurn.roleName !== "leader"
-                    && (terminalTurn.status !== "completed" || !providerGoalContinues(binding.goal))) {
-                    routeRoleEvent(store, event, terminalTurn.roleName, terminalTurn.purpose === "review" ? "review-result" : "role-turn-result", now);
+                // A structured failure routes its original runtime.agent-error below;
+                // the AgentRun terminal is the same fact, not a second notification.
+                const structuredFailure = input.observation?.kind === "turn.failed"
+                    && input.observation.payload.failure !== undefined;
+                if (!structuredFailure && terminalRun.roleName === "leader"
+                    && terminalRun.status === "failed") {
+                    routeRoleEvent(store, event, terminalRun.roleName, terminalRun.purpose === "review" ? "review-result" : "role-turn-result", now);
                 }
             }
             if (input.observation !== undefined)
@@ -1762,7 +1813,7 @@ export class FileSchedulerStoreAdapter {
             return {
                 session: sessions.sessions[input.agentId],
                 duplicate: false,
-                ...(terminalTurn === undefined ? {} : { turn: terminalTurn })
+                ...(terminalRun === undefined ? {} : { run: terminalRun })
             };
         });
     }
@@ -1771,8 +1822,7 @@ export class FileSchedulerStoreAdapter {
             const identity = [
                 input.taskId,
                 input.roleName,
-                input.turnId,
-                input.runtimeGenerationId ?? "unknown-runtime-generation",
+                input.runId,
                 String(input.deadStatus ?? "unknown-status")
             ].join("\0");
             const observationId = `tmux-host-exit-${createHash("sha256").update(identity).digest("hex")}`;
@@ -1780,26 +1830,19 @@ export class FileSchedulerStoreAdapter {
             if (events.some((event) => (event.type === "runtime.process-exit-observed"
                 && event.payload.observationId === observationId)))
                 return;
-            const stopReceipt = [...events].reverse().find((event) => (event.type === "runtime.session-termination"
-                && event.payload.roleName === input.roleName
-                && (input.runtimeGenerationId === undefined || event.payload.runtimeGenerationId === input.runtimeGenerationId)
-                && ["stop-requested", "graceful-stop", "forced-stop", "stop-confirmed"]
-                    .includes(event.payload.outcome ?? "")));
             const observation = validateRuntimeProcessExitObservation({
                 schemaVersion: 2,
                 observationId,
                 hostSequence: 1,
-                hostInstanceId: `tmux-${input.runtimeGenerationId ?? input.roleName}`,
+                hostInstanceId: `tmux-${input.roleName}`,
                 taskId: input.taskId,
                 roleName: input.roleName,
-                turnId: input.turnId,
-                runtimeGenerationId: input.runtimeGenerationId ?? `unknown-${input.turnId}`,
+                runId: input.runId,
                 ...(input.nativeSessionId === undefined
                     ? {}
                     : { nativeSessionId: input.nativeSessionId }),
                 processKind: "agent-host",
                 ...(input.deadStatus === undefined ? {} : { exitCode: input.deadStatus }),
-                ...(stopReceipt === undefined ? {} : { stopReceiptId: stopReceipt.id }),
                 observedAt: input.observedAt.toISOString()
             });
             const classification = classifyRuntimeProcessExit(observation, {});
@@ -1807,7 +1850,6 @@ export class FileSchedulerStoreAdapter {
                 observationId,
                 processKind: "agent-host",
                 roleName: input.roleName,
-                runtimeGenerationId: observation.runtimeGenerationId,
                 observedAt: observation.observedAt,
                 classification,
                 observation: JSON.stringify(observation)
@@ -1815,7 +1857,7 @@ export class FileSchedulerStoreAdapter {
         });
     }
     /**
-     * Issue 04: reopens each due retry on its original Native Session. A Turn
+     * Issue 04: reopens each due retry on its original Native Session. A AgentRun
      * whose Session is proven dead terminalizes with an exact replacement
      * blocker; a live Session is reopened for the existing delivery path, which
      * re-pushes the exact same input in the same pass.
@@ -1838,22 +1880,6 @@ export class FileSchedulerStoreAdapter {
                 if (input.kind === "conversation.observed") {
                     binding = updateProviderConversationRecoverability(binding, input.payload.recoverability);
                 }
-                else if (input.kind === "activation.started") {
-                    const active = binding.activations.find((entry) => entry.status === "active");
-                    if (active?.activationId !== input.fence.activationId) {
-                        binding = startProviderActivation(binding, {
-                            activationId: input.fence.activationId,
-                            startedAt: input.observedAt ?? input.receivedAt
-                        });
-                    }
-                }
-                else {
-                    binding = endProviderActivation(binding, input.fence.activationId, {
-                        status: input.kind === "activation.failed" ? "failed" : "ended",
-                        endedAt: input.observedAt ?? input.receivedAt,
-                        reason: input.kind
-                    });
-                }
             }
             catch {
                 recordCanonicalObservationObsolete(store, input, "provider-identity-conflict", now);
@@ -1925,16 +1951,11 @@ export class FileSchedulerStoreAdapter {
                         const taskId = input.fence.taskId;
                         const role = store.getRole(taskId, input.fence.roleName);
                         const sessions = store.getTaskRoleSessionSet(taskId, input.fence.roleName);
-                        const run = store.getTurn(taskId, input.fence.turnId);
+                        const run = store.getRun(taskId, input.fence.runId);
                         if (role === null || sessions === null || run === null) {
                             recordCanonicalObservationObsolete(store, input, "bind-state-missing", now);
                             return "obsolete";
                         }
-                        const mailbox = store.getWorkMailbox({
-                            kind: "role",
-                            taskId,
-                            roleName: input.fence.roleName
-                        });
                         const existingSession = sessions.sessions[input.fence.agentId];
                         const existingNativeSessionId = existingSession?.nativeSessionId;
                         const replacingNativeSession = existingNativeSessionId !== undefined
@@ -1948,7 +1969,6 @@ export class FileSchedulerStoreAdapter {
                             agentId: input.fence.agentId,
                             adapterId,
                             nativeSessionId: decision.outcome.nativeSessionId,
-                            runtimeGenerationId: input.fence.runtimeGenerationId,
                             policy: "fixed",
                             status: "active",
                             effective: run.effective
@@ -1959,15 +1979,14 @@ export class FileSchedulerStoreAdapter {
                         const withProvider = bindOrSupersedeProviderRuntime(bound, input, now, replacementBasis
                             ?? terminalProviderReplacementBasis(bound, input, run.mode));
                         store.saveTaskRoleSessionSet(withProvider);
-                        completeRuntimeHookReservation(store, { scope: "task", taskId, roleName: input.fence.roleName }, input.fence.runtimeGenerationId);
                     }
                     const current = store.getTaskRoleSessionSet(input.fence.taskId, input.fence.roleName);
                     const currentSession = current?.sessions[input.fence.agentId];
                     if (current !== null && current !== undefined
                         && currentSession?.nativeSessionId === input.fence.nativeSessionId) {
-                        const run = input.fence.turnId === undefined
+                        const run = input.fence.runId === undefined
                             ? null
-                            : store.getTurn(input.fence.taskId, input.fence.turnId);
+                            : store.getRun(input.fence.taskId, input.fence.runId);
                         const replacementBasis = run === null
                             ? undefined
                             : terminalSessionReplacementBasis(current, input, run)
@@ -1989,70 +2008,56 @@ export class FileSchedulerStoreAdapter {
     /** Provider acceptance is canonical before storage and remains receipt-fenced. */
     observeRuntimePromptAccepted(input, adapterId, now) {
         return this.store.transaction((store) => {
+            // A pipe write is retained as transport evidence, but cannot acknowledge
+            // the business input. A later native receipt/terminal proves acceptance.
+            if (input.authority === "transport")
+                return "applied";
             const continuation = input.fence.receiptId?.startsWith("turn-input:") === true;
             const ordinaryAttemptId = input.fence.receiptId;
-            if (!continuation && input.fence.turnId !== undefined) {
+            if (!continuation && input.fence.runId !== undefined) {
                 const exact = resolveTerminalExecution(store, {
                     taskId: input.fence.taskId,
                     roleName: input.fence.roleName,
                     agentId: input.fence.agentId,
                     adapterId,
-                    runtimeGenerationId: input.fence.runtimeGenerationId,
-                    activationId: input.fence.activationId,
                     conversationId: input.fence.conversationId,
                     nativeSessionId: input.fence.nativeSessionId,
                     nativeTurnId: input.fence.nativeTurnId,
                     attemptId: ordinaryAttemptId,
-                    turnId: input.fence.turnId
+                    runId: input.fence.runId
                 });
                 if (exact === null)
                     return "obsolete";
                 // A terminal can prove acceptance before the delayed receipt. Retain
                 // the receipt without recreating lifecycle state or touching a successor.
-                if (!exact.current || exact.turn?.status !== "active")
+                if (!exact.current || exact.run?.status !== "active")
                     return "applied";
             }
-            if (input.fence.turnId === undefined
+            if (input.fence.runId === undefined
                 && ordinaryAttemptId?.startsWith("direct:") === true) {
                 const taskId = input.fence.taskId;
                 const sessions = store.getTaskRoleSessionSet(taskId, input.fence.roleName);
                 const session = sessions?.sessions[input.fence.agentId];
                 const binding = sessions?.providerBinding;
                 const nativeTurnId = input.fence.nativeTurnId;
-                const active = store.getActiveTurn(taskId, input.fence.roleName);
-                if (sessions === null || sessions === undefined
-                    || binding === null || binding === undefined
-                    || session?.runtimeGenerationId !== input.fence.runtimeGenerationId
-                    || session.nativeSessionId !== input.fence.nativeSessionId
-                    || currentProviderConversation(binding).conversationId !== input.fence.nativeSessionId) {
+                if (sessions === null || sessions === undefined || binding === null || binding === undefined || session === undefined || session.nativeSessionId !== input.fence.nativeSessionId || currentProviderConversation(binding).conversationId !== input.fence.nativeSessionId) {
                     recordCanonicalObservationObsolete(store, input, "direct-turn-session-mismatch", now);
                     return "obsolete";
                 }
-                if (binding.turn?.attemptId === ordinaryAttemptId
-                    && binding.turn.nativeTurnId === nativeTurnId
-                    && binding.turn.turnId !== undefined
-                    && active?.id === binding.turn.turnId) {
+                if (binding.run?.attemptId === ordinaryAttemptId
+                    && binding.run.nativeTurnId === nativeTurnId) {
                     return "applied";
                 }
-                if (active !== null) {
-                    recordCanonicalObservationObsolete(store, input, "direct-turn-conflicts-with-active-turn", now);
-                    return "obsolete";
-                }
-                const turnId = store.nextTurnId(taskId);
-                const goalContinuation = input.payload.input === undefined
-                    && providerGoalContinues(binding.goal);
-                const direct = createTurn(turnId, taskId, input.fence.roleName, "resume", createTurnInput({
-                    source: goalContinuation
-                        ? { type: "provider", channel: "goal-continuation" }
-                        : { type: "user", channel: "direct" },
-                    ...(input.payload.input === undefined
-                        ? {}
-                        : { directive: input.payload.input }),
-                    deltaRefIds: []
-                }), now, { effective: session.effective });
+                // Native conversation is not an implicit managed assignment. Keep its
+                // observation without borrowing or overwriting another request's
+                // accepted, unknown, or waiting admission evidence.
+                if (binding.run !== null
+                    && (["submitting", "accepted", "delivery-unknown"].includes(binding.run.status)
+                        || (binding.run.runId !== undefined
+                            && store.getRun(taskId, binding.run.runId)?.status === "active")))
+                    return "applied";
                 const submittedAt = input.observedAt ?? input.receivedAt;
                 const accepted = acceptProviderTurn(beginProviderTurn(binding, {
-                    turnId,
                     attemptId: ordinaryAttemptId,
                     authorityEpoch: binding.authority.epoch,
                     submittedAt
@@ -2061,10 +2066,7 @@ export class FileSchedulerStoreAdapter {
                     nativeTurnId,
                     acceptedAt: submittedAt
                 });
-                store.saveTurn(direct);
-                store.saveActiveTurn(direct);
                 store.saveTaskRoleSessionSet(updateTaskRoleProviderRuntime(sessions, accepted, now));
-                store.saveEvent(taskId, createTaskEvent(store.nextEventId(taskId), taskId, "turn.dispatched", turnLaunchEventPayload(direct), now));
                 return "applied";
             }
             if (ordinaryAttemptId !== undefined) {
@@ -2073,10 +2075,9 @@ export class FileSchedulerStoreAdapter {
                 const binding = sessions?.providerBinding;
                 if (sessions !== null && sessions !== undefined
                     && binding !== null && binding !== undefined
-                    && binding.turn?.turnId === undefined
-                    && binding.turn?.attemptId === ordinaryAttemptId) {
-                    if (session?.runtimeGenerationId !== input.fence.runtimeGenerationId
-                        || session.nativeSessionId !== input.fence.nativeSessionId) {
+                    && binding.run?.runId === undefined
+                    && binding.run?.attemptId === ordinaryAttemptId) {
+                    if (session === undefined || session.nativeSessionId !== input.fence.nativeSessionId) {
                         recordCanonicalObservationObsolete(store, input, "ordinary-turn-session-mismatch", now);
                         return "obsolete";
                     }
@@ -2085,25 +2086,18 @@ export class FileSchedulerStoreAdapter {
                 }
             }
             if (continuation) {
-                const active = store.getActiveTurn(input.fence.taskId, input.fence.roleName);
+                const active = store.getActiveRun(input.fence.taskId, input.fence.roleName);
                 const sessions = store.getTaskRoleSessionSet(input.fence.taskId, input.fence.roleName);
                 const session = sessions?.sessions[input.fence.agentId];
-                if (active === null
-                    || active.id !== input.fence.turnId
-                    || active.status !== "active"
-                    || sessions === null
-                    || sessions === undefined
-                    || session?.runtimeGenerationId !== input.fence.runtimeGenerationId
-                    || session.nativeSessionId !== input.fence.nativeSessionId) {
+                if (active === null || active.id !== input.fence.runId || active.status !== "active" || sessions === null || sessions === undefined || session === undefined || session.nativeSessionId !== input.fence.nativeSessionId) {
                     recordCanonicalObservationObsolete(store, input, "continuation-fence-mismatch", now);
                     return "obsolete";
                 }
                 store.saveTaskRoleSessionSet(recordStructuredProviderAcceptance(sessions, input, now));
-                store.saveEvent(input.fence.taskId, createTaskEvent(store.nextEventId(input.fence.taskId), input.fence.taskId, "turn.input-delivered", {
+                store.saveEvent(input.fence.taskId, createTaskEvent(store.nextEventId(input.fence.taskId), input.fence.taskId, "run.input-delivered", {
                     attemptId: input.fence.receiptId,
-                    turnId: active.id,
+                    runId: active.id,
                     conversationId: input.fence.conversationId ?? input.fence.nativeSessionId,
-                    activationId: input.fence.activationId ?? input.fence.runtimeGenerationId,
                     ...(input.fence.nativeTurnId === undefined
                         ? {}
                         : { nativeTurnId: input.fence.nativeTurnId })
@@ -2125,9 +2119,9 @@ export class FileSchedulerStoreAdapter {
                 return "deferred";
             if (decision.kind === "idempotent")
                 return "applied";
-            const active = store.getActiveTurn(input.fence.taskId, input.fence.roleName);
+            const active = store.getActiveRun(input.fence.taskId, input.fence.roleName);
             if (active === null
-                || active.id !== input.fence.turnId
+                || active.id !== input.fence.runId
                 || active.status !== "active") {
                 recordCanonicalObservationObsolete(store, input, "turn-not-active", now);
                 return "obsolete";
@@ -2140,7 +2134,7 @@ export class FileSchedulerStoreAdapter {
         });
     }
     foldRuntimeLifecycleEvent(store, event, observation) {
-        const expectation = this.projectTurnExpectation(store, event.fence, observation.fence.turnId);
+        const expectation = this.projectRunExpectation(store, event.fence, observation.fence.runId);
         if (expectation === null) {
             return preallocatedRuntimeReadyAwaitingProjection(store, observation, this.drivers)
                 ? { kind: "apply", outcome: { outcome: "mark-ready", preInputReady: true } }
@@ -2160,14 +2154,14 @@ export class FileSchedulerStoreAdapter {
                 return { kind: "apply", outcome };
         }
     }
-    /** Reads durable Turn + Session state into the pure fold's expectation shape. */
-    projectTurnExpectation(store, fence, turnId) {
+    /** Reads durable AgentRun + Session state into the pure fold's expectation shape. */
+    projectRunExpectation(store, fence, runId) {
         const role = store.getRole(fence.taskId, fence.roleName);
         if (role === null)
             return null;
         const sessionSet = store.getTaskRoleSessionSet(fence.taskId, fence.roleName);
         const session = sessionSet?.sessions[fence.agentId] ?? null;
-        if (turnId === undefined) {
+        if (runId === undefined) {
             return {
                 fence,
                 sessionStarted: false,
@@ -2180,45 +2174,30 @@ export class FileSchedulerStoreAdapter {
                     : { boundNativeSessionId: session.nativeSessionId })
             };
         }
-        const run = store.getTurn(fence.taskId, turnId);
+        const run = store.getRun(fence.taskId, runId);
         if (run === null || run.status !== "active")
             return null;
-        const owner = { scope: "task", taskId: fence.taskId, roleName: fence.roleName };
-        const freshConversationLaunch = run.mode === "new"
-            && runtimeHookMatchesReservation(store, owner, fence.runtimeGenerationId);
+        const freshConversationLaunch = run.mode === "new" && session?.status !== "active";
         const boundNativeSessionId = freshConversationLaunch
             ? undefined
             : session?.nativeSessionId;
-        const runtimeGenerationId = freshConversationLaunch
-            ? fence.runtimeGenerationId
-            : session?.runtimeGenerationId
-                ?? (runtimeHookMatchesReservation(store, owner, fence.runtimeGenerationId) ? fence.runtimeGenerationId : undefined);
-        if (runtimeGenerationId === undefined)
-            return null;
-        const providerTurn = sessionSet?.providerBinding?.turn;
-        const managedTurnMatches = managedProviderTurnId(providerTurn) === run.id;
+        const providerTurn = sessionSet?.providerBinding?.run;
+        const managedRunMatches = managedProviderTurnId(providerTurn) === run.id;
         const expectedFence = {
             taskId: fence.taskId,
             roleName: fence.roleName,
             agentId: run.effective.agentId,
             adapterId: run.effective.adapterId,
-            turnId: run.id,
-            runtimeGenerationId,
-            receiptId: managedTurnMatches && providerTurn !== null && providerTurn !== undefined
+            runId: run.id,
+            receiptId: managedRunMatches && providerTurn !== null && providerTurn !== undefined
                 ? providerTurn.attemptId
-                : formatTurnReceiptId(run.taskId, run.id),
+                : formatRunReceiptId(run.taskId, run.id),
             ...(boundNativeSessionId === undefined ? {} : { nativeSessionId: boundNativeSessionId })
         };
         const driverId = this.drivers.requireByAdapterId(run.effective.adapterId).id;
         const lifecycleEvents = store.listEvents(fence.taskId).flatMap((event) => {
             const observation = runtimeObservationFromTaskEvent(event);
-            return observation !== null
-                && (observation.kind === "session.started" || observation.kind === "session.ready")
-                && observation.fence.roleName === fence.roleName
-                && observation.fence.agentId === run.effective.agentId
-                && observation.fence.driverId === driverId
-                && observation.fence.runtimeGenerationId === runtimeGenerationId
-                && observation.fence.nativeSessionId === (boundNativeSessionId ?? fence.nativeSessionId)
+            return observation !== null && (observation.kind === "session.started" || observation.kind === "session.ready") && observation.fence.roleName === fence.roleName && observation.fence.agentId === run.effective.agentId && observation.fence.driverId === driverId && observation.fence.nativeSessionId === (boundNativeSessionId ?? fence.nativeSessionId)
                 ? [observation]
                 : [];
         });
@@ -2226,8 +2205,8 @@ export class FileSchedulerStoreAdapter {
             fence: expectedFence,
             sessionStarted: lifecycleEvents.length > 0,
             ready: lifecycleEvents.some((event) => event.kind === "session.ready"),
-            pushed: managedTurnMatches,
-            accepted: managedTurnMatches && providerTurn !== null && providerTurn !== undefined
+            pushed: managedRunMatches,
+            accepted: managedRunMatches && providerTurn !== null && providerTurn !== undefined
                 && ["accepted", "completed", "failed", "cancelled"]
                     .includes(providerTurn.status),
             terminal: run.status !== "active",
@@ -2244,7 +2223,7 @@ export class FileSchedulerStoreAdapter {
     recordGlobalRuntimeNativeSession(input, now = new Date()) {
         return this.store.transaction((store) => (recordGlobalRuntimeNativeSession(store, input, now)));
     }
-    observeGlobalRuntimeTurnTerminal(input, now = new Date()) {
+    observeGlobalRuntimeRunTerminal(input, now = new Date()) {
         return this.store.transaction((store) => {
             const role = store.getGlobalRole(input.roleName);
             if (role === null)
@@ -2256,22 +2235,20 @@ export class FileSchedulerStoreAdapter {
                 scope: "global",
                 roleName: input.roleName
             };
-            if (existing === undefined
-                && !runtimeHookMatchesReservation(store, owner, input.runtimeGenerationId)) {
-                throw new Error("Runtime turn completion does not match the global launch reservation.");
+            if (existing === undefined && !runtimeHookMatchesLaunchIntent(store, owner)) {
+                throw new Error("Runtime turn completion has no matching global Session intent.");
             }
-            const nativeSessionId = globalCompletionNativeSessionId(existing, input);
-            const effectiveExisting = nativeTransitionExisting(store, owner, existing, nativeSessionId, input.runtimeGenerationId, "Runtime turn completion conflicts with the fixed global Role session.");
+            const nativeSessionId = input.nativeSessionId;
+            const effectiveExisting = nativeTransitionExisting(store, owner, existing, nativeSessionId, "Runtime turn completion conflicts with the fixed global Role session.");
             const effective = globalSessionEffective(role, effectiveExisting);
             if (effective.agentId !== input.agentId || effective.adapterId !== input.adapterId) {
-                throw new Error("Runtime turn completion does not match the effective global runtime generation identity.");
+                throw new Error("Runtime turn completion does not match the effective global runtime identity.");
             }
             const completedStatus = effectiveExisting?.status ?? "active";
             current = recordRoleAgentSession(current, {
                 agentId: input.agentId,
                 adapterId: input.adapterId,
                 nativeSessionId,
-                ...(input.runtimeGenerationId === undefined ? {} : { runtimeGenerationId: input.runtimeGenerationId }),
                 title: effectiveExisting?.title ?? input.title,
                 preview: effectiveExisting?.preview ?? sessionPreview(input.outcome.status === "completed"
                     ? input.outcome.output
@@ -2285,7 +2262,6 @@ export class FileSchedulerStoreAdapter {
             }, now);
             current = rememberRoleAgentCompletedTurn(current, input.agentId, nativeSessionId, input.nativeTurnId, now);
             store.saveGlobalRoleSessionSet(current);
-            completeRuntimeHookReservation(store, owner, input.runtimeGenerationId);
             if (input.roleName === SYSTEM_OPERATOR_ROLE
                 && input.adapterId === "codex"
                 && completedStatus === "active") {
@@ -2300,7 +2276,7 @@ export class FileSchedulerStoreAdapter {
             return current.sessions[input.agentId];
         });
     }
-    classifyGlobalRuntimeTurnTerminal(input) {
+    classifyGlobalRuntimeRunTerminal(input) {
         const role = this.store.getGlobalRole(input.roleName);
         if (role === null)
             return "obsolete";
@@ -2310,13 +2286,12 @@ export class FileSchedulerStoreAdapter {
             scope: "global",
             roleName: input.roleName
         };
-        if (existing === undefined
-            && !runtimeHookMatchesReservation(this.store, owner, input.runtimeGenerationId))
+        if (existing === undefined && !runtimeHookMatchesLaunchIntent(this.store, owner))
             return "obsolete";
-        const nativeSessionId = globalCompletionNativeSessionId(existing, input);
+        const nativeSessionId = input.nativeSessionId;
         let effectiveExisting;
         try {
-            effectiveExisting = nativeTransitionExisting(this.store, owner, existing, nativeSessionId, input.runtimeGenerationId, "Runtime turn completion conflicts with the fixed global Role session.");
+            effectiveExisting = nativeTransitionExisting(this.store, owner, existing, nativeSessionId, "Runtime turn completion conflicts with the fixed global Role session.");
         }
         catch {
             return "obsolete";
@@ -2334,8 +2309,7 @@ function runtimeObservationLifecycleFence(input, adapterId) {
         roleName: input.fence.roleName,
         agentId: input.fence.agentId,
         adapterId,
-        runtimeGenerationId: input.fence.runtimeGenerationId,
-        ...(input.fence.turnId === undefined ? {} : { turnId: input.fence.turnId }),
+        ...(input.fence.runId === undefined ? {} : { runId: input.fence.runId }),
         ...(input.fence.nativeSessionId === undefined
             ? {}
             : { nativeSessionId: input.fence.nativeSessionId }),
@@ -2343,7 +2317,7 @@ function runtimeObservationLifecycleFence(input, adapterId) {
     };
 }
 /**
- * A live parent Turn still owns its native child result. Only after that Turn
+ * A live parent AgentRun still owns its native child result. Only after that AgentRun
  * is terminal or absent does Yui route the continuation fact to the original
  * Role's supervisor. Mailbox coalescing remains the downstream batching
  * mechanism; this guard decides ownership before any wake is enqueued.
@@ -2352,33 +2326,34 @@ function routeContinuationResult(store, observation, event, reason, now) {
     const taskId = observation.fence.taskId;
     if (taskId === undefined)
         return;
-    const parentTurn = observation.fence.turnId === undefined
+    const parentRun = observation.fence.runId === undefined
         ? null
-        : store.getTurn(taskId, observation.fence.turnId);
-    if (parentTurn?.status === "active")
+        : store.getRun(taskId, observation.fence.runId);
+    if (parentRun?.status === "active")
         return;
     if (store.getRole(taskId, observation.fence.roleName) === null)
         return;
     routeRoleEvent(store, event, observation.fence.roleName, reason, now);
 }
-/** Accepts the original Turn receipt or a later mailbox activation receipt. */
-function runtimeReceiptBelongsToTurn(store, input) {
+/** Accepts the original AgentRun receipt or a later mailbox activation receipt. */
+function runtimeReceiptBelongsToRun(store, input) {
     const taskId = input.fence.taskId;
-    const turnId = input.fence.turnId;
+    const runId = input.fence.runId;
     const receiptId = input.fence.receiptId;
-    if (receiptId === formatTurnReceiptId(taskId, turnId))
+    if (receiptId === formatRunReceiptId(taskId, runId))
         return true;
     if (receiptId === undefined)
         return false;
+    const sessions = store.getTaskRoleSessionSet(taskId, input.fence.roleName);
+    const current = sessions?.providerBinding?.run;
+    if (current?.runId === runId && current.attemptId === receiptId
+        && current.status !== "rejected" && current.status !== "deferred"
+        && sessions?.sessions[input.fence.agentId]?.nativeSessionId === input.fence.nativeSessionId) {
+        return true;
+    }
     return store.listEvents(taskId).some((event) => {
         const accepted = runtimeObservationFromTaskEvent(event);
-        return accepted?.kind === "turn.accepted"
-            && accepted.fence.turnId === turnId
-            && accepted.fence.roleName === input.fence.roleName
-            && accepted.fence.agentId === input.fence.agentId
-            && accepted.fence.runtimeGenerationId === input.fence.runtimeGenerationId
-            && accepted.fence.nativeSessionId === input.fence.nativeSessionId
-            && accepted.fence.receiptId === receiptId;
+        return accepted?.kind === "turn.accepted" && accepted.fence.runId === runId && accepted.fence.roleName === input.fence.roleName && accepted.fence.agentId === input.fence.agentId && accepted.fence.nativeSessionId === input.fence.nativeSessionId && accepted.fence.receiptId === receiptId;
     });
 }
 function recordCanonicalObservationObsolete(store, input, reason, now) {
@@ -2392,9 +2367,8 @@ function recordCanonicalObservationObsolete(store, input, reason, now) {
         taskId,
         roleName: input.fence.roleName,
         agentId: input.fence.agentId,
-        ...(input.fence.turnId === undefined ? {} : { turnId: input.fence.turnId }),
-        runtimeGenerationId: input.fence.runtimeGenerationId,
-        nativeSessionId: input.fence.nativeSessionId ?? input.fence.runtimeGenerationId
+        ...(input.fence.runId === undefined ? {} : { runId: input.fence.runId }),
+        ...(input.fence.nativeSessionId === undefined ? {} : { nativeSessionId: input.fence.nativeSessionId })
     }, reason, now);
 }
 function recordObsoleteRuntimeEvent(store, input, reason, now) {
@@ -2407,9 +2381,8 @@ function recordObsoleteRuntimeEvent(store, input, reason, now) {
         eventType: input.eventType ?? input.type ?? "unknown",
         roleName: input.roleName,
         agentId: input.agentId,
-        nativeSessionId: input.nativeSessionId,
-        ...(input.turnId === undefined ? {} : { turnId: input.turnId }),
-        ...(input.runtimeGenerationId === undefined ? {} : { runtimeGenerationId: input.runtimeGenerationId }),
+        ...(input.nativeSessionId === undefined ? {} : { nativeSessionId: input.nativeSessionId }),
+        ...(input.runId === undefined ? {} : { runId: input.runId }),
         reason
     }, now));
 }
@@ -2420,44 +2393,36 @@ function sessionPreview(value) {
         ? truncated.slice(0, -1)
         : truncated;
 }
-function requireRuntimeLaunchReservation(store, owner, runtimeGenerationId) {
-    const mailbox = store.getWorkMailbox(runtimeLifecycleTarget(owner));
-    if (!isRuntimeLaunchReservation(mailbox?.processing, runtimeGenerationId)) {
-        throw new Error("Runtime launch reservation no longer matches the launch.");
-    }
-    return mailbox;
-}
-function runtimeHookMatchesReservation(store, owner, runtimeGenerationId) {
+function runtimeHookMatchesLaunchIntent(store, owner) {
     const mailbox = store.getWorkMailbox(runtimeLifecycleTarget(owner));
     if (hasRuntimeCleanupObligation(mailbox))
         return false;
-    const processing = mailbox?.processing;
-    return runtimeGenerationId !== undefined
-        && isRuntimeLaunchReservation(processing, runtimeGenerationId);
+    if (owner.scope === "global")
+        return true;
+    return store.getActiveRun(owner.taskId, owner.roleName)?.mode === "new";
 }
 function preallocatedRuntimeReadyAwaitingProjection(store, observation, drivers) {
     const taskId = observation.fence.taskId;
-    const turnId = observation.fence.turnId;
+    const runId = observation.fence.runId;
     const nativeSessionId = observation.fence.nativeSessionId;
     const driver = drivers.find(observation.fence.driverId);
     if (observation.kind !== "session.ready"
         || driver?.capabilities.observation.sessionBootstrap !== "preallocated"
         || taskId === undefined
-        || turnId === undefined
+        || runId === undefined
         || nativeSessionId === undefined)
         return false;
     const task = store.getTask(taskId);
     const role = store.getRole(taskId, observation.fence.roleName);
-    const run = store.getActiveTurn(taskId, observation.fence.roleName);
+    const run = store.getActiveRun(taskId, observation.fence.roleName);
     const sessions = store.getTaskRoleSessionSet(taskId, observation.fence.roleName);
-    if (task?.status !== "active"
-        || task.executionGate.state !== "enabled"
+    if (task == null || run == null || !runPurposeAdmitsTaskState(run.purpose, task)
         || role?.activeAgentId !== observation.fence.agentId
-        || run?.id !== turnId
+        || run?.id !== runId
         || run.status !== "active"
         || run.effective.agentId !== observation.fence.agentId
         || run.effective.adapterId !== driver.adapterId
-        || observation.fence.receiptId !== formatTurnReceiptId(run.taskId, run.id)
+        || observation.fence.receiptId !== formatRunReceiptId(run.taskId, run.id)
         || sessions?.sessions[observation.fence.agentId] !== undefined)
         return false;
     const mailbox = store.getWorkMailbox(runtimeLifecycleTarget({
@@ -2465,17 +2430,7 @@ function preallocatedRuntimeReadyAwaitingProjection(store, observation, drivers)
         taskId,
         roleName: observation.fence.roleName
     }));
-    return isRuntimeLaunchReservation(mailbox?.processing, observation.fence.runtimeGenerationId)
-        && !hasRuntimeCleanupObligation(mailbox)
-        && nativeSessionId === nativeSessionIdForLaunch(store.rootDirectory(), observation.fence.runtimeGenerationId, observation.fence.agentId, driver.adapterId);
-}
-function completeRuntimeHookReservation(store, owner, runtimeGenerationId) {
-    if (runtimeGenerationId === undefined)
-        return;
-    const mailbox = store.getWorkMailbox(runtimeLifecycleTarget(owner));
-    if (!isRuntimeLaunchReservation(mailbox?.processing, runtimeGenerationId))
-        return;
-    saveRuntimeLifecycleMailbox(store, completeProcessing(mailbox, runtimeGenerationId));
+    return !hasRuntimeCleanupObligation(mailbox);
 }
 function saveRuntimeLifecycleMailbox(store, mailbox) {
     if (!mailboxHasWork(mailbox)) {
@@ -2503,24 +2458,18 @@ function sameRuntimeOwner(left, right) {
             && left.roleName === right.roleName
         : right.scope === "global" && left.roleName === right.roleName;
 }
-function dormantRuntimeCandidateIsCurrent(store, candidate) {
+function dormantRuntimeCandidateIsCurrent(store, candidate, allowActiveRun = false) {
     const { owner } = candidate;
-    if (hasRuntimeLifecycleWork(store.getWorkMailbox(runtimeLifecycleTarget(owner)))) {
-        return false;
-    }
-    if (owner.scope === "task"
-        && store.getActiveTurn(owner.taskId, owner.roleName) !== null) {
+    if (!allowActiveRun && owner.scope === "task"
+        && store.getActiveRun(owner.taskId, owner.roleName) !== null) {
         return false;
     }
     const sessions = runtimeOwnerSessionSet(store, owner);
-    const active = sessions?.sessions[sessions.activeAgentId];
-    return active !== undefined
-        && active.status === "active"
-        && active.agentId === candidate.agentId
-        && active.adapterId === candidate.adapterId
-        && active.nativeSessionId === candidate.nativeSessionId
-        && active.runtimeGenerationId === candidate.runtimeGenerationId
-        && active.updatedAt === candidate.sessionUpdatedAt;
+    const active = allowActiveRun && owner.scope === "task"
+        ? taskRoleControlTarget(store.getTaskRoleSessionSet(owner.taskId, owner.roleName))
+        : sessions?.sessions[sessions.activeAgentId];
+    return active !== undefined && active.agentId === candidate.agentId && active.adapterId === candidate.adapterId
+        && active.nativeSessionId === candidate.nativeSessionId && (allowActiveRun || active.updatedAt === candidate.sessionUpdatedAt);
 }
 function endRuntimeOwnerSession(store, owner, now) {
     if (owner.scope === "task") {
@@ -2533,16 +2482,6 @@ function endRuntimeOwnerSession(store, owner, now) {
         let stopped = active.status === "ended"
             ? sessions
             : updateRoleAgentSessionStatus(sessions, sessions.activeAgentId, "ended", now, "stopped");
-        const activation = stopped.providerBinding === null
-            ? null
-            : currentProviderActivation(stopped.providerBinding);
-        if (activation !== null) {
-            stopped = updateTaskRoleProviderRuntime(stopped, endProviderActivation(stopped.providerBinding, activation.activationId, {
-                status: "ended",
-                endedAt: now.toISOString(),
-                reason: "session-ended"
-            }), now);
-        }
         if (stopped === sessions)
             return false;
         store.saveTaskRoleSessionSet(stopped);
@@ -2582,13 +2521,6 @@ function runtimeOwnerSessionSet(store, owner) {
         ? store.getTaskRoleSessionSet(owner.taskId, owner.roleName)
         : store.getGlobalRoleSessionSet(owner.roleName);
 }
-function runtimeSessionMatchesSettledLaunch(session, input) {
-    return session !== undefined
-        && session.agentId === input.agentId
-        && session.adapterId === input.adapterId
-        && (input.nativeSessionId === undefined
-            || session.nativeSessionId === input.nativeSessionId);
-}
 function recordTaskRuntimeNativeSession(store, input, now) {
     const task = store.getTask(input.taskId);
     if (task === null)
@@ -2596,32 +2528,45 @@ 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" || task.executionGate.state !== "enabled") {
+    // A Draft registers a Session only for its planning Turn. Admission is decided
+    // by the active Turn's purpose through the one shared invariant, so a Draft
+    // still cannot open an execution Session before activation.
+    const admittingRun = store.getActiveRun(input.taskId, input.roleName);
+    const existingPlanning = activeLiveRoleAgentSession(store.getTaskRoleSessionSet(input.taskId, input.roleName));
+    if (!(admittingRun !== null
+        && admittingRun.purpose === "planning"
+        && runPurposeAdmitsTaskState(admittingRun.purpose, task))
+        && !(task.status === "draft" && task.executionGate.state === "enabled" && input.roleName === "leader"
+            && existingPlanning?.effective.executionAuthority === "planning"
+            && existingPlanning.nativeSessionId === input.nativeSessionId)
+        && (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);
+    if (role.activeAgentId !== input.agentId
+        || activeRoleAgentBinding(role).adapterId !== input.adapterId) {
+        throw new Error("Native Session registration does not match the active Role Agent.");
+    }
     const current = store.getRoleSessionSet(input.taskId, input.roleName)
         ?? createRoleSessionSet({ scope: "task", taskId: input.taskId, roleName: input.roleName }, input.agentId, now);
     const existing = current.sessions[input.agentId];
-    const effectiveExisting = nativeTransitionExisting(store, { scope: "task", taskId: input.taskId, roleName: input.roleName }, existing, input.nativeSessionId, input.runtimeGenerationId, "Native session registration conflicts with the fixed Role session.");
-    if (existing?.status === "active"
-        && (input.runtimeGenerationId === undefined || existing.runtimeGenerationId === input.runtimeGenerationId))
+    const effectiveExisting = nativeTransitionExisting(store, { scope: "task", taskId: input.taskId, roleName: input.roleName }, existing, input.nativeSessionId, "Native session registration conflicts with the fixed Role session.");
+    if (existing?.status === "active")
         return existing;
     const resolvedEffective = taskSessionEffective(store, input.taskId, input.roleName, input.agentId, effectiveExisting);
     const effective = input.effective === undefined
         ? resolvedEffective
         : validateEffectiveLaunchSnapshot(input.effective);
     if (!roleSessionMayContinue(resolvedEffective, effective)) {
-        throw new Error("Reserved native Session effective launch changed before persistence.");
+        throw new Error("Native Session effective launch changed before persistence.");
     }
     if (effective.agentId !== input.agentId || effective.adapterId !== input.adapterId) {
-        throw new Error("Native session registration does not match the effective runtime generation identity.");
+        throw new Error("Native session registration does not match the effective runtime identity.");
     }
     const updated = recordRoleAgentSession(current, {
         agentId: input.agentId,
         adapterId: input.adapterId,
         nativeSessionId: input.nativeSessionId,
-        ...(input.runtimeGenerationId === undefined ? {} : { runtimeGenerationId: input.runtimeGenerationId }),
         policy: "fixed",
         status: "active",
         effective: effectiveExisting?.effective ?? effective
@@ -2633,28 +2578,30 @@ function recordGlobalRuntimeNativeSession(store, input, now) {
     const role = store.getGlobalRole(input.roleName);
     if (role === null)
         throw new Error(`Global Role not found: ${input.roleName}.`);
+    if (role.activeAgentId !== input.agentId
+        || role.agentBindings[role.activeAgentId]?.adapterId !== input.adapterId) {
+        throw new Error("Native Session registration does not match the active global Role Agent.");
+    }
     const current = store.getGlobalRoleSessionSet(input.roleName)
         ?? createRoleSessionSet({ scope: "global", roleName: input.roleName }, input.agentId, now);
     const existing = current.sessions[input.agentId];
-    const effectiveExisting = nativeTransitionExisting(store, { scope: "global", roleName: input.roleName }, existing, input.nativeSessionId, input.runtimeGenerationId, "Native session registration conflicts with the fixed global Role session.");
-    if (existing?.status === "active"
-        && (input.runtimeGenerationId === undefined || existing.runtimeGenerationId === input.runtimeGenerationId))
+    const effectiveExisting = nativeTransitionExisting(store, { scope: "global", roleName: input.roleName }, existing, input.nativeSessionId, "Native session registration conflicts with the fixed global Role session.");
+    if (existing?.status === "active")
         return existing;
     const resolvedEffective = globalSessionEffective(role, effectiveExisting);
     const effective = input.effective === undefined
         ? resolvedEffective
         : validateEffectiveLaunchSnapshot(input.effective);
     if (!roleSessionMayContinue(resolvedEffective, effective)) {
-        throw new Error("Reserved global native Session effective launch changed before persistence.");
+        throw new Error("Global native Session effective launch changed before persistence.");
     }
     if (effective.agentId !== input.agentId || effective.adapterId !== input.adapterId) {
-        throw new Error("Native session registration does not match the effective global runtime generation identity.");
+        throw new Error("Native session registration does not match the effective global runtime identity.");
     }
     const updated = recordRoleAgentSession(current, {
         agentId: input.agentId,
         adapterId: input.adapterId,
         nativeSessionId: input.nativeSessionId,
-        ...(input.runtimeGenerationId === undefined ? {} : { runtimeGenerationId: input.runtimeGenerationId }),
         policy: "fixed",
         status: "active",
         effective
@@ -2662,31 +2609,20 @@ function recordGlobalRuntimeNativeSession(store, input, now) {
     store.saveGlobalRoleSessionSet(updated);
     return updated.sessions[input.agentId];
 }
-function nativeTransitionExisting(store, owner, existing, nativeSessionId, runtimeGenerationId, conflictMessage) {
+function nativeTransitionExisting(store, owner, existing, nativeSessionId, conflictMessage) {
     if (existing === undefined || existing.nativeSessionId === nativeSessionId) {
         return existing;
     }
-    if (existing.status === "ended"
-        && runtimeHookMatchesReservation(store, owner, runtimeGenerationId)) {
+    if (existing.status === "ended" && runtimeHookMatchesLaunchIntent(store, owner)) {
         return undefined;
     }
     throw new Error(conflictMessage);
 }
-function globalCompletionNativeSessionId(existing, input) {
-    // Codex structured event sources can expose different native IDs for the
-    // same runtime generation. That generation remains the authoritative fence.
-    return input.adapterId === "codex"
-        && input.runtimeGenerationId !== undefined
-        && existing?.runtimeGenerationId === input.runtimeGenerationId
-        && existing.agentId === input.agentId
-        && existing.adapterId === input.adapterId
-        ? existing.nativeSessionId
-        : input.nativeSessionId;
-}
 function mapRole(store, role) {
     const binding = activeRoleAgentBinding(role);
+    const purpose = store.getTask(role.taskId)?.status === "draft" ? "planning" : "execution";
     const item = store.listWorkItems(role.taskId).find((candidate) => (candidate.assignee === role.name
-        && !["completed", "failed", "retired"].includes(candidate.status))) ?? null;
+        && !["accepted", "retired"].includes(candidate.status))) ?? null;
     const workspace = (item === null
         ? store.getTaskWorkspace(role.taskId)
         : store.getWorkItemWorkspace(role.taskId, item.id))
@@ -2695,17 +2631,20 @@ function mapRole(store, role) {
     const reopened = role.name === "leader"
         && store.getPendingWakeup(role.taskId)?.reasons.includes("task-reopened") === true;
     const liveSession = activeLiveRoleAgentSession(store.getTaskRoleSessionSet(role.taskId, role.name));
-    const effective = reopened
+    // This projection plans future dispatch. A live Session retains its actual
+    // source, but cannot silently override an explicit next-Agent selection.
+    // Active AgentRun delivery separately and exclusively uses turn.effective.
+    const effective = reopened || (liveSession !== null && liveSession.agentId !== role.activeAgentId)
         ? resolveEffectiveLaunch({
             role,
-            purpose: "execution",
+            purpose,
             ...(workspace === undefined ? {} : { workspace })
         })
         : liveSession !== null && workspace?.owner.type === "task"
             ? effectiveLaunchWithTaskMainWorkspace(liveSession.effective, workspace)
             : liveSession?.effective ?? resolveEffectiveLaunch({
                 role,
-                purpose: "execution",
+                purpose,
                 ...(workspace === undefined ? {} : { workspace })
             });
     return {
@@ -2721,14 +2660,14 @@ function mapRole(store, role) {
     };
 }
 function taskSessionEffective(store, taskId, roleName, agentId, existing) {
-    const active = store.getActiveTurn(taskId, roleName);
+    const active = store.getActiveRun(taskId, roleName);
     if (active !== null) {
         if (active.effective.agentId !== agentId) {
-            throw new Error(`Native Session registration does not match the effective Turn Agent: ${taskId}/${roleName}.`);
+            throw new Error(`Native Session registration does not match the effective AgentRun Agent: ${taskId}/${roleName}.`);
         }
         if (existing !== undefined) {
             if (!roleSessionMayContinue(existing.effective, active.effective)) {
-                throw new Error(`Native Session effective launch does not match the active Turn: ${taskId}/${roleName}.`);
+                throw new Error(`Native Session effective launch does not match the active AgentRun: ${taskId}/${roleName}.`);
             }
             return existing.effective;
         }
@@ -2740,7 +2679,7 @@ function taskSessionEffective(store, taskId, roleName, agentId, existing) {
     if (role === null)
         throw new Error(`Role not found: ${taskId}/${roleName}.`);
     const item = store.listWorkItems(taskId).find((candidate) => (candidate.assignee === roleName
-        && !["completed", "failed", "retired"].includes(candidate.status))) ?? null;
+        && !["accepted", "retired"].includes(candidate.status))) ?? null;
     const workspace = (item === null
         ? store.getTaskWorkspace(taskId)
         : store.getWorkItemWorkspace(taskId, item.id))
@@ -2765,7 +2704,6 @@ function mapSession(session) {
         agentId: session.agentId,
         adapterId: session.adapterId,
         nativeSessionId: session.nativeSessionId,
-        ...(session.runtimeGenerationId === undefined ? {} : { runtimeGenerationId: session.runtimeGenerationId }),
         ...(session.title === undefined ? {} : { title: session.title }),
         status: session.status,
         ...(session.endReason === undefined ? {} : { endReason: session.endReason }),
@@ -2773,14 +2711,13 @@ function mapSession(session) {
         updatedAt: session.updatedAt
     };
 }
-function saveTaskSession(store, role, session, status, now, runtimeGenerationId) {
+function saveTaskSession(store, role, session, status, now) {
     const current = store.getRoleSessionSet(role.taskId, role.name)
         ?? createRoleSessionSet({ scope: "task", taskId: role.taskId, roleName: role.name }, session.agentId, now);
     const updated = recordRoleAgentSession(current, {
         agentId: session.agentId,
         adapterId: session.adapterId,
         nativeSessionId: session.nativeSessionId,
-        ...(runtimeGenerationId === undefined ? {} : { runtimeGenerationId }),
         ...(session.title === undefined ? {} : { title: session.title }),
         policy: "fixed",
         status,
@@ -2794,11 +2731,7 @@ function saveTaskSession(store, role, session, status, now, runtimeGenerationId)
 function matchesStallSessionFence(current, expected) {
     if (current === null || expected === null)
         return current === expected;
-    return current.agentId === expected.agentId
-        && current.adapterId === expected.adapterId
-        && current.nativeSessionId === expected.nativeSessionId
-        && current.runtimeGenerationId === expected.runtimeGenerationId
-        && current.status === expected.status;
+    return current.agentId === expected.agentId && current.adapterId === expected.adapterId && current.nativeSessionId === expected.nativeSessionId && current.status === expected.status;
 }
 function requireRole(store, taskId, roleName) {
     const role = store.getRole(taskId, roleName);
@@ -2806,17 +2739,18 @@ function requireRole(store, taskId, roleName) {
         throw new Error(`Role not found: ${taskId}/${roleName}.`);
     return role;
 }
-function turnLaunchEventPayload(turn) {
+function runLaunchEventPayload(run) {
     return {
-        turnId: turn.id,
-        role: turn.roleName,
-        purpose: turn.purpose,
-        mode: turn.mode,
-        agent: `${turn.effective.agentId}/${turn.effective.adapterId}`,
-        effectiveRevision: String(turn.effective.sourceDesiredRevision),
-        profileAccess: turn.effective.profileAccess,
-        effectivePermission: turn.effective.permission.strategy,
-        writeProjectIds: turn.effective.writeProjectIds.join(",") || "none"
+        runId: run.id,
+        role: run.roleName,
+        purpose: run.purpose,
+        mode: run.mode,
+        agent: `${run.effective.agentId}/${run.effective.adapterId}`,
+        component: run.effective.component,
+        effectiveRevision: String(run.effective.sourceDesiredRevision),
+        profileAccess: run.effective.profileAccess,
+        effectivePermission: run.effective.permission.strategy,
+        writeProjectIds: run.effective.writeProjectIds.join(",") || "none"
     };
 }
 /**
@@ -2831,8 +2765,7 @@ function runtimeObservationTelemetryEntry(input) {
     return {
         taskId: input.fence.taskId,
         roleName: input.fence.roleName,
-        turnId: input.fence.turnId,
-        generation: input.fence.runtimeGenerationId,
+        runId: input.fence.runId,
         progressId: [
             input.kind,
             input.payload.operationId ?? input.payload.activity ?? "state"
@@ -2843,7 +2776,6 @@ function runtimeObservationTelemetryEntry(input) {
             kind: input.kind,
             authority: input.authority,
             driverId: input.fence.driverId,
-            runtimeGenerationId: input.fence.runtimeGenerationId,
             nativeSessionId: input.fence.nativeSessionId ?? "",
             nativeTurnId: input.fence.nativeTurnId ?? "",
             ...(input.payload.operation === undefined
@@ -2870,7 +2802,7 @@ function compactedRuntimeObservationIds(events, incoming) {
         const observation = runtimeObservationFromTaskEvent(event);
         const matches = incoming.kind.startsWith("operation.")
             ? observation !== null
-                && runtimeObservationTurnFenceMatches(observation.fence, incoming.fence)
+                && runtimeObservationRunFenceMatches(observation.fence, incoming.fence)
             : observation !== null
                 && runtimeObservationFenceMatches(observation.fence, incoming.fence);
         return observation !== null
@@ -2922,18 +2854,18 @@ function compactedRuntimeObservationIds(events, incoming) {
 function recordStructuredProviderAcceptance(sessions, input, now) {
     const current = sessions.providerBinding;
     const attemptId = input.fence.receiptId;
-    const turnId = input.fence.nativeTurnId;
+    const runId = input.fence.nativeTurnId;
     if (current === null || attemptId === undefined)
         return sessions;
-    if (current.turn === null
-        || current.turn.turnId !== input.fence.turnId)
+    if (current.run === null
+        || current.run.runId !== input.fence.runId)
         return sessions;
-    if (current.turn.attemptId === attemptId
-        && ["accepted", "completed", "failed", "cancelled"].includes(current.turn.status))
+    if (current.run.attemptId === attemptId
+        && ["accepted", "completed", "failed", "cancelled"].includes(current.run.status))
         return sessions;
     const binding = acceptProviderTurn(current, {
         attemptId,
-        nativeTurnId: turnId,
+        nativeTurnId: runId,
         acceptedAt: input.observedAt ?? input.receivedAt
     });
     return updateTaskRoleProviderRuntime(sessions, binding, now);
@@ -2948,18 +2880,16 @@ function resolveTerminalExecution(store, input) {
     const sessions = store.getTaskRoleSessionSet(input.taskId, input.roleName);
     const session = sessions?.sessions[input.agentId];
     const binding = sessions?.providerBinding;
-    const pending = binding?.turn;
+    const pending = binding?.run;
     const evidence = store.listEvents(input.taskId).map(runtimeObservationFromTaskEvent)
         .filter((event) => event !== null
-        && (event.kind === "turn.accepted" || isTurnTerminalObservation(event)));
+        && (event.kind === "turn.accepted" || isRunTerminalObservation(event)));
     if (input.attemptId !== undefined && evidence.some((event) => (event.fence.roleName === input.roleName
         && event.fence.agentId === input.agentId
         && event.fence.nativeSessionId === input.nativeSessionId
         && event.fence.receiptId === input.attemptId
-        && (event.fence.runtimeGenerationId !== input.runtimeGenerationId
-            && input.runtimeGenerationId !== undefined
-            || input.nativeTurnId !== undefined && event.fence.nativeTurnId !== undefined
-                && event.fence.nativeTurnId !== input.nativeTurnId))))
+        && input.nativeTurnId !== undefined && event.fence.nativeTurnId !== undefined
+        && event.fence.nativeTurnId !== input.nativeTurnId)))
         return null;
     const identityMatches = (attemptId, nativeTurnId) => ((input.attemptId === undefined
         ? input.nativeTurnId !== undefined && input.nativeTurnId === nativeTurnId
@@ -2969,75 +2899,67 @@ function resolveTerminalExecution(store, input) {
     if (binding !== null && binding !== undefined && pending !== null && pending !== undefined
         && session?.adapterId === input.adapterId
         && session.nativeSessionId === input.nativeSessionId
-        && (input.runtimeGenerationId === undefined
-            || (pending.activationId ?? session.runtimeGenerationId) === input.runtimeGenerationId)
         && currentProviderConversation(binding).conversationId === input.nativeSessionId
         && identityMatches(pending.attemptId, pending.nativeTurnId)
-        && (input.turnId === undefined || input.turnId === pending.turnId)
-        && pending.status !== "rejected") {
-        const activation = binding.activations.find((entry) => (entry.activationId === (input.runtimeGenerationId ?? pending.activationId ?? session.runtimeGenerationId)
-            && (input.activationId === undefined || entry.activationId === input.activationId)
-            && entry.conversationId === input.nativeSessionId));
-        const turn = pending.turnId === undefined ? null : store.getTurn(input.taskId, pending.turnId);
-        if (activation !== undefined && (pending.turnId === undefined || (turn !== null && turn.roleName === input.roleName
-            && turn.effective.agentId === input.agentId && turn.effective.adapterId === input.adapterId)))
+        && (input.runId === undefined || input.runId === pending.runId)
+        && pending.status !== "rejected" && pending.status !== "deferred") {
+        const run = pending.runId === undefined ? null : store.getRun(input.taskId, pending.runId);
+        if (pending.runId === undefined || (run !== null && run.roleName === input.roleName
+            && run.effective.agentId === input.agentId && run.effective.adapterId === input.adapterId))
             return {
-                turn, current: true, attemptId: pending.attemptId,
-                nativeTurnId: pending.nativeTurnId, activationId: activation.activationId
+                run, current: true, attemptId: pending.attemptId,
+                nativeTurnId: pending.nativeTurnId,
             };
     }
     // Old results use immutable acceptance/terminal evidence, not today's Role
-    // config, Session status, current generation or active Turn pointer.
+    // config, Session status or active AgentRun pointer.
     const matches = evidence.filter((event) => event.fence.roleName === input.roleName
         && event.fence.agentId === input.agentId
         && event.fence.nativeSessionId === input.nativeSessionId
-        && input.runtimeGenerationId !== undefined
-        && event.fence.runtimeGenerationId === input.runtimeGenerationId
-        && (input.activationId === undefined
-            || (event.fence.activationId ?? event.fence.runtimeGenerationId) === input.activationId)
         && identityMatches(event.fence.receiptId, event.fence.nativeTurnId)
-        && event.fence.turnId !== undefined
-        && (input.turnId === undefined || event.fence.turnId === input.turnId));
+        && (input.runId === undefined || event.fence.runId === input.runId));
     const accepted = matches[0];
     if (accepted === undefined || accepted.fence.receiptId === undefined)
         return null;
-    if (matches.some((event) => event.fence.turnId !== accepted.fence.turnId
+    if (matches.some((event) => event.fence.runId !== accepted.fence.runId
         || event.fence.receiptId !== accepted.fence.receiptId)) {
         throw new Error("Runtime terminal has conflicting durable execution bindings.");
     }
-    const turn = store.getTurn(input.taskId, accepted.fence.turnId);
-    if (turn === null || turn.effective.adapterId !== input.adapterId
-        || turn.effective.agentId !== input.agentId || turn.roleName !== input.roleName)
+    if (accepted.fence.runId === undefined) {
+        return { run: null, current: false, attemptId: accepted.fence.receiptId,
+            nativeTurnId: accepted.fence.nativeTurnId };
+    }
+    const run = store.getRun(input.taskId, accepted.fence.runId);
+    if (run === null || run.effective.adapterId !== input.adapterId
+        || run.effective.agentId !== input.agentId || run.roleName !== input.roleName)
         return null;
     return {
-        turn, current: false, attemptId: accepted.fence.receiptId,
+        run, current: false, attemptId: accepted.fence.receiptId,
         nativeTurnId: accepted.fence.nativeTurnId,
-        activationId: accepted.fence.activationId ?? accepted.fence.runtimeGenerationId
     };
 }
-function isTurnTerminalObservation(input) {
+function isRunTerminalObservation(input) {
     return ["turn.completed", "turn.failed", "turn.cancelled"].includes(input.kind);
 }
-function assertConsistentTerminal(store, input, turn) {
+function assertConsistentTerminal(store, input, run) {
     const previous = store.listEvents(input.taskId).map(runtimeObservationFromTaskEvent)
         .filter((event) => event !== null
-        && isTurnTerminalObservation(event)
+        && isRunTerminalObservation(event)
         && event.fence.roleName === input.roleName
         && event.fence.agentId === input.agentId
         && event.fence.nativeSessionId === input.nativeSessionId
-        && event.fence.runtimeGenerationId === input.runtimeGenerationId
         && (input.attemptId === undefined
             ? input.nativeTurnId !== undefined && event.fence.nativeTurnId === input.nativeTurnId
             : event.fence.receiptId === input.attemptId));
     if (input.observation !== undefined && previous.some((event) => (event.kind !== input.observation.kind
         || !isDeepStrictEqual(event.payload, input.observation.payload)
-        || event.fence.turnId !== input.observation.fence.turnId)))
+        || event.fence.runId !== input.observation.fence.runId)))
         throw new Error("Conflicting terminal content for the same execution.");
-    if (turn?.result?.provider !== undefined) {
-        if (turn.result.provider.status !== input.providerStatus
-            || (input.outcome.status === "completed" && turn.result.output !== input.outcome.output)
+    if (run?.result?.provider !== undefined) {
+        if (run.result.provider.status !== input.providerStatus
+            || (input.outcome.status === "completed" && run.result.output !== input.outcome.output)
             || (previous.length === 0 && input.outcome.status === "failed"
-                && turn.result.diagnostic !== input.outcome.diagnostic)) {
+                && run.result.diagnostic !== input.outcome.diagnostic)) {
             throw new Error("Conflicting result for the same execution.");
         }
     }
@@ -3051,49 +2973,30 @@ function terminalSessionReplacementBasis(sessions, input, run) {
         || session === undefined
         || incomingConversationId === undefined
         || currentProviderConversation(binding).conversationId === incomingConversationId
-        || currentProviderActivation(binding) !== null
-        || binding.authority.owner !== "none") {
+        || session.status !== "ended") {
         return undefined;
     }
-    // Pre-start persistence may already have replaced the terminal Role Session
-    // before Provider readiness arrives. A matching new Session plus the
-    // quiescent old Provider binding preserves the same terminal-session proof.
-    return session.status === "ended"
-        || session.nativeSessionId === input.fence.nativeSessionId
-        ? "terminal-session"
-        : undefined;
+    return "terminal-session";
 }
 function bindOrSupersedeProviderRuntime(sessions, input, now, replacementBasis) {
     const conversationId = input.fence.conversationId ?? input.fence.nativeSessionId;
-    const activationId = input.fence.activationId ?? input.fence.runtimeGenerationId;
     if (sessions.providerBinding === null) {
         return bindTaskRoleProviderRuntime(sessions, createProviderRuntimeBinding({
             providerNamespace: input.fence.driverId,
             accountScope: input.fence.agentId,
             conversationId,
-            activationId,
             startedAt: input.observedAt ?? input.receivedAt
         }), now);
     }
     const current = currentProviderConversation(sessions.providerBinding);
     if (current.conversationId === conversationId) {
-        const active = currentProviderActivation(sessions.providerBinding);
-        if (active?.activationId === activationId)
-            return sessions;
-        if (active !== null) {
-            throw new Error("Provider Conversation cannot start a second Activation while the current one is active.");
-        }
-        return updateTaskRoleProviderRuntime(sessions, startProviderActivation(sessions.providerBinding, {
-            activationId,
-            startedAt: input.observedAt ?? input.receivedAt
-        }), now);
+        return sessions;
     }
     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,
         basis: replacementBasis
     }), now);
@@ -3106,28 +3009,25 @@ function terminalProviderReplacementBasis(sessions, input, mode) {
         return undefined;
     }
     const current = sessions.sessions[input.fence.agentId];
-    if (current === undefined
-        || current.status !== "active"
-        || current.nativeSessionId !== input.fence.nativeSessionId
-        || current.runtimeGenerationId !== input.fence.runtimeGenerationId) {
+    if (current === undefined || current.status !== "active" || current.nativeSessionId !== input.fence.nativeSessionId) {
         return undefined;
     }
     const replaced = [...(sessions.history ?? [])].reverse().find((session) => (session.agentId === current.agentId
         && session.adapterId === current.adapterId
         && session.status === "ended"
-        && session.nativeSessionId !== current.nativeSessionId));
+        && session.nativeSessionId === currentProviderConversation(sessions.providerBinding).conversationId));
     return replaced === undefined ? undefined : "terminal-session";
 }
-function settleStructuredProviderTurn(sessions, turnId, status, now, attemptId) {
+function settleStructuredProviderTurn(sessions, runId, status, now, attemptId) {
     const binding = sessions.providerBinding;
-    if (binding === null || binding.turn === null
-        || (attemptId === undefined ? binding.turn.nativeTurnId !== turnId : binding.turn.attemptId !== attemptId)) {
+    if (binding === null || binding.run === null
+        || (attemptId === undefined ? binding.run.nativeTurnId !== runId : binding.run.attemptId !== attemptId)) {
         return sessions;
     }
-    if (["completed", "failed", "cancelled"].includes(binding.turn.status))
+    if (["completed", "failed", "cancelled"].includes(binding.run.status))
         return sessions;
     return updateTaskRoleProviderRuntime(sessions, settleProviderTurn(binding, {
-        nativeTurnId: turnId,
+        nativeTurnId: runId,
         ...(attemptId === undefined ? {} : { attemptId }),
         status,
         settledAt: now.toISOString()