@zq-silk/yui 0.2.0 → 0.4.2

package/dist/controller/fileSchedulerStoreAdapter.js

@@ -1,29 +1,48 @@
-import { createRoleSessionSet, recordRoleAgentSession, updateRoleAgentSessionStatus } from "../executor/agentExecutor.js";
+import { isDeepStrictEqual } from "node:util";
+import { activeLiveRoleAgentSession, bindTaskRoleRun, clearTaskRoleRun, createRoleSessionSet, markTaskRoleRunDelivered, markTaskRoleRunPushed, recordObservedTaskRoleCompletion, recordRoleAgentSession, rememberRoleAgentCompletedTurn, settleTaskRoleCompletion, updateRoleAgentSessionStatus } from "../executor/agentExecutor.js";
+import { createPendingTurnCompletion, hasRecentTurnId } from "../executor/turnCompletion.js";
 import { createTaskEvent } from "../event/taskEvent.js";
 import { answerInputRequest } from "../input/inputRequest.js";
 import { activeRoleAgentBinding, updateRoleStatus } from "../role/role.js";
+import { effectiveLaunchSnapshotsCompatible, resolveEffectiveLaunch, validateEffectiveLaunchSnapshot } from "../executor/effectiveLaunch.js";
 import { SYSTEM_OPERATOR_ROLE } from "../role/systemRoles.js";
-import { failAgentRun, markAgentRunDelivered } from "../run/agentRun.js";
+import { failAgentRun, markAgentRunDelivered, markAgentRunPushed } from "../run/agentRun.js";
+import { terminalizeExactTaskRun } from "../lifecycle/exactRunTerminalization.js";
+import { foldCanonicalLifecycleEvent } from "../lifecycle/canonicalLifecycleEvent.js";
+import { mapNativeLifecycleSignal } from "../lifecycle/providerLifecycleMapping.js";
+import { recordLeaderFailure } from "../scheduler/leaderFailure.js";
+import { createLeaderRecoveryNotification, createLeaderStallNotification } from "../scheduler/operatorNotification.js";
 import { pendingWakeupsMatch } from "../scheduler/pendingWakeup.js";
 import { queueLeaderWakeup } from "../scheduler/wakeupQueue.js";
-import { updateWorkItemStatus } from "../workItem/workItem.js";
+import { latestRunDurableProgressAt, latestRunEventTime, latestStallEvidenceKey, isRoleRunStalled, clearMatchingLeaderStallAttention, RUN_PROGRESS_EVENT, RUN_RECOVERED_EVENT, RUN_RESOURCE_SUPPRESSED_EVENT, RUN_STALLED_EVENT } from "../scheduler/roleRunStall.js";
+import { currentWorkItemExecutionGroup, updateWorkItemExecutionGroup, updateWorkItemStatus } from "../workItem/workItem.js";
+import { recordExecutionLaneResult } from "../execution/executionGroup.js";
+import { formatAgentRunReceiptId, formatTaskRecordReference } from "../task/taskRecordReference.js";
+import { bindExecution, claimPending, completeProcessing, releaseProcessing } from "../coordination/workMailbox.js";
+import { enqueueWork } from "../coordination/workMailboxQueue.js";
+import { RUNTIME_CLEANUP_REQUIRED_REASON, RUNTIME_LAUNCH_RESERVED_REASON, RUNTIME_LIFECYCLE_OWNER, hasRuntimeCleanupObligation, hasRuntimeLifecycleWork, isRuntimeLaunchReservation, runtimeLifecycleTarget } from "../runtime/lifecycleReservation.js";
+import { nativeSessionIdForLaunch } from "../runtime/preallocatedNativeSession.js";
 /** Maps the authoritative FileTaskStore records to the scheduler's narrow port. */
 export class FileSchedulerStoreAdapter {
     store;
     constructor(store) {
         this.store = store;
     }
+    getPresentationContext() {
+        return { timeZone: this.store.getConfig().timeZone };
+    }
     listTasks() { return this.store.listTasks(); }
     getTask(taskId) { return this.store.getTask(taskId); }
+    getTaskWorkspace(taskId) { return this.store.getTaskWorkspace(taskId); }
     getTaskBrief(taskId) { return this.store.getTaskBrief(taskId); }
     listDecisions(taskId) { return this.store.listDecisions(taskId); }
     listMilestones(taskId) { return this.store.listMilestones(taskId); }
     listRoles(taskId) {
-        return this.store.listRoles(taskId).map(mapRole);
+        return this.store.listRoles(taskId).map((role) => mapRole(this.store, role));
     }
     getRole(taskId, roleName) {
         const role = this.store.getRole(taskId, roleName);
-        return role === null ? null : mapRole(role);
+        return role === null ? null : mapRole(this.store, role);
     }
     getActiveAgentRun(taskId, roleName) {
         return this.store.getActiveAgentRun(taskId, roleName);
@@ -34,20 +53,28 @@ export class FileSchedulerStoreAdapter {
     listOpenInputRequests() {
         return this.store.listAllInputRequests().filter((request) => request.status === "open");
     }
+    getInputRequest(taskId, inputRequestId) {
+        return this.store.getInputRequest(taskId, inputRequestId);
+    }
     getOperatorDeliveryTarget() {
         const role = this.store.getGlobalRole(SYSTEM_OPERATOR_ROLE);
         if (role === null)
             return null;
+        const sessions = this.store.getGlobalRoleSessionSet(SYSTEM_OPERATOR_ROLE);
+        const effectiveSession = sessions?.sessions[sessions.activeAgentId];
+        if (effectiveSession?.status !== "ready")
+            return null;
         return {
             roleName: SYSTEM_OPERATOR_ROLE,
-            adapterId: activeRoleAgentBinding(role).adapterId
+            adapterId: effectiveSession.effective.adapterId
         };
     }
-    resolveExpiredInputRecommendations(now) {
+    resolveExpiredInputRecommendations(now, taskIds) {
         return this.store.transaction((store) => {
             const expired = store.listAllInputRequests().filter((request) => (request.status === "open"
                 && request.policy.kind === "recommended"
-                && Date.parse(request.policy.timeoutAt) <= now.getTime()));
+                && Date.parse(request.policy.timeoutAt) <= now.getTime()
+                && (taskIds === undefined || taskIds.has(request.taskId))));
             const resolved = [];
             for (const request of expired) {
                 const task = store.getTask(request.taskId);
@@ -56,18 +83,341 @@ export class FileSchedulerStoreAdapter {
                 const choiceKey = request.policy.recommendedChoiceKey;
                 const answered = answerInputRequest(request, { choiceKey }, "agent-timeout", now);
                 store.saveInputRequest(task.id, answered);
-                store.saveEvent(task.id, createTaskEvent(store.nextEventId(task.id), "input.auto-answered", { requestId: request.id, choiceKey }, now));
+                store.saveEvent(task.id, createTaskEvent(store.nextEventId(task.id), task.id, "input.auto-answered", { requestId: request.id, choiceKey }, now));
                 queueLeaderWakeup(store, task.id, `input-timeout:${request.id}`, now);
                 resolved.push({ inputRequestId: request.id, taskId: task.id, choiceKey });
             }
             return resolved;
         });
     }
-    getRoleSession(taskId, roleName) {
-        const session = this.store.getRoleSession(taskId, roleName);
-        return session === null ? null : mapSession(session);
+    getRoleSession(taskId, roleName, agentId) {
+        const sessions = this.store.getTaskRoleSessionSet(taskId, roleName);
+        const session = agentId === undefined
+            ? sessions?.sessions[sessions.activeAgentId]
+            : sessions?.sessions[agentId];
+        return session === undefined ? null : mapSession(session);
+    }
+    listEvents(taskId) {
+        return this.store.listEvents(taskId);
+    }
+    getRunDurableProgress(taskId, roleName, runId) {
+        return latestRunDurableProgressAt(this.store, taskId, roleName, runId);
+    }
+    recordRoleRunStall(input) {
+        return this.store.transaction((store) => {
+            const task = store.getTask(input.taskId);
+            const role = store.getRole(input.taskId, input.roleName);
+            const run = store.getActiveAgentRun(input.taskId, input.roleName);
+            if (task === null
+                || task.status !== "active"
+                || role === null
+                || run === null
+                || run.id !== input.runId
+                || run.status !== "active"
+                || run.effective.agentId !== input.agentId
+                || run.effective.adapterId !== input.adapterId)
+                return "state-changed";
+            const progress = latestRunDurableProgressAt(store, input.taskId, input.roleName, input.runId);
+            if (progress?.progressAt !== input.progressAt)
+                return "state-changed";
+            const session = store.getRoleSession(input.taskId, input.roleName);
+            if (!matchesStallSessionFence(session, input.session))
+                return "state-changed";
+            const existing = latestStallEvidenceKey(store.listEvents(task.id), run.id);
+            if (existing?.progressAt === input.progressAt)
+                return "already-raised";
+            const event = createTaskEvent(store.nextEventId(task.id), task.id, RUN_STALLED_EVENT, {
+                runId: run.id,
+                roleName: role.name,
+                kind: input.kind,
+                classification: input.classification,
+                progressAt: input.progressAt,
+                idleMs: String(Math.max(0, Math.floor(input.idleMs))),
+                evidenceKey: input.evidenceKey,
+                status: "needs-attention"
+            }, 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, "role-run-stalled", input.now);
+            }
+            return "raised";
+        });
+    }
+    recordRoleRunProgress(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 events = store.listEvents(task.id);
+            const previousStall = latestStallEvidenceKey(events, run.id);
+            // A progress fact can close only the matching, older stall episode. A
+            // stale/native observation must never clear a newer attention point.
+            if (previousStall !== undefined
+                && Date.parse(input.progressAt) <= Date.parse(previousStall.progressAt)) {
+                return "already-recorded";
+            }
+            const existing = events.some((event) => (event.type === RUN_PROGRESS_EVENT
+                && event.payload.runId === run.id
+                && (event.payload.progressAt === input.progressAt
+                    || (typeof event.payload.progressAt === "string"
+                        && Number.isFinite(Date.parse(event.payload.progressAt))
+                        && Date.parse(event.payload.progressAt) >= Date.parse(input.progressAt)))));
+            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));
+            if (!existing) {
+                store.saveEvent(task.id, createTaskEvent(store.nextEventId(task.id), task.id, RUN_PROGRESS_EVENT, {
+                    runId: run.id,
+                    roleName: input.roleName,
+                    kind: "durable-fold",
+                    progressAt: input.progressAt,
+                    evidence: input.evidence ?? ""
+                }, input.now));
+            }
+            if (recovered) {
+                store.saveEvent(task.id, createTaskEvent(store.nextEventId(task.id), task.id, RUN_RECOVERED_EVENT, {
+                    runId: run.id,
+                    roleName: input.roleName,
+                    progressAt: input.progressAt,
+                    kind: "durable-progress"
+                }, input.now));
+                clearMatchingLeaderStallAttention(store, task.id, run.id);
+            }
+            return existing && !recovered ? "already-recorded" : "recorded";
+        });
+    }
+    recordRoleRunResourceSuppression(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 session = store.getRoleSession(input.taskId, input.roleName);
+            if (session === null
+                || session.agentId !== input.agentId
+                || session.adapterId !== input.adapterId
+                || session.status === "stopped"
+                || session.status === "broken"
+                || session.nativeSessionId !== input.nativeSessionId
+                || session.launchId !== input.launchId)
+                return "state-changed";
+            const existing = store.listEvents(task.id).some((event) => (event.type === RUN_RESOURCE_SUPPRESSED_EVENT
+                && event.payload.runId === run.id
+                && event.payload.roleName === input.roleName
+                && event.payload.progressAt === input.progressAt));
+            if (existing)
+                return "already-recorded";
+            store.saveEvent(task.id, createTaskEvent(store.nextEventId(task.id), task.id, RUN_RESOURCE_SUPPRESSED_EVENT, {
+                runId: run.id,
+                roleName: input.roleName,
+                progressAt: input.progressAt,
+                observedAt: input.observedAt,
+                kind: "advisory-resource"
+            }, input.now));
+            return "recorded";
+        });
+    }
+    hasInFlightTurn(taskId, roleName) {
+        const sessions = this.store.getTaskRoleSessionSet(taskId, roleName);
+        return sessions !== null && sessions.inFlight !== null;
+    }
+    isRoleGenerationProviderReady(input) {
+        // A provider-ready fact for this exact generation is proven by a folded
+        // runtime.provider-session-lifecycle event with preInputReady true and a
+        // matching agent/launch/nativeSession fence. This reads durable folded truth
+        // only — no liveness, screen, or pane/PID inference.
+        return this.store.listEvents(input.taskId).some((event) => (event.type === "runtime.provider-session-lifecycle"
+            && event.payload.roleName === input.roleName
+            && event.payload.agentId === input.agentId
+            && event.payload.preInputReady === "true"
+            && (input.launchId === undefined || event.payload.launchId === input.launchId)
+            && (input.nativeSessionId === undefined
+                || event.payload.nativeSessionId === input.nativeSessionId)));
+    }
+    peekNextAgentRunId(taskId) {
+        return this.store.peekNextAgentRunId(taskId);
+    }
+    getWorkMailbox(target) { return this.store.getWorkMailbox(target); }
+    listWorkMailboxes() { return this.store.listWorkMailboxes(); }
+    queueTaskProgress(taskId, reason, now) {
+        this.store.transaction((store) => {
+            enqueueWork(store, { kind: "task", taskId }, reason, now, [
+                { type: "task", id: taskId }
+            ]);
+        });
+    }
+    enqueueLeaderWakeup(taskId, reason, now) {
+        return this.store.transaction((store) => (queueLeaderWakeup(store, taskId, reason, now)));
+    }
+    releaseLeaderWakeupAndEnqueue(taskId, batchId, reason, now) {
+        const target = { kind: "role", taskId, roleName: "leader" };
+        return this.store.transaction((store) => {
+            const mailbox = store.getWorkMailbox(target);
+            if (mailbox?.processing?.batchId !== batchId)
+                return false;
+            store.saveWorkMailbox(releaseProcessing(mailbox, batchId));
+            enqueueWork(store, target, reason, now);
+            return true;
+        });
+    }
+    claimWorkMailbox(input) {
+        return this.store.transaction((store) => {
+            const mailbox = store.getWorkMailbox(input.target);
+            if (mailbox === null || (mailbox.processing === null && mailbox.pending === null)) {
+                return { status: "empty" };
+            }
+            if (mailbox.processing !== null) {
+                return { status: "processing", processing: mailbox.processing };
+            }
+            let claimed = claimPending(mailbox, {
+                batchId: input.batchId,
+                owner: input.owner,
+                startedAt: input.now.toISOString()
+            });
+            if (input.executionRef !== undefined) {
+                claimed = bindExecution(claimed, input.batchId, input.executionRef);
+            }
+            store.saveWorkMailbox(claimed);
+            return { status: "claimed", processing: claimed.processing };
+        });
+    }
+    completeWorkMailbox(target, batchId) {
+        return this.store.transaction((store) => {
+            const mailbox = store.getWorkMailbox(target);
+            if (mailbox?.processing?.batchId !== batchId)
+                return false;
+            const completed = completeProcessing(mailbox, batchId);
+            if (target.kind === "role-runtime"
+                || target.kind === "global-role-runtime") {
+                saveRuntimeLifecycleMailbox(store, completed);
+            }
+            else {
+                store.saveWorkMailbox(completed);
+            }
+            return true;
+        });
+    }
+    releaseWorkMailbox(target, batchId) {
+        return this.store.transaction((store) => {
+            const mailbox = store.getWorkMailbox(target);
+            if (mailbox?.processing?.batchId !== batchId)
+                return false;
+            store.saveWorkMailbox(releaseProcessing(mailbox, batchId));
+            return true;
+        });
+    }
+    completeRuntimeCleanup(target, now) {
+        return this.store.transaction((store) => {
+            let mailbox = store.getWorkMailbox(target);
+            if (mailbox === null || !hasRuntimeCleanupObligation(mailbox))
+                return false;
+            if (mailbox.processing !== null) {
+                if (!isRuntimeLaunchReservation(mailbox.processing)
+                    && !mailbox.processing.batch.reasons.includes(RUNTIME_CLEANUP_REQUIRED_REASON)) {
+                    return false;
+                }
+                mailbox = completeProcessing(mailbox, mailbox.processing.batchId);
+            }
+            if (mailbox.pending !== null) {
+                if (mailbox.pending.reasons.length !== 1
+                    || mailbox.pending.reasons[0] !== RUNTIME_CLEANUP_REQUIRED_REASON) {
+                    return false;
+                }
+                const batchId = `runtime-cleanup-complete:${mailbox.pending.fromSequence}-${mailbox.pending.toSequence}`;
+                mailbox = completeProcessing(claimPending(mailbox, {
+                    batchId,
+                    owner: RUNTIME_LIFECYCLE_OWNER,
+                    startedAt: now.toISOString()
+                }), batchId);
+            }
+            markRuntimeOwnerSessionStopped(store, runtimeOwnerFromTarget(target), now);
+            saveRuntimeLifecycleMailbox(store, mailbox);
+            return true;
+        });
+    }
+    completeStoppedRuntimeReservation(target, batchId, now) {
+        return this.store.transaction((store) => {
+            const mailbox = store.getWorkMailbox(target);
+            if (!isRuntimeLaunchReservation(mailbox?.processing, batchId)) {
+                return false;
+            }
+            markRuntimeOwnerSessionStopped(store, runtimeOwnerFromTarget(target), now);
+            saveRuntimeLifecycleMailbox(store, completeProcessing(mailbox, batchId));
+            return true;
+        });
+    }
+    listDormantRuntimeOwners() {
+        const taskOwners = this.store.listTasks().flatMap((task) => (this.store.listRoleSessionSets(task.id).flatMap((sessions) => {
+            const active = sessions.sessions[sessions.activeAgentId];
+            return active !== undefined
+                && active.status !== "stopped"
+                && !hasRuntimeLifecycleWork(this.store.getWorkMailbox(runtimeLifecycleTarget(sessions.owner)))
+                && this.store.getActiveAgentRun(task.id, sessions.owner.roleName) === null
+                ? [{
+                        owner: sessions.owner,
+                        agentId: active.agentId,
+                        adapterId: active.adapterId,
+                        nativeSessionId: active.nativeSessionId,
+                        ...(active.launchId === undefined ? {} : { launchId: active.launchId }),
+                        sessionUpdatedAt: active.updatedAt
+                    }]
+                : [];
+        })));
+        const globalOwners = this.store.listGlobalRoleSessionSets().flatMap((sessions) => {
+            const active = sessions.sessions[sessions.activeAgentId];
+            return active !== undefined
+                && active.status !== "stopped"
+                && !hasRuntimeLifecycleWork(this.store.getWorkMailbox(runtimeLifecycleTarget(sessions.owner)))
+                ? [{
+                        owner: sessions.owner,
+                        agentId: active.agentId,
+                        adapterId: active.adapterId,
+                        nativeSessionId: active.nativeSessionId,
+                        ...(active.launchId === undefined ? {} : { launchId: active.launchId }),
+                        sessionUpdatedAt: active.updatedAt
+                    }]
+                : [];
+        });
+        return [...taskOwners, ...globalOwners];
+    }
+    markRuntimeOwnerStopped(candidate, now) {
+        return this.store.transaction((store) => {
+            if (!dormantRuntimeCandidateIsCurrent(store, candidate))
+                return false;
+            return markRuntimeOwnerSessionStopped(store, candidate.owner, now);
+        });
+    }
+    enqueueRuntimeCleanup(owner, now = new Date(), expectedDormantCandidate) {
+        return this.store.transaction((store) => {
+            if (expectedDormantCandidate !== undefined
+                && (!sameRuntimeOwner(owner, expectedDormantCandidate.owner)
+                    || !dormantRuntimeCandidateIsCurrent(store, expectedDormantCandidate))) {
+                return null;
+            }
+            if (owner.scope === "task" && store.getTask(owner.taskId) === null) {
+                return null;
+            }
+            const target = runtimeLifecycleTarget(owner);
+            enqueueWork(store, target, RUNTIME_CLEANUP_REQUIRED_REASON, now, owner.scope === "task" ? [{ type: "task", id: owner.taskId }] : []);
+            return target;
+        });
     }
-    nextAgentRunId(taskId) { return this.store.nextAgentRunId(taskId); }
     getPendingWakeup(taskId) { return this.store.getPendingWakeup(taskId); }
     listPendingWakeups() { return this.store.listPendingWakeups(); }
     savePendingWakeup(wakeup) {
@@ -83,18 +433,49 @@ export class FileSchedulerStoreAdapter {
                 return "unavailable";
             }
             const role = requireRole(store, input.task.id, input.role.name);
+            const binding = activeRoleAgentBinding(role);
             if (role.activeAgentId !== input.role.activeAgentId
-                || activeRoleAgentBinding(role).adapterId !== input.role.adapterId) {
+                || binding.adapterId !== input.role.adapterId
+                || binding.config.model !== input.role.model
+                || binding.config.effort !== input.role.effort
+                || role.workspace !== input.role.workspace) {
                 return "state-changed";
             }
+            if (!isDeepStrictEqual(input.run.effective, input.role.effective)) {
+                return "state-changed";
+            }
+            if (store.getAgentRun(input.task.id, input.run.id) !== null)
+                return "state-changed";
             if (store.getActiveAgentRun(input.task.id, input.role.name) !== null)
                 return "busy";
             const pending = store.getPendingWakeup(input.task.id);
             if (pending === null || !pendingWakeupsMatch(pending, input.wakeup)) {
                 return "state-changed";
             }
+            const target = { kind: "role", taskId: input.task.id, roleName: input.role.name };
+            const mailbox = store.getWorkMailbox(target);
+            if (mailbox === null || mailbox.pending === null)
+                return "state-changed";
+            if (mailbox.processing !== null)
+                return "busy";
+            if (store.peekNextAgentRunId(input.task.id) !== input.run.id) {
+                return "state-changed";
+            }
+            const allocatedRunId = store.nextAgentRunId(input.task.id);
+            if (allocatedRunId !== input.run.id) {
+                throw new Error(`Leader Run allocation changed unexpectedly: ${input.task.id}.`);
+            }
+            const batchId = formatAgentRunReceiptId(input.task.id, input.run.id);
+            const claimed = bindExecution(claimPending(mailbox, {
+                batchId,
+                owner: "controller",
+                startedAt: input.now.toISOString()
+            }), batchId, { type: "run", taskId: input.task.id, id: input.run.id });
             store.saveActiveAgentRun(input.run);
+            store.saveWorkMailbox(claimed);
             store.saveRole(input.task.id, updateRoleStatus(role, "running", input.now));
+            bindTaskRoleRunInFlight(store, role, input.run, input.now);
+            store.saveEvent(input.task.id, createTaskEvent(store.nextEventId(input.task.id), input.task.id, "run.dispatched", runLaunchEventPayload(input.run), input.now));
             if (input.session !== null && input.session.nativeSessionId !== undefined) {
                 saveTaskSession(store, role, {
                     ...input.session,
@@ -103,7 +484,6 @@ export class FileSchedulerStoreAdapter {
             }
             store.clearLeaderFailure(input.task.id);
             store.clearOperatorNotification(input.task.id);
-            store.clearPendingWakeup(input.task.id);
             return "claimed";
         });
     }
@@ -118,187 +498,1826 @@ export class FileSchedulerStoreAdapter {
             if (active === null || active.id !== input.run.id) {
                 throw new Error(`Active Agent run changed before delivery was persisted: ${input.run.id}.`);
             }
-            if (active.deliveredAt === undefined) {
-                store.saveAgentRun(markAgentRunDelivered(active, input.now));
+            // Transport success records prompt-pushed ONLY. Acceptance (deliveredAt)
+            // is written exclusively by an exact provider-accepted fold, never by the
+            // transport receipt — that removes the transport-to-delivered false path.
+            if (active.pushedAt === undefined) {
+                store.saveAgentRun(markAgentRunPushed(active, input.now));
+                markTaskRoleRunPushedInFlight(store, role, input.run, input.now);
+                store.saveEvent(task.id, createTaskEvent(store.nextEventId(task.id), task.id, "run.pushed", runLaunchEventPayload(active), input.now));
+            }
+            else {
+                const sessions = store.getTaskRoleSessionSet(input.task.id, input.role.name);
+                if (sessions?.inFlight?.runId === input.run.id
+                    && sessions.inFlight.pushedAt === undefined) {
+                    markTaskRoleRunPushedInFlight(store, role, input.run, input.now);
+                }
             }
             if (role.status !== "running") {
                 store.saveRole(input.task.id, updateRoleStatus(role, "running", input.now));
             }
             if (input.session !== null && input.session.nativeSessionId !== undefined) {
                 const existing = store.getRoleSession(input.task.id, input.role.name);
+                const reservation = matchingPreparedRuntimeReservation(store, input);
                 if (existing?.agentId !== input.session.agentId
                     || existing.adapterId !== input.session.adapterId
                     || existing.nativeSessionId !== input.session.nativeSessionId
+                    || (input.launchId !== undefined && existing.launchId !== input.launchId)
                     || existing.status !== "running") {
                     saveTaskSession(store, role, {
                         ...input.session,
                         nativeSessionId: input.session.nativeSessionId
-                    }, "running", input.now);
+                    }, "running", input.now, input.launchId);
                 }
+                completePreparedRuntimeReservation(store, reservation);
             }
         });
     }
-    saveLeaderDispatchFailure(input) {
+    saveRoleRunPrepared(input) {
         this.store.transaction((store) => {
             const task = store.getTask(input.task.id);
-            if (task === null || task.status !== "active")
-                return;
+            if (task === null || task.status !== "active") {
+                throw new Error(`Task is not active: ${input.task.id}.`);
+            }
             const role = requireRole(store, input.task.id, input.role.name);
-            if (input.claimed !== undefined) {
-                const active = store.getActiveAgentRun(input.task.id, input.role.name);
-                if (active?.id === input.claimed.run.id) {
-                    store.saveAgentRun(failAgentRun(active, input.failure.message, input.now));
-                    store.clearActiveAgentRun(input.task.id, input.role.name);
+            const active = store.getActiveAgentRun(input.task.id, input.role.name);
+            if (active === null || active.id !== input.run.id) {
+                throw new Error(`Active Agent run changed before preparation was persisted: ${input.run.id}.`);
+            }
+            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") {
+                    saveTaskSession(store, role, {
+                        ...input.session,
+                        nativeSessionId: input.session.nativeSessionId
+                    }, "running", input.now, input.launchId);
                 }
-                store.savePendingWakeup(restorePendingWakeup(input.claimed.wakeup, store.getPendingWakeup(input.task.id)));
             }
-            store.saveRole(input.task.id, updateRoleStatus(role, "failed", input.now));
-            breakTaskSessionIfPresent(store, input.task.id, role.name, role.activeAgentId, input.now);
-            store.saveLeaderFailure(input.failure);
-            store.saveOperatorNotification(input.notification);
+            bindTaskRoleRunInFlight(store, role, input.run, input.now);
         });
     }
-    saveExitedRoleRun(input) {
-        this.store.transaction((store) => {
-            const role = requireRole(store, input.task.id, input.role.name);
-            store.saveAgentRun(failAgentRun(input.run, input.summary, input.now));
-            store.clearActiveAgentRun(input.task.id, input.role.name);
-            if (input.run.workItemId !== undefined) {
-                const workItem = store.getWorkItem(input.task.id, input.run.workItemId);
-                if (workItem !== null && !["completed", "failed", "cancelled", "superseded"].includes(workItem.status)) {
-                    store.saveWorkItem(input.task.id, updateWorkItemStatus(workItem, "failed", input.summary, input.now));
+    saveRoleRunDeliveryFailure(input) {
+        return this.store.transaction((store) => {
+            const task = store.getTask(input.taskId);
+            const role = store.getRole(input.taskId, input.roleName);
+            const active = store.getActiveAgentRun(input.taskId, input.roleName);
+            const sessions = store.getTaskRoleSessionSet(input.taskId, input.roleName);
+            const session = sessions?.sessions[input.agentId];
+            const mailbox = store.getWorkMailbox({
+                kind: "role",
+                taskId: input.taskId,
+                roleName: input.roleName
+            });
+            const runtimeMailbox = store.getWorkMailbox(runtimeLifecycleTarget({
+                scope: "task",
+                taskId: input.taskId,
+                roleName: input.roleName
+            }));
+            if (task === null
+                || task.status !== "active"
+                || role === null
+                || active === null
+                || active.id !== input.runId
+                || active.status !== "active"
+                || active.pushedAt !== undefined
+                || active.effective.agentId !== input.agentId
+                || active.effective.adapterId !== input.adapterId
+                || mailbox?.processing?.batchId !== input.mailboxBatchId
+                || mailbox.processing.executionRef?.type !== "run"
+                || mailbox.processing.executionRef.taskId !== input.taskId
+                || mailbox.processing.executionRef.id !== input.runId
+                || !preparedDeliveryFailureSessionFenceMatches(sessions, session, input)
+                || !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 result = terminalizeExactTaskRun(store, {
+                taskId: input.taskId,
+                roleName: input.roleName,
+                agentId: input.agentId,
+                runId: input.runId,
+                receiptId: formatAgentRunReceiptId(input.taskId, input.runId),
+                ...(session?.nativeSessionId === undefined
+                    ? {}
+                    : { nativeSessionId: session.nativeSessionId }),
+                ...(input.launchId === undefined ? {} : { launchId: input.launchId }),
+                outcome: { status: "failed", summary }
+            }, input.now);
+            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 }]);
+            const terminal = result.run;
+            store.saveEvent(input.taskId, createTaskEvent(store.nextEventId(input.taskId), input.taskId, "runtime.role-delivery-failed", {
+                runId: terminal.id,
+                roleName: input.roleName,
+                outcome: terminal.status
+            }, input.now));
+            if (terminal.purpose === "execution" && terminal.workItemId !== undefined) {
+                const item = store.getWorkItem(input.taskId, terminal.workItemId);
+                if (item !== null && ![
+                    "completed", "failed", "retired"
+                ].includes(item.status)) {
+                    const group = currentWorkItemExecutionGroup(item);
+                    const groupedPanel = group !== undefined
+                        && (group.lanes.length > 1 || group.strategy.mode === "adaptive")
+                        && group.resolution === undefined;
+                    if (!groupedPanel) {
+                        store.saveWorkItem(input.taskId, updateWorkItemStatus(item, "failed", input.now, summary));
+                    }
+                }
+            }
+            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 }])
+                ]);
+            }
+            else {
+                const failedRole = store.getRole(input.taskId, input.roleName);
+                if (failedRole !== null) {
+                    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 }
+                ]);
             }
-            store.saveRole(input.task.id, updateRoleStatus(role, "exited", input.now));
-            stopTaskSessionIfPresent(store, input.task.id, role.name, role.activeAgentId, input.now);
+            return "failed";
         });
     }
-    saveArchivedTaskStopped(taskId, now) {
-        this.store.transaction((store) => {
-            const task = store.getTask(taskId);
-            if (task === null || task.status !== "archived")
-                return;
-            for (const role of store.listRoles(taskId)) {
-                if (role.status !== "idle") {
-                    store.saveRole(taskId, updateRoleStatus(role, "idle", now));
+    saveLeaderDispatchFailure(input) {
+        return this.store.transaction((store) => {
+            const task = store.getTask(input.task.id);
+            const role = store.getRole(input.task.id, input.role.name);
+            const active = store.getActiveAgentRun(input.task.id, input.role.name);
+            const target = {
+                kind: "role",
+                taskId: input.task.id,
+                roleName: input.role.name
+            };
+            const mailbox = store.getWorkMailbox(target);
+            if (task === null
+                || task.status !== "active"
+                || role === null
+                || active === null
+                || active.id !== input.claimed.run.id
+                || active.status !== "active"
+                || mailbox?.processing?.executionRef?.type !== "run"
+                || mailbox.processing.executionRef.taskId !== input.task.id
+                || mailbox.processing.executionRef.id !== input.claimed.run.id
+                || !schedulerRoleSessionsMatch(store.getRoleSession(input.task.id, input.role.name), input.session)) {
+                return "state-changed";
+            }
+            store.saveAgentRun(failAgentRun(active, input.failure.message, input.now));
+            store.clearActiveAgentRun(input.task.id, input.role.name);
+            clearTaskRoleRunInFlight(store, role, active, input.now);
+            store.saveWorkMailbox(releaseProcessing(mailbox, mailbox.processing.batchId));
+            store.saveRole(input.task.id, updateRoleStatus(role, "failed", input.now));
+            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 }
+            ]);
+            return "failed";
+        });
+    }
+    saveExitedRoleRun(input) {
+        return this.store.transaction((store) => {
+            const task = store.getTask(input.task.id);
+            const role = store.getRole(input.task.id, input.role.name);
+            const currentRun = store.getActiveAgentRun(input.task.id, input.role.name);
+            if (task === null
+                || task.status !== "active"
+                || role === null
+                || currentRun === null
+                || currentRun.id !== input.run.id
+                || currentRun.status !== "active") {
+                return "state-changed";
+            }
+            const sessions = store.getTaskRoleSessionSet(task.id, role.name);
+            if (sessions?.inFlight !== null
+                && sessions !== null
+                && (sessions.inFlight.agentId !== currentRun.effective.agentId
+                    || sessions.inFlight.runId !== currentRun.id
+                    || sessions.inFlight.receiptId !== formatAgentRunReceiptId(task.id, currentRun.id))) {
+                return "state-changed";
+            }
+            // Review launch failure uses the aggregate exact-terminalization path.
+            // It owns mailbox settlement and ReviewRound convergence together, so a
+            // pending pre-delivery dispatch cannot be consumed before its Run and
+            // Round pass the same immutable identity fences.
+            if (currentRun.purpose === "review") {
+                if (input.run.taskId !== currentRun.taskId
+                    || input.run.roleName !== currentRun.roleName
+                    || input.run.purpose !== "review"
+                    || input.run.reviewRoundId !== currentRun.reviewRoundId
+                    || input.run.workItemId !== currentRun.workItemId
+                    || input.run.effective.agentId !== currentRun.effective.agentId
+                    || input.run.effective.adapterId !== currentRun.effective.adapterId) {
+                    return "state-changed";
                 }
+                const terminal = terminalizeExactTaskRun(store, {
+                    taskId: task.id,
+                    roleName: role.name,
+                    agentId: currentRun.effective.agentId,
+                    runId: currentRun.id,
+                    receiptId: formatAgentRunReceiptId(task.id, currentRun.id),
+                    ...(input.session?.nativeSessionId === undefined
+                        ? {}
+                        : { nativeSessionId: input.session.nativeSessionId }),
+                    outcome: { status: "failed", summary: input.summary }
+                }, 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, "review-failed", input.now);
+                return "failed";
             }
-            for (const current of store.listRoleSessionSets(taskId)) {
-                if (Object.values(current.sessions).every((session) => session.status === "stopped")) {
-                    continue;
+            const target = { kind: "role", taskId: task.id, roleName: role.name };
+            const mailbox = store.getWorkMailbox(target);
+            const processing = mailbox?.processing;
+            if (mailbox !== null && processing !== null && processing !== undefined) {
+                if (processing.executionRef === undefined
+                    || processing.executionRef.type !== "run"
+                    || processing.executionRef.taskId !== task.id
+                    || processing.executionRef.id !== currentRun.id) {
+                    return "state-changed";
                 }
-                let updated = current;
-                for (const agentId of Object.keys(current.sessions)) {
-                    updated = updateRoleAgentSessionStatus(updated, agentId, "stopped", now);
+            }
+            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) {
+                store.saveWorkMailbox(completeProcessing(mailbox, processing.batchId));
+            }
+            if (currentRun.purpose === "execution" && currentRun.workItemId !== undefined) {
+                const workItem = store.getWorkItem(task.id, currentRun.workItemId);
+                if (workItem !== null && !["completed", "failed", "retired"].includes(workItem.status)) {
+                    // Terminalize the bound execution lane in the same transaction that
+                    // fails the Run. Without this, a scheduler-driven Worker failure
+                    // leaves the lane "running" behind a "failed" WorkItem, and a later
+                    // `yui task run retry` is rejected because the lane is not terminal.
+                    // The lane result and the WorkItem status are two ordered single-step
+                    // record revisions, matching the aggregate terminalization path.
+                    if (currentRun.executionGroupId !== undefined
+                        && currentRun.executionLaneId !== undefined
+                        && currentWorkItemExecutionGroup(workItem) !== undefined) {
+                        const group = currentWorkItemExecutionGroup(workItem);
+                        store.saveWorkItem(task.id, updateWorkItemExecutionGroup(workItem, recordExecutionLaneResult(group, currentRun.executionLaneId, { summary: input.summary }, "failed", input.now), input.now));
+                    }
+                    const laneUpdated = store.getWorkItem(task.id, currentRun.workItemId);
+                    const laneGroup = currentWorkItemExecutionGroup(laneUpdated);
+                    const groupedPanel = laneGroup !== undefined
+                        && (laneGroup.lanes.length > 1 || laneGroup.strategy.mode === "adaptive")
+                        && laneGroup.resolution === undefined;
+                    if (!groupedPanel) {
+                        store.saveWorkItem(task.id, updateWorkItemStatus(laneUpdated, "failed", input.now, input.summary));
+                    }
                 }
-                store.saveRoleSessionSet(updated);
             }
+            store.saveRole(task.id, updateRoleStatus(role, "exited", input.now));
+            stopTaskSessionIfPresent(store, task.id, role.name, currentRun.effective.agentId, input.now);
+            queueLeaderWakeup(store, task.id, role.name === "leader" ? "leader-run-failed" : "role-run-failed", input.now);
+            return "failed";
         });
     }
     /** Called by the internal Codex notify hook, never by an LLM prompt. */
     recordRuntimeNativeSession(input, now = new Date()) {
+        return this.store.transaction((store) => (recordTaskRuntimeNativeSession(store, input, now)));
+    }
+    reserveRuntimeLaunch(input, assertCurrent, now = new Date()) {
+        return this.store.transaction((store) => {
+            assertCurrent();
+            const target = runtimeLifecycleTarget(input.owner);
+            const existing = store.getWorkMailbox(target);
+            if (isRuntimeLaunchReservation(existing?.processing)) {
+                if (hasRuntimeCleanupObligation(existing)) {
+                    throw new Error("Runtime cleanup is still pending.");
+                }
+                const executionRef = existing.processing.executionRef;
+                if (executionRef?.type === "run"
+                    && (input.owner.scope !== "task"
+                        || executionRef.taskId !== input.owner.taskId)) {
+                    throw new Error("Runtime launch reservation belongs to another Task Run.");
+                }
+                return {
+                    status: "existing",
+                    launchId: existing.processing.batchId,
+                    ...(executionRef?.type === "run"
+                        ? { runId: executionRef.id }
+                        : {})
+                };
+            }
+            if (existing !== null
+                && (existing.processing !== null || existing.pending !== null)) {
+                throw new Error("Runtime lifecycle work is already pending.");
+            }
+            enqueueWork(store, target, RUNTIME_LAUNCH_RESERVED_REASON, now, input.owner.scope === "task"
+                ? [{ type: "task", id: input.owner.taskId }]
+                : []);
+            const queued = store.getWorkMailbox(target);
+            if (queued === null || queued.pending === null || queued.processing !== null) {
+                throw new Error("Runtime launch reservation could not be queued.");
+            }
+            let claimed = claimPending(queued, {
+                batchId: input.launchId,
+                owner: RUNTIME_LIFECYCLE_OWNER,
+                startedAt: now.toISOString()
+            });
+            if (input.runId !== undefined) {
+                if (input.owner.scope !== "task") {
+                    throw new Error("A Run-bound runtime reservation requires a Task owner.");
+                }
+                claimed = bindExecution(claimed, input.launchId, { type: "run", taskId: input.owner.taskId, id: input.runId });
+            }
+            store.saveWorkMailbox(claimed);
+            return {
+                status: "reserved",
+                launchId: input.launchId,
+                ...(input.runId === undefined ? {} : { runId: input.runId })
+            };
+        });
+    }
+    confirmRuntimeLaunchReservation(input, assertCurrent) {
+        return this.store.transaction((store) => {
+            assertCurrent();
+            const mailbox = store.getWorkMailbox(runtimeLifecycleTarget(input.owner));
+            if (isRuntimeLaunchReservation(mailbox?.processing, input.launchId)) {
+                return "reserved";
+            }
+            if (hasRuntimeCleanupObligation(mailbox)) {
+                throw new Error("Runtime cleanup is still pending.");
+            }
+            // A synchronous provider lifecycle Hook may bind a fresh native Session
+            // and complete the reservation while the host start call is still
+            // unwinding. Preserve that exact hook-won generation instead of treating
+            // the already-settled reservation as a launch failure.
+            const sessions = runtimeOwnerSessionSet(store, input.owner);
+            const active = sessions?.sessions[sessions.activeAgentId];
+            if (active?.status === "running"
+                && active.launchId === input.launchId)
+                return "provider-bound";
+            throw new Error("Runtime launch reservation no longer matches the launch.");
+        });
+    }
+    recordReservedRuntimeNativeSession(input, assertCurrent, now = new Date()) {
+        return this.store.transaction((store) => {
+            assertCurrent();
+            const mailbox = requireRuntimeLaunchReservation(store, input.owner, input.launchId);
+            if (hasRuntimeCleanupObligation(mailbox)) {
+                throw new Error("Runtime cleanup is still pending.");
+            }
+            const session = input.owner.scope === "task"
+                ? recordTaskRuntimeNativeSession(store, {
+                    taskId: input.owner.taskId,
+                    roleName: input.owner.roleName,
+                    agentId: input.agentId,
+                    adapterId: input.adapterId,
+                    nativeSessionId: input.nativeSessionId,
+                    launchId: input.launchId,
+                    effective: input.effective
+                }, now)
+                : recordGlobalRuntimeNativeSession(store, {
+                    roleName: input.owner.roleName,
+                    agentId: input.agentId,
+                    adapterId: input.adapterId,
+                    nativeSessionId: input.nativeSessionId,
+                    launchId: input.launchId,
+                    effective: input.effective
+                }, now);
+            saveRuntimeLifecycleMailbox(store, completeProcessing(mailbox, input.launchId));
+            return session;
+        });
+    }
+    completeRuntimeLaunchReservation(owner, launchId, expectedTerminalRunId, beforeComplete) {
+        return this.store.transaction((store) => {
+            const target = runtimeLifecycleTarget(owner);
+            const mailbox = store.getWorkMailbox(target);
+            if (!isRuntimeLaunchReservation(mailbox?.processing, launchId))
+                return false;
+            if (expectedTerminalRunId !== undefined) {
+                const expectedRun = owner.scope === "task"
+                    ? store.getAgentRun(owner.taskId, expectedTerminalRunId)
+                    : null;
+                if (owner.scope !== "task"
+                    || mailbox?.processing?.executionRef?.type !== "run"
+                    || mailbox.processing.executionRef.taskId !== owner.taskId
+                    || mailbox.processing.executionRef.id !== expectedTerminalRunId
+                    || expectedRun === null
+                    || expectedRun.status === "active") {
+                    return false;
+                }
+            }
+            beforeComplete?.();
+            saveRuntimeLifecycleMailbox(store, completeProcessing(mailbox, launchId));
+            return true;
+        });
+    }
+    /**
+     * Atomically settles a launch whose host is confirmed absent.
+     *
+     * The exact reservation is authoritative. If its matching Hook won the
+     * transaction race and already cleared that reservation, the session
+     * fallback is permitted only while the same Agent/native identity remains
+     * current and no later lifecycle work or Task Run exists.
+     */
+    settleStoppedRuntimeLaunch(input, now = new Date()) {
+        return this.store.transaction((store) => {
+            const target = runtimeLifecycleTarget(input.owner);
+            const mailbox = store.getWorkMailbox(target);
+            if (isRuntimeLaunchReservation(mailbox?.processing, input.launchId)) {
+                const sessions = runtimeOwnerSessionSet(store, input.owner);
+                const active = sessions?.sessions[sessions.activeAgentId];
+                if (runtimeSessionMatchesSettledLaunch(active, input)) {
+                    markRuntimeOwnerSessionStopped(store, input.owner, now);
+                }
+                saveRuntimeLifecycleMailbox(store, completeProcessing(mailbox, input.launchId));
+                return true;
+            }
+            if (hasRuntimeLifecycleWork(mailbox))
+                return false;
+            if (input.owner.scope === "task"
+                && store.getActiveAgentRun(input.owner.taskId, input.owner.roleName) !== null) {
+                return false;
+            }
+            const sessions = runtimeOwnerSessionSet(store, input.owner);
+            if (sessions === null)
+                return true;
+            const active = sessions.sessions[sessions.activeAgentId];
+            if (!runtimeSessionMatchesSettledLaunch(active, input))
+                return false;
+            if (active.status !== "stopped") {
+                markRuntimeOwnerSessionStopped(store, input.owner, now);
+            }
+            return true;
+        });
+    }
+    /**
+     * Fast hook path: durably records the native Turn boundary and a two-second
+     * closure deadline. It never performs tmux, workspace, or Controller I/O.
+     */
+    classifyRuntimeTurnCompleted(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)
+            return "obsolete";
+        const sessions = this.store.getTaskRoleSessionSet(input.taskId, input.roleName);
+        const existing = sessions?.sessions[input.agentId];
+        const owner = {
+            scope: "task",
+            taskId: input.taskId,
+            roleName: input.roleName
+        };
+        if (existing === undefined
+            && !runtimeHookMatchesReservation(this.store, owner, input.launchId))
+            return "obsolete";
+        try {
+            const effectiveExisting = nativeTransitionExisting(this.store, owner, existing, input.nativeSessionId, input.launchId, "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";
+            }
+        }
+        catch {
+            return "obsolete";
+        }
+        if (sessions?.pendingTurnCompletion !== null && sessions !== null) {
+            return sessions.pendingTurnCompletion.turnId === input.turnId
+                ? "apply"
+                : "deferred";
+        }
+        // A normal explicit CLI yield may precede its native Hook; that Hook still
+        // owns the turn fact. A forced cleanup boundary or stopped process instead
+        // makes the old generation obsolete.
+        if (sessions?.inFlight === null || sessions === null) {
+            const cleanup = hasRuntimeCleanupObligation(this.store.getWorkMailbox(runtimeLifecycleTarget({
+                scope: "task",
+                taskId: input.taskId,
+                roleName: input.roleName
+            })));
+            return cleanup || isObsoleteTerminalRuntimeRun(this.store, input)
+                ? "obsolete"
+                : "apply";
+        }
+        if (input.runId === undefined || sessions.inFlight.runId !== input.runId) {
+            return "obsolete";
+        }
+        // Provider completion is not a transport acknowledgement. Retain the
+        // immutable Hook until the exact pane receipt independently reconciles
+        // run.pushed; never infer transport from provider progress/terminal facts.
+        return sessions.inFlight.pushedAt === undefined ? "deferred" : "apply";
+    }
+    observeRuntimeTurnCompleted(input, now = new Date()) {
         return this.store.transaction((store) => {
             const task = store.getTask(input.taskId);
             if (task === null)
                 throw new Error(`Task not found: ${input.taskId}.`);
-            if (task.status === "archived") {
-                throw new Error(`Cannot register a native session for archived Task: ${input.taskId}.`);
-            }
             if (task.status !== "active") {
-                throw new Error(`Cannot register a native session for a Task that is not active: ${input.taskId}.`);
+                throw new Error(`Cannot complete a runtime turn for inactive Task: ${input.taskId}.`);
             }
             const role = requireRole(store, input.taskId, input.roleName);
-            const binding = activeRoleAgentBinding(role);
-            if (binding.agentId !== input.agentId || binding.adapterId !== input.adapterId) {
-                throw new Error("Native session registration does not match the active Role Agent binding.");
+            let sessions = store.getTaskRoleSessionSet(input.taskId, input.roleName)
+                ?? createRoleSessionSet({ scope: "task", taskId: input.taskId, roleName: input.roleName }, input.agentId, now);
+            const existing = sessions.sessions[input.agentId];
+            const owner = {
+                scope: "task",
+                taskId: input.taskId,
+                roleName: input.roleName
+            };
+            if (existing === undefined
+                && !runtimeHookMatchesReservation(store, owner, input.launchId)) {
+                throw new Error("Runtime turn completion does not match the launch reservation.");
             }
-            const current = store.getRoleSessionSet(input.taskId, input.roleName)
-                ?? createRoleSessionSet({ scope: "task", taskId: input.taskId, roleName: input.roleName }, role.activeAgentId, now);
-            const existing = current.sessions[input.agentId];
-            if (existing !== undefined && existing.nativeSessionId !== input.nativeSessionId) {
-                throw new Error("Native session registration conflicts with the fixed Role session.");
+            const effectiveExisting = nativeTransitionExisting(store, owner, existing, input.nativeSessionId, input.launchId, "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.");
+            }
+            if (effectiveExisting !== undefined
+                && hasRecentTurnId(effectiveExisting.recentCompletedTurnIds, input.turnId)) {
+                return { session: effectiveExisting, duplicate: true };
+            }
+            const pending = sessions.pendingTurnCompletion;
+            if (effectiveExisting !== undefined
+                && pending !== null
+                && pending.agentId === input.agentId
+                && pending.nativeSessionId === input.nativeSessionId
+                && pending.turnId === input.turnId
+                && pending.runId === input.runId) {
+                return {
+                    session: effectiveExisting,
+                    duplicate: true,
+                    pendingRunId: pending.runId
+                };
+            }
+            if (sessions.inFlight === null
+                && existing !== undefined
+                && (hasRuntimeCleanupObligation(store.getWorkMailbox(runtimeLifecycleTarget(owner)))
+                    || isObsoleteTerminalRuntimeRun(store, input))) {
+                return { session: existing, duplicate: false, disposition: "obsolete" };
+            }
+            // Classification is only an optimization. Revalidate the Run inside the
+            // authoritative transaction before a Hook may claim a native identity.
+            if (sessions.inFlight !== null
+                && (input.runId === undefined
+                    || sessions.inFlight.runId !== input.runId)) {
+                if (effectiveExisting === undefined) {
+                    throw new Error("Runtime turn completion no longer matches the in-flight Run.");
+                }
+                return { session: effectiveExisting, duplicate: false };
+            }
+            if (sessions.inFlight !== null && sessions.inFlight.pushedAt === undefined) {
+                throw new Error("Runtime turn completion requires an independently committed transport receipt.");
             }
-            if (existing?.status === "running")
-                return existing;
-            const updated = recordRoleAgentSession(current, {
+            const idleStatus = effectiveExisting?.status === "stopped"
+                || effectiveExisting?.status === "broken"
+                ? effectiveExisting.status
+                : "ready";
+            sessions = recordRoleAgentSession(sessions, {
                 agentId: input.agentId,
                 adapterId: input.adapterId,
                 nativeSessionId: input.nativeSessionId,
+                ...(input.launchId === undefined ? {} : { launchId: input.launchId }),
                 policy: "fixed",
-                status: "running"
+                status: sessions.inFlight === null ? idleStatus : "running",
+                effective
             }, now);
-            store.saveRoleSessionSet(updated);
-            return updated.sessions[input.agentId];
+            if (sessions.inFlight === null) {
+                sessions = rememberRoleAgentCompletedTurn(sessions, input.agentId, input.nativeSessionId, input.turnId, now);
+                store.saveTaskRoleSessionSet(sessions);
+                completeRuntimeHookReservation(store, owner, input.launchId);
+                return { session: sessions.sessions[input.agentId], duplicate: false };
+            }
+            const fence = {
+                agentId: sessions.inFlight.agentId,
+                runId: sessions.inFlight.runId,
+                receiptId: sessions.inFlight.receiptId
+            };
+            const completion = createPendingTurnCompletion({
+                taskId: task.id,
+                roleName: role.name,
+                agentId: input.agentId,
+                nativeSessionId: input.nativeSessionId,
+                turnId: input.turnId,
+                runId: fence.runId,
+                summary: input.summary,
+                observedAt: now,
+                dueAt: new Date(now.getTime() + 2_000)
+            });
+            const wasStalled = isRoleRunStalled(store.listEvents(task.id), fence.runId);
+            store.saveEvent(task.id, createTaskEvent(store.nextEventId(task.id), task.id, RUN_PROGRESS_EVENT, {
+                runId: fence.runId,
+                roleName: role.name,
+                kind: "native-turn",
+                turnId: input.turnId,
+                note: boundedRuntimeNote(input.summary)
+            }, now));
+            if (wasStalled) {
+                store.saveEvent(task.id, createTaskEvent(store.nextEventId(task.id), task.id, RUN_RECOVERED_EVENT, {
+                    runId: fence.runId,
+                    roleName: role.name,
+                    progressAt: now.toISOString(),
+                    kind: "native-turn"
+                }, now));
+            }
+            clearMatchingLeaderStallAttention(store, task.id, fence.runId);
+            sessions = recordObservedTaskRoleCompletion(sessions, completion);
+            const active = store.getActiveAgentRun(task.id, role.name);
+            if (active === null || active.id !== fence.runId || active.status !== "active") {
+                sessions = settleTaskRoleCompletion(sessions, {
+                    agentId: input.agentId,
+                    runId: fence.runId,
+                    turnId: input.turnId
+                }, now);
+                sessions = updateRoleAgentSessionStatus(sessions, input.agentId, "ready", now);
+                store.saveTaskRoleSessionSet(sessions);
+                completeRuntimeHookReservation(store, owner, input.launchId);
+                return { session: sessions.sessions[input.agentId], duplicate: false };
+            }
+            store.saveTaskRoleSessionSet(sessions);
+            completeRuntimeHookReservation(store, owner, input.launchId);
+            return {
+                session: sessions.sessions[input.agentId],
+                duplicate: false,
+                pendingRunId: fence.runId
+            };
+        });
+    }
+    listPendingRuntimeTurnCompletions() {
+        return this.store.listTasks().flatMap((task) => (this.store.listRoleSessionSets(task.id).flatMap((sessions) => (sessions.pendingTurnCompletion === null ? [] : [sessions.pendingTurnCompletion]))));
+    }
+    /** Resolves only completions whose grace deadline has elapsed. */
+    resolveDueRuntimeTurnCompletions(now, taskIds) {
+        const due = this.listPendingRuntimeTurnCompletions().filter((completion) => (Date.parse(completion.dueAt) <= now.getTime()
+            && (taskIds === undefined || taskIds.has(completion.taskId))));
+        const finalized = [];
+        for (const completion of due) {
+            this.store.transaction((store) => {
+                const current = store.getTaskRoleSessionSet(completion.taskId, completion.roleName);
+                if (current === null)
+                    return;
+                const pending = current.pendingTurnCompletion;
+                if (pending === null
+                    || pending.turnId !== completion.turnId
+                    || pending.runId !== completion.runId)
+                    return;
+                const active = store.getActiveAgentRun(completion.taskId, completion.roleName);
+                if (active?.id === completion.runId) {
+                    const result = this.recordRuntimeTurnCompleted({
+                        taskId: completion.taskId,
+                        roleName: completion.roleName,
+                        agentId: completion.agentId,
+                        adapterId: current.sessions[completion.agentId].adapterId,
+                        nativeSessionId: completion.nativeSessionId,
+                        turnId: completion.turnId,
+                        expectedRunId: completion.runId,
+                        summary: completion.summary
+                    }, now);
+                    if (result.finalizedRunId !== undefined) {
+                        finalized.push(formatTaskRecordReference(completion.taskId, result.finalizedRunId, "agentRun"));
+                    }
+                }
+                let settled = store.getTaskRoleSessionSet(completion.taskId, completion.roleName);
+                if (settled?.pendingTurnCompletion?.turnId !== completion.turnId)
+                    return;
+                settled = settleTaskRoleCompletion(settled, {
+                    agentId: completion.agentId,
+                    runId: completion.runId,
+                    turnId: completion.turnId
+                }, now);
+                settled = updateRoleAgentSessionStatus(settled, completion.agentId, "ready", now);
+                store.saveTaskRoleSessionSet(settled);
+            });
+        }
+        return finalized;
+    }
+    /** A structured native Turn-completion event terminalizes its exact Run fence. */
+    recordRuntimeTurnCompleted(input, now = new Date()) {
+        return this.store.transaction((store) => {
+            const task = store.getTask(input.taskId);
+            if (task === null)
+                throw new Error(`Task not found: ${input.taskId}.`);
+            if (task.status !== "active") {
+                throw new Error(`Cannot complete a runtime turn for inactive Task: ${input.taskId}.`);
+            }
+            const role = requireRole(store, input.taskId, input.roleName);
+            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 owner = {
+                scope: "task",
+                taskId: input.taskId,
+                roleName: input.roleName
+            };
+            if (existing === undefined
+                && !runtimeHookMatchesReservation(store, owner, input.launchId)) {
+                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 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.");
+            }
+            const sessions = effectiveExisting?.status === "ready"
+                ? current
+                : recordRoleAgentSession(current, {
+                    agentId: input.agentId,
+                    adapterId: input.adapterId,
+                    nativeSessionId: input.nativeSessionId,
+                    ...(input.launchId === undefined ? {} : { launchId: input.launchId }),
+                    policy: "fixed",
+                    status: "ready",
+                    effective
+                }, now);
+            if (input.expectedRunId !== undefined
+                && store.getActiveAgentRun(task.id, role.name)?.id !== input.expectedRunId) {
+                return { session: sessions.sessions[input.agentId] };
+            }
+            if (sessions !== current)
+                store.saveRoleSessionSet(sessions);
+            completeRuntimeHookReservation(store, owner, input.launchId);
+            const session = sessions.sessions[input.agentId];
+            const active = store.getActiveAgentRun(task.id, role.name);
+            if (task.status !== "active"
+                || active === null
+                || active.pushedAt === undefined
+                || (input.expectedRunId !== undefined && active.id !== input.expectedRunId)) {
+                return { session };
+            }
+            if (role.name !== "leader" || active.workItemId !== undefined) {
+                const summary = `Role turn completed without yui task run yield. Last assistant message: ${input.summary}`;
+                const result = terminalizeExactTaskRun(store, {
+                    taskId: task.id,
+                    roleName: role.name,
+                    agentId: active.effective.agentId,
+                    runId: active.id,
+                    receiptId: formatAgentRunReceiptId(task.id, active.id),
+                    nativeSessionId: input.nativeSessionId,
+                    ...(input.launchId === undefined ? {} : { launchId: input.launchId }),
+                    outcome: { status: "failed", summary }
+                }, now);
+                if (result.disposition !== "applied" || result.run === null) {
+                    throw new Error(`Role Run changed during native Turn completion: ${active.id}/${result.reason}.`);
+                }
+                const terminal = result.run;
+                if (active.purpose === "execution" && active.workItemId !== undefined) {
+                    const item = store.getWorkItem(task.id, active.workItemId);
+                    if (item !== null && !["completed", "failed", "retired"].includes(item.status)) {
+                        store.saveWorkItem(task.id, updateWorkItemStatus(item, "failed", now, summary));
+                    }
+                }
+                store.saveRole(task.id, updateRoleStatus(role, "idle", now));
+                clearMatchingLeaderStallAttention(store, task.id, terminal.id);
+                enqueueWork(store, { kind: "role", taskId: task.id, roleName: "leader" }, "role-run-failed", now, [
+                    { type: "run", taskId: task.id, id: terminal.id },
+                    ...(terminal.workItemId === undefined
+                        ? []
+                        : [{
+                                type: "work-item",
+                                taskId: task.id,
+                                id: terminal.workItemId
+                            }])
+                ]);
+                return { session, finalizedRunId: terminal.id };
+            }
+            const leaderTarget = { kind: "role", taskId: task.id, roleName: role.name };
+            const leaderMailbox = store.getWorkMailbox(leaderTarget);
+            const recoveryTurn = leaderMailbox?.processing?.executionRef?.type === "run"
+                && leaderMailbox.processing.executionRef.taskId === task.id
+                && leaderMailbox.processing.executionRef.id === active.id
+                && leaderMailbox.processing.batch.reasons.includes("leader-turn-unclosed");
+            const quiescent = leaderMailbox?.pending === null
+                && !store.listRoles(task.id).some((candidate) => (candidate.name !== "leader"
+                    && store.getActiveAgentRun(task.id, candidate.name) !== null))
+                && !store.listWorkItems(task.id).some((item) => item.status === "running")
+                && !store.listInputRequests(task.id).some((request) => request.status === "open");
+            const result = terminalizeExactTaskRun(store, {
+                taskId: task.id,
+                roleName: role.name,
+                agentId: active.effective.agentId,
+                runId: active.id,
+                receiptId: formatAgentRunReceiptId(task.id, active.id),
+                nativeSessionId: input.nativeSessionId,
+                ...(input.launchId === undefined ? {} : { launchId: input.launchId }),
+                outcome: { status: "yielded", summary: input.summary }
+            }, now);
+            if (result.disposition !== "applied" || result.run === null) {
+                throw new Error(`Leader Run changed during native Turn completion: ${active.id}/${result.reason}.`);
+            }
+            const terminal = result.run;
+            if (input.origin === "recovery") {
+                store.saveEvent(task.id, createTaskEvent(store.nextEventId(task.id), task.id, RUN_RECOVERED_EVENT, { runId: terminal.id, roleName: role.name, summary: input.summary }, now));
+            }
+            clearMatchingLeaderStallAttention(store, task.id, terminal.id);
+            if (quiescent) {
+                if (recoveryTurn) {
+                    const message = "Leader ended a recovery Turn without completing, blocking, or continuing the Task.";
+                    store.saveLeaderFailure(recordLeaderFailure(task.id, input.nativeSessionId, message, now, store.getLeaderFailure(task.id)));
+                    store.saveOperatorNotification(createLeaderRecoveryNotification(task.id, message, now, store.getOperatorNotification(task.id)));
+                    store.saveRole(task.id, updateRoleStatus(role, "failed", now));
+                    enqueueWork(store, { kind: "operator" }, "leader-recovery-failed", now, [
+                        { type: "task", id: task.id },
+                        { type: "run", taskId: task.id, id: terminal.id }
+                    ]);
+                }
+                else {
+                    enqueueWork(store, leaderTarget, "leader-turn-unclosed", now, [
+                        { type: "task", id: task.id },
+                        { type: "run", taskId: task.id, id: terminal.id }
+                    ]);
+                }
+            }
+            return { session, finalizedRunId: terminal.id };
+        });
+    }
+    classifyClaudeStopFailureEvent(input) {
+        const task = this.store.getTask(input.taskId);
+        if (task?.status !== "active")
+            return "obsolete";
+        const role = this.store.getRole(input.taskId, input.roleName);
+        if (role === null)
+            return "obsolete";
+        const run = this.store.getAgentRun(input.taskId, input.runId);
+        const active = this.store.getActiveAgentRun(input.taskId, input.roleName);
+        if (run === null
+            || run.status !== "active"
+            || active?.id !== run.id
+            || run.roleName !== input.roleName
+            || run.effective.agentId !== input.agentId
+            || run.effective.adapterId !== "claude"
+            || input.adapterId !== "claude")
+            return "obsolete";
+        const sessions = this.store.getTaskRoleSessionSet(input.taskId, input.roleName);
+        const session = sessions?.sessions[input.agentId];
+        if (sessions === null
+            || session?.nativeSessionId !== input.nativeSessionId
+            || session.launchId !== input.launchId
+            || sessions.inFlight?.agentId !== input.agentId
+            || sessions.inFlight.runId !== input.runId
+            || sessions.inFlight.receiptId !== `agent-run:${input.taskId}/${input.runId}`)
+            return "obsolete";
+        return "apply";
+    }
+    observeClaudeStopFailureEvent(input, now = new Date()) {
+        return this.store.transaction((store) => {
+            const before = store.getAgentRun(input.taskId, input.runId);
+            if (before === null) {
+                recordObsoleteRuntimeEvent(store, input, "run-missing", now);
+                return { disposition: "obsolete", runId: input.runId };
+            }
+            const summary = claudeStopFailureSummary(input);
+            const result = terminalizeExactTaskRun(store, {
+                taskId: input.taskId,
+                roleName: input.roleName,
+                agentId: input.agentId,
+                runId: input.runId,
+                receiptId: `agent-run:${input.taskId}/${input.runId}`,
+                nativeSessionId: input.nativeSessionId,
+                launchId: input.launchId,
+                outcome: {
+                    status: "failed",
+                    summary
+                }
+            }, now);
+            if (result.disposition === "obsolete" || result.run === null) {
+                recordObsoleteRuntimeEvent(store, input, result.reason ?? "identity-mismatch-or-terminal", now);
+                return { disposition: "obsolete", runId: input.runId };
+            }
+            enqueueWork(store, runtimeLifecycleTarget({
+                scope: "task",
+                taskId: input.taskId,
+                roleName: input.roleName
+            }), RUNTIME_CLEANUP_REQUIRED_REASON, now, [{ type: "task", id: input.taskId }]);
+            const terminal = result.run;
+            if (before.purpose === "execution" && before.workItemId !== undefined) {
+                const item = store.getWorkItem(input.taskId, before.workItemId);
+                if (item !== null && ![
+                    "completed", "failed", "retired"
+                ].includes(item.status)) {
+                    store.saveWorkItem(input.taskId, updateWorkItemStatus(item, "failed", now, summary));
+                }
+            }
+            const role = store.getRole(input.taskId, input.roleName);
+            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.claude-stop-failure", {
+                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 }
+                ]);
+            }
+            return { disposition: "applied", runId: input.runId };
+        });
+    }
+    /**
+     * Folds a provider SessionStart lifecycle fact
+     * through the canonical contract. Session-started/ready never advance Run
+     * acceptance; this only records generation facts and binds a discovered native
+     * id under the exact launch fence. Idempotent replays are no-ops.
+     */
+    observeProviderSessionLifecycle(input, now = new Date()) {
+        return this.store.transaction((store) => {
+            const decision = this.foldProviderSignal(store, {
+                kind: "native-session-start",
+                ...(input.sessionSource === undefined ? {} : { sessionSource: input.sessionSource }),
+                fence: providerFence(input)
+            }, input.runId);
+            switch (decision.kind) {
+                case "obsolete":
+                    recordCanonicalObsolete(store, input, "native-session-lifecycle", decision.reason, now);
+                    return "obsolete";
+                case "deferred":
+                    return "deferred";
+                case "idempotent":
+                    return "applied";
+                case "apply":
+                    if (decision.outcome.outcome === "mark-ready"
+                        && input.adapterId === "claude"
+                        && input.sessionSource === "startup"
+                        && store.getTaskRoleSessionSet(input.taskId, input.roleName)
+                            ?.sessions[input.agentId] === undefined) {
+                        // Claude emits startup readiness after native process creation but
+                        // before the Controller projects its preallocated Session. Keep
+                        // the immutable fact queued until that exact Session is durable.
+                        return "deferred";
+                    }
+                    if (decision.outcome.outcome === "bind-native-session") {
+                        const role = store.getRole(input.taskId, input.roleName);
+                        const sessions = store.getTaskRoleSessionSet(input.taskId, input.roleName);
+                        const run = input.runId === undefined
+                            ? null
+                            : store.getAgentRun(input.taskId, input.runId);
+                        if (role === null || sessions === null || run === null) {
+                            recordCanonicalObsolete(store, input, "native-session-lifecycle", "bind-state-missing", now);
+                            return "obsolete";
+                        }
+                        const bound = recordRoleAgentSession(sessions, {
+                            agentId: input.agentId,
+                            adapterId: input.adapterId,
+                            nativeSessionId: decision.outcome.nativeSessionId,
+                            launchId: input.launchId,
+                            policy: "fixed",
+                            status: "running",
+                            effective: run.effective
+                        }, now);
+                        store.saveTaskRoleSessionSet(bound);
+                        // Codex 0.145 emits SessionStart from inside run_turn(input), so a
+                        // runtime-discovered bind is durable evidence that this Run's
+                        // initial transport input already crossed the provider boundary.
+                        // Preserve that truth before clearing the launch reservation: a
+                        // restarted Controller must not allocate a second generation or
+                        // push the same first input again. UserPromptSubmit remains the
+                        // sole acceptance/delivered transition.
+                        if (input.adapterId === "codex" && run.pushedAt === undefined) {
+                            const pushed = markAgentRunPushed(run, now);
+                            store.saveAgentRun(pushed);
+                            markTaskRoleRunPushedInFlight(store, role, pushed, now);
+                            store.saveEvent(input.taskId, createTaskEvent(store.nextEventId(input.taskId), input.taskId, "run.pushed", runLaunchEventPayload(pushed), now));
+                        }
+                        completeRuntimeHookReservation(store, { scope: "task", taskId: input.taskId, roleName: input.roleName }, input.launchId);
+                    }
+                    // Session-started/ready/bind facts are recorded provider-neutrally as
+                    // an auditable event. The
+                    // payload carries the generation fence + preInputReady so the fresh
+                    // push gate can read the exact provider-ready fact for this generation.
+                    store.saveEvent(input.taskId, createTaskEvent(store.nextEventId(input.taskId), input.taskId, "runtime.provider-session-lifecycle", {
+                        eventId: input.eventId,
+                        roleName: input.roleName,
+                        agentId: input.agentId,
+                        adapterId: input.adapterId,
+                        launchId: input.launchId,
+                        nativeSessionId: input.nativeSessionId,
+                        outcome: decision.outcome.outcome,
+                        preInputReady: (decision.outcome.outcome === "mark-ready"
+                            && decision.outcome.preInputReady) ? "true" : "false",
+                        ...(input.runId === undefined ? {} : { runId: input.runId })
+                    }, now));
+                    return "applied";
+            }
+        });
+    }
+    /**
+     * Folds a provider UserPromptSubmit acceptance fact. This is the ONLY path
+     * that may advance a Run to accepted/delivered, and only after an exact
+     * transport receipt has independently committed run.pushed.
+     */
+    observeProviderPromptAccepted(input, now = new Date()) {
+        return this.store.transaction((store) => {
+            const decision = this.foldProviderSignal(store, {
+                kind: "native-prompt-submit",
+                fence: providerFence(input)
+            }, input.runId);
+            if (decision.kind === "obsolete") {
+                recordCanonicalObsolete(store, input, "native-prompt-accepted", decision.reason, now);
+                return "obsolete";
+            }
+            if (decision.kind === "deferred")
+                return "deferred";
+            if (decision.kind === "idempotent")
+                return "applied";
+            // decision.kind === "apply" && outcome advance-accepted
+            const active = store.getActiveAgentRun(input.taskId, input.roleName);
+            if (active === null || active.id !== input.runId || active.status !== "active") {
+                recordCanonicalObsolete(store, input, "native-prompt-accepted", "run-not-active", now);
+                return "obsolete";
+            }
+            const role = store.getRole(input.taskId, input.roleName);
+            if (role === null) {
+                recordCanonicalObsolete(store, input, "native-prompt-accepted", "role-missing", now);
+                return "obsolete";
+            }
+            if (active.deliveredAt === undefined) {
+                const delivered = markAgentRunDelivered(active, now);
+                store.saveAgentRun(delivered);
+                markTaskRoleRunDeliveredInFlight(store, role, delivered, now);
+                store.saveEvent(input.taskId, createTaskEvent(store.nextEventId(input.taskId), input.taskId, "run.delivered", runLaunchEventPayload(delivered), now));
+            }
+            return "applied";
+        });
+    }
+    /**
+     * Folds provider-native in-turn progress through the canonical lifecycle
+     * contract. Progress is an advisory semantic fence only: it never advances
+     * Run delivery/acceptance and never reads pane text or process counters.
+     */
+    observeProviderTurnProgress(input, now = new Date()) {
+        return this.store.transaction((store) => {
+            const receivedAtMs = Date.parse(input.receivedAt);
+            if (!Number.isFinite(receivedAtMs) || receivedAtMs > now.getTime()) {
+                recordCanonicalObsolete(store, input, "native-turn-progress", "received-at-invalid", now);
+                return "obsolete";
+            }
+            const decision = this.foldProviderSignal(store, {
+                kind: "native-turn-progress",
+                ...(input.sequence === undefined ? {} : { sequence: input.sequence }),
+                fence: providerFence(input)
+            }, input.runId);
+            switch (decision.kind) {
+                case "obsolete":
+                    recordCanonicalObsolete(store, input, "native-turn-progress", decision.reason, now);
+                    return "obsolete";
+                case "deferred":
+                    return "deferred";
+                case "idempotent":
+                    return "applied";
+                case "apply":
+                    if (decision.outcome.outcome !== "advance-progress")
+                        return "obsolete";
+                    if (store.listEvents(input.taskId).some((event) => (event.type === "runtime.provider-turn-progress"
+                        && event.payload.eventId === input.eventId)))
+                        return "applied";
+                    store.saveEvent(input.taskId, createTaskEvent(store.nextEventId(input.taskId), input.taskId, "runtime.provider-turn-progress", {
+                        eventId: input.eventId,
+                        roleName: input.roleName,
+                        agentId: input.agentId,
+                        adapterId: input.adapterId,
+                        launchId: input.launchId,
+                        nativeSessionId: input.nativeSessionId,
+                        runId: input.runId,
+                        progressId: input.progressId,
+                        progressAt: input.receivedAt,
+                        ...(input.sequence === undefined ? {} : { sequence: String(input.sequence) })
+                    }, now));
+                    return "applied";
+            }
+        });
+    }
+    /**
+     * Shared projection + canonical fold for provider-native lifecycle signals.
+     * Reads current durable Run/session state into a CanonicalRunExpectation,
+     * maps the neutral signal through the per-adapter registry, and folds. The
+     * fold owns every ordering/identity/evidence decision; this method only reads
+     * durable truth and never branches on the provider name.
+     */
+    foldProviderSignal(store, signal, runId) {
+        let event;
+        try {
+            event = mapNativeLifecycleSignal(signal);
+        }
+        catch (error) {
+            return { kind: "obsolete", reason: error instanceof Error ? error.message : "map-failed" };
+        }
+        const expectation = this.projectRunExpectation(store, signal.fence, runId);
+        if (expectation === null) {
+            if (preallocatedClaudeStartupAwaitingProjection(store, signal, runId)) {
+                return { kind: "deferred", reason: "preallocated-session-not-yet-projected" };
+            }
+            return { kind: "obsolete", reason: "run-or-role-missing" };
+        }
+        const outcome = foldCanonicalLifecycleEvent(event, expectation);
+        switch (outcome.outcome) {
+            case "obsolete":
+                return { kind: "obsolete", reason: outcome.reason };
+            case "fail-closed":
+                return { kind: "obsolete", reason: `fail-closed:${outcome.reason}` };
+            case "deferred":
+                return { kind: "deferred", reason: outcome.reason };
+            case "idempotent":
+                return { kind: "idempotent", reason: outcome.reason };
+            default:
+                return { kind: "apply", outcome };
+        }
+    }
+    /** Reads durable Run + session state into the pure fold's expectation shape. */
+    projectRunExpectation(store, fence, runId) {
+        const role = store.getRole(fence.taskId, fence.roleName);
+        if (role === null)
+            return null;
+        const sessionSet = store.getTaskRoleSessionSet(fence.taskId, fence.roleName);
+        const session = sessionSet?.sessions[fence.agentId] ?? null;
+        const boundNativeSessionId = session?.nativeSessionId;
+        if (runId === undefined) {
+            return {
+                fence,
+                sessionStarted: false,
+                ready: false,
+                pushed: false,
+                accepted: false,
+                terminal: false,
+                ...(boundNativeSessionId === undefined ? {} : { boundNativeSessionId })
+            };
+        }
+        const run = store.getAgentRun(fence.taskId, runId);
+        const inFlight = sessionSet?.inFlight;
+        if (run === null
+            || inFlight === null
+            || inFlight === undefined
+            || inFlight.runId !== run.id
+            || 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);
+        if (launchId === undefined)
+            return null;
+        const expectedFence = {
+            taskId: fence.taskId,
+            roleName: fence.roleName,
+            agentId: run.effective.agentId,
+            adapterId: run.effective.adapterId,
+            runId: run.id,
+            launchId,
+            receiptId: inFlight.receiptId,
+            ...(boundNativeSessionId === undefined ? {} : { nativeSessionId: boundNativeSessionId })
+        };
+        const lifecycleEvents = store.listEvents(fence.taskId).filter((event) => (event.type === "runtime.provider-session-lifecycle"
+            && event.payload.roleName === fence.roleName
+            && event.payload.agentId === run.effective.agentId
+            && event.payload.adapterId === run.effective.adapterId
+            && event.payload.launchId === launchId
+            && event.payload.nativeSessionId === (boundNativeSessionId ?? fence.nativeSessionId)));
+        return {
+            fence: expectedFence,
+            sessionStarted: lifecycleEvents.length > 0,
+            ready: lifecycleEvents.some((event) => event.payload.preInputReady === "true"),
+            pushed: run.pushedAt !== undefined,
+            accepted: run.deliveredAt !== undefined,
+            terminal: run.status !== "active",
+            ...(boundNativeSessionId === undefined ? {} : { boundNativeSessionId })
+        };
+    }
+    observeObsoleteRuntimeEvent(input, now = new Date()) {
+        this.store.transaction((store) => {
+            if (store.getTask(input.taskId) === null)
+                return;
+            recordObsoleteRuntimeEvent(store, input, input.reason, now);
         });
     }
     recordGlobalRuntimeNativeSession(input, now = new Date()) {
+        return this.store.transaction((store) => (recordGlobalRuntimeNativeSession(store, input, now)));
+    }
+    observeGlobalRuntimeTurnCompleted(input, now = new Date()) {
         return this.store.transaction((store) => {
             const role = store.getGlobalRole(input.roleName);
             if (role === null)
                 throw new Error(`Global Role not found: ${input.roleName}.`);
-            const binding = activeRoleAgentBinding(role);
-            if (binding.agentId !== input.agentId || binding.adapterId !== input.adapterId) {
-                throw new Error("Native session registration does not match the active global Role Agent binding.");
-            }
-            const current = store.getGlobalRoleSessionSet(input.roleName)
-                ?? createRoleSessionSet({ scope: "global", roleName: input.roleName }, role.activeAgentId, now);
+            let current = store.getGlobalRoleSessionSet(input.roleName)
+                ?? createRoleSessionSet({ scope: "global", roleName: input.roleName }, input.agentId, now);
             const existing = current.sessions[input.agentId];
-            if (existing !== undefined && existing.nativeSessionId !== input.nativeSessionId) {
-                throw new Error("Native session registration conflicts with the fixed global Role session.");
+            const owner = {
+                scope: "global",
+                roleName: input.roleName
+            };
+            if (existing === undefined
+                && !runtimeHookMatchesReservation(store, owner, input.launchId)) {
+                throw new Error("Runtime turn completion does not match the global launch reservation.");
             }
-            if (existing?.status === "running")
-                return existing;
-            const updated = recordRoleAgentSession(current, {
+            const effectiveExisting = nativeTransitionExisting(store, owner, existing, input.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.");
+            }
+            const completedStatus = effectiveExisting?.status === "stopped"
+                || effectiveExisting?.status === "broken"
+                ? effectiveExisting.status
+                : "ready";
+            current = recordRoleAgentSession(current, {
                 agentId: input.agentId,
                 adapterId: input.adapterId,
                 nativeSessionId: input.nativeSessionId,
+                ...(input.launchId === undefined ? {} : { launchId: input.launchId }),
+                title: effectiveExisting?.title ?? input.title,
+                preview: effectiveExisting?.preview ?? (input.summary === undefined ? undefined : sessionPreview(input.summary)),
                 policy: "fixed",
-                status: "running"
+                status: completedStatus,
+                effective
             }, now);
-            store.saveGlobalRoleSessionSet(updated);
-            return updated.sessions[input.agentId];
+            current = rememberRoleAgentCompletedTurn(current, input.agentId, input.nativeSessionId, input.turnId, now);
+            store.saveGlobalRoleSessionSet(current);
+            completeRuntimeHookReservation(store, owner, input.launchId);
+            return current.sessions[input.agentId];
         });
     }
+    classifyGlobalRuntimeTurnCompleted(input) {
+        const role = this.store.getGlobalRole(input.roleName);
+        if (role === null)
+            return "obsolete";
+        const existing = this.store.getGlobalRoleSessionSet(input.roleName)
+            ?.sessions[input.agentId];
+        const owner = {
+            scope: "global",
+            roleName: input.roleName
+        };
+        if (existing === undefined
+            && !runtimeHookMatchesReservation(this.store, owner, input.launchId))
+            return "obsolete";
+        let effectiveExisting;
+        try {
+            effectiveExisting = nativeTransitionExisting(this.store, owner, existing, input.nativeSessionId, input.launchId, "Runtime turn completion conflicts with the fixed global Role session.");
+        }
+        catch {
+            return "obsolete";
+        }
+        const effective = globalSessionEffective(role, effectiveExisting);
+        if (effective.agentId !== input.agentId || effective.adapterId !== input.adapterId) {
+            return "obsolete";
+        }
+        return "apply";
+    }
 }
-function restorePendingWakeup(claimed, current) {
-    if (current === null)
-        return claimed;
+function claudeStopFailureSummary(input) {
+    return [
+        "Claude StopFailure.",
+        `error: ${input.error}`,
+        ...(input.errorDetails === undefined
+            ? []
+            : [`error_details: ${input.errorDetails}`]),
+        ...(input.lastAssistantMessage === undefined
+            ? []
+            : [`last_assistant_message: ${input.lastAssistantMessage}`])
+    ].join("\n");
+}
+function providerFence(input) {
     return {
-        schemaVersion: 1,
-        taskId: claimed.taskId,
-        reasons: [...new Set([...claimed.reasons, ...current.reasons])],
-        requestCount: claimed.requestCount + current.requestCount,
-        firstRequestedAt: claimed.firstRequestedAt,
-        lastRequestedAt: current.lastRequestedAt
+        taskId: input.taskId,
+        roleName: input.roleName,
+        agentId: input.agentId,
+        adapterId: input.adapterId,
+        launchId: input.launchId,
+        nativeSessionId: input.nativeSessionId,
+        ...(input.runId === undefined ? {} : { runId: input.runId }),
+        ...(input.receiptId === undefined ? {} : { receiptId: input.receiptId })
     };
 }
-function mapRole(role) {
+function recordCanonicalObsolete(store, input, eventType, reason, now) {
+    recordObsoleteRuntimeEvent(store, { ...input, eventType }, reason, now);
+}
+function recordObsoleteRuntimeEvent(store, input, reason, now) {
+    if (store.listEvents(input.taskId).some((event) => (event.type === "runtime.event-obsolete"
+        && event.payload.eventId === input.eventId)))
+        return;
+    store.saveEvent(input.taskId, createTaskEvent(store.nextEventId(input.taskId), input.taskId, "runtime.event-obsolete", {
+        eventId: input.eventId,
+        eventType: input.eventType ?? input.type ?? "unknown",
+        roleName: input.roleName,
+        agentId: input.agentId,
+        nativeSessionId: input.nativeSessionId,
+        ...(input.runId === undefined ? {} : { runId: input.runId }),
+        ...(input.launchId === undefined ? {} : { launchId: input.launchId }),
+        reason
+    }, now));
+}
+function isLeaderDisposedWorkItemRun(store, input) {
+    if (input.runId === undefined)
+        return false;
+    const run = store.getAgentRun(input.taskId, input.runId);
+    if (run === null
+        || run.status !== "failed"
+        || run.roleName !== input.roleName
+        || run.effective.agentId !== input.agentId
+        || run.workItemId === undefined) {
+        return false;
+    }
+    return store.getWorkItem(input.taskId, run.workItemId)?.disposition !== undefined;
+}
+function isObsoleteTerminalRuntimeRun(store, input) {
+    if (isLeaderDisposedWorkItemRun(store, input))
+        return true;
+    if (input.runId === undefined)
+        return false;
+    const run = store.getAgentRun(input.taskId, input.runId);
+    if (run === null
+        || run.status !== "failed"
+        || run.roleName !== input.roleName
+        || run.effective.agentId !== input.agentId) {
+        return false;
+    }
+    return store.listEvents(input.taskId).some((event) => (event.type === "runtime.role-delivery-failed"
+        && event.payload.runId === input.runId));
+}
+function sessionPreview(value) {
+    const normalized = value.trim().replaceAll(/\s+/g, " ");
+    const truncated = normalized.slice(0, 1_024);
+    return /[\uD800-\uDBFF]$/.test(truncated)
+        ? truncated.slice(0, -1)
+        : truncated;
+}
+function boundedRuntimeNote(value) {
+    const normalized = value.trim().replaceAll(/\s+/gu, " ");
+    return normalized.length <= 280 ? normalized : `${normalized.slice(0, 279)}…`;
+}
+function requireRuntimeLaunchReservation(store, owner, launchId) {
+    const mailbox = store.getWorkMailbox(runtimeLifecycleTarget(owner));
+    if (!isRuntimeLaunchReservation(mailbox?.processing, launchId)) {
+        throw new Error("Runtime launch reservation no longer matches the launch.");
+    }
+    return mailbox;
+}
+function runtimeHookMatchesReservation(store, owner, launchId) {
+    const mailbox = store.getWorkMailbox(runtimeLifecycleTarget(owner));
+    if (hasRuntimeCleanupObligation(mailbox))
+        return false;
+    const processing = mailbox?.processing;
+    return launchId !== undefined
+        && isRuntimeLaunchReservation(processing, launchId);
+}
+/**
+ * Claude may publish SessionStart(startup) synchronously from host.start(),
+ * before the Controller can atomically project the returned Session and bind
+ * the Run. Preserve that exact immutable fact only while the matching launch
+ * reservation is still the durable owner of the active Run. Everything else
+ * remains obsolete/fail-closed.
+ */
+function preallocatedClaudeStartupAwaitingProjection(store, signal, runId) {
+    if (signal.kind !== "native-session-start"
+        || signal.sessionSource !== "startup"
+        || signal.fence.adapterId !== "claude"
+        || runId === undefined
+        || signal.fence.runId !== runId
+        || signal.fence.launchId === undefined
+        || signal.fence.nativeSessionId === undefined)
+        return false;
+    const task = store.getTask(signal.fence.taskId);
+    const role = store.getRole(signal.fence.taskId, signal.fence.roleName);
+    const run = store.getActiveAgentRun(signal.fence.taskId, signal.fence.roleName);
+    const sessions = store.getTaskRoleSessionSet(signal.fence.taskId, signal.fence.roleName);
+    if (task === null
+        || task.status !== "active"
+        || role === null
+        || role.activeAgentId !== signal.fence.agentId
+        || run === null
+        || run.id !== runId
+        || run.status !== "active"
+        || run.effective.agentId !== signal.fence.agentId
+        || run.effective.adapterId !== "claude"
+        || (sessions?.inFlight !== null && sessions?.inFlight !== undefined)
+        || sessions?.sessions[signal.fence.agentId] !== undefined)
+        return false;
+    const mailbox = store.getWorkMailbox(runtimeLifecycleTarget({
+        scope: "task",
+        taskId: signal.fence.taskId,
+        roleName: signal.fence.roleName
+    }));
+    const executionRef = mailbox?.processing?.executionRef;
+    return isRuntimeLaunchReservation(mailbox?.processing, signal.fence.launchId)
+        && !hasRuntimeCleanupObligation(mailbox)
+        && executionRef?.type === "run"
+        && executionRef.taskId === signal.fence.taskId
+        && executionRef.id === runId
+        && signal.fence.nativeSessionId === nativeSessionIdForLaunch(store.rootDirectory(), signal.fence.launchId, signal.fence.agentId, "claude");
+}
+function completeRuntimeHookReservation(store, owner, launchId) {
+    if (launchId === undefined)
+        return;
+    const mailbox = store.getWorkMailbox(runtimeLifecycleTarget(owner));
+    if (!isRuntimeLaunchReservation(mailbox?.processing, launchId))
+        return;
+    saveRuntimeLifecycleMailbox(store, completeProcessing(mailbox, launchId));
+}
+function saveRuntimeLifecycleMailbox(store, mailbox) {
+    if (mailbox.processing === null && mailbox.pending === null) {
+        store.removeWorkMailbox(mailbox.target);
+        return;
+    }
+    store.saveWorkMailbox(mailbox);
+}
+function runtimeOwnerFromTarget(target) {
+    return target.kind === "role-runtime"
+        ? {
+            scope: "task",
+            taskId: target.taskId,
+            roleName: target.roleName
+        }
+        : {
+            scope: "global",
+            roleName: target.roleName
+        };
+}
+function sameRuntimeOwner(left, right) {
+    return left.scope === "task"
+        ? right.scope === "task"
+            && left.taskId === right.taskId
+            && left.roleName === right.roleName
+        : right.scope === "global" && left.roleName === right.roleName;
+}
+function dormantRuntimeCandidateIsCurrent(store, candidate) {
+    const { owner } = candidate;
+    if (hasRuntimeLifecycleWork(store.getWorkMailbox(runtimeLifecycleTarget(owner)))) {
+        return false;
+    }
+    if (owner.scope === "task"
+        && store.getActiveAgentRun(owner.taskId, owner.roleName) !== null) {
+        return false;
+    }
+    const sessions = runtimeOwnerSessionSet(store, owner);
+    const active = sessions?.sessions[sessions.activeAgentId];
+    return active !== undefined
+        && active.status !== "stopped"
+        && active.agentId === candidate.agentId
+        && active.adapterId === candidate.adapterId
+        && active.nativeSessionId === candidate.nativeSessionId
+        && active.launchId === candidate.launchId
+        && active.updatedAt === candidate.sessionUpdatedAt;
+}
+function markRuntimeOwnerSessionStopped(store, owner, now) {
+    if (owner.scope === "task") {
+        const sessions = store.getTaskRoleSessionSet(owner.taskId, owner.roleName);
+        if (sessions === null)
+            return false;
+        const active = sessions.sessions[sessions.activeAgentId];
+        if (active === undefined || active.status === "stopped")
+            return false;
+        store.saveTaskRoleSessionSet(updateRoleAgentSessionStatus(sessions, sessions.activeAgentId, "stopped", now));
+        return true;
+    }
+    const sessions = store.getGlobalRoleSessionSet(owner.roleName);
+    if (sessions === null)
+        return false;
+    const active = sessions.sessions[sessions.activeAgentId];
+    if (active === undefined || active.status === "stopped")
+        return false;
+    store.saveGlobalRoleSessionSet(updateRoleAgentSessionStatus(sessions, sessions.activeAgentId, "stopped", now));
+    return true;
+}
+function runtimeOwnerSessionSet(store, owner) {
+    return owner.scope === "task"
+        ? store.getTaskRoleSessionSet(owner.taskId, owner.roleName)
+        : store.getGlobalRoleSessionSet(owner.roleName);
+}
+function runtimeSessionMatchesSettledLaunch(session, input) {
+    return session !== undefined
+        && session.agentId === input.agentId
+        && session.adapterId === input.adapterId
+        && (input.nativeSessionId === undefined
+            || session.nativeSessionId === input.nativeSessionId);
+}
+function preparedSessionMatches(session, agentId, adapterId, nativeSessionId, launchId) {
+    if (session === undefined)
+        return nativeSessionId === undefined;
+    if (session.agentId !== agentId
+        || session.adapterId !== adapterId
+        || session.status === "stopped"
+        || session.status === "broken"
+        || (nativeSessionId !== undefined
+            && session.nativeSessionId !== nativeSessionId)) {
+        return false;
+    }
+    return launchId === undefined
+        ? session.launchId === undefined
+        : session.launchId === launchId;
+}
+function preparedDeliveryFailureSessionFenceMatches(sessions, session, input) {
+    if (sessions === null)
+        return input.nativeSessionId === undefined;
+    if (sessions.activeAgentId !== input.agentId)
+        return false;
+    if (sessions.inFlight === null) {
+        return input.nativeSessionId === undefined
+            && session === undefined
+            && sessions.pendingTurnCompletion === null;
+    }
+    return sessions.inFlight.agentId === input.agentId
+        && sessions.inFlight.runId === input.runId
+        && sessions.inFlight.receiptId === formatAgentRunReceiptId(input.taskId, input.runId)
+        && sessions.inFlight.pushedAt === undefined
+        && preparedSessionMatches(session, input.agentId, input.adapterId, input.nativeSessionId, input.launchId);
+}
+function preparedReservationMatches(mailbox, taskId, runId, launchId) {
+    if (launchId === undefined) {
+        return !isRuntimeLaunchReservation(mailbox?.processing);
+    }
+    const processing = mailbox?.processing;
+    return isRuntimeLaunchReservation(processing, launchId)
+        && !hasRuntimeCleanupObligation(mailbox)
+        && processing?.executionRef?.type === "run"
+        && processing.executionRef.taskId === taskId
+        && processing.executionRef.id === runId;
+}
+function matchingPreparedRuntimeReservation(store, input) {
+    if (input.launchId === undefined
+        || input.session?.nativeSessionId === undefined) {
+        return null;
+    }
+    const owner = {
+        scope: "task",
+        taskId: input.task.id,
+        roleName: input.role.name
+    };
+    const mailbox = store.getWorkMailbox(runtimeLifecycleTarget(owner));
+    if (isRuntimeLaunchReservation(mailbox?.processing, input.launchId)
+        && mailbox?.processing?.executionRef?.type === "run"
+        && mailbox.processing.executionRef.id === input.run.id
+        && !hasRuntimeCleanupObligation(mailbox)) {
+        return mailbox;
+    }
+    throw new Error("Prepared Role session does not match its launch generation.");
+}
+function completePreparedRuntimeReservation(store, mailbox) {
+    if (mailbox === null || mailbox.processing === null)
+        return;
+    saveRuntimeLifecycleMailbox(store, completeProcessing(mailbox, mailbox.processing.batchId));
+}
+function recordTaskRuntimeNativeSession(store, input, now) {
+    const task = store.getTask(input.taskId);
+    if (task === null)
+        throw new Error(`Task not found: ${input.taskId}.`);
+    if (task.status === "archived") {
+        throw new Error(`Cannot register a native session for archived Task: ${input.taskId}.`);
+    }
+    if (task.status !== "active") {
+        throw new Error(`Cannot register a native session for a Task that is not active: ${input.taskId}.`);
+    }
+    const role = requireRole(store, input.taskId, input.roleName);
+    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.");
+    if (existing?.status === "running"
+        && (input.launchId === undefined || existing.launchId === input.launchId))
+        return existing;
+    const resolvedEffective = taskSessionEffective(store, input.taskId, input.roleName, input.agentId, effectiveExisting);
+    const effective = input.effective === undefined
+        ? resolvedEffective
+        : validateEffectiveLaunchSnapshot(input.effective);
+    if (!effectiveLaunchSnapshotsCompatible(resolvedEffective, effective)) {
+        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.");
+    }
+    const updated = recordRoleAgentSession(current, {
+        agentId: input.agentId,
+        adapterId: input.adapterId,
+        nativeSessionId: input.nativeSessionId,
+        ...(input.launchId === undefined ? {} : { launchId: input.launchId }),
+        policy: "fixed",
+        status: "running",
+        effective
+    }, now);
+    store.saveRoleSessionSet(updated);
+    return updated.sessions[input.agentId];
+}
+function recordGlobalRuntimeNativeSession(store, input, now) {
+    const role = store.getGlobalRole(input.roleName);
+    if (role === null)
+        throw new Error(`Global Role not found: ${input.roleName}.`);
+    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.");
+    if (existing?.status === "running"
+        && (input.launchId === undefined || existing.launchId === input.launchId))
+        return existing;
+    const resolvedEffective = globalSessionEffective(role, effectiveExisting);
+    const effective = input.effective === undefined
+        ? resolvedEffective
+        : validateEffectiveLaunchSnapshot(input.effective);
+    if (!effectiveLaunchSnapshotsCompatible(resolvedEffective, effective)) {
+        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.");
+    }
+    const updated = recordRoleAgentSession(current, {
+        agentId: input.agentId,
+        adapterId: input.adapterId,
+        nativeSessionId: input.nativeSessionId,
+        ...(input.launchId === undefined ? {} : { launchId: input.launchId }),
+        policy: "fixed",
+        status: "running",
+        effective
+    }, now);
+    store.saveGlobalRoleSessionSet(updated);
+    return updated.sessions[input.agentId];
+}
+function nativeTransitionExisting(store, owner, existing, nativeSessionId, launchId, conflictMessage) {
+    if (existing === undefined || existing.nativeSessionId === nativeSessionId) {
+        return existing;
+    }
+    if ((existing.status === "stopped" || existing.status === "broken")
+        && runtimeHookMatchesReservation(store, owner, launchId)) {
+        return undefined;
+    }
+    throw new Error(conflictMessage);
+}
+function mapRole(store, role) {
     const binding = activeRoleAgentBinding(role);
+    const item = store.listWorkItems(role.taskId).find((candidate) => (candidate.assignee === role.name
+        && !["completed", "failed", "retired"].includes(candidate.status))) ?? null;
+    const workspace = (item === null
+        ? store.getTaskWorkspace(role.taskId)
+        : store.getWorkItemWorkspace(role.taskId, item.id))
+        ?? store.getTaskWorkspace(role.taskId)
+        ?? undefined;
+    const reopened = role.name === "leader"
+        && store.getPendingWakeup(role.taskId)?.reasons.includes("task-reopened") === true;
+    const effective = reopened
+        ? resolveEffectiveLaunch({
+            role,
+            purpose: "execution",
+            ...(workspace === undefined ? {} : { workspace })
+        })
+        : activeLiveRoleAgentSession(store.getTaskRoleSessionSet(role.taskId, role.name))?.effective ?? resolveEffectiveLaunch({
+            role,
+            purpose: "execution",
+            ...(workspace === undefined ? {} : { workspace })
+        });
     return {
         taskId: role.taskId,
         name: role.name,
         activeAgentId: role.activeAgentId,
         adapterId: binding.adapterId,
+        ...(binding.config.model === undefined ? {} : { model: binding.config.model }),
+        ...(binding.config.effort === undefined ? {} : { effort: binding.config.effort }),
+        effective,
+        workspace: role.workspace,
+        ...(workspace === undefined ? {} : { managedWorkspace: workspace }),
         status: role.status
     };
 }
+function taskSessionEffective(store, taskId, roleName, agentId, existing) {
+    const active = store.getActiveAgentRun(taskId, roleName);
+    if (active !== null) {
+        if (active.effective.agentId !== agentId) {
+            throw new Error(`Native Session registration does not match the effective Run Agent: ${taskId}/${roleName}.`);
+        }
+        return active.effective;
+    }
+    if (existing !== undefined)
+        return existing.effective;
+    const role = store.getRole(taskId, roleName);
+    if (role === null)
+        throw new Error(`Role not found: ${taskId}/${roleName}.`);
+    const item = store.listWorkItems(taskId).find((candidate) => (candidate.assignee === roleName
+        && !["completed", "failed", "retired"].includes(candidate.status))) ?? null;
+    const workspace = (item === null
+        ? store.getTaskWorkspace(taskId)
+        : store.getWorkItemWorkspace(taskId, item.id))
+        ?? store.getTaskWorkspace(taskId)
+        ?? undefined;
+    const effective = resolveEffectiveLaunch({
+        role,
+        purpose: "execution",
+        ...(workspace === undefined ? {} : { workspace }),
+        ...(item === null ? {} : { workItemWriteProjectIds: item.writeProjectIds })
+    });
+    if (effective.agentId !== agentId) {
+        throw new Error(`Native Session registration does not match Role desired Agent: ${agentId}.`);
+    }
+    return effective;
+}
+function globalSessionEffective(role, existing) {
+    return existing?.effective ?? resolveEffectiveLaunch({ role, purpose: "execution" });
+}
 function mapSession(session) {
     return {
         agentId: session.agentId,
         adapterId: session.adapterId,
         nativeSessionId: session.nativeSessionId,
-        status: session.status
+        ...(session.launchId === undefined ? {} : { launchId: session.launchId }),
+        status: session.status,
+        effective: session.effective,
+        updatedAt: session.updatedAt
     };
 }
-function saveTaskSession(store, role, session, status, now) {
+function saveTaskSession(store, role, session, status, now, launchId) {
     const current = store.getRoleSessionSet(role.taskId, role.name)
-        ?? createRoleSessionSet({ scope: "task", taskId: role.taskId, roleName: role.name }, role.activeAgentId, now);
+        ?? 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 }),
         policy: "fixed",
-        status
+        status,
+        effective: session.effective
+    }, now);
+    store.saveRoleSessionSet(updated);
+}
+function bindTaskRoleRunInFlight(store, role, run, now) {
+    const agentId = run.effective.agentId;
+    let current = store.getRoleSessionSet(role.taskId, role.name)
+        ?? createRoleSessionSet({ scope: "task", taskId: role.taskId, roleName: role.name }, agentId, now);
+    if (current.activeAgentId !== agentId) {
+        if (current.inFlight !== null || current.pendingTurnCompletion !== null) {
+            throw new Error("Task Role Session identity cannot change with an unsettled Run fence.");
+        }
+        const liveConflict = Object.values(current.sessions).find((session) => (session.agentId !== agentId
+            && session.status !== "stopped"
+            && session.status !== "broken"));
+        if (liveConflict !== undefined) {
+            throw new Error(`Task Role Session identity cannot change while ${liveConflict.agentId} is live.`);
+        }
+        current = {
+            ...current,
+            activeAgentId: agentId,
+            updatedAt: now.toISOString()
+        };
+    }
+    const updated = bindTaskRoleRun(current, {
+        agentId,
+        runId: run.id,
+        receiptId: formatAgentRunReceiptId(role.taskId, run.id)
+    }, now);
+    store.saveRoleSessionSet(updated);
+}
+function markTaskRoleRunPushedInFlight(store, role, run, now) {
+    const current = store.getRoleSessionSet(role.taskId, role.name);
+    if (current === null) {
+        throw new Error(`Task Role session set is missing for pushed Run: ${run.id}.`);
+    }
+    const updated = markTaskRoleRunPushed(current, {
+        agentId: run.effective.agentId,
+        runId: run.id,
+        receiptId: formatAgentRunReceiptId(role.taskId, run.id)
+    }, now);
+    store.saveRoleSessionSet(updated);
+}
+function markTaskRoleRunDeliveredInFlight(store, role, run, now) {
+    const current = store.getRoleSessionSet(role.taskId, role.name);
+    if (current === null) {
+        throw new Error(`Task Role session set is missing for delivered Run: ${run.id}.`);
+    }
+    const updated = markTaskRoleRunDelivered(current, {
+        agentId: run.effective.agentId,
+        runId: run.id,
+        receiptId: formatAgentRunReceiptId(role.taskId, run.id)
+    }, now);
+    store.saveRoleSessionSet(updated);
+}
+function clearTaskRoleRunInFlight(store, role, run, now) {
+    const current = store.getRoleSessionSet(role.taskId, role.name);
+    if (current === null)
+        return;
+    if (current.inFlight?.runId !== run.id)
+        return;
+    const updated = clearTaskRoleRun(current, {
+        agentId: run.effective.agentId,
+        runId: run.id,
+        receiptId: formatAgentRunReceiptId(role.taskId, run.id)
     }, now);
     store.saveRoleSessionSet(updated);
 }
@@ -314,9 +2333,40 @@ function updateTaskSessionStatusIfPresent(store, taskId, roleName, agentId, stat
         return;
     store.saveRoleSessionSet(updateRoleAgentSessionStatus(set, agentId, status, now));
 }
+function schedulerRoleSessionsMatch(current, expected) {
+    if (current === null || expected === null)
+        return current === expected;
+    return current.agentId === expected.agentId
+        && current.adapterId === expected.adapterId
+        && current.nativeSessionId === expected.nativeSessionId
+        && current.launchId === expected.launchId
+        && isDeepStrictEqual(current.effective, expected.effective);
+}
+function matchesStallSessionFence(current, expected) {
+    if (current === null || expected === null)
+        return current === expected;
+    return current.agentId === expected.agentId
+        && current.adapterId === expected.adapterId
+        && current.nativeSessionId === expected.nativeSessionId
+        && current.launchId === expected.launchId
+        && current.status === expected.status;
+}
 function requireRole(store, taskId, roleName) {
     const role = store.getRole(taskId, roleName);
     if (role === null)
         throw new Error(`Role not found: ${taskId}/${roleName}.`);
     return role;
 }
+function runLaunchEventPayload(run) {
+    return {
+        runId: run.id,
+        role: run.roleName,
+        purpose: run.purpose,
+        mode: run.mode,
+        agent: `${run.effective.agentId}/${run.effective.adapterId}`,
+        effectiveRevision: String(run.effective.sourceDesiredRevision),
+        profileAccess: run.effective.profileAccess,
+        effectivePermission: run.effective.permission.strategy,
+        writeProjectIds: run.effective.writeProjectIds.join(",") || "none"
+    };
+}