@zq-silk/yui 0.14.1 → 0.14.2

package/dist/controller/fileSchedulerStoreAdapter.js

@@ -12,8 +12,8 @@ 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 { appendTurnInput, createTurn } from "../turn/turn.js";
+import { transportAgentResult } from "../domain/agentResultTransport.js";
 import { createTurnInput } from "../context/turnInputContract.js";
-import { parseReviewResultReport } from "../review/reviewRound.js";
 import { classifyRuntimeProcessExit, validateRuntimeProcessExitObservation } from "../runtime/processExitObservation.js";
 import { terminalizeExactTaskTurn } from "../lifecycle/exactTurnTerminalization.js";
 import { createCanonicalLifecycleEvent, foldCanonicalLifecycleEvent } from "../lifecycle/canonicalLifecycleEvent.js";
@@ -28,13 +28,14 @@ import { projectProviderContinuations } from "../runtime/runtimeContinuationProj
 import { providerContinuationKey } from "../runtime/providerContinuation.js";
 import { formatTurnReceiptId } from "../task/taskRecordReference.js";
 import { bindExecution, claimPending, completeProcessing, consumePendingBatch, mailboxHasPending, mailboxHasWork, releaseProcessing } from "../coordination/workMailbox.js";
-import { enqueueWork } from "../coordination/workMailboxQueue.js";
+import { enqueueWork, settleRoleTurnDispatch as settleRoleTurnDispatchMailbox } from "../coordination/workMailboxQueue.js";
 import { RUNTIME_CLEANUP_REQUIRED_REASON, RUNTIME_HOST_DETACH_REQUIRED_REASON, RUNTIME_LAUNCH_RESERVED_REASON, RUNTIME_LIFECYCLE_OWNER, RuntimeLifecycleBusyError, hasRuntimeCleanupObligation, hasRuntimeLifecycleWork, isRuntimeCleanupReason, isRuntimeLaunchReservation, runtimeCleanupDisposition, runtimeLifecycleTarget } from "../runtime/lifecycleReservation.js";
 import { nativeSessionIdForLaunch } from "../runtime/preallocatedNativeSession.js";
 import { builtinAgentDriverRegistry } from "../runtime/builtinAgentDrivers.js";
 import { standardAgentError } from "../runtime/agentError.js";
 import { RUNTIME_OBSERVATION_TASK_EVENT, createRuntimeObservation, isRuntimeTokenEvidence, runtimeObservationFenceMatches, runtimeObservationFromTaskEvent, runtimeObservationTurnFenceMatches, runtimeObservationTaskEventPayload } from "../runtime/runtimeObservation.js";
 import { contextSnapshotRef } from "../context/contextSnapshot.js";
+import { snapshotExecutionLaneWorkspaceSync } from "../repository/executionLaneGitSnapshot.js";
 import { contextSnapshotDeltaRefIds, freezeTurnContextSnapshot } from "../context/turnContextPack.js";
 export class AgentHostProviderTurnFenceError extends Error {
     constructor(message) {
@@ -47,11 +48,13 @@ export class FileSchedulerStoreAdapter {
     store;
     telemetry;
     drivers;
+    snapshotExecutionLaneWorkspace;
     /** Diagnostic telemetry is optional and never participates in runtime truth. */
-    constructor(store, telemetry = null, drivers = builtinAgentDriverRegistry()) {
+    constructor(store, telemetry = null, drivers = builtinAgentDriverRegistry(), snapshotExecutionLaneWorkspace = snapshotExecutionLaneWorkspaceSync) {
         this.store = store;
         this.telemetry = telemetry;
         this.drivers = drivers;
+        this.snapshotExecutionLaneWorkspace = snapshotExecutionLaneWorkspace;
     }
     freezeLeaderContextSnapshot(taskId, roleName, now) {
         return this.store.transaction((tx) => {
@@ -96,29 +99,14 @@ export class FileSchedulerStoreAdapter {
             case "input.accepted":
                 outcome = this.observeRuntimePromptAccepted(input, adapterId, now);
                 break;
-            case "turn.completed": {
-                const classification = this.classifyRuntimeTurnCompleted({
-                    taskId,
-                    roleName: input.fence.roleName,
-                    agentId: input.fence.agentId,
-                    adapterId,
-                    launchId: input.fence.launchId,
-                    nativeSessionId: input.fence.nativeSessionId,
-                    nativeTurnId: input.fence.nativeTurnId,
-                    attemptId: input.fence.receiptId,
-                    turnId: input.fence.turnId
-                });
-                if (classification !== "apply")
-                    return classification;
-                outcome = this.foldProviderTurnBoundary(input, adapterId, "completed", input.payload.summary ?? "Agent turn completed without a workflow outcome.", now);
+            case "turn.completed":
+                outcome = this.foldProviderTurnBoundary(input, adapterId, "completed", now);
                 break;
-            }
             case "turn.failed": {
-                const failureEvidence = input.payload.failure;
                 // A Provider Turn is an activation boundary, not a Task outcome.
                 // Keep the Turn and Session identity available for Agent-directed
                 // restore + submit, even when a provider marks its Turn terminal.
-                outcome = this.foldProviderTurnBoundary(input, adapterId, "failed", input.payload.summary ?? `Agent Turn failed: ${failureEvidence.error.message}`, now);
+                outcome = this.foldProviderTurnBoundary(input, adapterId, "failed", now);
                 break;
             }
             case "operation.started":
@@ -135,7 +123,7 @@ export class FileSchedulerStoreAdapter {
                 outcome = this.validateCanonicalTurnObservation(input, now);
                 break;
             case "turn.cancelled": {
-                outcome = this.foldProviderTurnBoundary(input, adapterId, "cancelled", input.payload.summary ?? "Provider Turn was cancelled.", now);
+                outcome = this.foldProviderTurnBoundary(input, adapterId, "cancelled", now);
                 break;
             }
             case "conversation.observed":
@@ -220,9 +208,8 @@ export class FileSchedulerStoreAdapter {
                 && run.roleName === input.fence.roleName
                 && run.effective.agentId === input.fence.agentId
                 && this.drivers.requireByAdapterId(run.effective.adapterId).id === input.fence.driverId
-                && (knownContinuation || (session?.launchId === input.fence.launchId
-                    && session.nativeSessionId === input.fence.nativeSessionId
-                    && input.fence.sessionGenerationId === input.fence.launchId))
+                && (knownContinuation || (session?.runtimeGenerationId === input.fence.runtimeGenerationId
+                    && session.nativeSessionId === input.fence.nativeSessionId))
                 && runtimeReceiptBelongsToTurn(store, input);
             if (!valid) {
                 recordCanonicalObservationObsolete(store, input, "runtime-fence-not-current", now);
@@ -231,25 +218,42 @@ export class FileSchedulerStoreAdapter {
             return "applied";
         });
     }
-    foldProviderTurnBoundary(input, adapterId, providerStatus, summary, now) {
+    foldProviderTurnBoundary(input, adapterId, providerStatus, now) {
+        const outcome = providerStatus === "completed"
+            ? input.payload.resultTransportDiagnostic === undefined
+                ? transportAgentResult(input.payload.output)
+                : {
+                    status: "failed",
+                    diagnostic: input.payload.resultTransportDiagnostic,
+                    failureReason: "missing-result"
+                }
+            : {
+                status: "failed",
+                diagnostic: providerStatus === "cancelled"
+                    ? "Provider cancelled the Agent Turn."
+                    : `Provider Agent Turn failed: ${input.payload.failure?.error.message ?? "unknown provider failure"}`,
+                failureReason: providerStatus === "cancelled"
+                    ? "cancelled"
+                    : "runtime-failed"
+            };
         const completed = {
             taskId: input.fence.taskId,
             roleName: input.fence.roleName,
             agentId: input.fence.agentId,
             adapterId,
-            launchId: input.fence.launchId,
+            runtimeGenerationId: input.fence.runtimeGenerationId,
             nativeSessionId: input.fence.nativeSessionId,
             nativeTurnId: input.fence.nativeTurnId,
             attemptId: input.fence.receiptId,
             turnId: input.fence.turnId,
             ...(input.payload.input === undefined ? {} : { input: input.payload.input }),
-            summary,
-            providerStatus
+            providerStatus,
+            outcome
         };
-        const classification = this.classifyRuntimeTurnCompleted(completed);
+        const classification = this.classifyRuntimeTurnTerminal(completed);
         if (classification !== "apply")
             return classification;
-        const result = this.observeRuntimeTurnCompleted(completed, now);
+        const result = this.observeRuntimeTurnTerminal(completed, now);
         return result.disposition === "obsolete" ? "obsolete" : "applied";
     }
     validateCanonicalSessionObservation(input, now) {
@@ -261,16 +265,15 @@ export class FileSchedulerStoreAdapter {
                 || run.roleName !== input.fence.roleName
                 || run.effective.agentId !== input.fence.agentId
                 || this.drivers.requireByAdapterId(run.effective.adapterId).id !== input.fence.driverId
-                || session?.launchId !== input.fence.launchId
-                || session.nativeSessionId !== input.fence.nativeSessionId
-                || input.fence.sessionGenerationId !== input.fence.launchId) {
+                || session?.runtimeGenerationId !== input.fence.runtimeGenerationId
+                || session.nativeSessionId !== input.fence.nativeSessionId) {
                 recordCanonicalObservationObsolete(store, input, "runtime-session-not-current", now);
                 return "obsolete";
             }
             const status = "ended";
             let updatedSessions = updateRoleAgentSessionStatus(sessions, input.fence.agentId, status, now, input.kind === "session.failed" ? "failed" : "stopped");
             if (updatedSessions.providerBinding !== null) {
-                const activationId = input.fence.activationId ?? input.fence.launchId;
+                const activationId = input.fence.activationId ?? input.fence.runtimeGenerationId;
                 updatedSessions = updateTaskRoleProviderRuntime(updatedSessions, endProviderActivation(updatedSessions.providerBinding, activationId, {
                     status: input.kind === "session.failed" ? "failed" : "ended",
                     endedAt: input.observedAt ?? input.receivedAt,
@@ -283,14 +286,14 @@ export class FileSchedulerStoreAdapter {
                     || continuation.identity.conversationId
                         !== (input.fence.conversationId ?? input.fence.nativeSessionId)
                     || continuation.identity.activationId
-                        !== (input.fence.activationId ?? input.fence.launchId)
+                        !== (input.fence.activationId ?? input.fence.runtimeGenerationId)
                     || continuation.execution === "quiescent"
                     || continuation.attachment === "detached")
                     continue;
                 const key = providerContinuationKey(continuation.identity);
                 const identityDigest = createHash("sha256").update(key).digest("hex");
                 const detached = createRuntimeObservation({
-                    schemaVersion: 2,
+                    schemaVersion: 4,
                     eventId: `derived-continuation-detached:${identityDigest}`,
                     semanticKey: `continuation-detached:${identityDigest}`,
                     kind: "continuation.started",
@@ -319,17 +322,9 @@ export class FileSchedulerStoreAdapter {
                     }
                 });
                 const eventId = store.nextEventId(input.fence.taskId);
-                store.saveEvent(input.fence.taskId, createTaskEvent(eventId, input.fence.taskId, RUNTIME_OBSERVATION_TASK_EVENT, runtimeObservationTaskEventPayload(detached), now));
-                enqueueWork(store, {
-                    kind: "role",
-                    taskId: input.fence.taskId,
-                    roleName: "leader"
-                }, "provider-continuation-detached", now, [
-                    { type: "event", taskId: input.fence.taskId, id: eventId }
-                ], {
-                    source: input.fence.driverId,
-                    dedupeKey: detached.semanticKey
-                });
+                const detachedEvent = createTaskEvent(eventId, input.fence.taskId, RUNTIME_OBSERVATION_TASK_EVENT, runtimeObservationTaskEventPayload(detached), now);
+                store.saveEvent(input.fence.taskId, detachedEvent);
+                routeContinuationResult(store, detached, detachedEvent, "provider-continuation-detached", now);
             }
             const active = store.getActiveTurn(input.fence.taskId, input.fence.roleName);
             const role = store.getRole(input.fence.taskId, input.fence.roleName);
@@ -392,7 +387,7 @@ export class FileSchedulerStoreAdapter {
                         .update(`${input.semanticKey}\u0000${identityKey}`)
                         .digest("hex");
                     const settled = createRuntimeObservation({
-                        schemaVersion: 2,
+                        schemaVersion: 4,
                         eventId: `native-snapshot-settled:${digest}`,
                         semanticKey: `native-snapshot-settled:${digest}`,
                         kind: "continuation.settled",
@@ -419,21 +414,16 @@ export class FileSchedulerStoreAdapter {
                         }
                     });
                     const settledEventId = store.nextEventId(taskId);
-                    store.saveEvent(taskId, createTaskEvent(settledEventId, taskId, RUNTIME_OBSERVATION_TASK_EVENT, runtimeObservationTaskEventPayload(settled), now));
-                    enqueueWork(store, { kind: "role", taskId, roleName: "leader" }, "provider-continuation-settled", now, [{ type: "event", taskId, id: settledEventId }], {
-                        source: input.fence.driverId,
-                        dedupeKey: settled.semanticKey
-                    });
+                    const settledEvent = createTaskEvent(settledEventId, taskId, RUNTIME_OBSERVATION_TASK_EVENT, runtimeObservationTaskEventPayload(settled), now);
+                    store.saveEvent(taskId, settledEvent);
+                    routeContinuationResult(store, settled, settledEvent, "provider-continuation-settled", now);
                 }
             }
             if (input.kind === "continuation.reported"
                 || input.kind === "continuation.settled") {
-                enqueueWork(store, { kind: "role", taskId, roleName: "leader" }, input.kind === "continuation.reported"
+                routeContinuationResult(store, input, observationEvent, input.kind === "continuation.reported"
                     ? "provider-continuation-report"
-                    : "provider-continuation-settled", now, [{ type: "event", taskId, id: observationEventId }], {
-                    source: input.fence.driverId,
-                    dedupeKey: input.semanticKey
-                });
+                    : "provider-continuation-settled", now);
             }
             if ((input.kind === "goal.cleared"
                 || (input.kind === "goal.updated" && input.payload.goalStatus !== "active"))
@@ -456,7 +446,7 @@ export class FileSchedulerStoreAdapter {
                     agentId: input.fence.agentId,
                     adapterId: run?.effective.adapterId ?? "unknown",
                     driverId: input.fence.driverId,
-                    launchId: input.fence.launchId,
+                    runtimeGenerationId: input.fence.runtimeGenerationId,
                     nativeSessionId: input.fence.nativeSessionId ?? "",
                     nativeTurnId: input.fence.nativeTurnId ?? "",
                     source: error.source,
@@ -823,7 +813,7 @@ export class FileSchedulerStoreAdapter {
                 || binding === null || binding === undefined
                 || (input.turnId !== undefined
                     && (active?.id !== input.turnId || active.effective.agentId !== input.agentId))
-                || session?.launchId !== input.launchId
+                || session?.runtimeGenerationId !== input.runtimeGenerationId
                 || session.nativeSessionId !== input.nativeSessionId
                 || currentProviderConversation(binding).conversationId !== input.nativeSessionId
                 || binding.authority.owner !== input.authorityOwner
@@ -892,7 +882,7 @@ export class FileSchedulerStoreAdapter {
                 agentId: run?.effective.agentId ?? sessions.activeAgentId,
                 adapterId: run?.effective.adapterId ?? session?.adapterId ?? "unknown",
                 driverId: driver?.id ?? "unknown",
-                launchId: session?.launchId ?? "",
+                runtimeGenerationId: session?.runtimeGenerationId ?? "",
                 nativeSessionId: session?.nativeSessionId ?? "",
                 nativeTurnId: "",
                 source: error.source,
@@ -921,7 +911,7 @@ export class FileSchedulerStoreAdapter {
         const session = sessions?.sessions[input.agentId];
         const binding = sessions?.providerBinding;
         if (binding === null || binding === undefined
-            || session?.launchId !== input.launchId
+            || session?.runtimeGenerationId !== input.runtimeGenerationId
             || session.nativeSessionId !== input.nativeSessionId
             || currentProviderConversation(binding).conversationId !== input.nativeSessionId)
             return null;
@@ -996,7 +986,7 @@ export class FileSchedulerStoreAdapter {
                 agentId: run?.effective.agentId ?? session?.agentId ?? "unknown",
                 adapterId: run?.effective.adapterId ?? session?.adapterId ?? "unknown",
                 driverId: driver?.id ?? "unknown",
-                launchId: session?.launchId ?? "",
+                runtimeGenerationId: session?.runtimeGenerationId ?? "",
                 nativeSessionId: session?.nativeSessionId ?? "",
                 nativeTurnId: "",
                 source: error.source,
@@ -1048,9 +1038,9 @@ export class FileSchedulerStoreAdapter {
      * the Leader wakeup. A terminal job without its wakeup enqueued is a lost
      * wakeup, so the two writes commit together or not at all.
      *
-     * f6: The wakeup targets the Leader role mailbox (not the Task mailbox)
-     * and also queues a pending wakeup so processLeaderWakeups dispatches
-     * the Leader Turn with the exact job-finished reason.
+     * f6: The wakeup targets the Leader role mailbox (not the Task mailbox).
+     * That mailbox is also the PendingWakeup authority consumed by
+     * processLeaderWakeups, so the signal must be enqueued exactly once.
      */
     transitionDurableJob(taskId, jobId, transition, now, wakeup) {
         return this.store.transaction((store) => {
@@ -1061,7 +1051,6 @@ export class FileSchedulerStoreAdapter {
             store.saveDurableJob(taskId, next);
             if (wakeup !== undefined) {
                 enqueueWork(store, { kind: "role", taskId, roleName: "leader" }, wakeup.reason, now, [...wakeup.refs]);
-                queueLeaderWakeup(store, taskId, wakeup.reason, now);
             }
             return next;
         });
@@ -1098,17 +1087,8 @@ export class FileSchedulerStoreAdapter {
             return { status: "claimed", processing: claimed.processing };
         });
     }
-    consumeWorkMailbox(target, expected) {
-        return this.store.transaction((store) => {
-            const mailbox = store.getWorkMailbox(target);
-            if (mailbox?.pending === null || mailbox?.pending === undefined
-                || mailbox.pending.fromSequence !== expected.fromSequence
-                || mailbox.pending.toSequence < expected.toSequence) {
-                return false;
-            }
-            store.saveWorkMailbox(consumePendingBatch(mailbox, expected));
-            return true;
-        });
+    settleRoleTurnDispatch(input) {
+        return this.store.transaction((store) => (settleRoleTurnDispatchMailbox(store, input, input.expected)));
     }
     completeWorkMailbox(target, batchId) {
         return this.store.transaction((store) => {
@@ -1195,7 +1175,7 @@ export class FileSchedulerStoreAdapter {
                     agentId: candidate.agentId,
                     adapterId: candidate.adapterId,
                     nativeSessionId: candidate.nativeSessionId,
-                    ...(candidate.launchId === undefined ? {} : { launchId: candidate.launchId }),
+                    ...(candidate.runtimeGenerationId === undefined ? {} : { runtimeGenerationId: candidate.runtimeGenerationId }),
                     sessionUpdatedAt: candidate.sessionUpdatedAt
                 }];
         });
@@ -1369,12 +1349,12 @@ export class FileSchedulerStoreAdapter {
                     && existing.status === "active";
                 if (!defersConversationReplacement
                     && (existing?.nativeSessionId !== input.session.nativeSessionId
-                        || (input.launchId !== undefined && existing.launchId !== input.launchId)
+                        || (input.runtimeGenerationId !== undefined && existing.runtimeGenerationId !== input.runtimeGenerationId)
                         || existing.status !== "active")) {
                     saveTaskSession(store, role, {
                         ...input.session,
                         nativeSessionId: input.session.nativeSessionId
-                    }, "active", input.now, input.launchId);
+                    }, "active", input.now, input.runtimeGenerationId);
                 }
             }
         });
@@ -1407,8 +1387,8 @@ export class FileSchedulerStoreAdapter {
                 ...(session?.nativeSessionId === undefined
                     ? {}
                     : { nativeSessionId: session.nativeSessionId }),
-                ...(input.launchId === undefined ? {} : { launchId: input.launchId }),
-                outcome: { status: "failed", summary, failureReason: input.failureReason }
+                ...(input.runtimeGenerationId === undefined ? {} : { runtimeGenerationId: input.runtimeGenerationId }),
+                outcome: { status: "failed", diagnostic: summary, failureReason: input.failureReason }
             }, input.now);
             if (result.disposition !== "applied" || result.turn === null) {
                 return "state-changed";
@@ -1444,7 +1424,7 @@ export class FileSchedulerStoreAdapter {
                 }
                 return {
                     status: "existing",
-                    launchId: existing.processing.batchId
+                    runtimeGenerationId: existing.processing.batchId
                 };
             }
             if (hasRuntimeLifecycleWork(existing)) {
@@ -1460,14 +1440,14 @@ export class FileSchedulerStoreAdapter {
                 throw new Error("Runtime launch reservation could not be queued.");
             }
             const claimed = claimPending(queued, {
-                batchId: input.launchId,
+                batchId: input.runtimeGenerationId,
                 owner: RUNTIME_LIFECYCLE_OWNER,
                 startedAt: now.toISOString()
             });
             store.saveWorkMailbox(claimed);
             return {
                 status: "reserved",
-                launchId: input.launchId
+                runtimeGenerationId: input.runtimeGenerationId
             };
         });
     }
@@ -1475,7 +1455,7 @@ export class FileSchedulerStoreAdapter {
         return this.store.transaction((store) => {
             assertCurrent();
             const mailbox = store.getWorkMailbox(runtimeLifecycleTarget(input.owner));
-            if (isRuntimeLaunchReservation(mailbox?.processing, input.launchId)) {
+            if (isRuntimeLaunchReservation(mailbox?.processing, input.runtimeGenerationId)) {
                 return "reserved";
             }
             if (hasRuntimeCleanupObligation(mailbox)) {
@@ -1488,7 +1468,7 @@ export class FileSchedulerStoreAdapter {
             const sessions = runtimeOwnerSessionSet(store, input.owner);
             const active = sessions?.sessions[sessions.activeAgentId];
             if (active?.status === "active"
-                && active.launchId === input.launchId)
+                && active.runtimeGenerationId === input.runtimeGenerationId)
                 return "provider-bound";
             throw new Error("Runtime launch reservation no longer matches the launch.");
         });
@@ -1496,7 +1476,7 @@ export class FileSchedulerStoreAdapter {
     recordReservedRuntimeNativeSession(input, assertCurrent, now = new Date()) {
         return this.store.transaction((store) => {
             assertCurrent();
-            const mailbox = requireRuntimeLaunchReservation(store, input.owner, input.launchId);
+            const mailbox = requireRuntimeLaunchReservation(store, input.owner, input.runtimeGenerationId);
             if (hasRuntimeCleanupObligation(mailbox)) {
                 throw new Error("Runtime cleanup is still pending.");
             }
@@ -1507,7 +1487,7 @@ export class FileSchedulerStoreAdapter {
                     agentId: input.agentId,
                     adapterId: input.adapterId,
                     nativeSessionId: input.nativeSessionId,
-                    launchId: input.launchId,
+                    runtimeGenerationId: input.runtimeGenerationId,
                     effective: input.effective
                 }, now)
                 : recordGlobalRuntimeNativeSession(store, {
@@ -1515,21 +1495,21 @@ export class FileSchedulerStoreAdapter {
                     agentId: input.agentId,
                     adapterId: input.adapterId,
                     nativeSessionId: input.nativeSessionId,
-                    launchId: input.launchId,
+                    runtimeGenerationId: input.runtimeGenerationId,
                     effective: input.effective
                 }, now);
-            saveRuntimeLifecycleMailbox(store, completeProcessing(mailbox, input.launchId));
+            saveRuntimeLifecycleMailbox(store, completeProcessing(mailbox, input.runtimeGenerationId));
             return session;
         });
     }
-    completeRuntimeLaunchReservation(owner, launchId, beforeComplete) {
+    completeRuntimeLaunchReservation(owner, runtimeGenerationId, beforeComplete) {
         return this.store.transaction((store) => {
             const target = runtimeLifecycleTarget(owner);
             const mailbox = store.getWorkMailbox(target);
-            if (!isRuntimeLaunchReservation(mailbox?.processing, launchId))
+            if (!isRuntimeLaunchReservation(mailbox?.processing, runtimeGenerationId))
                 return false;
             beforeComplete?.();
-            saveRuntimeLifecycleMailbox(store, completeProcessing(mailbox, launchId));
+            saveRuntimeLifecycleMailbox(store, completeProcessing(mailbox, runtimeGenerationId));
             return true;
         });
     }
@@ -1545,13 +1525,13 @@ export class FileSchedulerStoreAdapter {
         return this.store.transaction((store) => {
             const target = runtimeLifecycleTarget(input.owner);
             const mailbox = store.getWorkMailbox(target);
-            if (isRuntimeLaunchReservation(mailbox?.processing, input.launchId)) {
+            if (isRuntimeLaunchReservation(mailbox?.processing, input.runtimeGenerationId)) {
                 const sessions = runtimeOwnerSessionSet(store, input.owner);
                 const active = sessions?.sessions[sessions.activeAgentId];
                 if (runtimeSessionMatchesSettledLaunch(active, input)) {
                     endRuntimeOwnerSession(store, input.owner, now);
                 }
-                saveRuntimeLifecycleMailbox(store, completeProcessing(mailbox, input.launchId));
+                saveRuntimeLifecycleMailbox(store, completeProcessing(mailbox, input.runtimeGenerationId));
                 return true;
             }
             if (hasRuntimeLifecycleWork(mailbox))
@@ -1577,7 +1557,7 @@ export class FileSchedulerStoreAdapter {
      * retained as an intermediate child wait or recorded as a ready boundary
      * for later mailbox input. It never performs tmux, workspace, or Controller I/O.
      */
-    classifyRuntimeTurnCompleted(input) {
+    classifyRuntimeTurnTerminal(input) {
         const task = this.store.getTask(input.taskId);
         const role = this.store.getRole(input.taskId, input.roleName);
         if (task === null || task.status === "archived" || role === null)
@@ -1590,10 +1570,10 @@ export class FileSchedulerStoreAdapter {
             roleName: input.roleName
         };
         if (existing === undefined
-            && !runtimeHookMatchesReservation(this.store, owner, input.launchId))
+            && !runtimeHookMatchesReservation(this.store, owner, input.runtimeGenerationId))
             return "obsolete";
         try {
-            const effectiveExisting = nativeTransitionExisting(this.store, owner, existing, input.nativeSessionId, input.launchId, "Runtime turn completion conflicts with the fixed Role session.");
+            const effectiveExisting = nativeTransitionExisting(this.store, owner, existing, input.nativeSessionId, input.runtimeGenerationId, "Runtime turn completion conflicts with the fixed Role session.");
             const effective = taskSessionEffective(this.store, input.taskId, input.roleName, input.agentId, effectiveExisting);
             if (effective.agentId !== input.agentId || effective.adapterId !== input.adapterId) {
                 return "obsolete";
@@ -1621,7 +1601,7 @@ export class FileSchedulerStoreAdapter {
             return active === null ? "apply" : "obsolete";
         return active?.id === input.turnId ? "apply" : "obsolete";
     }
-    observeRuntimeTurnCompleted(input, now = new Date()) {
+    observeRuntimeTurnTerminal(input, now = new Date()) {
         return this.store.transaction((store) => {
             const task = store.getTask(input.taskId);
             if (task === null)
@@ -1648,13 +1628,13 @@ export class FileSchedulerStoreAdapter {
                 roleName: input.roleName
             };
             if (existing === undefined
-                && !runtimeHookMatchesReservation(store, owner, input.launchId)) {
+                && !runtimeHookMatchesReservation(store, owner, input.runtimeGenerationId)) {
                 throw new Error("Runtime turn completion does not match the launch reservation.");
             }
-            const effectiveExisting = nativeTransitionExisting(store, owner, existing, input.nativeSessionId, input.launchId, "Runtime turn completion conflicts with the fixed Role session.");
+            const effectiveExisting = nativeTransitionExisting(store, owner, existing, input.nativeSessionId, input.runtimeGenerationId, "Runtime turn completion conflicts with the fixed Role session.");
             const effective = taskSessionEffective(store, task.id, role.name, input.agentId, effectiveExisting);
             if (effective.agentId !== input.agentId || effective.adapterId !== input.adapterId) {
-                throw new Error("Runtime turn completion does not match the effective launch identity.");
+                throw new Error("Runtime turn completion does not match the effective runtime generation identity.");
             }
             if (effectiveExisting !== undefined
                 && hasRecentTurnId(effectiveExisting.recentCompletedTurnIds, canonicalTurnId)) {
@@ -1679,7 +1659,7 @@ export class FileSchedulerStoreAdapter {
                 agentId: input.agentId,
                 adapterId: input.adapterId,
                 nativeSessionId: input.nativeSessionId,
-                ...(input.launchId === undefined ? {} : { launchId: input.launchId }),
+                ...(input.runtimeGenerationId === undefined ? {} : { runtimeGenerationId: input.runtimeGenerationId }),
                 policy: "fixed",
                 status: sessionStatus,
                 ...(effectiveExisting?.endReason === undefined
@@ -1687,46 +1667,44 @@ export class FileSchedulerStoreAdapter {
                     : { endReason: effectiveExisting.endReason }),
                 effective
             }, now);
-            sessions = settleStructuredProviderTurn(sessions, canonicalTurnId, input.providerStatus ?? "completed", now);
+            sessions = settleStructuredProviderTurn(sessions, canonicalTurnId, input.providerStatus, now);
             sessions = recordTaskRoleTurnBoundary(sessions, {
                 agentId: input.agentId,
                 nativeSessionId: input.nativeSessionId,
                 turnId: canonicalTurnId
             }, now);
             store.saveTaskRoleSessionSet(sessions);
-            completeRuntimeHookReservation(store, owner, input.launchId);
+            completeRuntimeHookReservation(store, owner, input.runtimeGenerationId);
             let terminalTurn;
             if (recordedProviderTurn && observedTurn?.status === "active") {
                 const binding = sessions.providerBinding;
                 const conversation = currentProviderConversation(binding);
-                const activation = binding.activations.find((entry) => (entry.activationId === input.launchId
+                const activation = binding.activations.find((entry) => (entry.activationId === input.runtimeGenerationId
                     || (entry.conversationId === conversation.conversationId && entry.status === "active")));
                 if (activation === undefined) {
                     throw new Error("Provider Turn result has no matching Activation.");
                 }
-                const providerStatus = input.providerStatus ?? "completed";
-                let reviewResult;
-                if (observedTurn.purpose === "review" || observedTurn.executionGroupId !== undefined) {
-                    try {
-                        const parsed = parseReviewResultReport(input.summary);
-                        reviewResult = {
-                            report: parsed.report,
-                            checks: parsed.checks,
-                            ...(parsed.findings === undefined ? {} : { findings: parsed.findings }),
-                            ...(parsed.evidence === undefined ? {} : { evidence: parsed.evidence }),
-                            ...(parsed.evidenceCommit === undefined
-                                ? {}
-                                : { evidenceCommit: parsed.evidenceCommit }),
-                            ...(parsed.deltaDisposition === undefined
-                                ? {}
-                                : { deltaDisposition: parsed.deltaDisposition }),
-                            ...(parsed.deltaReasoning === undefined
-                                ? {}
-                                : { deltaReasoning: parsed.deltaReasoning })
-                        };
+                const providerStatus = input.providerStatus;
+                let systemEvidence;
+                let workspaceFailure;
+                if ((observedTurn.purpose === "execution" || observedTurn.purpose === "review")
+                    && observedTurn.executionGroupId !== undefined
+                    && observedTurn.executionLaneId !== undefined
+                    && observedTurn.workspace !== undefined
+                    && input.outcome.status === "completed") {
+                    const gitSnapshot = this.snapshotExecutionLaneWorkspace(store, observedTurn.workspace);
+                    if (gitSnapshot.status === "captured") {
+                        systemEvidence = { workspaceSnapshot: gitSnapshot.snapshot };
                     }
-                    catch {
-                        reviewResult = { report: input.summary, checks: [] };
+                    else {
+                        workspaceFailure = {
+                            failureReason: gitSnapshot.cause === "workspace-dirty"
+                                ? "workspace-dirty"
+                                : gitSnapshot.cause === "branch-mismatch"
+                                    ? "workspace-branch-mismatch"
+                                    : "workspace-unavailable",
+                            diagnostic: gitSnapshot.diagnostic
+                        };
                     }
                 }
                 const terminalized = terminalizeExactTaskTurn(store, {
@@ -1735,17 +1713,9 @@ export class FileSchedulerStoreAdapter {
                     agentId: input.agentId,
                     turnId: observedTurn.id,
                     nativeSessionId: input.nativeSessionId,
-                    ...(input.launchId === undefined ? {} : { launchId: input.launchId }),
+                    ...(input.runtimeGenerationId === undefined ? {} : { runtimeGenerationId: input.runtimeGenerationId }),
                     outcome: {
-                        status: providerStatus === "completed" ? "completed" : "failed",
-                        summary: input.summary,
-                        ...(providerStatus === "completed"
-                            ? {}
-                            : {
-                                failureReason: providerStatus === "cancelled"
-                                    ? "cancelled"
-                                    : "runtime-failed"
-                            }),
+                        ...input.outcome,
                         provider: {
                             providerNamespace: binding.providerNamespace,
                             accountScope: binding.accountScope,
@@ -1755,7 +1725,8 @@ export class FileSchedulerStoreAdapter {
                             status: providerStatus
                         }
                     },
-                    ...(reviewResult === undefined ? {} : { reviewResult })
+                    ...(systemEvidence === undefined ? {} : { systemEvidence }),
+                    ...(workspaceFailure === undefined ? {} : { workspaceFailure })
                 }, now);
                 if (terminalized.disposition !== "applied" || terminalized.turn === null) {
                     throw new Error(`Provider Turn terminal could not complete its exact Turn: ${terminalized.reason ?? "obsolete"}.`);
@@ -1765,12 +1736,11 @@ export class FileSchedulerStoreAdapter {
                     turnId: terminalTurn.id,
                     roleName: terminalTurn.roleName,
                     providerTurnId: canonicalTurnId,
-                    providerStatus,
-                    summary: input.summary
+                    providerStatus
                 }, now);
                 store.saveEvent(input.taskId, event);
                 if (terminalTurn.roleName !== "leader"
-                    && (providerStatus !== "completed" || !providerGoalContinues(binding.goal))) {
+                    && (terminalTurn.status !== "completed" || !providerGoalContinues(binding.goal))) {
                     routeRoleEvent(store, event, terminalTurn.roleName, terminalTurn.purpose === "review" ? "review-result" : "role-turn-result", now);
                 }
             }
@@ -1787,7 +1757,7 @@ export class FileSchedulerStoreAdapter {
                 input.taskId,
                 input.roleName,
                 input.turnId,
-                input.launchId ?? "unknown-launch",
+                input.runtimeGenerationId ?? "unknown-runtime-generation",
                 String(input.deadStatus ?? "unknown-status")
             ].join("\0");
             const observationId = `tmux-host-exit-${createHash("sha256").update(identity).digest("hex")}`;
@@ -1797,18 +1767,18 @@ export class FileSchedulerStoreAdapter {
                 return;
             const stopReceipt = [...events].reverse().find((event) => (event.type === "runtime.session-termination"
                 && event.payload.roleName === input.roleName
-                && (input.launchId === undefined || event.payload.launchId === input.launchId)
+                && (input.runtimeGenerationId === undefined || event.payload.runtimeGenerationId === input.runtimeGenerationId)
                 && ["stop-requested", "graceful-stop", "forced-stop", "stop-confirmed"]
                     .includes(event.payload.outcome ?? "")));
             const observation = validateRuntimeProcessExitObservation({
-                schemaVersion: 1,
+                schemaVersion: 2,
                 observationId,
                 hostSequence: 1,
-                hostInstanceId: `tmux-${input.launchId ?? input.roleName}`,
+                hostInstanceId: `tmux-${input.runtimeGenerationId ?? input.roleName}`,
                 taskId: input.taskId,
                 roleName: input.roleName,
                 turnId: input.turnId,
-                launchId: input.launchId ?? `unknown-${input.turnId}`,
+                runtimeGenerationId: input.runtimeGenerationId ?? `unknown-${input.turnId}`,
                 ...(input.nativeSessionId === undefined
                     ? {}
                     : { nativeSessionId: input.nativeSessionId }),
@@ -1822,7 +1792,7 @@ export class FileSchedulerStoreAdapter {
                 observationId,
                 processKind: "agent-host",
                 roleName: input.roleName,
-                launchId: observation.launchId,
+                runtimeGenerationId: observation.runtimeGenerationId,
                 observedAt: observation.observedAt,
                 classification,
                 observation: JSON.stringify(observation)
@@ -1954,11 +1924,7 @@ export class FileSchedulerStoreAdapter {
                         const existingNativeSessionId = existingSession?.nativeSessionId;
                         const replacingNativeSession = existingNativeSessionId !== undefined
                             && existingNativeSessionId !== decision.outcome.nativeSessionId;
-                        const replacementBasis = replacingNativeSession
-                            && run.mode === "new"
-                            && existingSession?.status === "ended"
-                            ? "terminal-session"
-                            : null;
+                        const replacementBasis = terminalSessionReplacementBasis(sessions, input, run) ?? null;
                         if (replacingNativeSession && replacementBasis === null) {
                             recordCanonicalObservationObsolete(store, input, "session-replacement-not-terminal", now);
                             return "obsolete";
@@ -1967,7 +1933,7 @@ export class FileSchedulerStoreAdapter {
                             agentId: input.fence.agentId,
                             adapterId,
                             nativeSessionId: decision.outcome.nativeSessionId,
-                            launchId: input.fence.launchId,
+                            runtimeGenerationId: input.fence.runtimeGenerationId,
                             policy: "fixed",
                             status: "active",
                             effective: run.effective
@@ -1975,15 +1941,30 @@ export class FileSchedulerStoreAdapter {
                         const bound = replacementBasis === null
                             ? recordRoleAgentSession(sessions, sessionInput, now)
                             : replaceTaskRoleAgentSession(sessions, sessionInput, now);
-                        const withProvider = bindOrSupersedeProviderRuntime(bound, input, now, replacementBasis ?? undefined);
+                        const withProvider = bindOrSupersedeProviderRuntime(bound, input, now, replacementBasis
+                            ?? terminalProviderReplacementBasis(bound, input, run.mode));
                         store.saveTaskRoleSessionSet(withProvider);
-                        completeRuntimeHookReservation(store, { scope: "task", taskId, roleName: input.fence.roleName }, input.fence.launchId);
+                        completeRuntimeHookReservation(store, { scope: "task", taskId, roleName: input.fence.roleName }, input.fence.runtimeGenerationId);
                     }
                     const current = store.getTaskRoleSessionSet(input.fence.taskId, input.fence.roleName);
                     const currentSession = current?.sessions[input.fence.agentId];
                     if (current !== null && current !== undefined
                         && currentSession?.nativeSessionId === input.fence.nativeSessionId) {
-                        store.saveTaskRoleSessionSet(bindOrSupersedeProviderRuntime(current, input, now));
+                        const run = input.fence.turnId === undefined
+                            ? null
+                            : store.getTurn(input.fence.taskId, input.fence.turnId);
+                        const replacementBasis = run === null
+                            ? undefined
+                            : terminalSessionReplacementBasis(current, input, run)
+                                ?? terminalProviderReplacementBasis(current, input, run.mode);
+                        if (current.providerBinding !== null
+                            && currentProviderConversation(current.providerBinding).conversationId
+                                !== (input.fence.conversationId ?? input.fence.nativeSessionId)
+                            && replacementBasis === undefined) {
+                            recordCanonicalObservationObsolete(store, input, "session-replacement-not-terminal", now);
+                            return "obsolete";
+                        }
+                        store.saveTaskRoleSessionSet(bindOrSupersedeProviderRuntime(current, input, now, replacementBasis));
                     }
                     return "applied";
                 }
@@ -2005,7 +1986,7 @@ export class FileSchedulerStoreAdapter {
                 const active = store.getActiveTurn(taskId, input.fence.roleName);
                 if (sessions === null || sessions === undefined
                     || binding === null || binding === undefined
-                    || session?.launchId !== input.fence.launchId
+                    || session?.runtimeGenerationId !== input.fence.runtimeGenerationId
                     || session.nativeSessionId !== input.fence.nativeSessionId
                     || currentProviderConversation(binding).conversationId !== input.fence.nativeSessionId) {
                     recordCanonicalObservationObsolete(store, input, "direct-turn-session-mismatch", now);
@@ -2058,7 +2039,7 @@ export class FileSchedulerStoreAdapter {
                     && binding !== null && binding !== undefined
                     && binding.turn?.turnId === undefined
                     && binding.turn?.attemptId === ordinaryAttemptId) {
-                    if (session?.launchId !== input.fence.launchId
+                    if (session?.runtimeGenerationId !== input.fence.runtimeGenerationId
                         || session.nativeSessionId !== input.fence.nativeSessionId) {
                         recordCanonicalObservationObsolete(store, input, "ordinary-turn-session-mismatch", now);
                         return "obsolete";
@@ -2076,7 +2057,7 @@ export class FileSchedulerStoreAdapter {
                     || active.status !== "active"
                     || sessions === null
                     || sessions === undefined
-                    || session?.launchId !== input.fence.launchId
+                    || session?.runtimeGenerationId !== input.fence.runtimeGenerationId
                     || session.nativeSessionId !== input.fence.nativeSessionId) {
                     recordCanonicalObservationObsolete(store, input, "continuation-fence-mismatch", now);
                     return "obsolete";
@@ -2086,7 +2067,7 @@ export class FileSchedulerStoreAdapter {
                     attemptId: input.fence.receiptId,
                     turnId: active.id,
                     conversationId: input.fence.conversationId ?? input.fence.nativeSessionId,
-                    activationId: input.fence.activationId ?? input.fence.launchId,
+                    activationId: input.fence.activationId ?? input.fence.runtimeGenerationId,
                     ...(input.fence.nativeTurnId === undefined
                         ? {}
                         : { nativeTurnId: input.fence.nativeTurnId })
@@ -2168,15 +2149,15 @@ export class FileSchedulerStoreAdapter {
             return null;
         const owner = { scope: "task", taskId: fence.taskId, roleName: fence.roleName };
         const freshConversationLaunch = run.mode === "new"
-            && runtimeHookMatchesReservation(store, owner, fence.launchId);
+            && runtimeHookMatchesReservation(store, owner, fence.runtimeGenerationId);
         const boundNativeSessionId = freshConversationLaunch
             ? undefined
             : session?.nativeSessionId;
-        const launchId = freshConversationLaunch
-            ? fence.launchId
-            : session?.launchId
-                ?? (runtimeHookMatchesReservation(store, owner, fence.launchId) ? fence.launchId : undefined);
-        if (launchId === undefined)
+        const runtimeGenerationId = freshConversationLaunch
+            ? fence.runtimeGenerationId
+            : session?.runtimeGenerationId
+                ?? (runtimeHookMatchesReservation(store, owner, fence.runtimeGenerationId) ? fence.runtimeGenerationId : undefined);
+        if (runtimeGenerationId === undefined)
             return null;
         const providerTurn = sessionSet?.providerBinding?.turn;
         const managedTurnMatches = managedProviderTurnId(providerTurn) === run.id;
@@ -2186,7 +2167,7 @@ export class FileSchedulerStoreAdapter {
             agentId: run.effective.agentId,
             adapterId: run.effective.adapterId,
             turnId: run.id,
-            launchId,
+            runtimeGenerationId,
             receiptId: managedTurnMatches && providerTurn !== null && providerTurn !== undefined
                 ? providerTurn.attemptId
                 : formatTurnReceiptId(run.taskId, run.id),
@@ -2200,7 +2181,7 @@ export class FileSchedulerStoreAdapter {
                 && observation.fence.roleName === fence.roleName
                 && observation.fence.agentId === run.effective.agentId
                 && observation.fence.driverId === driverId
-                && observation.fence.launchId === launchId
+                && observation.fence.runtimeGenerationId === runtimeGenerationId
                 && observation.fence.nativeSessionId === (boundNativeSessionId ?? fence.nativeSessionId)
                 ? [observation]
                 : [];
@@ -2227,7 +2208,7 @@ export class FileSchedulerStoreAdapter {
     recordGlobalRuntimeNativeSession(input, now = new Date()) {
         return this.store.transaction((store) => (recordGlobalRuntimeNativeSession(store, input, now)));
     }
-    observeGlobalRuntimeTurnCompleted(input, now = new Date()) {
+    observeGlobalRuntimeTurnTerminal(input, now = new Date()) {
         return this.store.transaction((store) => {
             const role = store.getGlobalRole(input.roleName);
             if (role === null)
@@ -2240,23 +2221,25 @@ export class FileSchedulerStoreAdapter {
                 roleName: input.roleName
             };
             if (existing === undefined
-                && !runtimeHookMatchesReservation(store, owner, input.launchId)) {
+                && !runtimeHookMatchesReservation(store, owner, input.runtimeGenerationId)) {
                 throw new Error("Runtime turn completion does not match the global launch reservation.");
             }
             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 effectiveExisting = nativeTransitionExisting(store, owner, existing, nativeSessionId, input.runtimeGenerationId, "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.");
+                throw new Error("Runtime turn completion does not match the effective global runtime generation identity.");
             }
             const completedStatus = effectiveExisting?.status ?? "active";
             current = recordRoleAgentSession(current, {
                 agentId: input.agentId,
                 adapterId: input.adapterId,
                 nativeSessionId,
-                ...(input.launchId === undefined ? {} : { launchId: input.launchId }),
+                ...(input.runtimeGenerationId === undefined ? {} : { runtimeGenerationId: input.runtimeGenerationId }),
                 title: effectiveExisting?.title ?? input.title,
-                preview: effectiveExisting?.preview ?? (input.summary === undefined ? undefined : sessionPreview(input.summary)),
+                preview: effectiveExisting?.preview ?? sessionPreview(input.outcome.status === "completed"
+                    ? input.outcome.output
+                    : input.outcome.diagnostic),
                 policy: "fixed",
                 status: completedStatus,
                 ...(effectiveExisting?.endReason === undefined
@@ -2266,7 +2249,7 @@ export class FileSchedulerStoreAdapter {
             }, now);
             current = rememberRoleAgentCompletedTurn(current, input.agentId, nativeSessionId, input.nativeTurnId, now);
             store.saveGlobalRoleSessionSet(current);
-            completeRuntimeHookReservation(store, owner, input.launchId);
+            completeRuntimeHookReservation(store, owner, input.runtimeGenerationId);
             if (input.roleName === SYSTEM_OPERATOR_ROLE
                 && input.adapterId === "codex"
                 && completedStatus === "active") {
@@ -2281,7 +2264,7 @@ export class FileSchedulerStoreAdapter {
             return current.sessions[input.agentId];
         });
     }
-    classifyGlobalRuntimeTurnCompleted(input) {
+    classifyGlobalRuntimeTurnTerminal(input) {
         const role = this.store.getGlobalRole(input.roleName);
         if (role === null)
             return "obsolete";
@@ -2292,12 +2275,12 @@ export class FileSchedulerStoreAdapter {
             roleName: input.roleName
         };
         if (existing === undefined
-            && !runtimeHookMatchesReservation(this.store, owner, input.launchId))
+            && !runtimeHookMatchesReservation(this.store, owner, input.runtimeGenerationId))
             return "obsolete";
         const nativeSessionId = globalCompletionNativeSessionId(existing, input);
         let effectiveExisting;
         try {
-            effectiveExisting = nativeTransitionExisting(this.store, owner, existing, nativeSessionId, input.launchId, "Runtime turn completion conflicts with the fixed global Role session.");
+            effectiveExisting = nativeTransitionExisting(this.store, owner, existing, nativeSessionId, input.runtimeGenerationId, "Runtime turn completion conflicts with the fixed global Role session.");
         }
         catch {
             return "obsolete";
@@ -2315,7 +2298,7 @@ function runtimeObservationLifecycleFence(input, adapterId) {
         roleName: input.fence.roleName,
         agentId: input.fence.agentId,
         adapterId,
-        launchId: input.fence.launchId,
+        runtimeGenerationId: input.fence.runtimeGenerationId,
         ...(input.fence.turnId === undefined ? {} : { turnId: input.fence.turnId }),
         ...(input.fence.nativeSessionId === undefined
             ? {}
@@ -2323,6 +2306,25 @@ function runtimeObservationLifecycleFence(input, adapterId) {
         ...(input.fence.receiptId === undefined ? {} : { receiptId: input.fence.receiptId })
     };
 }
+/**
+ * A live parent Turn still owns its native child result. Only after that Turn
+ * is terminal or absent does Yui route the continuation fact to the original
+ * Role's supervisor. Mailbox coalescing remains the downstream batching
+ * mechanism; this guard decides ownership before any wake is enqueued.
+ */
+function routeContinuationResult(store, observation, event, reason, now) {
+    const taskId = observation.fence.taskId;
+    if (taskId === undefined)
+        return;
+    const parentTurn = observation.fence.turnId === undefined
+        ? null
+        : store.getTurn(taskId, observation.fence.turnId);
+    if (parentTurn?.status === "active")
+        return;
+    if (store.getRole(taskId, observation.fence.roleName) === null)
+        return;
+    routeRoleEvent(store, event, observation.fence.roleName, reason, now);
+}
 /** Accepts the original Turn receipt or a later mailbox activation receipt. */
 function runtimeReceiptBelongsToTurn(store, input) {
     const taskId = input.fence.taskId;
@@ -2338,7 +2340,7 @@ function runtimeReceiptBelongsToTurn(store, input) {
             && accepted.fence.turnId === turnId
             && accepted.fence.roleName === input.fence.roleName
             && accepted.fence.agentId === input.fence.agentId
-            && accepted.fence.launchId === input.fence.launchId
+            && accepted.fence.runtimeGenerationId === input.fence.runtimeGenerationId
             && accepted.fence.nativeSessionId === input.fence.nativeSessionId
             && accepted.fence.receiptId === receiptId;
     });
@@ -2355,8 +2357,8 @@ function recordCanonicalObservationObsolete(store, input, reason, now) {
         roleName: input.fence.roleName,
         agentId: input.fence.agentId,
         ...(input.fence.turnId === undefined ? {} : { turnId: input.fence.turnId }),
-        launchId: input.fence.launchId,
-        nativeSessionId: input.fence.nativeSessionId ?? input.fence.sessionGenerationId
+        runtimeGenerationId: input.fence.runtimeGenerationId,
+        nativeSessionId: input.fence.nativeSessionId ?? input.fence.runtimeGenerationId
     }, reason, now);
 }
 function recordObsoleteRuntimeEvent(store, input, reason, now) {
@@ -2371,7 +2373,7 @@ function recordObsoleteRuntimeEvent(store, input, reason, now) {
         agentId: input.agentId,
         nativeSessionId: input.nativeSessionId,
         ...(input.turnId === undefined ? {} : { turnId: input.turnId }),
-        ...(input.launchId === undefined ? {} : { launchId: input.launchId }),
+        ...(input.runtimeGenerationId === undefined ? {} : { runtimeGenerationId: input.runtimeGenerationId }),
         reason
     }, now));
 }
@@ -2410,20 +2412,20 @@ function sessionPreview(value) {
         ? truncated.slice(0, -1)
         : truncated;
 }
-function requireRuntimeLaunchReservation(store, owner, launchId) {
+function requireRuntimeLaunchReservation(store, owner, runtimeGenerationId) {
     const mailbox = store.getWorkMailbox(runtimeLifecycleTarget(owner));
-    if (!isRuntimeLaunchReservation(mailbox?.processing, launchId)) {
+    if (!isRuntimeLaunchReservation(mailbox?.processing, runtimeGenerationId)) {
         throw new Error("Runtime launch reservation no longer matches the launch.");
     }
     return mailbox;
 }
-function runtimeHookMatchesReservation(store, owner, launchId) {
+function runtimeHookMatchesReservation(store, owner, runtimeGenerationId) {
     const mailbox = store.getWorkMailbox(runtimeLifecycleTarget(owner));
     if (hasRuntimeCleanupObligation(mailbox))
         return false;
     const processing = mailbox?.processing;
-    return launchId !== undefined
-        && isRuntimeLaunchReservation(processing, launchId);
+    return runtimeGenerationId !== undefined
+        && isRuntimeLaunchReservation(processing, runtimeGenerationId);
 }
 function preallocatedRuntimeReadyAwaitingProjection(store, observation, drivers) {
     const taskId = observation.fence.taskId;
@@ -2455,17 +2457,17 @@ function preallocatedRuntimeReadyAwaitingProjection(store, observation, drivers)
         taskId,
         roleName: observation.fence.roleName
     }));
-    return isRuntimeLaunchReservation(mailbox?.processing, observation.fence.launchId)
+    return isRuntimeLaunchReservation(mailbox?.processing, observation.fence.runtimeGenerationId)
         && !hasRuntimeCleanupObligation(mailbox)
-        && nativeSessionId === nativeSessionIdForLaunch(store.rootDirectory(), observation.fence.launchId, observation.fence.agentId, driver.adapterId);
+        && nativeSessionId === nativeSessionIdForLaunch(store.rootDirectory(), observation.fence.runtimeGenerationId, observation.fence.agentId, driver.adapterId);
 }
-function completeRuntimeHookReservation(store, owner, launchId) {
-    if (launchId === undefined)
+function completeRuntimeHookReservation(store, owner, runtimeGenerationId) {
+    if (runtimeGenerationId === undefined)
         return;
     const mailbox = store.getWorkMailbox(runtimeLifecycleTarget(owner));
-    if (!isRuntimeLaunchReservation(mailbox?.processing, launchId))
+    if (!isRuntimeLaunchReservation(mailbox?.processing, runtimeGenerationId))
         return;
-    saveRuntimeLifecycleMailbox(store, completeProcessing(mailbox, launchId));
+    saveRuntimeLifecycleMailbox(store, completeProcessing(mailbox, runtimeGenerationId));
 }
 function saveRuntimeLifecycleMailbox(store, mailbox) {
     if (!mailboxHasWork(mailbox)) {
@@ -2509,7 +2511,7 @@ function dormantRuntimeCandidateIsCurrent(store, candidate) {
         && active.agentId === candidate.agentId
         && active.adapterId === candidate.adapterId
         && active.nativeSessionId === candidate.nativeSessionId
-        && active.launchId === candidate.launchId
+        && active.runtimeGenerationId === candidate.runtimeGenerationId
         && active.updatedAt === candidate.sessionUpdatedAt;
 }
 function endRuntimeOwnerSession(store, owner, now) {
@@ -2593,9 +2595,9 @@ function recordTaskRuntimeNativeSession(store, input, now) {
     const current = store.getRoleSessionSet(input.taskId, input.roleName)
         ?? createRoleSessionSet({ scope: "task", taskId: input.taskId, roleName: input.roleName }, input.agentId, now);
     const existing = current.sessions[input.agentId];
-    const effectiveExisting = nativeTransitionExisting(store, { scope: "task", taskId: input.taskId, roleName: input.roleName }, existing, input.nativeSessionId, input.launchId, "Native session registration conflicts with the fixed Role session.");
+    const effectiveExisting = nativeTransitionExisting(store, { scope: "task", taskId: input.taskId, roleName: input.roleName }, existing, input.nativeSessionId, input.runtimeGenerationId, "Native session registration conflicts with the fixed Role session.");
     if (existing?.status === "active"
-        && (input.launchId === undefined || existing.launchId === input.launchId))
+        && (input.runtimeGenerationId === undefined || existing.runtimeGenerationId === input.runtimeGenerationId))
         return existing;
     const resolvedEffective = taskSessionEffective(store, input.taskId, input.roleName, input.agentId, effectiveExisting);
     const effective = input.effective === undefined
@@ -2605,13 +2607,13 @@ function recordTaskRuntimeNativeSession(store, input, now) {
         throw new Error("Reserved native Session effective launch changed before persistence.");
     }
     if (effective.agentId !== input.agentId || effective.adapterId !== input.adapterId) {
-        throw new Error("Native session registration does not match the effective launch identity.");
+        throw new Error("Native session registration does not match the effective runtime generation identity.");
     }
     const updated = recordRoleAgentSession(current, {
         agentId: input.agentId,
         adapterId: input.adapterId,
         nativeSessionId: input.nativeSessionId,
-        ...(input.launchId === undefined ? {} : { launchId: input.launchId }),
+        ...(input.runtimeGenerationId === undefined ? {} : { runtimeGenerationId: input.runtimeGenerationId }),
         policy: "fixed",
         status: "active",
         effective: effectiveExisting?.effective ?? effective
@@ -2626,9 +2628,9 @@ function recordGlobalRuntimeNativeSession(store, input, now) {
     const current = store.getGlobalRoleSessionSet(input.roleName)
         ?? createRoleSessionSet({ scope: "global", roleName: input.roleName }, input.agentId, now);
     const existing = current.sessions[input.agentId];
-    const effectiveExisting = nativeTransitionExisting(store, { scope: "global", roleName: input.roleName }, existing, input.nativeSessionId, input.launchId, "Native session registration conflicts with the fixed global Role session.");
+    const effectiveExisting = nativeTransitionExisting(store, { scope: "global", roleName: input.roleName }, existing, input.nativeSessionId, input.runtimeGenerationId, "Native session registration conflicts with the fixed global Role session.");
     if (existing?.status === "active"
-        && (input.launchId === undefined || existing.launchId === input.launchId))
+        && (input.runtimeGenerationId === undefined || existing.runtimeGenerationId === input.runtimeGenerationId))
         return existing;
     const resolvedEffective = globalSessionEffective(role, effectiveExisting);
     const effective = input.effective === undefined
@@ -2638,13 +2640,13 @@ function recordGlobalRuntimeNativeSession(store, input, now) {
         throw new Error("Reserved global native Session effective launch changed before persistence.");
     }
     if (effective.agentId !== input.agentId || effective.adapterId !== input.adapterId) {
-        throw new Error("Native session registration does not match the effective global launch identity.");
+        throw new Error("Native session registration does not match the effective global runtime generation identity.");
     }
     const updated = recordRoleAgentSession(current, {
         agentId: input.agentId,
         adapterId: input.adapterId,
         nativeSessionId: input.nativeSessionId,
-        ...(input.launchId === undefined ? {} : { launchId: input.launchId }),
+        ...(input.runtimeGenerationId === undefined ? {} : { runtimeGenerationId: input.runtimeGenerationId }),
         policy: "fixed",
         status: "active",
         effective
@@ -2652,22 +2654,22 @@ function recordGlobalRuntimeNativeSession(store, input, now) {
     store.saveGlobalRoleSessionSet(updated);
     return updated.sessions[input.agentId];
 }
-function nativeTransitionExisting(store, owner, existing, nativeSessionId, launchId, conflictMessage) {
+function nativeTransitionExisting(store, owner, existing, nativeSessionId, runtimeGenerationId, conflictMessage) {
     if (existing === undefined || existing.nativeSessionId === nativeSessionId) {
         return existing;
     }
     if (existing.status === "ended"
-        && runtimeHookMatchesReservation(store, owner, launchId)) {
+        && runtimeHookMatchesReservation(store, owner, runtimeGenerationId)) {
         return undefined;
     }
     throw new Error(conflictMessage);
 }
 function globalCompletionNativeSessionId(existing, input) {
     // Codex structured event sources can expose different native IDs for the
-    // same launch. The launch generation remains the authoritative fence.
+    // same runtime generation. That generation remains the authoritative fence.
     return input.adapterId === "codex"
-        && input.launchId !== undefined
-        && existing?.launchId === input.launchId
+        && input.runtimeGenerationId !== undefined
+        && existing?.runtimeGenerationId === input.runtimeGenerationId
         && existing.agentId === input.agentId
         && existing.adapterId === input.adapterId
         ? existing.nativeSessionId
@@ -2755,7 +2757,7 @@ function mapSession(session) {
         agentId: session.agentId,
         adapterId: session.adapterId,
         nativeSessionId: session.nativeSessionId,
-        ...(session.launchId === undefined ? {} : { launchId: session.launchId }),
+        ...(session.runtimeGenerationId === undefined ? {} : { runtimeGenerationId: session.runtimeGenerationId }),
         ...(session.title === undefined ? {} : { title: session.title }),
         status: session.status,
         ...(session.endReason === undefined ? {} : { endReason: session.endReason }),
@@ -2763,14 +2765,14 @@ function mapSession(session) {
         updatedAt: session.updatedAt
     };
 }
-function saveTaskSession(store, role, session, status, now, launchId) {
+function saveTaskSession(store, role, session, status, now, runtimeGenerationId) {
     const current = store.getRoleSessionSet(role.taskId, role.name)
         ?? createRoleSessionSet({ scope: "task", taskId: role.taskId, roleName: role.name }, session.agentId, now);
     const updated = recordRoleAgentSession(current, {
         agentId: session.agentId,
         adapterId: session.adapterId,
         nativeSessionId: session.nativeSessionId,
-        ...(launchId === undefined ? {} : { launchId }),
+        ...(runtimeGenerationId === undefined ? {} : { runtimeGenerationId }),
         ...(session.title === undefined ? {} : { title: session.title }),
         policy: "fixed",
         status,
@@ -2787,7 +2789,7 @@ function matchesStallSessionFence(current, expected) {
     return current.agentId === expected.agentId
         && current.adapterId === expected.adapterId
         && current.nativeSessionId === expected.nativeSessionId
-        && current.launchId === expected.launchId
+        && current.runtimeGenerationId === expected.runtimeGenerationId
         && current.status === expected.status;
 }
 function requireRole(store, taskId, roleName) {
@@ -2814,7 +2816,7 @@ function runtimeObservationTelemetryEntry(input) {
         taskId: input.fence.taskId,
         roleName: input.fence.roleName,
         turnId: input.fence.turnId,
-        generation: input.fence.sessionGenerationId,
+        generation: input.fence.runtimeGenerationId,
         progressId: [
             input.kind,
             input.payload.operationId ?? input.payload.activity ?? "state"
@@ -2825,7 +2827,7 @@ function runtimeObservationTelemetryEntry(input) {
             kind: input.kind,
             authority: input.authority,
             driverId: input.fence.driverId,
-            launchId: input.fence.launchId,
+            runtimeGenerationId: input.fence.runtimeGenerationId,
             nativeSessionId: input.fence.nativeSessionId ?? "",
             nativeTurnId: input.fence.nativeTurnId ?? "",
             ...(input.payload.operation === undefined
@@ -2934,9 +2936,30 @@ function canonicalStructuredProviderTurnId(sessions, observedTurnId, attemptId)
         ? turn.nativeTurnId
         : observedTurnId;
 }
+function terminalSessionReplacementBasis(sessions, input, run) {
+    const binding = sessions.providerBinding;
+    const session = sessions.sessions[input.fence.agentId];
+    const incomingConversationId = input.fence.conversationId ?? input.fence.nativeSessionId;
+    if (run.mode !== "new"
+        || binding === null
+        || session === undefined
+        || incomingConversationId === undefined
+        || currentProviderConversation(binding).conversationId === incomingConversationId
+        || currentProviderActivation(binding) !== null
+        || binding.authority.owner !== "none") {
+        return undefined;
+    }
+    // Pre-start persistence may already have replaced the terminal Role Session
+    // before Provider readiness arrives. A matching new Session plus the
+    // quiescent old Provider binding preserves the same terminal-session proof.
+    return session.status === "ended"
+        || session.nativeSessionId === input.fence.nativeSessionId
+        ? "terminal-session"
+        : undefined;
+}
 function bindOrSupersedeProviderRuntime(sessions, input, now, replacementBasis) {
     const conversationId = input.fence.conversationId ?? input.fence.nativeSessionId;
-    const activationId = input.fence.activationId ?? input.fence.launchId;
+    const activationId = input.fence.activationId ?? input.fence.runtimeGenerationId;
     if (sessions.providerBinding === null) {
         return bindTaskRoleProviderRuntime(sessions, createProviderRuntimeBinding({
             providerNamespace: input.fence.driverId,
@@ -2969,6 +2992,26 @@ function bindOrSupersedeProviderRuntime(sessions, input, now, replacementBasis)
         basis: replacementBasis
     }), now);
 }
+function terminalProviderReplacementBasis(sessions, input, mode) {
+    if (mode !== "new" || sessions.providerBinding === null)
+        return undefined;
+    if (sessions.providerBinding.providerNamespace !== input.fence.driverId
+        || sessions.providerBinding.accountScope !== input.fence.agentId) {
+        return undefined;
+    }
+    const current = sessions.sessions[input.fence.agentId];
+    if (current === undefined
+        || current.status !== "active"
+        || current.nativeSessionId !== input.fence.nativeSessionId
+        || current.runtimeGenerationId !== input.fence.runtimeGenerationId) {
+        return undefined;
+    }
+    const replaced = [...(sessions.history ?? [])].reverse().find((session) => (session.agentId === current.agentId
+        && session.adapterId === current.adapterId
+        && session.status === "ended"
+        && session.nativeSessionId !== current.nativeSessionId));
+    return replaced === undefined ? undefined : "terminal-session";
+}
 function settleStructuredProviderTurn(sessions, turnId, status, now) {
     const binding = sessions.providerBinding;
     if (binding === null || binding.turn === null || binding.turn.nativeTurnId !== turnId) {