@zq-silk/yui 0.11.3 → 0.12.1

package/dist/controller/fileSchedulerStoreAdapter.js

@@ -1,18 +1,17 @@
 import { createHash } from "node:crypto";
 import { isDeepStrictEqual } from "node:util";
-import { activeLiveRoleAgentSession, bindTaskRoleProviderRuntime, bindTaskRoleRun, clearTaskRoleProviderRuntimeForCleanup, clearTaskRoleRun, createRoleSessionSet, markTaskRoleRunDelivered, markTaskRoleRunPushed, prepareTaskRoleRunRedispatch, recordRoleAgentSession, recordTaskRoleTurnBoundary, rememberRoleAgentCompletedTurn, updateRoleAgentSessionStatus, updateTaskRoleProviderRuntime } from "../executor/agentExecutor.js";
-import { acceptProviderTurn, beginProviderTurn, createProviderRuntimeBinding, endProviderActivation, currentProviderActivation, currentProviderConversation, markProviderTurnDeliveryUnknown, rejectProviderTurn, settleProviderTurn, startProviderActivation, supersedeProviderConversation, updateProviderConversationRecoverability } from "../runtime/providerRuntimeIdentity.js";
+import { activeLiveRoleAgentSession, bindTaskRoleProviderRuntime, bindTaskRoleRun, clearTaskRoleRun, createRoleSessionSet, markTaskRoleRunDelivered, markTaskRoleRunPushed, prepareTaskRoleRunRedispatch, recordRoleAgentSession, replaceTaskRoleAgentSessionForConversationSwitch, recordTaskRoleTurnBoundary, rememberRoleAgentCompletedTurn, stopTaskRoleRuntimeAfterPhysicalExit, updateRoleAgentSessionStatus, updateTaskRoleProviderRuntime } from "../executor/agentExecutor.js";
+import { acceptProviderTurn, beginProviderTurn, createProviderRuntimeBinding, endProviderActivation, currentProviderActivation, currentProviderConversation, markProviderTurnDeliveryUnknown, rejectProviderTurn, settleProviderTurnSubmission, settleProviderTurn, startProviderActivation, supersedeProviderConversation, updateProviderConversationRecoverability } from "../runtime/providerRuntimeIdentity.js";
+import { CONVERSATION_SWITCH_DETACHED_EVENT, CONVERSATION_SWITCH_RESOLVED_EVENT, conversationDetachmentBasis, conversationReplacementBasis, pendingConversationSwitch, roleSessionDispatchModeWithConversationSwitch } from "../runtime/conversationSwitch.js";
 import { decideProviderRecovery } from "../runtime/providerRecoveryDecision.js";
 import { hasRecentTurnId } from "../executor/turnCompletion.js";
 import { createTaskEvent } from "../event/taskEvent.js";
 import { operationalTaskRecords } from "../task/taskRecordRetirement.js";
 import { buildTaskWakeEnvelope } from "../context/wakeNotification.js";
 import { createTaskWake, fallbackWakeCursor, latestTaskWake } from "../scheduler/taskWake.js";
-import { rolloverTaskRoleSessionForContextBudget } from "../lifecycle/contextBudgetRollover.js";
-import { resolveContextBudget } from "../config/yuiConfig.js";
 import { answerInputRequest } from "../input/inputRequest.js";
 import { activeRoleAgentBinding, updateRoleStatus } from "../role/role.js";
-import { effectiveLaunchWithTaskMainWorkspace, effectiveLaunchSnapshotsCompatible, effectiveLaunchSnapshotsCompatibleForTaskMain, resolveEffectiveLaunch, validateEffectiveLaunchSnapshot } from "../executor/effectiveLaunch.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 { markWorkflowOutcomeRequestDispatched } from "../run/runControlRequest.js";
@@ -23,11 +22,11 @@ import { classifyRuntimeProcessExit, validateRuntimeProcessExitObservation } fro
 import { terminalizeExactTaskRun } from "../lifecycle/exactRunTerminalization.js";
 import { createCanonicalLifecycleEvent, foldCanonicalLifecycleEvent } from "../lifecycle/canonicalLifecycleEvent.js";
 import { recordLeaderFailure } from "../scheduler/leaderFailure.js";
-import { createLeaderRecoveryNotification, createLeaderStallNotification } from "../scheduler/operatorNotification.js";
+import { recordLeaderAttentionRequired, routeRoleEvent } from "../scheduler/operatorEvent.js";
 import { pendingWakeupsMatch } from "../scheduler/pendingWakeup.js";
 import { queueLeaderWakeup } from "../scheduler/wakeupQueue.js";
 import { wakeReason } from "../scheduler/wakeReason.js";
-import { foldRunProgressFacts, latestRunDurableProgressAt, latestRunEventTime, latestStallEvidenceKey, clearMatchingLeaderStallAttention, RUN_PROGRESS_EVENT, RUN_RECOVERED_EVENT, RUN_STALLED_EVENT } from "../scheduler/roleRunStall.js";
+import { foldRunProgressFacts, latestRunDurableProgressAt, latestRunEventTime, latestStallEvidenceKey, isRoleRunStalled, RUN_PROGRESS_EVENT, RUN_DIAGNOSTIC_FINISHED_EVENT, RUN_RECOVERED_EVENT, RUN_STALLED_EVENT } from "../scheduler/roleRunStall.js";
 import { projectProviderContinuations } from "../runtime/runtimeContinuationProjection.js";
 import { providerContinuationKey } from "../runtime/providerContinuation.js";
 import { currentWorkItemExecutionGroup, updateWorkItemExecutionGroup, updateWorkItemStatus, workItemOwnsUnresolvedExecutionLane } from "../workItem/workItem.js";
@@ -38,7 +37,7 @@ 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 { nativeSessionIdForLaunch } from "../runtime/preallocatedNativeSession.js";
 import { builtinAgentDriverRegistry } from "../runtime/builtinAgentDrivers.js";
-import { RUNTIME_OBSERVATION_TASK_EVENT, createRuntimeObservation, runtimeObservationFenceMatches, runtimeObservationFromTaskEvent, runtimeObservationRunFenceMatches, runtimeObservationTaskEventPayload } from "../runtime/runtimeObservation.js";
+import { RUNTIME_OBSERVATION_TASK_EVENT, createRuntimeObservation, isRuntimeTokenEvidence, runtimeObservationFenceMatches, runtimeObservationFromTaskEvent, runtimeObservationRunFenceMatches, runtimeObservationTaskEventPayload, runHasActiveRuntimeOperations } from "../runtime/runtimeObservation.js";
 import { projectRuntimeTaskEvents } from "../runtime/runtimeProjection.js";
 import { contextSnapshotRef } from "../context/contextSnapshot.js";
 import { contextSnapshotDeltaRefIds, freezeRunContextSnapshot } from "../context/runContextPack.js";
@@ -90,8 +89,7 @@ export class FileSchedulerStoreAdapter {
         if (adapterId === null) {
             return this.recordObsoleteCanonicalObservation(input, "driver-or-run-mismatch", now);
         }
-        if (this.store.listEvents(taskId).some((event) => (event.type === RUNTIME_OBSERVATION_TASK_EVENT
-            && event.payload.semanticKey === input.semanticKey)))
+        if (hasPersistedRuntimeObservation(this.store.listEvents(taskId), input))
             return "applied";
         let outcome;
         switch (input.kind) {
@@ -112,6 +110,7 @@ export class FileSchedulerStoreAdapter {
                     launchId: input.fence.launchId,
                     nativeSessionId: input.fence.nativeSessionId,
                     turnId: input.fence.nativeTurnId,
+                    attemptId: input.fence.receiptId,
                     runId: input.fence.runId,
                     summary: input.payload.summary ?? "Agent turn completed without a workflow outcome."
                 };
@@ -152,6 +151,7 @@ export class FileSchedulerStoreAdapter {
                         launchId: input.fence.launchId,
                         nativeSessionId: input.fence.nativeSessionId,
                         turnId: input.fence.nativeTurnId,
+                        attemptId: input.fence.receiptId,
                         runId: input.fence.runId,
                         summary: input.payload.summary ?? `Provider Turn failed: ${failureEvidence.code}.`,
                         providerStatus: "failed"
@@ -223,7 +223,8 @@ export class FileSchedulerStoreAdapter {
         }
         if (outcome === "applied"
             && input.kind === "activity.observed"
-            && input.payload.activityId !== undefined) {
+            && input.payload.activityId !== undefined
+            && input.payload.usage === undefined) {
             this.clearProviderRetryForProgress(input, "correlated-activity", now);
         }
         if (outcome === "applied")
@@ -251,9 +252,9 @@ export class FileSchedulerStoreAdapter {
     }
     validateCanonicalRunObservation(input, now) {
         return this.store.transaction((store) => {
-            if (store.listEvents(input.fence.taskId).some((event) => (event.type === RUNTIME_OBSERVATION_TASK_EVENT
-                && event.payload.semanticKey === input.semanticKey)))
+            if (hasPersistedRuntimeObservation(store.listEvents(input.fence.taskId), input)) {
                 return "applied";
+            }
             const run = store.getAgentRun(input.fence.taskId, input.fence.runId);
             const active = store.getActiveAgentRun(input.fence.taskId, input.fence.roleName);
             const sessions = store.getTaskRoleSessionSet(input.fence.taskId, input.fence.roleName);
@@ -386,12 +387,14 @@ export class FileSchedulerStoreAdapter {
                     const message = [
                         `Leader native Session became unavailable while Run ${active.id} remains active.`,
                         "Yui preserved the Run because Session/host termination is not a workflow outcome.",
-                        "Inspect native-child and mailbox facts, then explicitly continue, reset, or request user input."
+                        "Inspect native-child and mailbox facts, then explicitly diagnose, recover the Run, request a Conversation switch, or request user input."
                     ].join(" ");
-                    store.saveOperatorNotification(createLeaderRecoveryNotification(input.fence.taskId, message, now, store.getOperatorNotification(input.fence.taskId)));
-                    enqueueWork(store, { kind: "operator" }, "leader-runtime-detached", now, [
-                        { type: "run", taskId: input.fence.taskId, id: active.id }
-                    ]);
+                    recordLeaderAttentionRequired(store, {
+                        taskId: input.fence.taskId,
+                        reason: "leader-runtime-detached",
+                        payload: { message, runId: active.id },
+                        now
+                    });
                 }
                 else {
                     enqueueWork(store, {
@@ -410,22 +413,16 @@ export class FileSchedulerStoreAdapter {
         this.store.transaction((store) => {
             const taskId = input.fence.taskId;
             const events = store.listEvents(taskId);
-            if (events.some((event) => (event.type === RUNTIME_OBSERVATION_TASK_EVENT
-                && event.payload.semanticKey === input.semanticKey)))
+            if (hasPersistedRuntimeObservation(events, input))
                 return;
             if (usageSnapshotIsSuperseded(events, input))
                 return;
-            const confirmedActivity = confirmedUsageActivityObservation(events, input);
-            const removable = [
-                ...compactedRuntimeObservationIds(events, input),
-                ...(confirmedActivity === null
-                    ? []
-                    : compactedRuntimeObservationIds(events, confirmedActivity))
-            ];
+            const removable = compactedRuntimeObservationIds(events, input);
             if (removable.length > 0)
                 store.removeEvents(taskId, removable);
             const observationEventId = store.nextEventId(taskId);
-            store.saveEvent(taskId, createTaskEvent(observationEventId, taskId, RUNTIME_OBSERVATION_TASK_EVENT, runtimeObservationTaskEventPayload(input), now));
+            const observationEvent = createTaskEvent(observationEventId, taskId, RUNTIME_OBSERVATION_TASK_EVENT, runtimeObservationTaskEventPayload(input), now);
+            store.saveEvent(taskId, observationEvent);
             if (input.kind === "native-work.snapshot"
                 && input.payload.snapshotComplete === true
                 && input.payload.observationQuality === "exact") {
@@ -503,14 +500,9 @@ export class FileSchedulerStoreAdapter {
                 // 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")) {
-                    enqueueWork(store, role.name === "leader"
-                        ? { kind: "operator" }
-                        : { kind: "role", taskId, roleName: "leader" }, "detached-native-subagent-terminal", now, [{ type: "run", taskId, id: input.fence.runId }]);
+                    routeRoleEvent(store, observationEvent, role.name, "detached-native-subagent-terminal", now);
                 }
             }
-            if (confirmedActivity !== null) {
-                store.saveEvent(taskId, createTaskEvent(store.nextEventId(taskId), taskId, RUNTIME_OBSERVATION_TASK_EVENT, runtimeObservationTaskEventPayload(confirmedActivity), now));
-            }
         });
         if (this.telemetry !== null && input.fence.runId !== undefined) {
             try {
@@ -573,9 +565,6 @@ export class FileSchedulerStoreAdapter {
     withRuntimeEventTransaction(execute) {
         return this.store.withRuntimeEventTransaction(execute);
     }
-    getPresentationContext() {
-        return { timeZone: this.store.getConfig().timeZone };
-    }
     listTasks() { return this.store.listTasks(); }
     listActiveTaskIds() {
         return [...this.store.listActiveTaskIds()].sort((left, right) => (left.localeCompare(right, undefined, { numeric: true })));
@@ -608,12 +597,6 @@ export class FileSchedulerStoreAdapter {
             });
         });
     }
-    rolloverTaskRoleSessionForContextBudget(input) {
-        return this.store.transaction((reader) => rolloverTaskRoleSessionForContextBudget(reader, input.taskId, input.roleName, { peakTokens: input.peakTokens, hardTokens: input.hardTokens }, input.now));
-    }
-    getContextBudget() {
-        return resolveContextBudget(this.store.getConfig().contextBudget);
-    }
     listRoles(taskId) {
         return this.store.listRoles(taskId).map((role) => mapRole(this.store, role));
     }
@@ -646,6 +629,17 @@ export class FileSchedulerStoreAdapter {
             adapterId: effectiveSession.effective.adapterId
         };
     }
+    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));
+        });
+    }
     resolveExpiredInputRecommendations(now, taskIds) {
         return this.store.transaction((store) => {
             const selectedTaskIds = taskIds === undefined
@@ -725,6 +719,27 @@ export class FileSchedulerStoreAdapter {
         // the fold as present and skips the per-candidate fallback scans.
         return latestRunDurableProgressAt(view, taskId, roleName, runId, projected.runFacts.get(runId) ?? {});
     }
+    recordRoleRunDiagnostic(input) {
+        return this.store.transaction((store) => {
+            const task = store.getTask(input.taskId);
+            const run = store.getActiveAgentRun(input.taskId, input.roleName);
+            if (task === null || task.status !== "active"
+                || run === null || run.id !== input.runId || run.status !== "active") {
+                return "state-changed";
+            }
+            const latest = latestRunEventTime(store.listEvents(input.taskId), RUN_DIAGNOSTIC_FINISHED_EVENT, input.runId);
+            if (latest !== undefined && Date.parse(latest) >= Date.parse(input.startedAt)) {
+                return "already-recorded";
+            }
+            store.saveEvent(input.taskId, createTaskEvent(store.nextEventId(input.taskId), input.taskId, RUN_DIAGNOSTIC_FINISHED_EVENT, {
+                runId: input.runId,
+                roleName: input.roleName,
+                outcome: input.outcome,
+                startedAt: input.startedAt
+            }, input.now));
+            return "recorded";
+        });
+    }
     recordRoleRunStall(input) {
         return this.store.transaction((store) => {
             const task = store.getTask(input.taskId);
@@ -756,18 +771,9 @@ export class FileSchedulerStoreAdapter {
                 progressAt: input.progressAt,
                 idleMs: String(Math.max(0, Math.floor(input.idleMs))),
                 evidenceKey: input.evidenceKey,
-                status: "needs-attention"
+                status: "diagnostic-only"
             }, input.now);
             store.saveEvent(task.id, event);
-            if (role.name === "leader") {
-                store.saveOperatorNotification(createLeaderStallNotification(task.id, run.id, input.progressAt, input.evidenceKey, input.now, store.getOperatorNotification(task.id)));
-                enqueueWork(store, { kind: "operator" }, "leader-run-stalled", input.now, [
-                    { type: "task", id: task.id }
-                ]);
-            }
-            else {
-                queueLeaderWakeup(store, task.id, wakeReason("role-run-stalled"), input.now);
-            }
             return "raised";
         });
     }
@@ -795,10 +801,9 @@ export class FileSchedulerStoreAdapter {
                     || (typeof event.payload.progressAt === "string"
                         && Number.isFinite(Date.parse(event.payload.progressAt))
                         && Date.parse(event.payload.progressAt) >= Date.parse(input.progressAt)))));
-            const stalledAt = latestRunEventTime(events, RUN_STALLED_EVENT, run.id);
-            const recoveredAt = latestRunEventTime(events, RUN_RECOVERED_EVENT, run.id);
-            const recovered = stalledAt !== undefined
-                && (recoveredAt === undefined || Date.parse(recoveredAt) <= Date.parse(stalledAt));
+            // Advisory 30-minute diagnostics are intentionally not lifecycle
+            // episodes and therefore must never synthesize run.recovered.
+            const recovered = isRoleRunStalled(events, run.id);
             if (!existing) {
                 store.saveEvent(task.id, createTaskEvent(store.nextEventId(task.id), task.id, RUN_PROGRESS_EVENT, {
                     runId: run.id,
@@ -815,7 +820,6 @@ export class FileSchedulerStoreAdapter {
                     progressAt: input.progressAt,
                     kind: "durable-progress"
                 }, input.now));
-                clearMatchingLeaderStallAttention(store, task.id, run.id);
             }
             return existing && !recovered ? "already-recorded" : "recorded";
         });
@@ -824,11 +828,92 @@ export class FileSchedulerStoreAdapter {
         const sessions = this.store.getTaskRoleSessionSet(taskId, roleName);
         return sessions !== null && sessions.inFlight !== null;
     }
+    detachAgentHostProviderForConversationSwitch(input) {
+        return this.store.transaction((store) => {
+            const sessions = store.getTaskRoleSessionSet(input.taskId, input.roleName);
+            const run = store.getAgentRun(input.taskId, input.runId);
+            const mailbox = store.getWorkMailbox({
+                kind: "role",
+                taskId: input.taskId,
+                roleName: input.roleName
+            });
+            const binding = sessions?.providerBinding;
+            const session = sessions?.sessions[input.agentId];
+            const task = store.getTask(input.taskId);
+            const role = store.getRole(input.taskId, input.roleName);
+            const activeRun = store.getActiveAgentRun(input.taskId, input.roleName);
+            if (task === null || task.status !== "active"
+                || role === null || role.activeAgentId !== input.agentId
+                || sessions === null || sessions === undefined
+                || run === null || run.status !== "active" || run.mode !== "new"
+                || activeRun?.id !== run.id
+                || run.effective.agentId !== input.agentId
+                || session?.nativeSessionId !== input.previousNativeSessionId
+                || binding === null || binding === undefined
+                || currentProviderConversation(binding).conversationId !== input.previousConversationId
+                || sessions.inFlight?.runId !== input.runId
+                || mailbox?.processing?.batchId !== sessions.inFlight.receiptId
+                || mailbox.processing.owner !== "controller"
+                || mailbox.processing.executionRef?.type !== "run"
+                || mailbox.processing.executionRef.taskId !== input.taskId
+                || mailbox.processing.executionRef.id !== input.runId
+                || mailbox.inputDelivery !== null
+                || pendingConversationSwitch(store.listEvents(input.taskId), input.roleName, sessions) === null
+                || !runtimeHookMatchesReservation(store, { scope: "task", taskId: input.taskId, roleName: input.roleName }, input.launchId)
+                || input.nextAuthorityHolderId !== input.launchId) {
+                throw new Error("Provider Conversation detachment no longer matches the exact switch Run.");
+            }
+            const target = binding.activations.find((entry) => (entry.activationId === input.previousActivationId
+                && entry.conversationId === input.previousConversationId));
+            if (target === undefined) {
+                throw new Error("Provider Conversation detachment targets an unknown Activation.");
+            }
+            if (target.status !== "active") {
+                if (binding.authority.owner !== "none"
+                    || input.nextAuthorityEpoch !== binding.authority.epoch + 1) {
+                    throw new Error("Provider Conversation detachment replay has a stale authority fence.");
+                }
+                return "already-detached";
+            }
+            if (conversationDetachmentBasis({
+                sessions,
+                events: store.listEvents(input.taskId),
+                mailbox,
+                roleName: input.roleName,
+                runId: input.runId,
+                runMode: run.mode
+            }) !== "actor-request"
+                || binding.authority.owner !== "controller"
+                || binding.authority.holderId !== target.activationId
+                || input.nextAuthorityEpoch !== binding.authority.epoch + 2) {
+                throw new Error("Provider Conversation detachment is not authorized at this boundary.");
+            }
+            const detached = endProviderActivation(binding, target.activationId, {
+                status: "ended",
+                endedAt: input.now.toISOString(),
+                reason: "conversation-switch"
+            });
+            store.saveTaskRoleSessionSet(updateTaskRoleProviderRuntime(sessions, detached, input.now));
+            store.saveEvent(input.taskId, createTaskEvent(store.nextEventId(input.taskId), input.taskId, CONVERSATION_SWITCH_DETACHED_EVENT, {
+                runId: input.runId,
+                roleName: input.roleName,
+                launchId: input.launchId,
+                conversationId: input.previousConversationId,
+                activationId: input.previousActivationId
+            }, input.now));
+            return "detached";
+        });
+    }
     beginAgentHostProviderTurn(input) {
         this.store.transaction((store) => {
             const sessions = store.getTaskRoleSessionSet(input.taskId, input.roleName);
             const session = sessions?.sessions[input.agentId];
             const binding = sessions?.providerBinding;
+            const mailbox = store.getWorkMailbox({
+                kind: "role",
+                taskId: input.taskId,
+                roleName: input.roleName
+            });
             if (sessions === null || sessions === undefined
                 || binding === null || binding === undefined
                 || sessions.inFlight?.runId !== input.runId
@@ -838,7 +923,8 @@ export class FileSchedulerStoreAdapter {
                 || currentProviderConversation(binding).conversationId !== input.nativeSessionId
                 || binding.authority.owner !== input.authorityOwner
                 || binding.authority.epoch !== input.authorityEpoch
-                || binding.authority.holderId !== input.holderId) {
+                || binding.authority.holderId !== input.holderId
+                || !processingOwnsExactInitialDelivery(mailbox, input.taskId, input.runId, input.attemptId)) {
                 throw new AgentHostProviderTurnFenceError("Agent Host Provider Turn carries a stale durable writer fence. Release and reacquire Provider authority before retrying input.");
             }
             const exactReplay = binding.turn?.attemptId === input.attemptId
@@ -863,21 +949,15 @@ export class FileSchedulerStoreAdapter {
             if (sessions === null || sessions === undefined
                 || binding === null || binding === undefined
                 || binding.runId !== input.runId
-                || binding.turn?.attemptId !== input.attemptId
-                || binding.turn.status !== "submitting") {
+                || binding.turn?.attemptId !== input.attemptId) {
                 throw new Error("Agent Host Provider Turn submission is no longer current.");
             }
-            const updated = input.status === "delivery-unknown"
-                ? markProviderTurnDeliveryUnknown(binding, {
-                    attemptId: input.attemptId,
-                    observedAt: input.now.toISOString(),
-                    reason: input.reason
-                })
-                : rejectProviderTurn(binding, {
-                    attemptId: input.attemptId,
-                    rejectedAt: input.now.toISOString(),
-                    reason: input.reason
-                });
+            const updated = settleProviderTurnSubmission(binding, {
+                attemptId: input.attemptId,
+                status: input.status,
+                reason: input.reason,
+                resolvedAt: input.now.toISOString()
+            });
             store.saveTaskRoleSessionSet(updateTaskRoleProviderRuntime(sessions, updated, input.now));
         });
     }
@@ -900,68 +980,6 @@ export class FileSchedulerStoreAdapter {
             ...binding.authority
         };
     }
-    beginRoleRunProviderTurn(input) {
-        return this.store.transaction((store) => {
-            const sessions = store.getTaskRoleSessionSet(input.taskId, input.roleName);
-            const session = sessions?.sessions[input.agentId];
-            const binding = sessions?.providerBinding;
-            if (sessions === null || sessions === undefined
-                || binding === null || binding === undefined
-                || sessions.inFlight?.runId !== input.runId
-                || binding.runId !== input.runId
-                || session?.launchId !== input.launchId
-                || session.nativeSessionId !== input.nativeSessionId
-                || currentProviderConversation(binding).conversationId !== input.nativeSessionId
-                || binding.authority.owner !== "controller")
-                return false;
-            store.saveTaskRoleSessionSet(updateTaskRoleProviderRuntime(sessions, beginProviderTurn(binding, {
-                attemptId: input.attemptId,
-                authorityEpoch: binding.authority.epoch,
-                submittedAt: input.now.toISOString()
-            }), input.now));
-            return true;
-        });
-    }
-    resolveRoleRunProviderSubmission(input) {
-        return this.store.transaction((store) => {
-            const sessions = store.getTaskRoleSessionSet(input.taskId, input.roleName);
-            const binding = sessions?.providerBinding;
-            if (sessions === null || sessions === undefined
-                || binding === null || binding === undefined
-                || binding.runId !== input.runId
-                || binding.turn?.attemptId !== input.attemptId
-                || binding.turn.status !== "submitting")
-                return false;
-            const updated = input.status === "delivery-unknown"
-                ? markProviderTurnDeliveryUnknown(binding, {
-                    attemptId: input.attemptId,
-                    observedAt: input.now.toISOString(),
-                    reason: input.reason
-                })
-                : rejectProviderTurn(binding, {
-                    attemptId: input.attemptId,
-                    rejectedAt: input.now.toISOString(),
-                    reason: input.reason
-                });
-            store.saveTaskRoleSessionSet(updateTaskRoleProviderRuntime(sessions, updated, input.now));
-            return true;
-        });
-    }
-    isRoleGenerationProviderReady(input) {
-        // A session.ready observation for this exact generation is the durable
-        // pre-input fence. This reads folded Driver truth
-        // only — no liveness, screen, or pane/PID inference. Served from the
-        // revision projection: a stale miss only repeats an idempotent first push.
-        return this.listEvents(input.taskId).some((event) => {
-            const observation = runtimeObservationFromTaskEvent(event);
-            return observation?.kind === "session.ready"
-                && observation.fence.roleName === input.roleName
-                && observation.fence.agentId === input.agentId
-                && (input.launchId === undefined || observation.fence.launchId === input.launchId)
-                && (input.nativeSessionId === undefined
-                    || observation.fence.nativeSessionId === input.nativeSessionId);
-        });
-    }
     peekNextAgentRunId(taskId) {
         return this.store.peekNextAgentRunId(taskId);
     }
@@ -1161,17 +1179,11 @@ export class FileSchedulerStoreAdapter {
             const unknown = markMailboxInputDeliveryUnknown(mailbox, attemptId, reason, now);
             markSubmittingProviderTurnUnknown(store, target, mailbox.inputDelivery, now, reason);
             store.saveWorkMailbox(unknown);
-            const taskId = target.kind === "role" ? target.taskId : undefined;
-            if (taskId !== undefined) {
-                store.saveEvent(taskId, createTaskEvent(store.nextEventId(taskId), taskId, "run.input-delivery-unknown", { attemptId, reason }, now));
-                enqueueWork(store, { kind: "operator" }, "run-input-delivery-unknown", now, [
-                    unknown.inputDelivery.executionRef
-                ], {
-                    source: "input-router",
-                    dedupeKey: `input-delivery-unknown:${attemptId}`,
-                    deliveryMode: "followup",
-                    lane: "normal"
-                });
+            if (target.kind === "role") {
+                const taskId = target.taskId;
+                const event = createTaskEvent(store.nextEventId(taskId), taskId, "run.input-delivery-unknown", { attemptId, reason }, now);
+                store.saveEvent(taskId, event);
+                routeRoleEvent(store, event, target.roleName, "run-input-delivery-unknown", now);
             }
             return true;
         });
@@ -1228,12 +1240,6 @@ export class FileSchedulerStoreAdapter {
             }
             const owner = runtimeOwnerFromTarget(target);
             markRuntimeOwnerSessionStopped(store, owner, now);
-            if (owner.scope === "task") {
-                const sessions = store.getTaskRoleSessionSet(owner.taskId, owner.roleName);
-                if (sessions !== null && sessions.providerBinding !== null) {
-                    store.saveTaskRoleSessionSet(clearTaskRoleProviderRuntimeForCleanup(sessions, now));
-                }
-            }
             saveRuntimeLifecycleMailbox(store, mailbox);
             return true;
         });
@@ -1298,7 +1304,6 @@ export class FileSchedulerStoreAdapter {
     }
     clearPendingWakeup(taskId) { this.store.clearPendingWakeup(taskId); }
     getLeaderFailure(taskId) { return this.store.getLeaderFailure(taskId); }
-    getOperatorNotification(taskId) { return this.store.getOperatorNotification(taskId); }
     saveLeaderDispatch(input) {
         return this.store.transaction((store) => {
             const task = store.getTask(input.task.id);
@@ -1371,14 +1376,15 @@ export class FileSchedulerStoreAdapter {
                     now: input.now
                 }));
             }
-            if (input.session !== null && input.session.nativeSessionId !== undefined) {
+            if (input.run.mode !== "new"
+                && input.session !== null
+                && input.session.nativeSessionId !== undefined) {
                 saveTaskSession(store, role, {
                     ...input.session,
                     nativeSessionId: input.session.nativeSessionId
                 }, "running", input.now);
             }
             store.clearLeaderFailure(input.task.id);
-            store.clearOperatorNotification(input.task.id);
             return "claimed";
         });
     }
@@ -1469,9 +1475,13 @@ export class FileSchedulerStoreAdapter {
             if (input.session !== null && input.session.nativeSessionId !== undefined) {
                 const existing = store.getRoleSession(input.task.id, input.role.name);
                 matchingPreparedRuntimeReservation(store, input);
-                if (existing?.nativeSessionId !== input.session.nativeSessionId
-                    || (input.launchId !== undefined && existing.launchId !== input.launchId)
-                    || existing.status !== "running") {
+                const defersConversationReplacement = active.mode === "new"
+                    && existing !== null
+                    && existing.nativeSessionId !== input.session.nativeSessionId;
+                if (!defersConversationReplacement
+                    && (existing?.nativeSessionId !== input.session.nativeSessionId
+                        || (input.launchId !== undefined && existing.launchId !== input.launchId)
+                        || existing.status !== "running")) {
                     saveTaskSession(store, role, {
                         ...input.session,
                         nativeSessionId: input.session.nativeSessionId
@@ -1515,7 +1525,8 @@ export class FileSchedulerStoreAdapter {
                 || !preparedReservationMatches(runtimeMailbox, input.taskId, input.runId, input.launchId)) {
                 return "state-changed";
             }
-            const summary = `Role delivery retry limit exhausted before exact Run input delivery: ${input.runId}.`;
+            const summary = input.summary
+                ?? `Role delivery retry limit exhausted before exact Run input delivery: ${input.runId}.`;
             const result = terminalizeExactTaskRun(store, {
                 taskId: input.taskId,
                 roleName: input.roleName,
@@ -1531,17 +1542,20 @@ export class FileSchedulerStoreAdapter {
             if (result.disposition !== "applied" || result.run === null) {
                 return "state-changed";
             }
-            enqueueWork(store, runtimeLifecycleTarget({
-                scope: "task",
-                taskId: input.taskId,
-                roleName: input.roleName
-            }), RUNTIME_CLEANUP_REQUIRED_REASON, input.now, [{ type: "task", id: input.taskId }]);
+            if (input.cleanupRequired !== false) {
+                enqueueWork(store, runtimeLifecycleTarget({
+                    scope: "task",
+                    taskId: input.taskId,
+                    roleName: input.roleName
+                }), RUNTIME_CLEANUP_REQUIRED_REASON, input.now, [{ type: "task", id: input.taskId }]);
+            }
             const terminal = result.run;
-            store.saveEvent(input.taskId, createTaskEvent(store.nextEventId(input.taskId), input.taskId, "runtime.role-delivery-failed", {
+            const deliveryFailureEvent = createTaskEvent(store.nextEventId(input.taskId), input.taskId, "runtime.role-delivery-failed", {
                 runId: terminal.id,
                 roleName: input.roleName,
                 outcome: terminal.status
-            }, input.now));
+            }, input.now);
+            store.saveEvent(input.taskId, deliveryFailureEvent);
             if (terminal.purpose === "execution" && terminal.workItemId !== undefined) {
                 const item = store.getWorkItem(input.taskId, terminal.workItemId);
                 if (item !== null && ![
@@ -1553,12 +1567,7 @@ export class FileSchedulerStoreAdapter {
                 }
             }
             if (input.roleName !== "leader") {
-                enqueueWork(store, { kind: "role", taskId: input.taskId, roleName: "leader" }, terminal.purpose === "review" ? "review-failed" : "role-run-failed", input.now, [
-                    { type: "run", taskId: input.taskId, id: terminal.id },
-                    ...(terminal.workItemId === undefined
-                        ? []
-                        : [{ type: "work-item", taskId: input.taskId, id: terminal.workItemId }])
-                ]);
+                routeRoleEvent(store, deliveryFailureEvent, input.roleName, terminal.purpose === "review" ? "review-failed" : "role-run-failed", input.now);
             }
             else {
                 const failedRole = store.getRole(input.taskId, input.roleName);
@@ -1566,11 +1575,7 @@ export class FileSchedulerStoreAdapter {
                     store.saveRole(input.taskId, updateRoleStatus(failedRole, "failed", input.now));
                 }
                 store.saveLeaderFailure(recordLeaderFailure(input.taskId, session?.nativeSessionId ?? "(unregistered)", summary, input.now, store.getLeaderFailure(input.taskId)));
-                store.saveOperatorNotification(createLeaderRecoveryNotification(input.taskId, summary, input.now, store.getOperatorNotification(input.taskId)));
-                enqueueWork(store, { kind: "operator" }, "leader-run-failed", input.now, [
-                    { type: "task", id: input.taskId },
-                    { type: "run", taskId: input.taskId, id: terminal.id }
-                ]);
+                routeRoleEvent(store, deliveryFailureEvent, input.roleName, "leader-run-failed", input.now);
             }
             return "failed";
         });
@@ -1606,10 +1611,15 @@ export class FileSchedulerStoreAdapter {
             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);
-            store.saveOperatorNotification(createLeaderRecoveryNotification(input.task.id, input.notification.message, input.now, store.getOperatorNotification(input.task.id)));
-            enqueueWork(store, { kind: "operator" }, "leader-recovery-failed", input.now, [
-                { type: "task", id: input.task.id }
-            ]);
+            recordLeaderAttentionRequired(store, {
+                taskId: input.task.id,
+                reason: "leader-recovery-failed",
+                payload: {
+                    message: input.failure.message,
+                    runId: active.id
+                },
+                now: input.now
+            });
             return "failed";
         });
     }
@@ -1661,7 +1671,6 @@ export class FileSchedulerStoreAdapter {
                 }, input.now);
                 if (terminal.disposition !== "applied")
                     return "state-changed";
-                clearMatchingLeaderStallAttention(store, task.id, currentRun.id);
                 store.saveRole(task.id, updateRoleStatus(role, "exited", input.now));
                 stopTaskSessionIfPresent(store, task.id, role.name, currentRun.effective.agentId, input.now);
                 queueLeaderWakeup(store, task.id, wakeReason("review-failed"), input.now);
@@ -1679,7 +1688,6 @@ export class FileSchedulerStoreAdapter {
                 }
             }
             store.saveAgentRun(failAgentRun(currentRun, input.summary, input.now));
-            clearMatchingLeaderStallAttention(store, task.id, currentRun.id);
             store.clearActiveAgentRun(task.id, role.name);
             clearTaskRoleRunInFlight(store, role, currentRun, input.now);
             if (mailbox !== null && processing !== null && processing !== undefined) {
@@ -1945,6 +1953,7 @@ export class FileSchedulerStoreAdapter {
             const role = requireRole(store, input.taskId, input.roleName);
             let sessions = store.getTaskRoleSessionSet(input.taskId, input.roleName)
                 ?? createRoleSessionSet({ scope: "task", taskId: input.taskId, roleName: input.roleName }, input.agentId, now);
+            const canonicalTurnId = canonicalStructuredProviderTurnId(sessions, input.turnId, input.attemptId);
             const existing = sessions.sessions[input.agentId];
             const owner = {
                 scope: "task",
@@ -1961,7 +1970,7 @@ export class FileSchedulerStoreAdapter {
                 throw new Error("Runtime turn completion does not match the effective launch identity.");
             }
             if (effectiveExisting !== undefined
-                && hasRecentTurnId(effectiveExisting.recentCompletedTurnIds, input.turnId)) {
+                && hasRecentTurnId(effectiveExisting.recentCompletedTurnIds, canonicalTurnId)) {
                 return { session: effectiveExisting, duplicate: true };
             }
             if (sessions.inFlight === null
@@ -1998,9 +2007,9 @@ export class FileSchedulerStoreAdapter {
                     : sessions.inFlight === null ? idleStatus : "running",
                 effective
             }, now);
-            sessions = settleStructuredProviderTurn(sessions, input.turnId, input.providerStatus ?? "completed", now);
+            sessions = settleStructuredProviderTurn(sessions, canonicalTurnId, input.providerStatus ?? "completed", now);
             if (sessions.inFlight === null) {
-                sessions = rememberRoleAgentCompletedTurn(sessions, input.agentId, input.nativeSessionId, input.turnId, now);
+                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
@@ -2024,7 +2033,7 @@ export class FileSchedulerStoreAdapter {
             sessions = recordTaskRoleTurnBoundary(sessions, {
                 agentId: input.agentId,
                 nativeSessionId: input.nativeSessionId,
-                turnId: input.turnId
+                turnId: canonicalTurnId
             }, now);
             store.saveTaskRoleSessionSet(sessions);
             completeRuntimeHookReservation(store, owner, input.launchId);
@@ -2109,27 +2118,16 @@ export class FileSchedulerStoreAdapter {
             if (role !== null) {
                 store.saveRole(input.taskId, updateRoleStatus(role, input.roleName === "leader" ? "failed" : "idle", now));
             }
-            store.saveEvent(input.taskId, createTaskEvent(store.nextEventId(input.taskId), input.taskId, "runtime.turn-failed", {
+            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));
-            if (input.roleName !== "leader") {
-                enqueueWork(store, { kind: "role", taskId: input.taskId, roleName: "leader" }, before.purpose === "review" ? "review-failed" : "role-run-failed", now, [
-                    { type: "run", taskId: input.taskId, id: terminal.id },
-                    ...(terminal.workItemId === undefined
-                        ? []
-                        : [{ type: "work-item", taskId: input.taskId, id: terminal.workItemId }])
-                ]);
-            }
-            else {
-                store.saveOperatorNotification(createLeaderRecoveryNotification(input.taskId, summary, now, store.getOperatorNotification(input.taskId)));
-                enqueueWork(store, { kind: "operator" }, "leader-run-failed", now, [
-                    { type: "task", id: input.taskId },
-                    { type: "run", taskId: input.taskId, id: terminal.id }
-                ]);
-            }
+            }, 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 };
         });
     }
@@ -2222,14 +2220,12 @@ export class FileSchedulerStoreAdapter {
                 if (blocked.outcome === "exhausted")
                     return null;
                 store.saveAgentRun(withProviderRetry(run, blocked.retry));
-                this.recordProviderRetryClassified(store, input, classification.errorClass, {
+                const classifiedEvent = this.recordProviderRetryClassified(store, input, classification.errorClass, {
                     wouldRetry: "false",
                     shadow: "false",
                     note: "delivery-deduplication-unproven"
                 }, now);
-                enqueueWork(store, input.roleName === "leader"
-                    ? { kind: "operator" }
-                    : { kind: "role", taskId: input.taskId, roleName: "leader" }, "provider-delivery-uncertain", now, [{ type: "run", taskId: input.taskId, id: input.runId }]);
+                routeRoleEvent(store, classifiedEvent, input.roleName, "provider-delivery-uncertain", now);
                 return { disposition: "applied", runId: input.runId };
             }
         }
@@ -2314,22 +2310,14 @@ export class FileSchedulerStoreAdapter {
         if (retryDecision.outcome === "exhausted")
             return null;
         store.saveAgentRun(withProviderRetry(run, retryDecision.retry));
-        this.recordProviderRetryClassified(store, input, "policy-denied", {
+        const classifiedEvent = this.recordProviderRetryClassified(store, input, "policy-denied", {
             wouldRetry: "false",
             shadow: "false",
             note: "policy-denied-blocker"
         }, now);
-        if (input.roleName !== "leader") {
-            enqueueWork(store, { kind: "role", taskId: input.taskId, roleName: "leader" }, "provider-policy-blocked", now, [{ type: "run", taskId: input.taskId, id: input.runId }]);
-        }
-        else {
-            const message = `Leader Run ${input.runId} is blocked by Provider policy: ${summary}`;
-            store.saveOperatorNotification(createLeaderRecoveryNotification(input.taskId, message, now, store.getOperatorNotification(input.taskId)));
-            enqueueWork(store, { kind: "operator" }, "leader-provider-policy-blocked", now, [
-                { type: "task", id: input.taskId },
-                { type: "run", taskId: input.taskId, id: input.runId }
-            ]);
-        }
+        routeRoleEvent(store, classifiedEvent, input.roleName, input.roleName === "leader"
+            ? "leader-provider-policy-blocked"
+            : "provider-policy-blocked", now);
         return { disposition: "applied", runId: input.runId };
     }
     /**
@@ -2355,7 +2343,7 @@ export class FileSchedulerStoreAdapter {
             return null;
         store.saveAgentRun(withProviderRetry(run, decision.retry));
         const driver = this.drivers.requireByAdapterId(input.adapterId);
-        store.saveEvent(input.taskId, createTaskEvent(store.nextEventId(input.taskId), input.taskId, "runtime.context-capacity-failure", {
+        const capacityEvent = createTaskEvent(store.nextEventId(input.taskId), input.taskId, "runtime.context-capacity-failure", {
             eventId: input.eventId,
             runId: input.runId,
             roleName: input.roleName,
@@ -2366,15 +2354,14 @@ export class FileSchedulerStoreAdapter {
             action: driver.capabilities.lifecycle.compaction === "native-explicit"
                 ? "native-explicit-compaction-required"
                 : "await-provider-native-recovery"
-        }, now));
+        }, now);
+        store.saveEvent(input.taskId, capacityEvent);
         this.recordProviderRetryClassified(store, input, "context-capacity", {
             wouldRetry: "false",
             shadow: "false",
             note: "provider-native-capacity-recovery-only"
         }, now);
-        enqueueWork(store, input.roleName === "leader"
-            ? { kind: "operator" }
-            : { kind: "role", taskId: input.taskId, roleName: "leader" }, "provider-context-capacity-recovery-required", now, [{ type: "run", taskId: input.taskId, id: input.runId }]);
+        routeRoleEvent(store, capacityEvent, input.roleName, "provider-context-capacity-recovery-required", now);
         return { disposition: "applied", runId: input.runId };
     }
     applyNativeSessionRecoverabilityBlock(store, input, summary, now) {
@@ -2393,27 +2380,28 @@ export class FileSchedulerStoreAdapter {
         if (decision.outcome === "exhausted")
             return null;
         store.saveAgentRun(withProviderRetry(run, decision.retry));
-        store.saveEvent(input.taskId, createTaskEvent(store.nextEventId(input.taskId), input.taskId, "runtime.native-session-recoverability-unproven", {
+        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));
-        enqueueWork(store, input.roleName === "leader"
-            ? { kind: "operator" }
-            : { kind: "role", taskId: input.taskId, roleName: "leader" }, "native-session-recoverability-unproven", now, [{ type: "run", taskId: input.taskId, id: input.runId }]);
+        }, 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) {
-        store.saveEvent(input.taskId, createTaskEvent(store.nextEventId(input.taskId), input.taskId, "runtime.provider-retry-classified", {
+        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));
+        }, now);
+        store.saveEvent(input.taskId, event);
+        return event;
     }
     /**
      * Issue 04 durable retry timer: lists active Runs whose in-place retry is
@@ -2474,7 +2462,7 @@ export class FileSchedulerStoreAdapter {
     /**
      * Issue 04: reopens each due retry on its original Native Session. A Run
      * whose Session is proven dead terminalizes with an exact replacement
-     * blocker; a live Session is reset for the existing delivery path, which
+     * 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) {
@@ -2507,9 +2495,10 @@ export class FileSchedulerStoreAdapter {
                     || !providerRetryIsDue(run.providerRetry, now)) {
                     return;
                 }
-                let sessions = store.getTaskRoleSessionSet(entry.taskId, entry.roleName);
+                const sessions = store.getTaskRoleSessionSet(entry.taskId, entry.roleName);
                 const providerBinding = sessions?.providerBinding;
                 let recoveryMode = "resume";
+                let replacementRequired = false;
                 if (providerBinding === null || providerBinding === undefined) {
                     deferUnprovenProviderRecovery(store, run, entry.roleName, "Provider Conversation identity is missing; automatic recovery is fenced.", now);
                     return;
@@ -2554,13 +2543,7 @@ export class FileSchedulerStoreAdapter {
                         deferUnprovenProviderRecovery(store, run, entry.roleName, "Provider replacement lacks an exact missing-Conversation observation.", now);
                         return;
                     }
-                    recoveryMode = "new";
-                    const currentSession = sessions?.sessions[run.effective.agentId];
-                    if (sessions !== null && currentSession !== undefined
-                        && currentSession.status !== "broken") {
-                        sessions = updateRoleAgentSessionStatus(sessions, run.effective.agentId, "broken", now);
-                        store.saveTaskRoleSessionSet(sessions);
-                    }
+                    replacementRequired = true;
                 }
                 const session = sessions?.sessions[run.effective.agentId];
                 const identityMatches = session !== undefined
@@ -2580,21 +2563,25 @@ export class FileSchedulerStoreAdapter {
                         return;
                     }
                     store.saveAgentRun(withProviderRetry(run, deferred));
-                    if (!store.listEvents(entry.taskId).some((event) => (event.type === "runtime.provider-retry-native-resume-unproven"
-                        && event.payload.runId === run.id))) {
-                        store.saveEvent(entry.taskId, createTaskEvent(store.nextEventId(entry.taskId), entry.taskId, "runtime.provider-retry-native-resume-unproven", {
+                    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));
+                        }, now);
+                        store.saveEvent(entry.taskId, attentionEvent);
                     }
-                    enqueueWork(store, { kind: "operator" }, "provider-retry-native-resume-unproven", now, [
-                        { type: "task", id: entry.taskId },
-                        { type: "run", taskId: entry.taskId, id: run.id }
-                    ]);
+                    routeRoleEvent(store, attentionEvent, entry.roleName, "provider-retry-native-resume-unproven", now);
                     return;
                 }
-                if (hasUnsettledRuntimeOperations(store, entry.taskId, run.id)) {
+                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);
@@ -2603,6 +2590,21 @@ export class FileSchedulerStoreAdapter {
                     store.saveAgentRun(withProviderRetry(run, deferred));
                     return;
                 }
+                if (replacementRequired) {
+                    try {
+                        recoveryMode = roleSessionDispatchModeWithConversationSwitch(sessions, store.listEvents(entry.taskId), roleMailbox, entry.roleName, run.effective.agentId, run.effective);
+                    }
+                    catch (error) {
+                        deferUnprovenProviderRecovery(store, run, entry.roleName, error instanceof Error
+                            ? error.message
+                            : "Independent Conversation-switch evaluation failed closed.", now);
+                        return;
+                    }
+                    if (recoveryMode !== "new") {
+                        deferUnprovenProviderRecovery(store, run, entry.roleName, "Independent Conversation-switch evaluation kept the current Conversation.", now);
+                        return;
+                    }
+                }
                 // Reopen the Run on its original Session: reset transport markers,
                 // switch to resume, and mark the projection in-flight. The delivery
                 // pass re-pushes the exact same input in this same pass.
@@ -2712,7 +2714,30 @@ export class FileSchedulerStoreAdapter {
                             recordCanonicalObservationObsolete(store, input, "bind-state-missing", now);
                             return "obsolete";
                         }
-                        const bound = recordRoleAgentSession(sessions, {
+                        const mailbox = store.getWorkMailbox({
+                            kind: "role",
+                            taskId,
+                            roleName: input.fence.roleName
+                        });
+                        const existingNativeSessionId = sessions.sessions[input.fence.agentId]
+                            ?.nativeSessionId;
+                        const replacingNativeSession = existingNativeSessionId !== undefined
+                            && existingNativeSessionId !== decision.outcome.nativeSessionId;
+                        const replacementBasis = replacingNativeSession
+                            ? conversationReplacementBasis({
+                                sessions,
+                                events: store.listEvents(taskId),
+                                mailbox,
+                                roleName: input.fence.roleName,
+                                runId: run.id,
+                                runMode: run.mode
+                            })
+                            : null;
+                        if (replacingNativeSession && replacementBasis === null) {
+                            recordCanonicalObservationObsolete(store, input, "conversation-switch-not-authorized", now);
+                            return "obsolete";
+                        }
+                        const sessionInput = {
                             agentId: input.fence.agentId,
                             adapterId,
                             nativeSessionId: decision.outcome.nativeSessionId,
@@ -2720,9 +2745,20 @@ export class FileSchedulerStoreAdapter {
                             policy: "fixed",
                             status: "running",
                             effective: run.effective
-                        }, now);
-                        const withProvider = bindOrSupersedeProviderRuntime(bound, input, now);
+                        };
+                        const bound = replacementBasis === null
+                            ? recordRoleAgentSession(sessions, sessionInput, now)
+                            : replaceTaskRoleAgentSessionForConversationSwitch(sessions, sessionInput, now);
+                        const withProvider = bindOrSupersedeProviderRuntime(bound, input, now, replacementBasis ?? undefined);
                         store.saveTaskRoleSessionSet(withProvider);
+                        if (replacementBasis === "actor-request") {
+                            resolveConversationSwitchRequest(store, taskId, input.fence.roleName, sessions, "applied", now, {
+                                conversationId: input.fence.conversationId
+                                    ?? decision.outcome.nativeSessionId,
+                                activationId: input.fence.activationId ?? input.fence.launchId,
+                                launchId: input.fence.launchId
+                            });
+                        }
                         const driver = this.drivers.require(input.fence.driverId);
                         if (driver.capabilities.observation.sessionBootstrap === "discovered"
                             && run.pushedAt === undefined) {
@@ -2943,7 +2979,6 @@ export class FileSchedulerStoreAdapter {
             return null;
         const sessionSet = store.getTaskRoleSessionSet(fence.taskId, fence.roleName);
         const session = sessionSet?.sessions[fence.agentId] ?? null;
-        const boundNativeSessionId = session?.nativeSessionId;
         if (runId === undefined) {
             return {
                 fence,
@@ -2952,7 +2987,9 @@ export class FileSchedulerStoreAdapter {
                 pushed: false,
                 accepted: false,
                 terminal: false,
-                ...(boundNativeSessionId === undefined ? {} : { boundNativeSessionId })
+                ...(session?.nativeSessionId === undefined
+                    ? {}
+                    : { boundNativeSessionId: session.nativeSessionId })
             };
         }
         const run = store.getAgentRun(fence.taskId, runId);
@@ -2964,8 +3001,15 @@ export class FileSchedulerStoreAdapter {
             || inFlight.agentId !== run.effective.agentId)
             return null;
         const owner = { scope: "task", taskId: fence.taskId, roleName: fence.roleName };
-        const launchId = session?.launchId
-            ?? (runtimeHookMatchesReservation(store, owner, fence.launchId) ? fence.launchId : undefined);
+        const freshConversationLaunch = run.mode === "new"
+            && runtimeHookMatchesReservation(store, owner, fence.launchId);
+        const boundNativeSessionId = freshConversationLaunch
+            ? undefined
+            : session?.nativeSessionId;
+        const launchId = freshConversationLaunch
+            ? fence.launchId
+            : session?.launchId
+                ?? (runtimeHookMatchesReservation(store, owner, fence.launchId) ? fence.launchId : undefined);
         if (launchId === undefined)
             return null;
         const expectedFence = {
@@ -3027,7 +3071,8 @@ export class FileSchedulerStoreAdapter {
                 && !runtimeHookMatchesReservation(store, owner, input.launchId)) {
                 throw new Error("Runtime turn completion does not match the global launch reservation.");
             }
-            const effectiveExisting = nativeTransitionExisting(store, owner, existing, input.nativeSessionId, input.launchId, "Runtime turn completion conflicts with the fixed global Role session.");
+            const nativeSessionId = globalCompletionNativeSessionId(existing, input);
+            const effectiveExisting = nativeTransitionExisting(store, owner, existing, nativeSessionId, input.launchId, "Runtime turn completion conflicts with the fixed global Role session.");
             const effective = globalSessionEffective(role, effectiveExisting);
             if (effective.agentId !== input.agentId || effective.adapterId !== input.adapterId) {
                 throw new Error("Runtime turn completion does not match the effective global launch identity.");
@@ -3039,7 +3084,7 @@ export class FileSchedulerStoreAdapter {
             current = recordRoleAgentSession(current, {
                 agentId: input.agentId,
                 adapterId: input.adapterId,
-                nativeSessionId: input.nativeSessionId,
+                nativeSessionId,
                 ...(input.launchId === undefined ? {} : { launchId: input.launchId }),
                 title: effectiveExisting?.title ?? input.title,
                 preview: effectiveExisting?.preview ?? (input.summary === undefined ? undefined : sessionPreview(input.summary)),
@@ -3047,7 +3092,7 @@ export class FileSchedulerStoreAdapter {
                 status: completedStatus,
                 effective
             }, now);
-            current = rememberRoleAgentCompletedTurn(current, input.agentId, input.nativeSessionId, input.turnId, now);
+            current = rememberRoleAgentCompletedTurn(current, input.agentId, nativeSessionId, input.turnId, now);
             store.saveGlobalRoleSessionSet(current);
             completeRuntimeHookReservation(store, owner, input.launchId);
             return current.sessions[input.agentId];
@@ -3066,9 +3111,10 @@ export class FileSchedulerStoreAdapter {
         if (existing === undefined
             && !runtimeHookMatchesReservation(this.store, owner, input.launchId))
             return "obsolete";
+        const nativeSessionId = globalCompletionNativeSessionId(existing, input);
         let effectiveExisting;
         try {
-            effectiveExisting = nativeTransitionExisting(this.store, owner, existing, input.nativeSessionId, input.launchId, "Runtime turn completion conflicts with the fixed global Role session.");
+            effectiveExisting = nativeTransitionExisting(this.store, owner, existing, nativeSessionId, input.launchId, "Runtime turn completion conflicts with the fixed global Role session.");
         }
         catch {
             return "obsolete";
@@ -3080,14 +3126,6 @@ export class FileSchedulerStoreAdapter {
         return "apply";
     }
 }
-function hasUnsettledRuntimeOperations(store, taskId, runId) {
-    return store.listEvents(taskId).some((event) => {
-        const observation = runtimeObservationFromTaskEvent(event);
-        return observation !== null
-            && observation.fence.runId === runId
-            && observation.kind === "operation.started";
-    });
-}
 function runtimeTurnFailureSummary(input) {
     return [
         "Agent runtime turn failed.",
@@ -3313,9 +3351,12 @@ 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)
             return false;
-        store.saveTaskRoleSessionSet(updateRoleAgentSessionStatus(sessions, sessions.activeAgentId, "stopped", now));
+        const stopped = stopTaskRoleRuntimeAfterPhysicalExit(sessions, now);
+        if (stopped === sessions)
+            return false;
+        store.saveTaskRoleSessionSet(stopped);
         return true;
     }
     const sessions = store.getGlobalRoleSessionSet(owner.roleName);
@@ -3369,7 +3410,7 @@ function finalizeProviderRetryDeadline(store, run, summary, reason, now) {
     if (terminalization.disposition !== "applied" || terminalization.run === null)
         return false;
     const terminal = terminalization.run;
-    store.saveEvent(run.taskId, createTaskEvent(store.nextEventId(run.taskId), run.taskId, "runtime.provider-retry-exhausted", {
+    const exhaustionEvent = createTaskEvent(store.nextEventId(run.taskId), run.taskId, "runtime.provider-retry-exhausted", {
         runId: run.id,
         roleName: run.roleName,
         episodeId: retry.episodeId,
@@ -3377,7 +3418,8 @@ function finalizeProviderRetryDeadline(store, run, summary, reason, now) {
         consecutiveFailures: String(retry.consecutiveFailures),
         dispatchedRetries: String(retry.dispatchedRetries),
         elapsedMs: String(Math.max(0, now.getTime() - Date.parse(retry.firstFailureAt)))
-    }, now));
+    }, now);
+    store.saveEvent(run.taskId, exhaustionEvent);
     if (terminal.purpose === "execution" && terminal.workItemId !== undefined) {
         const item = store.getWorkItem(run.taskId, terminal.workItemId);
         if (item !== null
@@ -3392,15 +3434,8 @@ function finalizeProviderRetryDeadline(store, run, summary, reason, now) {
     }
     if (run.roleName === "leader") {
         store.saveLeaderFailure(recordLeaderFailure(run.taskId, retry.nativeSessionId ?? "(unproven)", summary, now, store.getLeaderFailure(run.taskId)));
-        store.saveOperatorNotification(createLeaderRecoveryNotification(run.taskId, summary, now, store.getOperatorNotification(run.taskId)));
-        enqueueWork(store, { kind: "operator" }, "provider-retry-exhausted", now, [
-            { type: "task", id: run.taskId },
-            { type: "run", taskId: run.taskId, id: run.id }
-        ]);
-    }
-    else {
-        enqueueWork(store, { kind: "role", taskId: run.taskId, roleName: "leader" }, "provider-retry-exhausted", now, [{ type: "run", taskId: run.taskId, id: run.id }]);
     }
+    routeRoleEvent(store, exhaustionEvent, run.roleName, "provider-retry-exhausted", now);
     return true;
 }
 function preparedDeliveryFailureSessionFenceMatches(sessions, session, input, expectedReceiptId) {
@@ -3475,7 +3510,7 @@ function recordTaskRuntimeNativeSession(store, input, now) {
     const effective = input.effective === undefined
         ? resolvedEffective
         : validateEffectiveLaunchSnapshot(input.effective);
-    if (!effectiveLaunchSnapshotsCompatibleForTaskMain(resolvedEffective, effective, store.getTaskWorkspace(input.taskId))) {
+    if (!effectiveLaunchSnapshotsCompatibleForTaskSession(resolvedEffective, effective)) {
         throw new Error("Reserved native Session effective launch changed before persistence.");
     }
     if (effective.agentId !== input.agentId || effective.adapterId !== input.adapterId) {
@@ -3536,6 +3571,17 @@ function nativeTransitionExisting(store, owner, existing, nativeSessionId, launc
     }
     throw new Error(conflictMessage);
 }
+function globalCompletionNativeSessionId(existing, input) {
+    // Codex app-server and its notify Hook expose different native IDs for the
+    // same launch. The launch generation remains the authoritative fence.
+    return input.adapterId === "codex"
+        && input.launchId !== undefined
+        && existing?.launchId === input.launchId
+        && existing.agentId === input.agentId
+        && existing.adapterId === input.adapterId
+        ? existing.nativeSessionId
+        : input.nativeSessionId;
+}
 function mapRole(store, role) {
     const binding = activeRoleAgentBinding(role);
     const item = store.listWorkItems(role.taskId).find((candidate) => (candidate.assignee === role.name
@@ -3581,8 +3627,7 @@ function taskSessionEffective(store, taskId, roleName, agentId, existing) {
             throw new Error(`Native Session registration does not match the effective Run Agent: ${taskId}/${roleName}.`);
         }
         if (existing !== undefined) {
-            const workspace = active.workspace ?? store.getTaskWorkspace(taskId);
-            if (!effectiveLaunchSnapshotsCompatibleForTaskMain(existing.effective, active.effective, workspace)) {
+            if (!effectiveLaunchSnapshotsCompatibleForTaskSession(existing.effective, active.effective)) {
                 throw new Error(`Native Session effective launch does not match the active Run: ${taskId}/${roleName}.`);
             }
             return existing.effective;
@@ -3727,6 +3772,19 @@ function schedulerRoleSessionsMatch(current, expected) {
         && 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;
+ * this closes the gap where a Session could start without any user Turn.
+ */
+function processingOwnsExactInitialDelivery(mailbox, taskId, runId, attemptId) {
+    const processing = mailbox?.processing;
+    return processing?.batchId === attemptId
+        && processing.owner === "controller"
+        && processing.executionRef?.type === "run"
+        && processing.executionRef.taskId === taskId
+        && processing.executionRef.id === runId;
+}
 function matchesStallSessionFence(current, expected) {
     if (current === null || expected === null)
         return current === expected;
@@ -3788,11 +3846,10 @@ function runtimeObservationTelemetryEntry(input) {
     };
 }
 /**
- * Runtime observations are a current-state snapshot, not an append-only
- * semantic history. Retain active operations, one latest usage baseline, and
- * one latest confirmed activity boundary so a token stream remains
- * O(active operations) per Run without losing the delta that was already
- * proven before an unchanged later snapshot arrived.
+ * Usage observations and incomplete request boundaries are authoritative
+ * read-only history: retain each one so consecutive deltas remain projectable.
+ * Other activity observations are a current explicit boundary and may replace
+ * their predecessor. Token evidence never becomes lifecycle activity.
  */
 function compactedRuntimeObservationIds(events, incoming) {
     const existing = events.flatMap((event) => {
@@ -3809,9 +3866,10 @@ function compactedRuntimeObservationIds(events, incoming) {
     });
     const remove = ({ observation }) => {
         if (incoming.kind === "activity.observed") {
+            if (isRuntimeTokenEvidence(incoming))
+                return false;
             return observation.kind === "activity.observed"
-                && (observation.payload.usage === undefined)
-                    === (incoming.payload.usage === undefined);
+                && !isRuntimeTokenEvidence(observation);
         }
         if (incoming.kind === "operation.started") {
             return (observation.kind === "operation.started"
@@ -3854,7 +3912,6 @@ function recordStructuredProviderAcceptance(sessions, input, now) {
     if (current === null || attemptId === undefined || turnId === undefined)
         return sessions;
     if (current.turn?.attemptId === attemptId
-        && current.turn.turnId === turnId
         && ["accepted", "running", "completed", "failed", "cancelled"].includes(current.turn.status))
         return sessions;
     const binding = acceptProviderTurn(current, {
@@ -3864,7 +3921,21 @@ function recordStructuredProviderAcceptance(sessions, input, now) {
     });
     return updateTaskRoleProviderRuntime(sessions, binding, now);
 }
-function bindOrSupersedeProviderRuntime(sessions, input, now) {
+/**
+ * A Provider may expose the same accepted input through more than one exact
+ * observation surface. Preserve the first native Turn identity bound to the
+ * durable attempt; a later transport alias may settle that same attempt but
+ * must neither replace nor strand the canonical identity.
+ */
+function canonicalStructuredProviderTurnId(sessions, observedTurnId, attemptId) {
+    const turn = sessions.providerBinding?.turn;
+    return attemptId !== undefined
+        && turn?.attemptId === attemptId
+        && turn.turnId !== undefined
+        ? turn.turnId
+        : observedTurnId;
+}
+function bindOrSupersedeProviderRuntime(sessions, input, now, replacementBasis) {
     if (sessions.inFlight === null)
         return sessions;
     const conversationId = input.fence.conversationId ?? input.fence.nativeSessionId;
@@ -3899,9 +3970,22 @@ function bindOrSupersedeProviderRuntime(sessions, input, now) {
         conversationId,
         activationId,
         switchedAt: input.observedAt ?? input.receivedAt,
-        noUnsettledInputDelivery
+        noUnsettledInputDelivery,
+        ...(replacementBasis === undefined ? {} : { basis: replacementBasis })
     }), now);
 }
+function resolveConversationSwitchRequest(store, taskId, roleName, previousSessions, status, now, replacement) {
+    const request = pendingConversationSwitch(store.listEvents(taskId), roleName, previousSessions);
+    if (request === null)
+        return;
+    store.saveEvent(taskId, createTaskEvent(store.nextEventId(taskId), taskId, CONVERSATION_SWITCH_RESOLVED_EVENT, {
+        requestId: request.requestId,
+        roleName,
+        generation: request.generation,
+        status,
+        ...(replacement === undefined ? {} : replacement)
+    }, now));
+}
 function rejectSubmittingProviderTurn(store, target, delivery, now, reason) {
     if (target.kind !== "role"
         || delivery.executionRef.type !== "run"
@@ -3931,16 +4015,14 @@ function deferUnprovenProviderRecovery(store, run, roleName, reason, now) {
         return;
     }
     store.saveAgentRun(withProviderRetry(run, deferred));
-    store.saveEvent(run.taskId, createTaskEvent(store.nextEventId(run.taskId), run.taskId, "runtime.provider-recovery-attention", {
+    const attentionEvent = createTaskEvent(store.nextEventId(run.taskId), run.taskId, "runtime.provider-recovery-attention", {
         runId: run.id,
         roleName,
         reason,
         nextAttemptAt: deferred.nextAttemptAt ?? ""
-    }, now));
-    enqueueWork(store, { kind: "operator" }, "provider-recovery-attention", now, [
-        { type: "task", id: run.taskId },
-        { type: "run", taskId: run.taskId, id: run.id }
-    ]);
+    }, 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"
@@ -3974,39 +4056,6 @@ function settleStructuredProviderTurn(sessions, turnId, status, now) {
         settledAt: now.toISOString()
     }), now);
 }
-function confirmedUsageActivityObservation(events, incoming) {
-    const usage = incoming.payload.usage;
-    if (incoming.kind !== "activity.observed" || usage === undefined)
-        return null;
-    const previous = events
-        .map(runtimeObservationFromTaskEvent)
-        .filter((observation) => (observation !== null
-        && observation.kind === "activity.observed"
-        && observation.payload.usage !== undefined
-        && runtimeObservationFenceMatches(observation.fence, incoming.fence)))
-        .sort(compareCanonicalObservationOrder)
-        .at(-1)?.payload.usage;
-    if (previous === undefined
-        || usage.inputTokens + usage.outputTokens
-            <= previous.inputTokens + previous.outputTokens)
-        return null;
-    const digest = createHash("sha256")
-        .update(`confirmed-runtime-activity\0${incoming.eventId}`)
-        .digest("hex");
-    return createRuntimeObservation({
-        schemaVersion: 2,
-        eventId: `runtime-activity-${digest}`,
-        semanticKey: `runtime-activity-${digest}`,
-        kind: "activity.observed",
-        authority: "controller",
-        receivedAt: incoming.receivedAt,
-        ...(incoming.observedAt === undefined ? {} : { observedAt: incoming.observedAt }),
-        ...(incoming.sequence === undefined ? {} : { sequence: incoming.sequence }),
-        ...(incoming.ordinal === undefined ? {} : { ordinal: incoming.ordinal }),
-        fence: incoming.fence,
-        payload: { activity: incoming.payload.activity ?? "model" }
-    });
-}
 function usageSnapshotIsSuperseded(events, incoming) {
     if (incoming.kind !== "activity.observed" || incoming.payload.usage === undefined) {
         return false;
@@ -4019,6 +4068,15 @@ function usageSnapshotIsSuperseded(events, incoming) {
         && runtimeObservationFenceMatches(observation.fence, incoming.fence)
         && observationIsStrictlyNewer(observation, incoming));
 }
+function hasPersistedRuntimeObservation(events, incoming) {
+    const usageIdentity = isRuntimeTokenEvidence(incoming)
+        ? incoming.eventId
+        : undefined;
+    return events.some((event) => (event.type === RUNTIME_OBSERVATION_TASK_EVENT
+        && (usageIdentity === undefined
+            ? event.payload.semanticKey === incoming.semanticKey
+            : event.payload.eventId === usageIdentity)));
+}
 function observationIsStrictlyNewer(left, right) {
     return compareCanonicalObservationOrder(left, right) > 0;
 }