@zq-silk/yui 0.13.8 → 0.13.9

package/dist/controller/fileSchedulerStoreAdapter.js

@@ -1,8 +1,7 @@
 import { createHash } from "node:crypto";
 import { isDeepStrictEqual } from "node:util";
-import { activeLiveRoleAgentSession, bindTaskRoleProviderRuntime, bindTaskRoleRun, clearTaskRoleRun, createRoleSessionSet, markTaskRoleRunDelivered, markTaskRoleRunPushed, prepareTaskRoleRunRedispatch, recordRoleAgentSession, replaceTaskRoleAgentSession, recordTaskRoleTurnBoundary, rememberRoleAgentCompletedTurn, stopTaskRoleRuntimeAfterPhysicalExit, updateRoleAgentSessionStatus, updateTaskRoleProviderRuntime } from "../executor/agentExecutor.js";
+import { activeLiveRoleAgentSession, bindTaskRoleProviderRuntime, bindTaskRoleRun, clearTaskRoleRun, createRoleSessionSet, markTaskRoleRunDelivered, markTaskRoleRunPushed, recordRoleAgentSession, replaceTaskRoleAgentSession, recordTaskRoleTurnBoundary, rememberRoleAgentCompletedTurn, detachRoleAgentSessionHost, updateRoleAgentSessionStatus, updateTaskRoleProviderRuntime } from "../executor/agentExecutor.js";
 import { acceptProviderTurn, beginProviderTurn, createProviderRuntimeBinding, endProviderActivation, currentProviderActivation, currentProviderConversation, markProviderTurnDeliveryUnknown, rejectProviderTurn, settleProviderTurnSubmission, settleProviderTurn, startProviderActivation, supersedeProviderConversation, updateProviderConversationRecoverability } from "../runtime/providerRuntimeIdentity.js";
-import { decideProviderRecovery } from "../runtime/providerRecoveryDecision.js";
 import { hasRecentTurnId } from "../executor/turnCompletion.js";
 import { createTaskEvent } from "../event/taskEvent.js";
 import { operationalTaskRecords } from "../task/taskRecordRetirement.js";
@@ -12,11 +11,8 @@ import { answerInputRequest } from "../input/inputRequest.js";
 import { activeRoleAgentBinding } from "../role/role.js";
 import { effectiveLaunchWithTaskMainWorkspace, effectiveLaunchSnapshotsCompatible, effectiveLaunchSnapshotsCompatibleForTaskSession, resolveEffectiveLaunch, validateEffectiveLaunchSnapshot } from "../executor/effectiveLaunch.js";
 import { SYSTEM_OPERATOR_ROLE } from "../role/systemRoles.js";
-import { failAgentRun, markAgentRunDelivered, markAgentRunPushed, reopenRunForProviderRetry, clearProviderRetryOnProgress, agentRunDeliveryReceiptId, withProviderRetry } from "../run/agentRun.js";
+import { markAgentRunDelivered, markAgentRunPushed, agentRunDeliveryReceiptId } from "../run/agentRun.js";
 import { markWorkflowOutcomeRequestDispatched } from "../run/runControlRequest.js";
-import { classifyProviderError, isRetryableProviderErrorClass } from "../lifecycle/providerErrorClass.js";
-import { deferProviderRetry, markProviderRetryDispatched, providerRetryIsDue, scheduleProviderRetry } from "../run/providerRetry.js";
-import { providerRetryAdapterEnabled, providerRetryConfig } from "../run/providerRetryConfig.js";
 import { classifyRuntimeProcessExit, validateRuntimeProcessExitObservation } from "../runtime/processExitObservation.js";
 import { terminalizeExactTaskRun } from "../lifecycle/exactRunTerminalization.js";
 import { createCanonicalLifecycleEvent, foldCanonicalLifecycleEvent } from "../lifecycle/canonicalLifecycleEvent.js";
@@ -28,15 +24,14 @@ import { wakeReason } from "../scheduler/wakeReason.js";
 import { foldRunProgressFacts, latestRunDurableProgressAt, latestRunEventTime, latestStallEvidenceKey, isRoleRunStalled, RUN_PROGRESS_EVENT, RUN_DIAGNOSTIC_FINISHED_EVENT, RUN_RECOVERED_EVENT, RUN_STALLED_EVENT } from "../scheduler/roleRunStall.js";
 import { projectProviderContinuations } from "../runtime/runtimeContinuationProjection.js";
 import { providerContinuationKey } from "../runtime/providerContinuation.js";
-import { currentWorkItemExecutionGroup, updateWorkItemExecutionGroup } from "../workItem/workItem.js";
-import { recordExecutionLaneResult } from "../execution/executionGroup.js";
-import { formatAgentRunReceiptId, formatTaskRecordReference } from "../task/taskRecordReference.js";
+import { formatAgentRunReceiptId } from "../task/taskRecordReference.js";
 import { bindExecution, claimPending, claimInputDelivery as claimMailboxInputDelivery, completeInputDelivery as completeMailboxInputDelivery, completeProcessing, mailboxHasPending, mailboxHasWork, pendingLane, markInputDeliveryPushed as markMailboxInputDeliveryPushed, markInputDeliveryUnknown as markMailboxInputDeliveryUnknown, releaseInputDelivery as releaseMailboxInputDelivery, resolveInputDeliveryNotAccepted as resolveMailboxInputDeliveryNotAccepted, releaseProcessing } from "../coordination/workMailbox.js";
 import { enqueueWork } from "../coordination/workMailboxQueue.js";
-import { RUNTIME_CLEANUP_REQUIRED_REASON, RUNTIME_LAUNCH_RESERVED_REASON, RUNTIME_LIFECYCLE_OWNER, RuntimeLifecycleBusyError, hasRuntimeCleanupObligation, hasRuntimeLifecycleWork, isRuntimeLaunchReservation, runtimeLifecycleTarget } from "../runtime/lifecycleReservation.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 { builtinAgentDriverRegistry } from "../runtime/builtinAgentDrivers.js";
-import { RUNTIME_OBSERVATION_TASK_EVENT, createRuntimeObservation, isRuntimeTokenEvidence, runtimeObservationFenceMatches, runtimeObservationFromTaskEvent, runtimeObservationRunFenceMatches, runtimeObservationTaskEventPayload, runHasActiveRuntimeOperations } from "../runtime/runtimeObservation.js";
+import { standardAgentError } from "../runtime/agentError.js";
+import { RUNTIME_OBSERVATION_TASK_EVENT, createRuntimeObservation, isRuntimeTokenEvidence, runtimeObservationFenceMatches, runtimeObservationFromTaskEvent, runtimeObservationRunFenceMatches, runtimeObservationTaskEventPayload } from "../runtime/runtimeObservation.js";
 import { projectRuntimeTaskEvents } from "../runtime/runtimeProjection.js";
 import { contextSnapshotRef } from "../context/contextSnapshot.js";
 import { contextSnapshotDeltaRefIds, freezeRunContextSnapshot } from "../context/runContextPack.js";
@@ -126,51 +121,10 @@ export class FileSchedulerStoreAdapter {
             }
             case "turn.failed": {
                 const failureEvidence = input.payload.failure;
-                if (failureEvidence.runTerminal !== true) {
-                    outcome = this.foldProviderTurnBoundary(input, adapterId, "failed", input.payload.summary ?? `Provider Turn failed: ${failureEvidence.code}.`, now);
-                    break;
-                }
-                const active = this.store.getActiveAgentRun(taskId, input.fence.roleName);
-                const recordedTurn = this.store.getTaskRoleSessionSet(taskId, input.fence.roleName)?.providerBinding?.turn;
-                if (input.fence.runId !== undefined
-                    && active?.id !== input.fence.runId
-                    && recordedTurn !== null
-                    && recordedTurn !== undefined
-                    && recordedTurn.runId === input.fence.runId
-                    && recordedTurn.turnId === input.fence.nativeTurnId) {
-                    outcome = this.foldProviderTurnBoundary(input, adapterId, "failed", input.payload.summary ?? `Provider Turn failed: ${failureEvidence.code}.`, now);
-                    break;
-                }
-                const failure = {
-                    eventId: input.eventId,
-                    eventType: input.kind,
-                    taskId,
-                    roleName: input.fence.roleName,
-                    agentId: input.fence.agentId,
-                    adapterId,
-                    launchId: input.fence.launchId,
-                    nativeSessionId: input.fence.nativeSessionId,
-                    nativeTurnId: input.fence.nativeTurnId,
-                    runId: input.fence.runId,
-                    ...(failureEvidence.errorCode === undefined
-                        ? {}
-                        : { errorCode: failureEvidence.errorCode }),
-                    error: failureEvidence.code,
-                    ...(failureEvidence.details === undefined
-                        ? {}
-                        : { errorDetails: failureEvidence.details }),
-                    ...(failureEvidence.lastOutput === undefined
-                        ? {}
-                        : { lastAssistantMessage: failureEvidence.lastOutput }),
-                    ...(failureEvidence.retryAfterMs === undefined
-                        ? {}
-                        : { retryAfterMs: failureEvidence.retryAfterMs })
-                };
-                if (this.classifyRuntimeTurnFailed(failure) !== "apply")
-                    return "obsolete";
-                outcome = this.observeRuntimeTurnFailed(failure, now).disposition === "applied"
-                    ? "applied"
-                    : "obsolete";
+                // A Provider Turn is an activation boundary, not a Yui Run outcome.
+                // Keep the Run and Session identity available for Agent-directed
+                // restore + submit, even when a provider marks its Turn terminal.
+                outcome = this.foldProviderTurnBoundary(input, adapterId, "failed", input.payload.summary ?? `Agent Turn failed: ${failureEvidence.error.message}`, now);
                 break;
             }
             case "operation.started":
@@ -206,12 +160,6 @@ export class FileSchedulerStoreAdapter {
             default:
                 outcome = "obsolete";
         }
-        if (outcome === "applied"
-            && input.kind === "activity.observed"
-            && input.payload.activityId !== undefined
-            && input.payload.usage === undefined) {
-            this.clearProviderRetryForProgress(input, "correlated-activity", now);
-        }
         if (outcome === "applied")
             this.persistRuntimeObservation(input, now);
         return outcome;
@@ -313,8 +261,8 @@ export class FileSchedulerStoreAdapter {
                 recordCanonicalObservationObsolete(store, input, "runtime-session-not-current", now);
                 return "obsolete";
             }
-            const status = input.kind === "session.failed" ? "broken" : "stopped";
-            let updatedSessions = updateRoleAgentSessionStatus(sessions, input.fence.agentId, status, now);
+            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.launchId;
                 updatedSessions = updateTaskRoleProviderRuntime(updatedSessions, endProviderActivation(updatedSessions.providerBinding, activationId, {
@@ -488,13 +436,52 @@ export class FileSchedulerStoreAdapter {
                     lane: "normal"
                 });
             }
-            if (input.kind === "turn.failed" && input.payload.failure?.runTerminal !== true) {
-                enqueueWork(store, { kind: "role", taskId, roleName: "leader" }, "provider-turn-failed", now, [{ type: "event", taskId, id: observationEventId }], {
+            if (input.kind === "turn.failed" && input.payload.failure !== undefined) {
+                const failure = input.payload.failure;
+                const error = failure.error;
+                const run = input.fence.runId === undefined
+                    ? null
+                    : store.getAgentRun(taskId, input.fence.runId);
+                const errorEvent = createTaskEvent(store.nextEventId(taskId), taskId, "runtime.agent-error", {
+                    sourceEventId: input.eventId,
+                    observationEventId,
+                    runId: input.fence.runId ?? "",
+                    roleName: input.fence.roleName,
+                    agentId: input.fence.agentId,
+                    adapterId: run?.effective.adapterId ?? "unknown",
+                    driverId: input.fence.driverId,
+                    launchId: input.fence.launchId,
+                    nativeSessionId: input.fence.nativeSessionId ?? "",
+                    nativeTurnId: input.fence.nativeTurnId ?? "",
+                    source: error.source,
+                    phase: error.phase,
+                    category: error.category,
+                    code: error.code,
+                    message: error.message,
+                    raw: error.raw,
+                    inputDisposition: error.inputDisposition,
+                    sessionDisposition: error.sessionDisposition,
+                    ...(error.retryAfterMs === undefined
+                        ? {}
+                        : { retryAfterMs: String(error.retryAfterMs) }),
+                    ...(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: input.semanticKey,
+                    dedupeKey: `agent-error:${taskId}:${input.eventId}`,
                     deliveryMode: "followup",
                     lane: "normal"
                 });
+                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}`,
+                        deliveryMode: "followup",
+                        lane: "normal"
+                    });
+                }
             }
             if ((input.kind === "operation.completed" || input.kind === "operation.failed")
                 && input.payload.operation === "subagent") {
@@ -503,7 +490,7 @@ export class FileSchedulerStoreAdapter {
                 // A live provider Session owns delivery of its native child result.
                 // Route a Yui wake only when that parent is gone and another observer
                 // supplied the child's terminal fact.
-                if (role !== null && (session?.status === "stopped" || session?.status === "broken")) {
+                if (role !== null && session?.status === "ended") {
                     routeRoleEvent(store, observationEvent, role.name, "detached-native-subagent-terminal", now);
                 }
             }
@@ -626,7 +613,7 @@ export class FileSchedulerStoreAdapter {
             return null;
         const sessions = this.store.getGlobalRoleSessionSet(SYSTEM_OPERATOR_ROLE);
         const effectiveSession = sessions?.sessions[sessions.activeAgentId];
-        if (effectiveSession?.status !== "ready")
+        if (effectiveSession?.status !== "active")
             return null;
         return {
             roleName: SYSTEM_OPERATOR_ROLE,
@@ -634,15 +621,7 @@ export class FileSchedulerStoreAdapter {
         };
     }
     markOperatorTurnStarted(now) {
-        this.store.transaction((store) => {
-            const sessions = store.getGlobalRoleSessionSet(SYSTEM_OPERATOR_ROLE);
-            if (sessions === null)
-                return;
-            const active = sessions.sessions[sessions.activeAgentId];
-            if (active === undefined || active.status !== "ready")
-                return;
-            store.saveGlobalRoleSessionSet(updateRoleAgentSessionStatus(sessions, sessions.activeAgentId, "running", now));
-        });
+        void now;
     }
     resolveExpiredInputRecommendations(now, taskIds) {
         return this.store.transaction((store) => {
@@ -888,6 +867,53 @@ export class FileSchedulerStoreAdapter {
                 resolvedAt: input.now.toISOString()
             });
             store.saveTaskRoleSessionSet(updateTaskRoleProviderRuntime(sessions, updated, input.now));
+            const run = store.getAgentRun(input.taskId, input.runId);
+            const session = sessions.sessions[sessions.activeAgentId];
+            const driver = run === null
+                ? null
+                : this.drivers.findByAdapterId(run.effective.adapterId);
+            const error = standardAgentError({
+                source: "driver",
+                phase: "turn-submit",
+                classification: driver?.runtime.mapError({
+                    message: input.reason,
+                    raw: input.raw
+                }),
+                message: input.reason,
+                raw: input.raw,
+                inputDisposition: input.status === "rejected" ? "not-accepted" : "unknown"
+            });
+            const errorEvent = createTaskEvent(store.nextEventId(input.taskId), input.taskId, "runtime.agent-error", {
+                sourceEventId: input.attemptId,
+                runId: input.runId,
+                roleName: input.roleName,
+                agentId: run?.effective.agentId ?? sessions.activeAgentId,
+                adapterId: run?.effective.adapterId ?? session?.adapterId ?? "unknown",
+                driverId: driver?.id ?? "unknown",
+                launchId: session?.launchId ?? "",
+                nativeSessionId: session?.nativeSessionId ?? "",
+                nativeTurnId: "",
+                source: error.source,
+                phase: error.phase,
+                category: error.category,
+                code: error.code,
+                message: error.message,
+                raw: error.raw,
+                inputDisposition: error.inputDisposition,
+                sessionDisposition: error.sessionDisposition
+            }, input.now);
+            store.saveEvent(input.taskId, errorEvent);
+            const route = input.roleName === "leader"
+                ? { kind: "operator" }
+                : { kind: "role", taskId: input.taskId, roleName: "leader" };
+            enqueueWork(store, route, input.roleName === "leader"
+                ? "leader-turn-submission-error"
+                : wakeReason("agent-error", errorEvent.id), input.now, [{ type: "event", taskId: input.taskId, id: errorEvent.id }], {
+                source: driver?.id ?? "agent-host",
+                dedupeKey: `agent-error:${input.taskId}:${input.attemptId}`,
+                deliveryMode: "followup",
+                lane: "normal"
+            });
         });
     }
     getProviderAuthorityFence(input) {
@@ -924,6 +950,80 @@ export class FileSchedulerStoreAdapter {
     enqueueLeaderWakeup(taskId, reason, now) {
         return this.store.transaction((store) => (queueLeaderWakeup(store, taskId, reason, now)));
     }
+    recordAgentError(input, now) {
+        return this.store.transaction((store) => {
+            const duplicate = [...store.listEvents(input.taskId)].reverse().find((event) => (event.type === "runtime.agent-error"
+                && event.payload.runId === input.runId
+                && event.payload.phase === input.phase
+                && event.payload.raw === input.raw));
+            if (duplicate !== undefined)
+                return duplicate.id;
+            const run = store.getAgentRun(input.taskId, input.runId);
+            const sessionSet = store.getTaskRoleSessionSet(input.taskId, input.roleName);
+            const sessionAgentId = run?.effective.agentId ?? sessionSet?.activeAgentId;
+            const session = sessionAgentId === undefined
+                ? undefined
+                : sessionSet?.sessions[sessionAgentId];
+            const driver = run === null
+                ? null
+                : this.drivers.findByAdapterId(run.effective.adapterId);
+            const error = standardAgentError({
+                source: input.source,
+                phase: input.phase,
+                classification: driver?.runtime.mapError({
+                    message: input.message,
+                    raw: input.raw
+                }),
+                message: input.message,
+                raw: input.raw,
+                ...(input.inputDisposition === undefined
+                    ? {}
+                    : { inputDisposition: input.inputDisposition }),
+                ...(input.sessionDisposition === undefined
+                    ? {}
+                    : { sessionDisposition: input.sessionDisposition })
+            });
+            const event = createTaskEvent(store.nextEventId(input.taskId), input.taskId, "runtime.agent-error", {
+                sourceEventId: `${input.runId}:${input.phase}`,
+                runId: input.runId,
+                roleName: input.roleName,
+                agentId: run?.effective.agentId ?? session?.agentId ?? "unknown",
+                adapterId: run?.effective.adapterId ?? session?.adapterId ?? "unknown",
+                driverId: driver?.id ?? "unknown",
+                launchId: session?.launchId ?? "",
+                nativeSessionId: session?.nativeSessionId ?? "",
+                nativeTurnId: "",
+                source: error.source,
+                phase: error.phase,
+                category: error.category,
+                code: error.code,
+                message: error.message,
+                raw: error.raw,
+                inputDisposition: error.inputDisposition,
+                sessionDisposition: error.sessionDisposition
+            }, now);
+            store.saveEvent(input.taskId, event);
+            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.runId}:${input.phase}:${event.id}`,
+                    deliveryMode: "followup",
+                    lane: "normal"
+                });
+            }
+            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.runId}:${event.id}`,
+                    deliveryMode: "followup",
+                    lane: "normal"
+                });
+            }
+            return event.id;
+        });
+    }
     /**
      * Records that a Leader wake was suppressed by scheduler single-flight
      * (the Role runtime lifecycle lane was busy). The wake stays durable and
@@ -1007,15 +1107,6 @@ export class FileSchedulerStoreAdapter {
             const pending = pendingLane(mailbox, input.lane);
             if (pending === null)
                 return { status: "empty" };
-            const claimed = claimMailboxInputDelivery(mailbox, {
-                attemptId: input.attemptId,
-                lane: input.lane,
-                mode: input.mode,
-                owner: input.owner,
-                startedAt: input.now.toISOString(),
-                executionRef: input.executionRef,
-                providerFence: input.providerFence
-            });
             if (input.target.kind === "role"
                 && input.executionRef.type === "run"
                 && input.executionRef.taskId === input.target.taskId) {
@@ -1026,6 +1117,11 @@ export class FileSchedulerStoreAdapter {
                     || binding.authority.owner !== "controller") {
                     throw new Error("Controller does not own the Provider writer authority.");
                 }
+                if (binding.turn !== null
+                    && ["submitting", "accepted", "running", "delivery-unknown"]
+                        .includes(binding.turn.status)) {
+                    return { status: "busy" };
+                }
                 const conversation = currentProviderConversation(binding);
                 const activation = currentProviderActivation(binding);
                 if (input.providerFence === undefined
@@ -1041,6 +1137,15 @@ export class FileSchedulerStoreAdapter {
                 });
                 store.saveTaskRoleSessionSet(updateTaskRoleProviderRuntime(sessions, next, input.now));
             }
+            const claimed = claimMailboxInputDelivery(mailbox, {
+                attemptId: input.attemptId,
+                lane: input.lane,
+                mode: input.mode,
+                owner: input.owner,
+                startedAt: input.now.toISOString(),
+                executionRef: input.executionRef,
+                providerFence: input.providerFence
+            });
             store.saveWorkMailbox(claimed);
             return { status: "claimed", delivery: claimed.inputDelivery };
         });
@@ -1144,19 +1249,20 @@ export class FileSchedulerStoreAdapter {
     completeRuntimeCleanup(target, now) {
         return this.store.transaction((store) => {
             let mailbox = store.getWorkMailbox(target);
-            if (mailbox === null || !hasRuntimeCleanupObligation(mailbox))
+            const disposition = runtimeCleanupDisposition(mailbox);
+            if (mailbox === null || disposition === null)
                 return false;
             if (mailbox.processing !== null) {
                 if (!isRuntimeLaunchReservation(mailbox.processing)
-                    && !mailbox.processing.batch.reasons.includes(RUNTIME_CLEANUP_REQUIRED_REASON)) {
+                    && !mailbox.processing.batch.reasons.every(isRuntimeCleanupReason)) {
                     return false;
                 }
                 mailbox = completeProcessing(mailbox, mailbox.processing.batchId);
             }
             const pending = pendingLane(mailbox, "normal");
             if (pending !== null) {
-                if (pending.reasons.length !== 1
-                    || pending.reasons[0] !== RUNTIME_CLEANUP_REQUIRED_REASON) {
+                if (pending.reasons.length === 0
+                    || !pending.reasons.every(isRuntimeCleanupReason)) {
                     return false;
                 }
                 const batchId = `runtime-cleanup-complete:${pending.fromSequence}-${pending.toSequence}`;
@@ -1167,7 +1273,12 @@ export class FileSchedulerStoreAdapter {
                 }), batchId);
             }
             const owner = runtimeOwnerFromTarget(target);
-            markRuntimeOwnerSessionStopped(store, owner, now);
+            if (disposition === "end-session") {
+                endRuntimeOwnerSession(store, owner, now);
+            }
+            else {
+                detachRuntimeOwnerHost(store, owner, now);
+            }
             saveRuntimeLifecycleMailbox(store, mailbox);
             return true;
         });
@@ -1178,7 +1289,7 @@ export class FileSchedulerStoreAdapter {
             if (!isRuntimeLaunchReservation(mailbox?.processing, batchId)) {
                 return false;
             }
-            markRuntimeOwnerSessionStopped(store, runtimeOwnerFromTarget(target), now);
+            endRuntimeOwnerSession(store, runtimeOwnerFromTarget(target), now);
             saveRuntimeLifecycleMailbox(store, completeProcessing(mailbox, batchId));
             return true;
         });
@@ -1203,14 +1314,22 @@ export class FileSchedulerStoreAdapter {
     listRuntimeSessionCandidates(query = {}) {
         return this.store.listRuntimeSessionCandidates(query);
     }
-    markRuntimeOwnerStopped(candidate, now) {
+    enqueueRuntimeCleanup(owner, now = new Date(), expectedDormantCandidate) {
         return this.store.transaction((store) => {
-            if (!dormantRuntimeCandidateIsCurrent(store, candidate))
-                return false;
-            return markRuntimeOwnerSessionStopped(store, candidate.owner, now);
+            if (expectedDormantCandidate !== undefined
+                && (!sameRuntimeOwner(owner, expectedDormantCandidate.owner)
+                    || !dormantRuntimeCandidateIsCurrent(store, expectedDormantCandidate))) {
+                return null;
+            }
+            if (owner.scope === "task" && store.getTask(owner.taskId) === null) {
+                return null;
+            }
+            const target = runtimeLifecycleTarget(owner);
+            enqueueWork(store, target, RUNTIME_CLEANUP_REQUIRED_REASON, now, owner.scope === "task" ? [{ type: "task", id: owner.taskId }] : []);
+            return target;
         });
     }
-    enqueueRuntimeCleanup(owner, now = new Date(), expectedDormantCandidate) {
+    enqueueRuntimeHostDetach(owner, now = new Date(), expectedDormantCandidate) {
         return this.store.transaction((store) => {
             if (expectedDormantCandidate !== undefined
                 && (!sameRuntimeOwner(owner, expectedDormantCandidate.owner)
@@ -1221,7 +1340,7 @@ export class FileSchedulerStoreAdapter {
                 return null;
             }
             const target = runtimeLifecycleTarget(owner);
-            enqueueWork(store, target, RUNTIME_CLEANUP_REQUIRED_REASON, now, owner.scope === "task" ? [{ type: "task", id: owner.taskId }] : []);
+            enqueueWork(store, target, RUNTIME_HOST_DETACH_REQUIRED_REASON, now, owner.scope === "task" ? [{ type: "task", id: owner.taskId }] : []);
             return target;
         });
     }
@@ -1309,7 +1428,7 @@ export class FileSchedulerStoreAdapter {
                 saveTaskSession(store, role, {
                     ...input.session,
                     nativeSessionId: input.session.nativeSessionId
-                }, "running", input.now);
+                }, "active", input.now);
             }
             store.clearLeaderFailure(input.task.id);
             return "claimed";
@@ -1327,17 +1446,6 @@ export class FileSchedulerStoreAdapter {
                 throw new Error(`Active Agent run changed before delivery was persisted: ${input.run.id}.`);
             }
             let deliveryRun = active;
-            if (active.providerRetry?.state === "dispatching") {
-                deliveryRun = withProviderRetry(active, markProviderRetryDispatched(active.providerRetry));
-                store.saveAgentRun(deliveryRun);
-                store.saveEvent(task.id, createTaskEvent(store.nextEventId(task.id), task.id, "runtime.provider-retry-dispatched", {
-                    runId: active.id,
-                    roleName: active.roleName,
-                    episodeId: active.providerRetry.episodeId,
-                    receiptId: active.providerRetry.lastRetryReceiptId ?? "",
-                    dispatchedRetries: String(active.providerRetry.dispatchedRetries + 1)
-                }, input.now));
-            }
             if (active.controlRequest?.state === "dispatching") {
                 deliveryRun = {
                     ...active,
@@ -1370,18 +1478,16 @@ export class FileSchedulerStoreAdapter {
             }
             if (input.session !== null && input.session.nativeSessionId !== undefined) {
                 const existing = store.getRoleSession(input.task.id, input.role.name);
-                const reservation = matchingPreparedRuntimeReservation(store, input);
                 if (existing?.agentId !== input.session.agentId
                     || existing.adapterId !== input.session.adapterId
                     || existing.nativeSessionId !== input.session.nativeSessionId
                     || (input.launchId !== undefined && existing.launchId !== input.launchId)
-                    || existing.status !== "running") {
+                    || existing.status !== "active") {
                     saveTaskSession(store, role, {
                         ...input.session,
                         nativeSessionId: input.session.nativeSessionId
-                    }, "running", input.now, input.launchId);
+                    }, "active", input.now, input.launchId);
                 }
-                completePreparedRuntimeReservation(store, reservation);
             }
         });
     }
@@ -1398,7 +1504,6 @@ export class FileSchedulerStoreAdapter {
             }
             if (input.session !== null && input.session.nativeSessionId !== undefined) {
                 const existing = store.getRoleSession(input.task.id, input.role.name);
-                matchingPreparedRuntimeReservation(store, input);
                 // A terminal Session is audit history, not the current execution
                 // identity. Preallocated providers must publish the replacement fence
                 // before the new Agent Host starts so its exact-runtime preflight sees
@@ -1406,16 +1511,15 @@ export class FileSchedulerStoreAdapter {
                 const defersConversationReplacement = active.mode === "new"
                     && existing !== null
                     && existing.nativeSessionId !== input.session.nativeSessionId
-                    && existing.status !== "stopped"
-                    && existing.status !== "broken";
+                    && existing.status === "active";
                 if (!defersConversationReplacement
                     && (existing?.nativeSessionId !== input.session.nativeSessionId
                         || (input.launchId !== undefined && existing.launchId !== input.launchId)
-                        || existing.status !== "running")) {
+                        || existing.status !== "active")) {
                     saveTaskSession(store, role, {
                         ...input.session,
                         nativeSessionId: input.session.nativeSessionId
-                    }, "running", input.now, input.launchId);
+                    }, "active", input.now, input.launchId);
                 }
             }
             bindTaskRoleRunInFlight(store, role, input.run, input.now);
@@ -1433,11 +1537,6 @@ export class FileSchedulerStoreAdapter {
                 taskId: input.taskId,
                 roleName: input.roleName
             });
-            const runtimeMailbox = store.getWorkMailbox(runtimeLifecycleTarget({
-                scope: "task",
-                taskId: input.taskId,
-                roleName: input.roleName
-            }));
             if (task === null
                 || task.status !== "active"
                 || task.executionGate.state !== "enabled"
@@ -1452,12 +1551,11 @@ export class FileSchedulerStoreAdapter {
                 || mailbox.processing.executionRef?.type !== "run"
                 || mailbox.processing.executionRef.taskId !== input.taskId
                 || mailbox.processing.executionRef.id !== input.runId
-                || !preparedDeliveryFailureSessionFenceMatches(sessions, session, input, agentRunDeliveryReceiptId(active))
-                || !preparedReservationMatches(runtimeMailbox, input.taskId, input.runId, input.launchId)) {
+                || !preparedDeliveryFailureSessionFenceMatches(sessions, session, input, agentRunDeliveryReceiptId(active))) {
                 return "state-changed";
             }
             const summary = input.summary
-                ?? `Role delivery retry limit exhausted before exact Run input delivery: ${input.runId}.`;
+                ?? `Role delivery failed conclusively before exact Run input acceptance: ${input.runId}.`;
             const result = terminalizeExactTaskRun(store, {
                 taskId: input.taskId,
                 roleName: input.roleName,
@@ -1478,7 +1576,7 @@ export class FileSchedulerStoreAdapter {
                     scope: "task",
                     taskId: input.taskId,
                     roleName: input.roleName
-                }), RUNTIME_CLEANUP_REQUIRED_REASON, input.now, [{ type: "task", id: input.taskId }]);
+                }), RUNTIME_HOST_DETACH_REQUIRED_REASON, input.now, [{ type: "task", id: input.taskId }]);
             }
             const terminal = result.run;
             const deliveryFailureEvent = createTaskEvent(store.nextEventId(input.taskId), input.taskId, "runtime.role-delivery-failed", {
@@ -1492,160 +1590,7 @@ export class FileSchedulerStoreAdapter {
             }
             else {
                 store.saveLeaderFailure(recordLeaderFailure(input.taskId, session?.nativeSessionId ?? "(unregistered)", summary, input.now, store.getLeaderFailure(input.taskId)));
-                routeRoleEvent(store, deliveryFailureEvent, input.roleName, "leader-run-failed", input.now);
-            }
-            return "failed";
-        });
-    }
-    saveLeaderDispatchFailure(input) {
-        return this.store.transaction((store) => {
-            const task = store.getTask(input.task.id);
-            const role = store.getRole(input.task.id, input.role.name);
-            const active = store.getActiveAgentRun(input.task.id, input.role.name);
-            const target = {
-                kind: "role",
-                taskId: input.task.id,
-                roleName: input.role.name
-            };
-            const mailbox = store.getWorkMailbox(target);
-            if (task === null
-                || task.status !== "active"
-                || task.executionGate.state !== "enabled"
-                || role === null
-                || active === null
-                || active.id !== input.claimed.run.id
-                || active.status !== "active"
-                || mailbox?.processing?.executionRef?.type !== "run"
-                || mailbox.processing.executionRef.taskId !== input.task.id
-                || mailbox.processing.executionRef.id !== input.claimed.run.id
-                || !schedulerRoleSessionsMatch(store.getRoleSession(input.task.id, input.role.name), input.session)) {
-                return "state-changed";
-            }
-            store.saveAgentRun(failAgentRun(active, input.failure.message, input.now));
-            store.clearActiveAgentRun(input.task.id, input.role.name);
-            clearTaskRoleRunInFlight(store, role, active, input.now);
-            // Consume this failed delivery attempt. Releasing it would immediately
-            // redispatch the same wake and manufacture another Leader Session.
-            store.saveWorkMailbox(completeProcessing(mailbox, mailbox.processing.batchId));
-            breakTaskSessionIfPresent(store, input.task.id, role.name, active.effective.agentId, input.now);
-            const failure = recordLeaderFailure(input.task.id, input.failure.nativeSessionId, input.failure.message, input.now, store.getLeaderFailure(input.task.id));
-            store.saveLeaderFailure(failure);
-            recordLeaderAttentionRequired(store, {
-                taskId: input.task.id,
-                reason: "leader-recovery-failed",
-                payload: {
-                    message: input.failure.message,
-                    runId: active.id
-                },
-                now: input.now
-            });
-            return "failed";
-        });
-    }
-    saveExitedRoleRun(input) {
-        return this.store.transaction((store) => {
-            const task = store.getTask(input.task.id);
-            const role = store.getRole(input.task.id, input.role.name);
-            const currentRun = store.getActiveAgentRun(input.task.id, input.role.name);
-            if (task === null
-                || task.status !== "active"
-                || task.executionGate.state !== "enabled"
-                || role === null
-                || currentRun === null
-                || currentRun.id !== input.run.id
-                || currentRun.status !== "active") {
-                return "state-changed";
-            }
-            const sessions = store.getTaskRoleSessionSet(task.id, role.name);
-            if (sessions?.inFlight !== null
-                && sessions !== null
-                && (sessions.inFlight.agentId !== currentRun.effective.agentId
-                    || sessions.inFlight.runId !== currentRun.id
-                    || sessions.inFlight.receiptId !== agentRunDeliveryReceiptId(currentRun))) {
-                return "state-changed";
-            }
-            // Review launch failure uses the aggregate exact-terminalization path.
-            // It owns mailbox settlement and ReviewRound convergence together, so a
-            // pending pre-delivery dispatch cannot be consumed before its Run and
-            // Round pass the same immutable identity fences.
-            if (currentRun.purpose === "review") {
-                if (input.run.taskId !== currentRun.taskId
-                    || input.run.roleName !== currentRun.roleName
-                    || input.run.purpose !== "review"
-                    || input.run.reviewRoundId !== currentRun.reviewRoundId
-                    || input.run.workItemId !== currentRun.workItemId
-                    || input.run.effective.agentId !== currentRun.effective.agentId
-                    || input.run.effective.adapterId !== currentRun.effective.adapterId) {
-                    return "state-changed";
-                }
-                const terminal = terminalizeExactTaskRun(store, {
-                    taskId: task.id,
-                    roleName: role.name,
-                    agentId: currentRun.effective.agentId,
-                    runId: currentRun.id,
-                    receiptId: agentRunDeliveryReceiptId(currentRun),
-                    ...(input.session?.nativeSessionId === undefined
-                        ? {}
-                        : { nativeSessionId: input.session.nativeSessionId }),
-                    outcome: { status: "failed", summary: input.summary }
-                }, input.now);
-                if (terminal.disposition !== "applied")
-                    return "state-changed";
-                stopTaskSessionIfPresent(store, task.id, role.name, currentRun.effective.agentId, input.now);
-                queueLeaderWakeup(store, task.id, wakeReason("review-failed"), input.now);
-                return "failed";
-            }
-            const target = { kind: "role", taskId: task.id, roleName: role.name };
-            const mailbox = store.getWorkMailbox(target);
-            const processing = mailbox?.processing;
-            if (mailbox !== null && processing !== null && processing !== undefined) {
-                if (processing.executionRef === undefined
-                    || processing.executionRef.type !== "run"
-                    || processing.executionRef.taskId !== task.id
-                    || processing.executionRef.id !== currentRun.id) {
-                    return "state-changed";
-                }
-            }
-            store.saveAgentRun(failAgentRun(currentRun, input.summary, input.now));
-            store.clearActiveAgentRun(task.id, role.name);
-            clearTaskRoleRunInFlight(store, role, currentRun, input.now);
-            if (mailbox !== null && processing !== null && processing !== undefined) {
-                store.saveWorkMailbox(completeProcessing(mailbox, processing.batchId));
-            }
-            if (currentRun.purpose === "execution" && currentRun.workItemId !== undefined) {
-                const workItem = store.getWorkItem(task.id, currentRun.workItemId);
-                if (workItem !== null && !["completed", "failed", "retired"].includes(workItem.status)) {
-                    // Terminalize the bound execution lane in the same transaction that
-                    // fails the Run. Without this, a scheduler-driven Worker failure
-                    // leaves the lane "running" behind a "failed" WorkItem, and a later
-                    // `yui task run retry` is rejected because the lane is not terminal.
-                    // The lane result and the WorkItem status are two ordered single-step
-                    // record revisions, matching the aggregate terminalization path.
-                    if (currentRun.executionGroupId !== undefined
-                        && currentRun.executionLaneId !== undefined
-                        && currentWorkItemExecutionGroup(workItem) !== undefined) {
-                        const group = currentWorkItemExecutionGroup(workItem);
-                        store.saveWorkItem(task.id, updateWorkItemExecutionGroup(workItem, recordExecutionLaneResult(group, currentRun.executionLaneId, { summary: input.summary }, "failed", input.now), input.now));
-                    }
-                }
-            }
-            const leaderFailed = role.name === "leader";
-            stopTaskSessionIfPresent(store, task.id, role.name, currentRun.effective.agentId, input.now);
-            if (leaderFailed) {
-                const failure = recordLeaderFailure(task.id, input.session?.nativeSessionId ?? "(unregistered)", input.summary, input.now, store.getLeaderFailure(task.id));
-                store.saveLeaderFailure(failure);
-                recordLeaderAttentionRequired(store, {
-                    taskId: task.id,
-                    reason: "leader-recovery-failed",
-                    payload: {
-                        message: failure.message,
-                        runId: currentRun.id
-                    },
-                    now: input.now
-                });
-                return "failed";
             }
-            queueLeaderWakeup(store, task.id, wakeReason("role-run-failed"), input.now);
             return "failed";
         });
     }
@@ -1662,47 +1607,32 @@ export class FileSchedulerStoreAdapter {
                 if (hasRuntimeCleanupObligation(existing)) {
                     throw new Error("Runtime cleanup is still pending.");
                 }
-                const executionRef = existing.processing.executionRef;
-                if (executionRef?.type === "run"
-                    && (input.owner.scope !== "task"
-                        || executionRef.taskId !== input.owner.taskId)) {
-                    throw new Error("Runtime launch reservation belongs to another Task Run.");
-                }
                 return {
                     status: "existing",
-                    launchId: existing.processing.batchId,
-                    ...(executionRef?.type === "run"
-                        ? { runId: executionRef.id }
-                        : {})
+                    launchId: existing.processing.batchId
                 };
             }
-            if (existing !== null
-                && (existing.processing !== null || existing.pending !== null)) {
+            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) {
+            if (queued === null
+                || pendingLane(queued, "normal") === null
+                || queued.processing !== null) {
                 throw new Error("Runtime launch reservation could not be queued.");
             }
-            let claimed = claimPending(queued, {
+            const claimed = claimPending(queued, {
                 batchId: input.launchId,
                 owner: RUNTIME_LIFECYCLE_OWNER,
                 startedAt: now.toISOString()
             });
-            if (input.runId !== undefined) {
-                if (input.owner.scope !== "task") {
-                    throw new Error("A Run-bound runtime reservation requires a Task owner.");
-                }
-                claimed = bindExecution(claimed, input.launchId, { type: "run", taskId: input.owner.taskId, id: input.runId });
-            }
             store.saveWorkMailbox(claimed);
             return {
                 status: "reserved",
-                launchId: input.launchId,
-                ...(input.runId === undefined ? {} : { runId: input.runId })
+                launchId: input.launchId
             };
         });
     }
@@ -1722,7 +1652,7 @@ export class FileSchedulerStoreAdapter {
             // the already-settled reservation as a launch failure.
             const sessions = runtimeOwnerSessionSet(store, input.owner);
             const active = sessions?.sessions[sessions.activeAgentId];
-            if (active?.status === "running"
+            if (active?.status === "active"
                 && active.launchId === input.launchId)
                 return "provider-bound";
             throw new Error("Runtime launch reservation no longer matches the launch.");
@@ -1757,25 +1687,12 @@ export class FileSchedulerStoreAdapter {
             return session;
         });
     }
-    completeRuntimeLaunchReservation(owner, launchId, expectedTerminalRunId, beforeComplete) {
+    completeRuntimeLaunchReservation(owner, launchId, beforeComplete) {
         return this.store.transaction((store) => {
             const target = runtimeLifecycleTarget(owner);
             const mailbox = store.getWorkMailbox(target);
             if (!isRuntimeLaunchReservation(mailbox?.processing, launchId))
                 return false;
-            if (expectedTerminalRunId !== undefined) {
-                const expectedRun = owner.scope === "task"
-                    ? store.getAgentRun(owner.taskId, expectedTerminalRunId)
-                    : null;
-                if (owner.scope !== "task"
-                    || mailbox?.processing?.executionRef?.type !== "run"
-                    || mailbox.processing.executionRef.taskId !== owner.taskId
-                    || mailbox.processing.executionRef.id !== expectedTerminalRunId
-                    || expectedRun === null
-                    || expectedRun.status === "active") {
-                    return false;
-                }
-            }
             beforeComplete?.();
             saveRuntimeLifecycleMailbox(store, completeProcessing(mailbox, launchId));
             return true;
@@ -1797,7 +1714,7 @@ export class FileSchedulerStoreAdapter {
                 const sessions = runtimeOwnerSessionSet(store, input.owner);
                 const active = sessions?.sessions[sessions.activeAgentId];
                 if (runtimeSessionMatchesSettledLaunch(active, input)) {
-                    markRuntimeOwnerSessionStopped(store, input.owner, now);
+                    endRuntimeOwnerSession(store, input.owner, now);
                 }
                 saveRuntimeLifecycleMailbox(store, completeProcessing(mailbox, input.launchId));
                 return true;
@@ -1814,8 +1731,8 @@ export class FileSchedulerStoreAdapter {
             const active = sessions.sessions[sessions.activeAgentId];
             if (!runtimeSessionMatchesSettledLaunch(active, input))
                 return false;
-            if (active.status !== "stopped") {
-                markRuntimeOwnerSessionStopped(store, input.owner, now);
+            if (active.status !== "ended") {
+                endRuntimeOwnerSession(store, input.owner, now);
             }
             return true;
         });
@@ -1945,19 +1862,17 @@ export class FileSchedulerStoreAdapter {
                 : sessions.inFlight !== null && sessions.inFlight.pushedAt === undefined) {
                 throw new Error("Runtime turn completion requires an independently committed transport receipt.");
             }
-            const idleStatus = effectiveExisting?.status === "stopped"
-                || effectiveExisting?.status === "broken"
-                ? effectiveExisting.status
-                : "ready";
+            const sessionStatus = effectiveExisting?.status ?? "active";
             sessions = recordRoleAgentSession(sessions, {
                 agentId: input.agentId,
                 adapterId: input.adapterId,
                 nativeSessionId: input.nativeSessionId,
                 ...(input.launchId === undefined ? {} : { launchId: input.launchId }),
                 policy: "fixed",
-                status: idleStatus === "stopped" || idleStatus === "broken"
-                    ? idleStatus
-                    : sessions.inFlight === null ? idleStatus : "running",
+                status: sessionStatus,
+                ...(effectiveExisting?.endReason === undefined
+                    ? {}
+                    : { endReason: effectiveExisting.endReason }),
                 effective
             }, now);
             sessions = settleStructuredProviderTurn(sessions, canonicalTurnId, input.providerStatus ?? "completed", now);
@@ -1965,18 +1880,6 @@ export class FileSchedulerStoreAdapter {
                 sessions = rememberRoleAgentCompletedTurn(sessions, input.agentId, input.nativeSessionId, canonicalTurnId, now);
                 store.saveTaskRoleSessionSet(sessions);
                 completeRuntimeHookReservation(store, owner, input.launchId);
-                // The in-flight fence was cleared by an in-place provider retry
-                // decision. If the active Run is still in its retry window and this
-                // completion belongs to it, the recovered CLI finished the original
-                // turn: clear the retry projection so the deadline does not re-push
-                // the prompt. The Run stays active for the normal completion path.
-                const activeRun = store.getActiveAgentRun(task.id, role.name);
-                if (activeRun !== null
-                    && activeRun.providerRetry !== undefined
-                    && input.runId === activeRun.id) {
-                    const { providerRetry: _removed, ...rest } = activeRun;
-                    store.saveAgentRun({ ...rest, updatedAt: now.toISOString() });
-                }
                 return { session: sessions.sessions[input.agentId], duplicate: false };
             }
             // A provider Turn is an activation boundary, not a Yui Run outcome.
@@ -1996,367 +1899,6 @@ export class FileSchedulerStoreAdapter {
             };
         });
     }
-    classifyRuntimeTurnFailed(input) {
-        const task = this.store.getTask(input.taskId);
-        if (task?.status !== "active" || task.executionGate.state !== "enabled")
-            return "obsolete";
-        const role = this.store.getRole(input.taskId, input.roleName);
-        if (role === null)
-            return "obsolete";
-        const run = this.store.getAgentRun(input.taskId, input.runId);
-        const active = this.store.getActiveAgentRun(input.taskId, input.roleName);
-        if (run === null
-            || run.status !== "active"
-            || active?.id !== run.id
-            || run.roleName !== input.roleName
-            || run.effective.agentId !== input.agentId
-            || run.effective.adapterId !== input.adapterId)
-            return "obsolete";
-        const sessions = this.store.getTaskRoleSessionSet(input.taskId, input.roleName);
-        const session = sessions?.sessions[input.agentId];
-        if (sessions === null
-            || session?.nativeSessionId !== input.nativeSessionId
-            || session.launchId !== input.launchId
-            || sessions.inFlight?.agentId !== input.agentId
-            || sessions.inFlight.runId !== input.runId
-            || sessions.inFlight.receiptId !== agentRunDeliveryReceiptId(run))
-            return "obsolete";
-        return "apply";
-    }
-    observeRuntimeTurnFailed(input, now = new Date()) {
-        return this.store.transaction((store) => {
-            const before = store.getAgentRun(input.taskId, input.runId);
-            if (before === null) {
-                recordObsoleteRuntimeEvent(store, input, "run-missing", now);
-                return { disposition: "obsolete", runId: input.runId };
-            }
-            const sessions = store.getTaskRoleSessionSet(input.taskId, input.roleName);
-            if (sessions?.providerBinding?.turn?.runId === input.runId
-                && sessions.providerBinding.turn.turnId === input.nativeTurnId) {
-                store.saveTaskRoleSessionSet(settleStructuredProviderTurn(sessions, input.nativeTurnId, "failed", now));
-            }
-            const summary = runtimeTurnFailureSummary(input);
-            // Issue 04: a classified transient Provider failure keeps the exact Run
-            // and Native Session and is retried in place instead of terminalizing.
-            const retryDecision = this.providerRetryDecision(store, input, summary, now);
-            if (retryDecision !== null)
-                return retryDecision;
-            const result = terminalizeExactTaskRun(store, {
-                taskId: input.taskId,
-                roleName: input.roleName,
-                agentId: input.agentId,
-                runId: input.runId,
-                receiptId: agentRunDeliveryReceiptId(before),
-                nativeSessionId: input.nativeSessionId,
-                launchId: input.launchId,
-                outcome: {
-                    status: "failed",
-                    summary
-                }
-            }, now);
-            if (result.disposition === "obsolete" || result.run === null) {
-                recordObsoleteRuntimeEvent(store, input, result.reason ?? "identity-mismatch-or-terminal", now);
-                return { disposition: "obsolete", runId: input.runId };
-            }
-            enqueueWork(store, runtimeLifecycleTarget({
-                scope: "task",
-                taskId: input.taskId,
-                roleName: input.roleName
-            }), RUNTIME_CLEANUP_REQUIRED_REASON, now, [{ type: "task", id: input.taskId }]);
-            const terminal = result.run;
-            const failureEvent = createTaskEvent(store.nextEventId(input.taskId), input.taskId, "runtime.turn-failed", {
-                eventId: input.eventId,
-                runId: input.runId,
-                roleName: input.roleName,
-                outcome: terminal.status
-            }, now);
-            store.saveEvent(input.taskId, failureEvent);
-            routeRoleEvent(store, failureEvent, input.roleName, input.roleName !== "leader" && before.purpose === "review"
-                ? "review-failed"
-                : input.roleName === "leader" ? "leader-run-failed" : "role-run-failed", now);
-            return { disposition: "applied", runId: input.runId };
-        });
-    }
-    /**
-     * Issue 04 in-place retry decision for one classified Provider failure.
-     * Returns an observation when the failure was handled without terminalizing
-     * the Run, or `null` to fall through to the existing terminalization path.
-     */
-    providerRetryDecision(store, input, summary, now) {
-        const config = providerRetryConfig(this.store.getConfig());
-        if (config.mode === "off")
-            return null;
-        const classification = classifyProviderError({
-            adapterId: input.adapterId,
-            ...(input.errorCode === undefined ? {} : { errorCode: input.errorCode }),
-            error: input.error,
-            errorDetails: input.errorDetails,
-            summary: input.lastAssistantMessage
-        });
-        const adapterEnabled = providerRetryAdapterEnabled(config, input.adapterId);
-        const retryable = adapterEnabled
-            && isRetryableProviderErrorClass(classification.errorClass);
-        const shadow = config.mode === "shadow";
-        // Shadow mode records the classification and "would retry" fact without
-        // changing any behavior; the Run still terminalizes below.
-        if (shadow || !retryable) {
-            if (adapterEnabled) {
-                this.recordProviderRetryClassified(store, input, classification.errorClass, {
-                    wouldRetry: String(retryable),
-                    basis: classification.basis,
-                    shadow: String(shadow)
-                }, now);
-            }
-            if (!shadow && classification.errorClass === "policy-denied") {
-                const blocked = this.applyProviderPolicyBlock(store, input, summary, now);
-                if (blocked !== null)
-                    return blocked;
-            }
-            if (!shadow && classification.errorClass === "context-capacity") {
-                const blocked = this.applyContextCapacityBlock(store, input, summary, now);
-                if (blocked !== null)
-                    return blocked;
-            }
-            if (!shadow && classification.errorClass === "session-dead") {
-                const run = store.getAgentRun(input.taskId, input.runId);
-                if (run !== null && run.status === "active" && run.mode === "resume") {
-                    // A structured failure on the exact resume launch is the only Core
-                    // evidence that native continuation is unrecoverable. The normal
-                    // terminal path below may now request a fresh managed generation.
-                    store.saveEvent(input.taskId, createTaskEvent(store.nextEventId(input.taskId), input.taskId, "runtime.native-resume-unrecoverable", {
-                        eventId: input.eventId,
-                        runId: input.runId,
-                        roleName: input.roleName,
-                        launchId: input.launchId,
-                        nativeSessionId: input.nativeSessionId,
-                        ...(run.assignment.contextSnapshotRef === undefined
-                            ? {}
-                            : {
-                                contextSnapshotId: run.assignment.contextSnapshotRef.id,
-                                contextSnapshotDigest: run.assignment.contextSnapshotRef.digest
-                            })
-                    }, now));
-                }
-                else {
-                    const blocked = this.applyNativeSessionRecoverabilityBlock(store, input, summary, now);
-                    if (blocked !== null)
-                        return blocked;
-                }
-            }
-            return null;
-        }
-        // transport-uncertain: the Provider may have accepted the turn. If a
-        // native completion is already durable, the completion path owns the
-        // yield; do not resend.
-        if (classification.errorClass === "transport-uncertain") {
-            const driver = this.drivers.requireByAdapterId(input.adapterId);
-            if (driver.capabilities.lifecycle.deliveryDeduplication !== "exact") {
-                const run = store.getAgentRun(input.taskId, input.runId);
-                if (run === null || run.status !== "active")
-                    return null;
-                const blocked = scheduleProviderRetry(run.providerRetry, {
-                    failureEventId: input.eventId,
-                    errorClass: classification.errorClass,
-                    launchId: input.launchId,
-                    nativeSessionId: input.nativeSessionId,
-                    failedNativeTurnId: input.nativeTurnId,
-                    lastErrorSummary: summary,
-                    scheduleNextAttempt: false
-                }, now, configuredProviderRetryPolicy(store));
-                if (blocked.outcome === "exhausted")
-                    return null;
-                store.saveAgentRun(withProviderRetry(run, blocked.retry));
-                const classifiedEvent = this.recordProviderRetryClassified(store, input, classification.errorClass, {
-                    wouldRetry: "false",
-                    shadow: "false",
-                    note: "delivery-deduplication-unproven"
-                }, now);
-                routeRoleEvent(store, classifiedEvent, input.roleName, "provider-delivery-uncertain", now);
-                return { disposition: "applied", runId: input.runId };
-            }
-        }
-        const run = store.getAgentRun(input.taskId, input.runId);
-        if (run === null || run.status !== "active")
-            return null;
-        const retryDecision = scheduleProviderRetry(run.providerRetry, {
-            failureEventId: input.eventId,
-            errorClass: classification.errorClass,
-            launchId: input.launchId,
-            nativeSessionId: input.nativeSessionId,
-            failedNativeTurnId: input.nativeTurnId,
-            lastErrorSummary: summary,
-            ...(input.retryAfterMs === undefined ? {} : { retryAfterMs: input.retryAfterMs })
-        }, now, configuredProviderRetryPolicy(store));
-        if (retryDecision.outcome === "exhausted") {
-            this.recordProviderRetryClassified(store, input, classification.errorClass, {
-                wouldRetry: "false",
-                shadow: "false",
-                note: `episode-exhausted-${retryDecision.reason}`,
-                consecutiveFailures: String(run.providerRetry?.consecutiveFailures ?? 0),
-                dispatchedRetries: String(run.providerRetry?.dispatchedRetries ?? 0)
-            }, now);
-            if (run.providerRetry === undefined)
-                return null;
-            const finalized = finalizeProviderRetryDeadline(store, run, retryDecision.reason === "attempts"
-                ? `Provider retry failed after all ${run.providerRetry.maxRetries} in-Session continuation attempts.`
-                : retryDecision.reason === "retry-after-window"
-                    ? `Provider Retry-After exceeded the bounded ${config.maxWindowMs / 1_000}-second episode window.`
-                    : `Provider retry did not recover within the bounded ${config.maxWindowMs / 1_000}-second episode window.`, retryDecision.reason === "attempts" ? "attempts-exhausted" : "episode-window-exhausted", now);
-            return finalized ? { disposition: "applied", runId: input.runId } : null;
-        }
-        const retry = retryDecision.retry;
-        store.saveAgentRun(withProviderRetry(run, retry));
-        // The in-flight fence and Provider Conversation stay bound while the
-        // retry waits. resolveDueProviderRetries advances only the delivery
-        // receipt immediately before the exact redispatch.
-        // Settle the delivery claim so the retry push can re-claim the mailbox.
-        const target = runtimeLifecycleTarget({
-            scope: "task",
-            taskId: input.taskId,
-            roleName: input.roleName
-        });
-        const mailbox = store.getWorkMailbox(target);
-        if (mailbox !== null && mailbox.processing !== null) {
-            const settled = completeProcessing(mailbox, mailbox.processing.batchId);
-            if (settled.processing === null && settled.pending === null) {
-                store.removeWorkMailbox(target);
-            }
-            else {
-                store.saveWorkMailbox(settled);
-            }
-        }
-        this.recordProviderRetryClassified(store, input, classification.errorClass, {
-            wouldRetry: "true",
-            shadow: "false",
-            consecutiveFailures: String(retry.consecutiveFailures),
-            dispatchedRetries: String(retry.dispatchedRetries),
-            nextAttemptAt: retry.nextAttemptAt
-        }, now);
-        return { disposition: "applied", runId: input.runId };
-    }
-    /**
-     * Issue 04 policy-denied handling: the Run stays active on its original
-     * Session, no retry is scheduled, and the Leader receives a bounded blocker.
-     * Yui never works around a policy denial by switching Session or widening
-     * permission.
-     */
-    applyProviderPolicyBlock(store, input, summary, now) {
-        const run = store.getAgentRun(input.taskId, input.runId);
-        if (run === null || run.status !== "active")
-            return null;
-        const retryDecision = scheduleProviderRetry(run.providerRetry, {
-            failureEventId: input.eventId,
-            errorClass: "policy-denied",
-            launchId: input.launchId,
-            nativeSessionId: input.nativeSessionId,
-            failedNativeTurnId: input.nativeTurnId,
-            lastErrorSummary: summary,
-            scheduleNextAttempt: false
-        }, now, configuredProviderRetryPolicy(store));
-        if (retryDecision.outcome === "exhausted")
-            return null;
-        store.saveAgentRun(withProviderRetry(run, retryDecision.retry));
-        const classifiedEvent = this.recordProviderRetryClassified(store, input, "policy-denied", {
-            wouldRetry: "false",
-            shadow: "false",
-            note: "policy-denied-blocker"
-        }, now);
-        routeRoleEvent(store, classifiedEvent, input.roleName, input.roleName === "leader"
-            ? "leader-provider-policy-blocked"
-            : "provider-policy-blocked", now);
-        return { disposition: "applied", runId: input.runId };
-    }
-    /**
-     * Exact Provider capacity failures never trigger a token-threshold rollover.
-     * Keep the native lineage intact and surface the Driver's explicit native
-     * compaction/resume capability; unsupported/unknown capabilities fail safe
-     * for Leader/Operator action instead of forcing a fresh generation.
-     */
-    applyContextCapacityBlock(store, input, summary, now) {
-        const run = store.getAgentRun(input.taskId, input.runId);
-        if (run === null || run.status !== "active")
-            return null;
-        const decision = scheduleProviderRetry(run.providerRetry, {
-            failureEventId: input.eventId,
-            errorClass: "context-capacity",
-            launchId: input.launchId,
-            nativeSessionId: input.nativeSessionId,
-            failedNativeTurnId: input.nativeTurnId,
-            lastErrorSummary: summary,
-            scheduleNextAttempt: false
-        }, now, configuredProviderRetryPolicy(store));
-        if (decision.outcome === "exhausted")
-            return null;
-        store.saveAgentRun(withProviderRetry(run, decision.retry));
-        const driver = this.drivers.requireByAdapterId(input.adapterId);
-        const capacityEvent = createTaskEvent(store.nextEventId(input.taskId), input.taskId, "runtime.context-capacity-failure", {
-            eventId: input.eventId,
-            runId: input.runId,
-            roleName: input.roleName,
-            nativeSessionId: input.nativeSessionId,
-            launchId: input.launchId,
-            compactionCapability: driver.capabilities.lifecycle.compaction,
-            nativeResumeCapability: driver.capabilities.lifecycle.nativeConversationResume,
-            action: driver.capabilities.lifecycle.compaction === "native-explicit"
-                ? "native-explicit-compaction-required"
-                : "await-provider-native-recovery"
-        }, now);
-        store.saveEvent(input.taskId, capacityEvent);
-        this.recordProviderRetryClassified(store, input, "context-capacity", {
-            wouldRetry: "false",
-            shadow: "false",
-            note: "provider-native-capacity-recovery-only"
-        }, now);
-        routeRoleEvent(store, capacityEvent, input.roleName, "provider-context-capacity-recovery-required", now);
-        return { disposition: "applied", runId: input.runId };
-    }
-    applyNativeSessionRecoverabilityBlock(store, input, summary, now) {
-        const run = store.getAgentRun(input.taskId, input.runId);
-        if (run === null || run.status !== "active")
-            return null;
-        const decision = scheduleProviderRetry(run.providerRetry, {
-            failureEventId: input.eventId,
-            errorClass: "session-dead",
-            launchId: input.launchId,
-            nativeSessionId: input.nativeSessionId,
-            failedNativeTurnId: input.nativeTurnId,
-            lastErrorSummary: summary,
-            scheduleNextAttempt: false
-        }, now, configuredProviderRetryPolicy(store));
-        if (decision.outcome === "exhausted")
-            return null;
-        store.saveAgentRun(withProviderRetry(run, decision.retry));
-        const recoverabilityEvent = createTaskEvent(store.nextEventId(input.taskId), input.taskId, "runtime.native-session-recoverability-unproven", {
-            eventId: input.eventId,
-            runId: input.runId,
-            roleName: input.roleName,
-            launchId: input.launchId,
-            nativeSessionId: input.nativeSessionId,
-            requiredEvidence: "exact-native-resume-outcome"
-        }, now);
-        store.saveEvent(input.taskId, recoverabilityEvent);
-        routeRoleEvent(store, recoverabilityEvent, input.roleName, "native-session-recoverability-unproven", now);
-        return { disposition: "applied", runId: input.runId };
-    }
-    recordProviderRetryClassified(store, input, errorClass, extra, now) {
-        const event = createTaskEvent(store.nextEventId(input.taskId), input.taskId, "runtime.provider-retry-classified", {
-            eventId: input.eventId,
-            runId: input.runId,
-            roleName: input.roleName,
-            errorClass,
-            ...extra
-        }, now);
-        store.saveEvent(input.taskId, event);
-        return event;
-    }
-    /**
-     * Issue 04 durable retry timer: lists active Runs whose in-place retry is
-     * due. The Controller arms its deadline timer from this projection, so a
-     * Controller restart resumes the same attempt lineage.
-     */
-    listPendingProviderRetries(taskIds) {
-        return this.store.listPendingProviderRetries(taskIds);
-    }
     saveRoleHostExitObservation(input) {
         this.store.transaction((store) => {
             const identity = [
@@ -2411,159 +1953,6 @@ export class FileSchedulerStoreAdapter {
      * blocker; a live Session is reopened for the existing delivery path, which
      * re-pushes the exact same input in the same pass.
      */
-    resolveDueProviderRetries(now, taskIds) {
-        const selectedTaskIds = taskIds === undefined
-            ? undefined
-            : [...taskIds].sort((left, right) => (left.localeCompare(right, undefined, { numeric: true })));
-        const due = this.listPendingProviderRetries(selectedTaskIds).filter((entry) => Date.parse(entry.dueAt) <= now.getTime());
-        const reopened = [];
-        for (const entry of due) {
-            this.store.transaction((store) => {
-                const run = store.getAgentRun(entry.taskId, entry.runId);
-                if (run === null
-                    || run.status !== "active"
-                    || run.providerRetry === undefined) {
-                    return;
-                }
-                if (run.providerRetry.state === "dispatching"
-                    || run.providerRetry.state === "awaiting-progress") {
-                    if (now.getTime() < Date.parse(run.providerRetry.episodeDeadlineAt))
-                        return;
-                    finalizeProviderRetryDeadline(store, run, run.providerRetry.state === "dispatching"
-                        ? "Provider retry delivery outcome remained uncertain through the bounded episode deadline; no correlated Provider progress was observed."
-                        : "Provider retry produced no correlated Provider input/output progress before the bounded episode deadline.", run.providerRetry.state === "dispatching"
-                        ? "retry-delivery-outcome-uncertain"
-                        : "provider-progress-timeout", now);
-                    return;
-                }
-                if (run.providerRetry.state !== "scheduled"
-                    || run.providerRetry.nextAttemptAt === undefined
-                    || !providerRetryIsDue(run.providerRetry, now)) {
-                    return;
-                }
-                const sessions = store.getTaskRoleSessionSet(entry.taskId, entry.roleName);
-                const providerBinding = sessions?.providerBinding;
-                if (providerBinding === null || providerBinding === undefined) {
-                    deferUnprovenProviderRecovery(store, run, entry.roleName, "Provider Conversation identity is missing; automatic recovery is fenced.", now);
-                    return;
-                }
-                const conversation = currentProviderConversation(providerBinding);
-                const roleMailbox = store.getWorkMailbox({
-                    kind: "role",
-                    taskId: entry.taskId,
-                    roleName: entry.roleName
-                });
-                const activeTurnId = providerBinding.turn !== null
-                    && ["accepted", "running"].includes(providerBinding.turn.status)
-                    ? providerBinding.turn.turnId
-                    : undefined;
-                const recovery = decideProviderRecovery({
-                    binding: providerBinding,
-                    probe: {
-                        state: conversation.recoverability === "recoverable"
-                            ? "exists"
-                            : conversation.recoverability === "unrecoverable" ? "missing" : "unknown",
-                        conversationId: conversation.conversationId,
-                        ...(activeTurnId === undefined ? {} : { activeTurnId })
-                    },
-                    unsettledInputDelivery: roleMailbox?.inputDelivery != null
-                });
-                if (recovery.action === "attention") {
-                    deferUnprovenProviderRecovery(store, run, entry.roleName, recovery.reason, now);
-                    return;
-                }
-                if (recovery.action === "observe-active-turn") {
-                    const deferred = deferProviderRetry(run.providerRetry, now);
-                    if (deferred === null) {
-                        finalizeProviderRetryDeadline(store, run, `Provider Turn ${recovery.turnId} remained active through the bounded recovery deadline.`, "provider-progress-timeout", now);
-                    }
-                    else {
-                        store.saveAgentRun(withProviderRetry(run, deferred));
-                    }
-                    return;
-                }
-                if (recovery.action === "restart-run") {
-                    const finalized = finalizeProviderRetryDeadline(store, run, "Provider Conversation is unavailable; retry the work with a fresh Run and Session.", "provider-conversation-unavailable", now);
-                    if (finalized) {
-                        const currentSessions = store.getTaskRoleSessionSet(entry.taskId, entry.roleName);
-                        const currentSession = currentSessions?.sessions[run.effective.agentId];
-                        if (currentSessions !== null && currentSessions !== undefined
-                            && currentSession !== undefined
-                            && currentSession.status !== "stopped"
-                            && currentSession.status !== "broken") {
-                            store.saveTaskRoleSessionSet(updateRoleAgentSessionStatus(currentSessions, run.effective.agentId, "broken", now));
-                        }
-                    }
-                    return;
-                }
-                const session = sessions?.sessions[run.effective.agentId];
-                const identityMatches = session !== undefined
-                    && session.adapterId === run.effective.adapterId
-                    && (run.providerRetry.nativeSessionId === undefined
-                        || session.nativeSessionId === run.providerRetry.nativeSessionId)
-                    && (run.providerRetry.launchId === undefined
-                        || session.launchId === run.providerRetry.launchId);
-                if (!identityMatches || session?.nativeSessionId === undefined) {
-                    // Local Session projection loss is not native-session-dead evidence.
-                    // Keep the bounded retry episode; if native identity never returns,
-                    // the episode fails and a later Run can continue from Task progress.
-                    const deferred = deferProviderRetry(run.providerRetry, now);
-                    if (deferred === null) {
-                        finalizeProviderRetryDeadline(store, run, "Provider retry safety could not be re-established before the bounded episode deadline; native Session recoverability remains unproven.", "native-resume-unproven", now);
-                        return;
-                    }
-                    store.saveAgentRun(withProviderRetry(run, deferred));
-                    let attentionEvent = store.listEvents(entry.taskId).find((event) => (event.type === "runtime.provider-retry-native-resume-unproven"
-                        && event.payload.runId === run.id));
-                    if (attentionEvent === undefined) {
-                        attentionEvent = createTaskEvent(store.nextEventId(entry.taskId), entry.taskId, "runtime.provider-retry-native-resume-unproven", {
-                            runId: run.id,
-                            consecutiveFailures: String(run.providerRetry.consecutiveFailures),
-                            dispatchedRetries: String(run.providerRetry.dispatchedRetries)
-                        }, now);
-                        store.saveEvent(entry.taskId, attentionEvent);
-                    }
-                    routeRoleEvent(store, attentionEvent, entry.roleName, "provider-retry-native-resume-unproven", now);
-                    return;
-                }
-                if (runHasActiveRuntimeOperations(store.listEvents(entry.taskId), {
-                    taskId: entry.taskId,
-                    roleName: entry.roleName,
-                    runId: run.id,
-                    agentId: run.effective.agentId
-                })) {
-                    const deferred = deferProviderRetry(run.providerRetry, now);
-                    if (deferred === null) {
-                        finalizeProviderRetryDeadline(store, run, "Provider retry stopped because tool/subagent outcome remained uncertain through the bounded episode deadline.", "operation-outcome-uncertain", now);
-                        return;
-                    }
-                    store.saveAgentRun(withProviderRetry(run, deferred));
-                    return;
-                }
-                // Reopen the Run on its original Session: reset transport markers,
-                // switch to resume, and mark the projection in-flight. The delivery
-                // pass re-pushes the exact same input in this same pass.
-                const reopenedRun = reopenRunForProviderRetry(run, `provider-retry-${run.providerRetry.episodeId}-${run.providerRetry.dispatchedRetries + 1}`, now, "resume");
-                store.saveAgentRun(reopenedRun);
-                if (sessions !== null && sessions.inFlight !== null) {
-                    store.saveTaskRoleSessionSet(prepareTaskRoleRunRedispatch(sessions, {
-                        agentId: run.effective.agentId,
-                        runId: run.id,
-                        receiptId: agentRunDeliveryReceiptId(reopenedRun)
-                    }, now));
-                }
-                // The retry decision settled the original delivery claim; re-queue the
-                // Role mailbox so the delivery pass can claim and re-push the Run.
-                enqueueWork(store, { kind: "role", taskId: entry.taskId, roleName: entry.roleName }, "provider-retry-repush", now, [{ type: "run", taskId: entry.taskId, id: run.id }]);
-                reopened.push(formatTaskRecordReference(entry.taskId, run.id, "agentRun"));
-            });
-        }
-        return reopened;
-    }
-    /**
-     * Applies already-normalized Session observations. Driver-specific startup
-     * names and source variants have terminated before this boundary.
-     */
     observeProviderRuntimeIdentity(input, now) {
         return this.store.transaction((store) => {
             const taskId = input.fence.taskId;
@@ -2659,7 +2048,7 @@ export class FileSchedulerStoreAdapter {
                             && existingNativeSessionId !== decision.outcome.nativeSessionId;
                         const replacementBasis = replacingNativeSession
                             && run.mode === "new"
-                            && (existingSession?.status === "stopped" || existingSession?.status === "broken")
+                            && existingSession?.status === "ended"
                             ? "terminal-session"
                             : null;
                         if (replacingNativeSession && replacementBasis === null) {
@@ -2672,7 +2061,7 @@ export class FileSchedulerStoreAdapter {
                             nativeSessionId: decision.outcome.nativeSessionId,
                             launchId: input.fence.launchId,
                             policy: "fixed",
-                            status: "running",
+                            status: "active",
                             effective: run.effective
                         };
                         const bound = replacementBasis === null
@@ -2737,7 +2126,7 @@ export class FileSchedulerStoreAdapter {
                     recordCanonicalObservationObsolete(store, input, "human-turn-fence-mismatch", now);
                     return "obsolete";
                 }
-                store.saveTaskRoleSessionSet(recordStructuredProviderAcceptance(updateRoleAgentSessionStatus(sessions, input.fence.agentId, "running", now), input, now));
+                store.saveTaskRoleSessionSet(recordStructuredProviderAcceptance(sessions, input, now));
                 store.saveEvent(input.fence.taskId, createTaskEvent(store.nextEventId(input.fence.taskId), input.fence.taskId, "run.human-input-delivered", {
                     attemptId: humanAttemptId,
                     runId: active.id,
@@ -2760,7 +2149,7 @@ export class FileSchedulerStoreAdapter {
                     recordCanonicalObservationObsolete(store, input, "continuation-fence-mismatch", now);
                     return "obsolete";
                 }
-                store.saveTaskRoleSessionSet(recordStructuredProviderAcceptance(updateRoleAgentSessionStatus(sessions, input.fence.agentId, "running", now), input, now));
+                store.saveTaskRoleSessionSet(recordStructuredProviderAcceptance(sessions, input, now));
                 store.saveEvent(input.fence.taskId, createTaskEvent(store.nextEventId(input.fence.taskId), input.fence.taskId, "run.input-delivered", {
                     attemptId: inputDelivery.attemptId,
                     runId: active.id,
@@ -2771,9 +2160,6 @@ export class FileSchedulerStoreAdapter {
                         : { nativeTurnId: input.fence.nativeTurnId })
                 }, now));
                 store.saveWorkMailbox(completeMailboxInputDelivery(mailbox, inputDelivery.attemptId, now));
-                if (active.providerRetry !== undefined) {
-                    this.clearProviderRetryProjection(store, active, input, "provider-accepted", now);
-                }
                 return "applied";
             }
             const event = createCanonicalLifecycleEvent({
@@ -2807,24 +2193,8 @@ export class FileSchedulerStoreAdapter {
             if (sessions !== null) {
                 store.saveTaskRoleSessionSet(recordStructuredProviderAcceptance(sessions, input, now));
             }
-            const progressed = clearProviderRetryOnProgress(active);
-            if (progressed !== active) {
-                store.saveAgentRun(progressed);
-                store.saveEvent(input.fence.taskId, createTaskEvent(store.nextEventId(input.fence.taskId), input.fence.taskId, "runtime.provider-retry-recovered", {
-                    runId: active.id,
-                    roleName: active.roleName,
-                    evidence: "provider-accepted",
-                    nativeSessionId: input.fence.nativeSessionId ?? "",
-                    episodeId: active.providerRetry?.episodeId ?? "",
-                    consecutiveFailures: String(active.providerRetry?.consecutiveFailures ?? 0),
-                    dispatchedRetries: String(active.providerRetry?.dispatchedRetries ?? 0),
-                    recoveryLatencyMs: String(active.providerRetry === undefined
-                        ? 0
-                        : Math.max(0, now.getTime() - Date.parse(active.providerRetry.firstFailureAt)))
-                }, now));
-            }
-            if (progressed.deliveredAt === undefined) {
-                const delivered = markAgentRunDelivered(progressed, now);
+            if (active.deliveredAt === undefined) {
+                const delivered = markAgentRunDelivered(active, now);
                 store.saveAgentRun(delivered);
                 markTaskRoleRunDeliveredInFlight(store, role, delivered, now);
                 store.saveEvent(input.fence.taskId, createTaskEvent(store.nextEventId(input.fence.taskId), input.fence.taskId, "run.delivered", runLaunchEventPayload(delivered), now));
@@ -2839,35 +2209,6 @@ export class FileSchedulerStoreAdapter {
             return "applied";
         });
     }
-    clearProviderRetryForProgress(input, evidence, now) {
-        this.store.transaction((store) => {
-            const taskId = input.fence.taskId;
-            const runId = input.fence.runId;
-            if (taskId === undefined || runId === undefined)
-                return;
-            const run = store.getAgentRun(taskId, runId);
-            if (run === null || run.status !== "active" || run.providerRetry === undefined)
-                return;
-            this.clearProviderRetryProjection(store, run, input, evidence, now);
-        });
-    }
-    clearProviderRetryProjection(store, run, input, evidence, now) {
-        const retry = run.providerRetry;
-        if (retry === undefined)
-            return;
-        store.saveAgentRun(clearProviderRetryOnProgress(run));
-        store.saveEvent(run.taskId, createTaskEvent(store.nextEventId(run.taskId), run.taskId, "runtime.provider-retry-recovered", {
-            runId: run.id,
-            roleName: input.fence.roleName,
-            evidence,
-            episodeId: retry.episodeId,
-            consecutiveFailures: String(retry.consecutiveFailures),
-            dispatchedRetries: String(retry.dispatchedRetries),
-            recoveryLatencyMs: String(Math.max(0, now.getTime() - Date.parse(retry.firstFailureAt))),
-            nativeSessionId: input.fence.nativeSessionId ?? "",
-            activityId: input.payload.activityId ?? ""
-        }, now));
-    }
     foldRuntimeLifecycleEvent(store, event, observation) {
         const expectation = this.projectRunExpectation(store, event.fence, observation.fence.runId);
         if (expectation === null) {
@@ -2994,10 +2335,7 @@ export class FileSchedulerStoreAdapter {
             if (effective.agentId !== input.agentId || effective.adapterId !== input.adapterId) {
                 throw new Error("Runtime turn completion does not match the effective global launch identity.");
             }
-            const completedStatus = effectiveExisting?.status === "stopped"
-                || effectiveExisting?.status === "broken"
-                ? effectiveExisting.status
-                : "ready";
+            const completedStatus = effectiveExisting?.status ?? "active";
             current = recordRoleAgentSession(current, {
                 agentId: input.agentId,
                 adapterId: input.adapterId,
@@ -3007,6 +2345,9 @@ export class FileSchedulerStoreAdapter {
                 preview: effectiveExisting?.preview ?? (input.summary === undefined ? undefined : sessionPreview(input.summary)),
                 policy: "fixed",
                 status: completedStatus,
+                ...(effectiveExisting?.endReason === undefined
+                    ? {}
+                    : { endReason: effectiveExisting.endReason }),
                 effective
             }, now);
             current = rememberRoleAgentCompletedTurn(current, input.agentId, nativeSessionId, input.turnId, now);
@@ -3014,13 +2355,13 @@ export class FileSchedulerStoreAdapter {
             completeRuntimeHookReservation(store, owner, input.launchId);
             if (input.roleName === SYSTEM_OPERATOR_ROLE
                 && input.adapterId === "codex"
-                && completedStatus === "ready") {
+                && completedStatus === "active") {
                 const operatorMailbox = store.getWorkMailbox({ kind: "operator" });
                 // A completed foreground Codex Turn leaves its native TUI attached to
                 // the thread. Stop only that idle Role runtime so Desktop can become
                 // the writer; the durable nativeSessionId remains available to resume.
                 if (operatorMailbox === null || !mailboxHasWork(operatorMailbox)) {
-                    enqueueWork(store, runtimeLifecycleTarget(owner), RUNTIME_CLEANUP_REQUIRED_REASON, now);
+                    enqueueWork(store, runtimeLifecycleTarget(owner), RUNTIME_HOST_DETACH_REQUIRED_REASON, now);
                 }
             }
             return current.sessions[input.agentId];
@@ -3054,18 +2395,6 @@ export class FileSchedulerStoreAdapter {
         return "apply";
     }
 }
-function runtimeTurnFailureSummary(input) {
-    return [
-        "Agent runtime turn failed.",
-        `error: ${input.error}`,
-        ...(input.errorDetails === undefined
-            ? []
-            : [`error_details: ${input.errorDetails}`]),
-        ...(input.lastAssistantMessage === undefined
-            ? []
-            : [`last_assistant_message: ${input.lastAssistantMessage}`])
-    ].join("\n");
-}
 function runtimeObservationLifecycleFence(input, adapterId) {
     return {
         taskId: input.fence.taskId,
@@ -3213,12 +2542,8 @@ function preallocatedRuntimeReadyAwaitingProjection(store, observation, drivers)
         taskId,
         roleName: observation.fence.roleName
     }));
-    const executionRef = mailbox?.processing?.executionRef;
     return isRuntimeLaunchReservation(mailbox?.processing, observation.fence.launchId)
         && !hasRuntimeCleanupObligation(mailbox)
-        && executionRef?.type === "run"
-        && executionRef.taskId === taskId
-        && executionRef.id === runId
         && nativeSessionId === nativeSessionIdForLaunch(store.rootDirectory(), observation.fence.launchId, observation.fence.agentId, driver.adapterId);
 }
 function completeRuntimeHookReservation(store, owner, launchId) {
@@ -3267,14 +2592,14 @@ function dormantRuntimeCandidateIsCurrent(store, candidate) {
     const sessions = runtimeOwnerSessionSet(store, owner);
     const active = sessions?.sessions[sessions.activeAgentId];
     return active !== undefined
-        && active.status !== "stopped"
+        && active.status === "active"
         && active.agentId === candidate.agentId
         && active.adapterId === candidate.adapterId
         && active.nativeSessionId === candidate.nativeSessionId
         && active.launchId === candidate.launchId
         && active.updatedAt === candidate.sessionUpdatedAt;
 }
-function markRuntimeOwnerSessionStopped(store, owner, now) {
+function endRuntimeOwnerSession(store, owner, now) {
     if (owner.scope === "task") {
         const sessions = store.getTaskRoleSessionSet(owner.taskId, owner.roleName);
         if (sessions === null)
@@ -3282,7 +2607,19 @@ function markRuntimeOwnerSessionStopped(store, owner, now) {
         const active = sessions.sessions[sessions.activeAgentId];
         if (active === undefined)
             return false;
-        const stopped = stopTaskRoleRuntimeAfterPhysicalExit(sessions, 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);
@@ -3292,9 +2629,29 @@ function markRuntimeOwnerSessionStopped(store, owner, now) {
     if (sessions === null)
         return false;
     const active = sessions.sessions[sessions.activeAgentId];
-    if (active === undefined || active.status === "stopped")
+    if (active === undefined || active.status === "ended")
+        return false;
+    store.saveGlobalRoleSessionSet(updateRoleAgentSessionStatus(sessions, sessions.activeAgentId, "ended", now, "stopped"));
+    return true;
+}
+function detachRuntimeOwnerHost(store, owner, now) {
+    if (owner.scope === "task") {
+        const sessions = store.getTaskRoleSessionSet(owner.taskId, owner.roleName);
+        if (sessions === null)
+            return false;
+        const detached = detachRoleAgentSessionHost(sessions, now);
+        if (detached === sessions)
+            return false;
+        store.saveTaskRoleSessionSet(detached);
+        return true;
+    }
+    const sessions = store.getGlobalRoleSessionSet(owner.roleName);
+    if (sessions === null)
         return false;
-    store.saveGlobalRoleSessionSet(updateRoleAgentSessionStatus(sessions, sessions.activeAgentId, "stopped", now));
+    const detached = detachRoleAgentSessionHost(sessions, now);
+    if (detached === sessions)
+        return false;
+    store.saveGlobalRoleSessionSet(detached);
     return true;
 }
 function runtimeOwnerSessionSet(store, owner) {
@@ -3314,8 +2671,7 @@ function preparedSessionMatches(session, agentId, adapterId, nativeSessionId, la
         return nativeSessionId === undefined;
     if (session.agentId !== agentId
         || session.adapterId !== adapterId
-        || session.status === "stopped"
-        || session.status === "broken"
+        || session.status === "ended"
         || (nativeSessionId !== undefined
             && session.nativeSessionId !== nativeSessionId)) {
         return false;
@@ -3324,45 +2680,13 @@ function preparedSessionMatches(session, agentId, adapterId, nativeSessionId, la
         ? session.launchId === undefined
         : session.launchId === launchId;
 }
-function finalizeProviderRetryDeadline(store, run, summary, reason, now) {
-    const retry = run.providerRetry;
-    if (retry === undefined)
-        return false;
-    const terminalization = terminalizeExactTaskRun(store, {
-        taskId: run.taskId,
-        roleName: run.roleName,
-        agentId: run.effective.agentId,
-        runId: run.id,
-        receiptId: agentRunDeliveryReceiptId(run),
-        outcome: { status: "failed", summary }
-    }, now);
-    if (terminalization.disposition !== "applied" || terminalization.run === null)
-        return false;
-    const terminal = terminalization.run;
-    const exhaustionEvent = createTaskEvent(store.nextEventId(run.taskId), run.taskId, "runtime.provider-retry-exhausted", {
-        runId: run.id,
-        roleName: run.roleName,
-        episodeId: retry.episodeId,
-        reason,
-        consecutiveFailures: String(retry.consecutiveFailures),
-        dispatchedRetries: String(retry.dispatchedRetries),
-        elapsedMs: String(Math.max(0, now.getTime() - Date.parse(retry.firstFailureAt)))
-    }, now);
-    store.saveEvent(run.taskId, exhaustionEvent);
-    if (run.roleName === "leader") {
-        store.saveLeaderFailure(recordLeaderFailure(run.taskId, retry.nativeSessionId ?? "(unproven)", summary, now, store.getLeaderFailure(run.taskId)));
-    }
-    routeRoleEvent(store, exhaustionEvent, run.roleName, "provider-retry-exhausted", now);
-    return true;
-}
 function preparedDeliveryFailureSessionFenceMatches(sessions, session, input, expectedReceiptId) {
     if (sessions === null)
         return input.nativeSessionId === undefined;
     if (sessions.activeAgentId !== input.agentId)
         return false;
     if (sessions.inFlight === null) {
-        return input.nativeSessionId === undefined
-            && session === undefined;
+        return preparedSessionMatches(session, input.agentId, input.adapterId, input.nativeSessionId, input.launchId);
     }
     return sessions.inFlight.agentId === input.agentId
         && sessions.inFlight.runId === input.runId
@@ -3370,41 +2694,6 @@ function preparedDeliveryFailureSessionFenceMatches(sessions, session, input, ex
         && sessions.inFlight.pushedAt === undefined
         && preparedSessionMatches(session, input.agentId, input.adapterId, input.nativeSessionId, input.launchId);
 }
-function preparedReservationMatches(mailbox, taskId, runId, launchId) {
-    if (launchId === undefined) {
-        return !isRuntimeLaunchReservation(mailbox?.processing);
-    }
-    const processing = mailbox?.processing;
-    return isRuntimeLaunchReservation(processing, launchId)
-        && !hasRuntimeCleanupObligation(mailbox)
-        && processing?.executionRef?.type === "run"
-        && processing.executionRef.taskId === taskId
-        && processing.executionRef.id === runId;
-}
-function matchingPreparedRuntimeReservation(store, input) {
-    if (input.launchId === undefined
-        || input.session?.nativeSessionId === undefined) {
-        return null;
-    }
-    const owner = {
-        scope: "task",
-        taskId: input.task.id,
-        roleName: input.role.name
-    };
-    const mailbox = store.getWorkMailbox(runtimeLifecycleTarget(owner));
-    if (isRuntimeLaunchReservation(mailbox?.processing, input.launchId)
-        && mailbox?.processing?.executionRef?.type === "run"
-        && mailbox.processing.executionRef.id === input.run.id
-        && !hasRuntimeCleanupObligation(mailbox)) {
-        return mailbox;
-    }
-    throw new Error("Prepared Role session does not match its launch generation.");
-}
-function completePreparedRuntimeReservation(store, mailbox) {
-    if (mailbox === null || mailbox.processing === null)
-        return;
-    saveRuntimeLifecycleMailbox(store, completeProcessing(mailbox, mailbox.processing.batchId));
-}
 function recordTaskRuntimeNativeSession(store, input, now) {
     const task = store.getTask(input.taskId);
     if (task === null)
@@ -3420,7 +2709,7 @@ function recordTaskRuntimeNativeSession(store, input, now) {
         ?? 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.launchId, "Native session registration conflicts with the fixed Role session.");
-    if (existing?.status === "running"
+    if (existing?.status === "active"
         && (input.launchId === undefined || existing.launchId === input.launchId))
         return existing;
     const resolvedEffective = taskSessionEffective(store, input.taskId, input.roleName, input.agentId, effectiveExisting);
@@ -3439,7 +2728,7 @@ function recordTaskRuntimeNativeSession(store, input, now) {
         nativeSessionId: input.nativeSessionId,
         ...(input.launchId === undefined ? {} : { launchId: input.launchId }),
         policy: "fixed",
-        status: "running",
+        status: "active",
         effective: effectiveExisting?.effective ?? effective
     }, now);
     store.saveRoleSessionSet(updated);
@@ -3453,7 +2742,7 @@ function recordGlobalRuntimeNativeSession(store, input, now) {
         ?? 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.launchId, "Native session registration conflicts with the fixed global Role session.");
-    if (existing?.status === "running"
+    if (existing?.status === "active"
         && (input.launchId === undefined || existing.launchId === input.launchId))
         return existing;
     const resolvedEffective = globalSessionEffective(role, effectiveExisting);
@@ -3472,7 +2761,7 @@ function recordGlobalRuntimeNativeSession(store, input, now) {
         nativeSessionId: input.nativeSessionId,
         ...(input.launchId === undefined ? {} : { launchId: input.launchId }),
         policy: "fixed",
-        status: "running",
+        status: "active",
         effective
     }, now);
     store.saveGlobalRoleSessionSet(updated);
@@ -3482,7 +2771,7 @@ function nativeTransitionExisting(store, owner, existing, nativeSessionId, launc
     if (existing === undefined || existing.nativeSessionId === nativeSessionId) {
         return existing;
     }
-    if ((existing.status === "stopped" || existing.status === "broken")
+    if (existing.status === "ended"
         && runtimeHookMatchesReservation(store, owner, launchId)) {
         return undefined;
     }
@@ -3584,6 +2873,7 @@ function mapSession(session) {
         ...(session.launchId === undefined ? {} : { launchId: session.launchId }),
         ...(session.title === undefined ? {} : { title: session.title }),
         status: session.status,
+        ...(session.endReason === undefined ? {} : { endReason: session.endReason }),
         effective: session.effective,
         updatedAt: session.updatedAt
     };
@@ -3599,6 +2889,9 @@ function saveTaskSession(store, role, session, status, now, launchId) {
         ...(session.title === undefined ? {} : { title: session.title }),
         policy: "fixed",
         status,
+        ...(status !== "ended" || session.endReason === undefined
+            ? {}
+            : { endReason: session.endReason }),
         effective: session.effective
     }, now);
     store.saveRoleSessionSet(updated);
@@ -3612,8 +2905,7 @@ function bindTaskRoleRunInFlight(store, role, run, now) {
             throw new Error("Task Role Session identity cannot change with an unsettled Run fence.");
         }
         const liveConflict = Object.values(current.sessions).find((session) => (session.agentId !== agentId
-            && session.status !== "stopped"
-            && session.status !== "broken"));
+            && session.status === "active"));
         if (liveConflict !== undefined) {
             throw new Error(`Task Role Session identity cannot change while ${liveConflict.agentId} is live.`);
         }
@@ -3667,27 +2959,6 @@ function clearTaskRoleRunInFlight(store, role, run, now) {
     }, now);
     store.saveRoleSessionSet(updated);
 }
-function breakTaskSessionIfPresent(store, taskId, roleName, agentId, now) {
-    updateTaskSessionStatusIfPresent(store, taskId, roleName, agentId, "broken", now);
-}
-function stopTaskSessionIfPresent(store, taskId, roleName, agentId, now) {
-    updateTaskSessionStatusIfPresent(store, taskId, roleName, agentId, "stopped", now);
-}
-function updateTaskSessionStatusIfPresent(store, taskId, roleName, agentId, status, now) {
-    const set = store.getRoleSessionSet(taskId, roleName);
-    if (set === null || set.sessions[agentId] === undefined)
-        return;
-    store.saveRoleSessionSet(updateRoleAgentSessionStatus(set, agentId, status, now));
-}
-function schedulerRoleSessionsMatch(current, expected) {
-    if (current === null || expected === null)
-        return current === expected;
-    return current.agentId === expected.agentId
-        && current.adapterId === expected.adapterId
-        && current.nativeSessionId === expected.nativeSessionId
-        && current.launchId === expected.launchId
-        && isDeepStrictEqual(current.effective, expected.effective);
-}
 /**
  * The durable Run/mailbox claim is the pre-Host delivery intent. The Host may
  * create a ProviderTurn only while that exact reservation still owns the Run;
@@ -3910,24 +3181,6 @@ function rejectSubmittingProviderTurn(store, target, delivery, now, reason) {
         reason
     }), now));
 }
-function deferUnprovenProviderRecovery(store, run, roleName, reason, now) {
-    if (run.providerRetry === undefined)
-        return;
-    const deferred = deferProviderRetry(run.providerRetry, now);
-    if (deferred === null) {
-        finalizeProviderRetryDeadline(store, run, reason, "native-resume-unproven", now);
-        return;
-    }
-    store.saveAgentRun(withProviderRetry(run, deferred));
-    const attentionEvent = createTaskEvent(store.nextEventId(run.taskId), run.taskId, "runtime.provider-recovery-attention", {
-        runId: run.id,
-        roleName,
-        reason,
-        nextAttemptAt: deferred.nextAttemptAt ?? ""
-    }, now);
-    store.saveEvent(run.taskId, attentionEvent);
-    routeRoleEvent(store, attentionEvent, roleName, "provider-recovery-attention", now);
-}
 function markSubmittingProviderTurnUnknown(store, target, delivery, now, reason) {
     if (target.kind !== "role"
         || delivery.executionRef.type !== "run"
@@ -3990,7 +3243,3 @@ function compareCanonicalObservationOrder(left, right) {
         || (left.ordinal ?? -1) - (right.ordinal ?? -1)
         || left.eventId.localeCompare(right.eventId);
 }
-function configuredProviderRetryPolicy(store) {
-    const config = providerRetryConfig(store.getConfig());
-    return { delaysMs: config.delaysMs, maxWindowMs: config.maxWindowMs };
-}