@zq-silk/yui 0.11.2 → 0.12.0

package/dist/controller/fileSchedulerStoreAdapter.js

@@ -8,11 +8,9 @@ import { createTaskEvent } from "../event/taskEvent.js";
 import { operationalTaskRecords } from "../task/taskRecordRetirement.js";
 import { buildTaskWakeEnvelope } from "../context/wakeNotification.js";
 import { createTaskWake, fallbackWakeCursor, latestTaskWake } from "../scheduler/taskWake.js";
-import { rolloverTaskRoleSessionForContextBudget } from "../lifecycle/contextBudgetRollover.js";
-import { resolveContextBudget } from "../config/yuiConfig.js";
 import { answerInputRequest } from "../input/inputRequest.js";
 import { activeRoleAgentBinding, updateRoleStatus } from "../role/role.js";
-import { effectiveLaunchWithTaskMainWorkspace, effectiveLaunchSnapshotsCompatible, effectiveLaunchSnapshotsCompatibleForTaskMain, resolveEffectiveLaunch, validateEffectiveLaunchSnapshot } from "../executor/effectiveLaunch.js";
+import { effectiveLaunchWithTaskMainWorkspace, effectiveLaunchSnapshotsCompatible, effectiveLaunchSnapshotsCompatibleForTaskSession, resolveEffectiveLaunch, validateEffectiveLaunchSnapshot } from "../executor/effectiveLaunch.js";
 import { SYSTEM_OPERATOR_ROLE } from "../role/systemRoles.js";
 import { failAgentRun, markAgentRunDelivered, markAgentRunPushed, reopenRunForProviderRetry, clearProviderRetryOnProgress, agentRunDeliveryReceiptId, withProviderRetry } from "../run/agentRun.js";
 import { markWorkflowOutcomeRequestDispatched } from "../run/runControlRequest.js";
@@ -23,11 +21,11 @@ import { classifyRuntimeProcessExit, validateRuntimeProcessExitObservation } fro
 import { terminalizeExactTaskRun } from "../lifecycle/exactRunTerminalization.js";
 import { createCanonicalLifecycleEvent, foldCanonicalLifecycleEvent } from "../lifecycle/canonicalLifecycleEvent.js";
 import { recordLeaderFailure } from "../scheduler/leaderFailure.js";
-import { createLeaderRecoveryNotification, createLeaderStallNotification } from "../scheduler/operatorNotification.js";
+import { enqueueOperatorEvent, recordLeaderAttentionRequired, routeRoleEvent } from "../scheduler/operatorEvent.js";
 import { pendingWakeupsMatch } from "../scheduler/pendingWakeup.js";
 import { queueLeaderWakeup } from "../scheduler/wakeupQueue.js";
 import { wakeReason } from "../scheduler/wakeReason.js";
-import { foldRunProgressFacts, latestRunDurableProgressAt, latestRunEventTime, latestStallEvidenceKey, clearMatchingLeaderStallAttention, RUN_PROGRESS_EVENT, RUN_RECOVERED_EVENT, RUN_STALLED_EVENT } from "../scheduler/roleRunStall.js";
+import { foldRunProgressFacts, latestRunDurableProgressAt, latestRunEventTime, latestStallEvidenceKey, RUN_PROGRESS_EVENT, RUN_RECOVERED_EVENT, RUN_STALLED_EVENT } from "../scheduler/roleRunStall.js";
 import { projectProviderContinuations } from "../runtime/runtimeContinuationProjection.js";
 import { providerContinuationKey } from "../runtime/providerContinuation.js";
 import { currentWorkItemExecutionGroup, updateWorkItemExecutionGroup, updateWorkItemStatus, workItemOwnsUnresolvedExecutionLane } from "../workItem/workItem.js";
@@ -38,7 +36,7 @@ import { enqueueWork } from "../coordination/workMailboxQueue.js";
 import { RUNTIME_CLEANUP_REQUIRED_REASON, RUNTIME_LAUNCH_RESERVED_REASON, RUNTIME_LIFECYCLE_OWNER, RuntimeLifecycleBusyError, hasRuntimeCleanupObligation, hasRuntimeLifecycleWork, isRuntimeLaunchReservation, runtimeLifecycleTarget } from "../runtime/lifecycleReservation.js";
 import { nativeSessionIdForLaunch } from "../runtime/preallocatedNativeSession.js";
 import { builtinAgentDriverRegistry } from "../runtime/builtinAgentDrivers.js";
-import { RUNTIME_OBSERVATION_TASK_EVENT, createRuntimeObservation, runtimeObservationFenceMatches, runtimeObservationFromTaskEvent, runtimeObservationRunFenceMatches, runtimeObservationTaskEventPayload } from "../runtime/runtimeObservation.js";
+import { RUNTIME_OBSERVATION_TASK_EVENT, createRuntimeObservation, isRuntimeTokenEvidence, runtimeObservationFenceMatches, runtimeObservationFromTaskEvent, runtimeObservationRunFenceMatches, runtimeObservationTaskEventPayload } from "../runtime/runtimeObservation.js";
 import { projectRuntimeTaskEvents } from "../runtime/runtimeProjection.js";
 import { contextSnapshotRef } from "../context/contextSnapshot.js";
 import { contextSnapshotDeltaRefIds, freezeRunContextSnapshot } from "../context/runContextPack.js";
@@ -90,8 +88,7 @@ export class FileSchedulerStoreAdapter {
         if (adapterId === null) {
             return this.recordObsoleteCanonicalObservation(input, "driver-or-run-mismatch", now);
         }
-        if (this.store.listEvents(taskId).some((event) => (event.type === RUNTIME_OBSERVATION_TASK_EVENT
-            && event.payload.semanticKey === input.semanticKey)))
+        if (hasPersistedRuntimeObservation(this.store.listEvents(taskId), input))
             return "applied";
         let outcome;
         switch (input.kind) {
@@ -112,6 +109,7 @@ export class FileSchedulerStoreAdapter {
                     launchId: input.fence.launchId,
                     nativeSessionId: input.fence.nativeSessionId,
                     turnId: input.fence.nativeTurnId,
+                    attemptId: input.fence.receiptId,
                     runId: input.fence.runId,
                     summary: input.payload.summary ?? "Agent turn completed without a workflow outcome."
                 };
@@ -152,6 +150,7 @@ export class FileSchedulerStoreAdapter {
                         launchId: input.fence.launchId,
                         nativeSessionId: input.fence.nativeSessionId,
                         turnId: input.fence.nativeTurnId,
+                        attemptId: input.fence.receiptId,
                         runId: input.fence.runId,
                         summary: input.payload.summary ?? `Provider Turn failed: ${failureEvidence.code}.`,
                         providerStatus: "failed"
@@ -223,7 +222,8 @@ export class FileSchedulerStoreAdapter {
         }
         if (outcome === "applied"
             && input.kind === "activity.observed"
-            && input.payload.activityId !== undefined) {
+            && input.payload.activityId !== undefined
+            && input.payload.usage === undefined) {
             this.clearProviderRetryForProgress(input, "correlated-activity", now);
         }
         if (outcome === "applied")
@@ -251,9 +251,9 @@ export class FileSchedulerStoreAdapter {
     }
     validateCanonicalRunObservation(input, now) {
         return this.store.transaction((store) => {
-            if (store.listEvents(input.fence.taskId).some((event) => (event.type === RUNTIME_OBSERVATION_TASK_EVENT
-                && event.payload.semanticKey === input.semanticKey)))
+            if (hasPersistedRuntimeObservation(store.listEvents(input.fence.taskId), input)) {
                 return "applied";
+            }
             const run = store.getAgentRun(input.fence.taskId, input.fence.runId);
             const active = store.getActiveAgentRun(input.fence.taskId, input.fence.roleName);
             const sessions = store.getTaskRoleSessionSet(input.fence.taskId, input.fence.roleName);
@@ -388,10 +388,12 @@ export class FileSchedulerStoreAdapter {
                         "Yui preserved the Run because Session/host termination is not a workflow outcome.",
                         "Inspect native-child and mailbox facts, then explicitly continue, reset, or request user input."
                     ].join(" ");
-                    store.saveOperatorNotification(createLeaderRecoveryNotification(input.fence.taskId, message, now, store.getOperatorNotification(input.fence.taskId)));
-                    enqueueWork(store, { kind: "operator" }, "leader-runtime-detached", now, [
-                        { type: "run", taskId: input.fence.taskId, id: active.id }
-                    ]);
+                    recordLeaderAttentionRequired(store, {
+                        taskId: input.fence.taskId,
+                        reason: "leader-runtime-detached",
+                        payload: { message, runId: active.id },
+                        now
+                    });
                 }
                 else {
                     enqueueWork(store, {
@@ -410,22 +412,16 @@ export class FileSchedulerStoreAdapter {
         this.store.transaction((store) => {
             const taskId = input.fence.taskId;
             const events = store.listEvents(taskId);
-            if (events.some((event) => (event.type === RUNTIME_OBSERVATION_TASK_EVENT
-                && event.payload.semanticKey === input.semanticKey)))
+            if (hasPersistedRuntimeObservation(events, input))
                 return;
             if (usageSnapshotIsSuperseded(events, input))
                 return;
-            const confirmedActivity = confirmedUsageActivityObservation(events, input);
-            const removable = [
-                ...compactedRuntimeObservationIds(events, input),
-                ...(confirmedActivity === null
-                    ? []
-                    : compactedRuntimeObservationIds(events, confirmedActivity))
-            ];
+            const removable = compactedRuntimeObservationIds(events, input);
             if (removable.length > 0)
                 store.removeEvents(taskId, removable);
             const observationEventId = store.nextEventId(taskId);
-            store.saveEvent(taskId, createTaskEvent(observationEventId, taskId, RUNTIME_OBSERVATION_TASK_EVENT, runtimeObservationTaskEventPayload(input), now));
+            const observationEvent = createTaskEvent(observationEventId, taskId, RUNTIME_OBSERVATION_TASK_EVENT, runtimeObservationTaskEventPayload(input), now);
+            store.saveEvent(taskId, observationEvent);
             if (input.kind === "native-work.snapshot"
                 && input.payload.snapshotComplete === true
                 && input.payload.observationQuality === "exact") {
@@ -503,14 +499,9 @@ export class FileSchedulerStoreAdapter {
                 // Route a Yui wake only when that parent is gone and another observer
                 // supplied the child's terminal fact.
                 if (role !== null && (session?.status === "stopped" || session?.status === "broken")) {
-                    enqueueWork(store, role.name === "leader"
-                        ? { kind: "operator" }
-                        : { kind: "role", taskId, roleName: "leader" }, "detached-native-subagent-terminal", now, [{ type: "run", taskId, id: input.fence.runId }]);
+                    routeRoleEvent(store, observationEvent, role.name, "detached-native-subagent-terminal", now);
                 }
             }
-            if (confirmedActivity !== null) {
-                store.saveEvent(taskId, createTaskEvent(store.nextEventId(taskId), taskId, RUNTIME_OBSERVATION_TASK_EVENT, runtimeObservationTaskEventPayload(confirmedActivity), now));
-            }
         });
         if (this.telemetry !== null && input.fence.runId !== undefined) {
             try {
@@ -573,9 +564,6 @@ export class FileSchedulerStoreAdapter {
     withRuntimeEventTransaction(execute) {
         return this.store.withRuntimeEventTransaction(execute);
     }
-    getPresentationContext() {
-        return { timeZone: this.store.getConfig().timeZone };
-    }
     listTasks() { return this.store.listTasks(); }
     listActiveTaskIds() {
         return [...this.store.listActiveTaskIds()].sort((left, right) => (left.localeCompare(right, undefined, { numeric: true })));
@@ -608,12 +596,6 @@ export class FileSchedulerStoreAdapter {
             });
         });
     }
-    rolloverTaskRoleSessionForContextBudget(input) {
-        return this.store.transaction((reader) => rolloverTaskRoleSessionForContextBudget(reader, input.taskId, input.roleName, { peakTokens: input.peakTokens, hardTokens: input.hardTokens }, input.now));
-    }
-    getContextBudget() {
-        return resolveContextBudget(this.store.getConfig().contextBudget);
-    }
     listRoles(taskId) {
         return this.store.listRoles(taskId).map((role) => mapRole(this.store, role));
     }
@@ -646,6 +628,17 @@ export class FileSchedulerStoreAdapter {
             adapterId: effectiveSession.effective.adapterId
         };
     }
+    markOperatorTurnStarted(now) {
+        this.store.transaction((store) => {
+            const sessions = store.getGlobalRoleSessionSet(SYSTEM_OPERATOR_ROLE);
+            if (sessions === null)
+                return;
+            const active = sessions.sessions[sessions.activeAgentId];
+            if (active === undefined || active.status !== "ready")
+                return;
+            store.saveGlobalRoleSessionSet(updateRoleAgentSessionStatus(sessions, sessions.activeAgentId, "running", now));
+        });
+    }
     resolveExpiredInputRecommendations(now, taskIds) {
         return this.store.transaction((store) => {
             const selectedTaskIds = taskIds === undefined
@@ -760,10 +753,7 @@ export class FileSchedulerStoreAdapter {
             }, 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 }
-                ]);
+                enqueueOperatorEvent(store, event, "leader-run-stalled", input.now);
             }
             else {
                 queueLeaderWakeup(store, task.id, wakeReason("role-run-stalled"), input.now);
@@ -815,7 +805,6 @@ export class FileSchedulerStoreAdapter {
                     progressAt: input.progressAt,
                     kind: "durable-progress"
                 }, input.now));
-                clearMatchingLeaderStallAttention(store, task.id, run.id);
             }
             return existing && !recovered ? "already-recorded" : "recorded";
         });
@@ -1161,17 +1150,11 @@ export class FileSchedulerStoreAdapter {
             const unknown = markMailboxInputDeliveryUnknown(mailbox, attemptId, reason, now);
             markSubmittingProviderTurnUnknown(store, target, mailbox.inputDelivery, now, reason);
             store.saveWorkMailbox(unknown);
-            const taskId = target.kind === "role" ? target.taskId : undefined;
-            if (taskId !== undefined) {
-                store.saveEvent(taskId, createTaskEvent(store.nextEventId(taskId), taskId, "run.input-delivery-unknown", { attemptId, reason }, now));
-                enqueueWork(store, { kind: "operator" }, "run-input-delivery-unknown", now, [
-                    unknown.inputDelivery.executionRef
-                ], {
-                    source: "input-router",
-                    dedupeKey: `input-delivery-unknown:${attemptId}`,
-                    deliveryMode: "followup",
-                    lane: "normal"
-                });
+            if (target.kind === "role") {
+                const taskId = target.taskId;
+                const event = createTaskEvent(store.nextEventId(taskId), taskId, "run.input-delivery-unknown", { attemptId, reason }, now);
+                store.saveEvent(taskId, event);
+                routeRoleEvent(store, event, target.roleName, "run-input-delivery-unknown", now);
             }
             return true;
         });
@@ -1298,7 +1281,6 @@ export class FileSchedulerStoreAdapter {
     }
     clearPendingWakeup(taskId) { this.store.clearPendingWakeup(taskId); }
     getLeaderFailure(taskId) { return this.store.getLeaderFailure(taskId); }
-    getOperatorNotification(taskId) { return this.store.getOperatorNotification(taskId); }
     saveLeaderDispatch(input) {
         return this.store.transaction((store) => {
             const task = store.getTask(input.task.id);
@@ -1378,7 +1360,6 @@ export class FileSchedulerStoreAdapter {
                 }, "running", input.now);
             }
             store.clearLeaderFailure(input.task.id);
-            store.clearOperatorNotification(input.task.id);
             return "claimed";
         });
     }
@@ -1537,11 +1518,12 @@ export class FileSchedulerStoreAdapter {
                 roleName: input.roleName
             }), RUNTIME_CLEANUP_REQUIRED_REASON, input.now, [{ type: "task", id: input.taskId }]);
             const terminal = result.run;
-            store.saveEvent(input.taskId, createTaskEvent(store.nextEventId(input.taskId), input.taskId, "runtime.role-delivery-failed", {
+            const deliveryFailureEvent = createTaskEvent(store.nextEventId(input.taskId), input.taskId, "runtime.role-delivery-failed", {
                 runId: terminal.id,
                 roleName: input.roleName,
                 outcome: terminal.status
-            }, input.now));
+            }, input.now);
+            store.saveEvent(input.taskId, deliveryFailureEvent);
             if (terminal.purpose === "execution" && terminal.workItemId !== undefined) {
                 const item = store.getWorkItem(input.taskId, terminal.workItemId);
                 if (item !== null && ![
@@ -1553,12 +1535,7 @@ export class FileSchedulerStoreAdapter {
                 }
             }
             if (input.roleName !== "leader") {
-                enqueueWork(store, { kind: "role", taskId: input.taskId, roleName: "leader" }, terminal.purpose === "review" ? "review-failed" : "role-run-failed", input.now, [
-                    { type: "run", taskId: input.taskId, id: terminal.id },
-                    ...(terminal.workItemId === undefined
-                        ? []
-                        : [{ type: "work-item", taskId: input.taskId, id: terminal.workItemId }])
-                ]);
+                routeRoleEvent(store, deliveryFailureEvent, input.roleName, terminal.purpose === "review" ? "review-failed" : "role-run-failed", input.now);
             }
             else {
                 const failedRole = store.getRole(input.taskId, input.roleName);
@@ -1566,11 +1543,7 @@ export class FileSchedulerStoreAdapter {
                     store.saveRole(input.taskId, updateRoleStatus(failedRole, "failed", input.now));
                 }
                 store.saveLeaderFailure(recordLeaderFailure(input.taskId, session?.nativeSessionId ?? "(unregistered)", summary, input.now, store.getLeaderFailure(input.taskId)));
-                store.saveOperatorNotification(createLeaderRecoveryNotification(input.taskId, summary, input.now, store.getOperatorNotification(input.taskId)));
-                enqueueWork(store, { kind: "operator" }, "leader-run-failed", input.now, [
-                    { type: "task", id: input.taskId },
-                    { type: "run", taskId: input.taskId, id: terminal.id }
-                ]);
+                routeRoleEvent(store, deliveryFailureEvent, input.roleName, "leader-run-failed", input.now);
             }
             return "failed";
         });
@@ -1606,10 +1579,15 @@ export class FileSchedulerStoreAdapter {
             breakTaskSessionIfPresent(store, input.task.id, role.name, active.effective.agentId, input.now);
             const failure = recordLeaderFailure(input.task.id, input.failure.nativeSessionId, input.failure.message, input.now, store.getLeaderFailure(input.task.id));
             store.saveLeaderFailure(failure);
-            store.saveOperatorNotification(createLeaderRecoveryNotification(input.task.id, input.notification.message, input.now, store.getOperatorNotification(input.task.id)));
-            enqueueWork(store, { kind: "operator" }, "leader-recovery-failed", input.now, [
-                { type: "task", id: input.task.id }
-            ]);
+            recordLeaderAttentionRequired(store, {
+                taskId: input.task.id,
+                reason: "leader-recovery-failed",
+                payload: {
+                    message: input.failure.message,
+                    runId: active.id
+                },
+                now: input.now
+            });
             return "failed";
         });
     }
@@ -1661,7 +1639,6 @@ export class FileSchedulerStoreAdapter {
                 }, input.now);
                 if (terminal.disposition !== "applied")
                     return "state-changed";
-                clearMatchingLeaderStallAttention(store, task.id, currentRun.id);
                 store.saveRole(task.id, updateRoleStatus(role, "exited", input.now));
                 stopTaskSessionIfPresent(store, task.id, role.name, currentRun.effective.agentId, input.now);
                 queueLeaderWakeup(store, task.id, wakeReason("review-failed"), input.now);
@@ -1679,7 +1656,6 @@ export class FileSchedulerStoreAdapter {
                 }
             }
             store.saveAgentRun(failAgentRun(currentRun, input.summary, input.now));
-            clearMatchingLeaderStallAttention(store, task.id, currentRun.id);
             store.clearActiveAgentRun(task.id, role.name);
             clearTaskRoleRunInFlight(store, role, currentRun, input.now);
             if (mailbox !== null && processing !== null && processing !== undefined) {
@@ -1945,6 +1921,7 @@ export class FileSchedulerStoreAdapter {
             const role = requireRole(store, input.taskId, input.roleName);
             let sessions = store.getTaskRoleSessionSet(input.taskId, input.roleName)
                 ?? createRoleSessionSet({ scope: "task", taskId: input.taskId, roleName: input.roleName }, input.agentId, now);
+            const canonicalTurnId = canonicalStructuredProviderTurnId(sessions, input.turnId, input.attemptId);
             const existing = sessions.sessions[input.agentId];
             const owner = {
                 scope: "task",
@@ -1961,7 +1938,7 @@ export class FileSchedulerStoreAdapter {
                 throw new Error("Runtime turn completion does not match the effective launch identity.");
             }
             if (effectiveExisting !== undefined
-                && hasRecentTurnId(effectiveExisting.recentCompletedTurnIds, input.turnId)) {
+                && hasRecentTurnId(effectiveExisting.recentCompletedTurnIds, canonicalTurnId)) {
                 return { session: effectiveExisting, duplicate: true };
             }
             if (sessions.inFlight === null
@@ -1998,9 +1975,9 @@ export class FileSchedulerStoreAdapter {
                     : sessions.inFlight === null ? idleStatus : "running",
                 effective
             }, now);
-            sessions = settleStructuredProviderTurn(sessions, input.turnId, input.providerStatus ?? "completed", now);
+            sessions = settleStructuredProviderTurn(sessions, canonicalTurnId, input.providerStatus ?? "completed", now);
             if (sessions.inFlight === null) {
-                sessions = rememberRoleAgentCompletedTurn(sessions, input.agentId, input.nativeSessionId, input.turnId, now);
+                sessions = rememberRoleAgentCompletedTurn(sessions, input.agentId, input.nativeSessionId, canonicalTurnId, now);
                 store.saveTaskRoleSessionSet(sessions);
                 completeRuntimeHookReservation(store, owner, input.launchId);
                 // The in-flight fence was cleared by an in-place provider retry
@@ -2024,7 +2001,7 @@ export class FileSchedulerStoreAdapter {
             sessions = recordTaskRoleTurnBoundary(sessions, {
                 agentId: input.agentId,
                 nativeSessionId: input.nativeSessionId,
-                turnId: input.turnId
+                turnId: canonicalTurnId
             }, now);
             store.saveTaskRoleSessionSet(sessions);
             completeRuntimeHookReservation(store, owner, input.launchId);
@@ -2109,27 +2086,16 @@ export class FileSchedulerStoreAdapter {
             if (role !== null) {
                 store.saveRole(input.taskId, updateRoleStatus(role, input.roleName === "leader" ? "failed" : "idle", now));
             }
-            store.saveEvent(input.taskId, createTaskEvent(store.nextEventId(input.taskId), input.taskId, "runtime.turn-failed", {
+            const failureEvent = createTaskEvent(store.nextEventId(input.taskId), input.taskId, "runtime.turn-failed", {
                 eventId: input.eventId,
                 runId: input.runId,
                 roleName: input.roleName,
                 outcome: terminal.status
-            }, now));
-            if (input.roleName !== "leader") {
-                enqueueWork(store, { kind: "role", taskId: input.taskId, roleName: "leader" }, before.purpose === "review" ? "review-failed" : "role-run-failed", now, [
-                    { type: "run", taskId: input.taskId, id: terminal.id },
-                    ...(terminal.workItemId === undefined
-                        ? []
-                        : [{ type: "work-item", taskId: input.taskId, id: terminal.workItemId }])
-                ]);
-            }
-            else {
-                store.saveOperatorNotification(createLeaderRecoveryNotification(input.taskId, summary, now, store.getOperatorNotification(input.taskId)));
-                enqueueWork(store, { kind: "operator" }, "leader-run-failed", now, [
-                    { type: "task", id: input.taskId },
-                    { type: "run", taskId: input.taskId, id: terminal.id }
-                ]);
-            }
+            }, now);
+            store.saveEvent(input.taskId, failureEvent);
+            routeRoleEvent(store, failureEvent, input.roleName, input.roleName !== "leader" && before.purpose === "review"
+                ? "review-failed"
+                : input.roleName === "leader" ? "leader-run-failed" : "role-run-failed", now);
             return { disposition: "applied", runId: input.runId };
         });
     }
@@ -2222,14 +2188,12 @@ export class FileSchedulerStoreAdapter {
                 if (blocked.outcome === "exhausted")
                     return null;
                 store.saveAgentRun(withProviderRetry(run, blocked.retry));
-                this.recordProviderRetryClassified(store, input, classification.errorClass, {
+                const classifiedEvent = this.recordProviderRetryClassified(store, input, classification.errorClass, {
                     wouldRetry: "false",
                     shadow: "false",
                     note: "delivery-deduplication-unproven"
                 }, now);
-                enqueueWork(store, input.roleName === "leader"
-                    ? { kind: "operator" }
-                    : { kind: "role", taskId: input.taskId, roleName: "leader" }, "provider-delivery-uncertain", now, [{ type: "run", taskId: input.taskId, id: input.runId }]);
+                routeRoleEvent(store, classifiedEvent, input.roleName, "provider-delivery-uncertain", now);
                 return { disposition: "applied", runId: input.runId };
             }
         }
@@ -2314,22 +2278,14 @@ export class FileSchedulerStoreAdapter {
         if (retryDecision.outcome === "exhausted")
             return null;
         store.saveAgentRun(withProviderRetry(run, retryDecision.retry));
-        this.recordProviderRetryClassified(store, input, "policy-denied", {
+        const classifiedEvent = this.recordProviderRetryClassified(store, input, "policy-denied", {
             wouldRetry: "false",
             shadow: "false",
             note: "policy-denied-blocker"
         }, now);
-        if (input.roleName !== "leader") {
-            enqueueWork(store, { kind: "role", taskId: input.taskId, roleName: "leader" }, "provider-policy-blocked", now, [{ type: "run", taskId: input.taskId, id: input.runId }]);
-        }
-        else {
-            const message = `Leader Run ${input.runId} is blocked by Provider policy: ${summary}`;
-            store.saveOperatorNotification(createLeaderRecoveryNotification(input.taskId, message, now, store.getOperatorNotification(input.taskId)));
-            enqueueWork(store, { kind: "operator" }, "leader-provider-policy-blocked", now, [
-                { type: "task", id: input.taskId },
-                { type: "run", taskId: input.taskId, id: input.runId }
-            ]);
-        }
+        routeRoleEvent(store, classifiedEvent, input.roleName, input.roleName === "leader"
+            ? "leader-provider-policy-blocked"
+            : "provider-policy-blocked", now);
         return { disposition: "applied", runId: input.runId };
     }
     /**
@@ -2355,7 +2311,7 @@ export class FileSchedulerStoreAdapter {
             return null;
         store.saveAgentRun(withProviderRetry(run, decision.retry));
         const driver = this.drivers.requireByAdapterId(input.adapterId);
-        store.saveEvent(input.taskId, createTaskEvent(store.nextEventId(input.taskId), input.taskId, "runtime.context-capacity-failure", {
+        const capacityEvent = createTaskEvent(store.nextEventId(input.taskId), input.taskId, "runtime.context-capacity-failure", {
             eventId: input.eventId,
             runId: input.runId,
             roleName: input.roleName,
@@ -2366,15 +2322,14 @@ export class FileSchedulerStoreAdapter {
             action: driver.capabilities.lifecycle.compaction === "native-explicit"
                 ? "native-explicit-compaction-required"
                 : "await-provider-native-recovery"
-        }, now));
+        }, now);
+        store.saveEvent(input.taskId, capacityEvent);
         this.recordProviderRetryClassified(store, input, "context-capacity", {
             wouldRetry: "false",
             shadow: "false",
             note: "provider-native-capacity-recovery-only"
         }, now);
-        enqueueWork(store, input.roleName === "leader"
-            ? { kind: "operator" }
-            : { kind: "role", taskId: input.taskId, roleName: "leader" }, "provider-context-capacity-recovery-required", now, [{ type: "run", taskId: input.taskId, id: input.runId }]);
+        routeRoleEvent(store, capacityEvent, input.roleName, "provider-context-capacity-recovery-required", now);
         return { disposition: "applied", runId: input.runId };
     }
     applyNativeSessionRecoverabilityBlock(store, input, summary, now) {
@@ -2393,27 +2348,28 @@ export class FileSchedulerStoreAdapter {
         if (decision.outcome === "exhausted")
             return null;
         store.saveAgentRun(withProviderRetry(run, decision.retry));
-        store.saveEvent(input.taskId, createTaskEvent(store.nextEventId(input.taskId), input.taskId, "runtime.native-session-recoverability-unproven", {
+        const recoverabilityEvent = createTaskEvent(store.nextEventId(input.taskId), input.taskId, "runtime.native-session-recoverability-unproven", {
             eventId: input.eventId,
             runId: input.runId,
             roleName: input.roleName,
             launchId: input.launchId,
             nativeSessionId: input.nativeSessionId,
             requiredEvidence: "exact-native-resume-outcome"
-        }, now));
-        enqueueWork(store, input.roleName === "leader"
-            ? { kind: "operator" }
-            : { kind: "role", taskId: input.taskId, roleName: "leader" }, "native-session-recoverability-unproven", now, [{ type: "run", taskId: input.taskId, id: input.runId }]);
+        }, now);
+        store.saveEvent(input.taskId, recoverabilityEvent);
+        routeRoleEvent(store, recoverabilityEvent, input.roleName, "native-session-recoverability-unproven", now);
         return { disposition: "applied", runId: input.runId };
     }
     recordProviderRetryClassified(store, input, errorClass, extra, now) {
-        store.saveEvent(input.taskId, createTaskEvent(store.nextEventId(input.taskId), input.taskId, "runtime.provider-retry-classified", {
+        const event = createTaskEvent(store.nextEventId(input.taskId), input.taskId, "runtime.provider-retry-classified", {
             eventId: input.eventId,
             runId: input.runId,
             roleName: input.roleName,
             errorClass,
             ...extra
-        }, now));
+        }, now);
+        store.saveEvent(input.taskId, event);
+        return event;
     }
     /**
      * Issue 04 durable retry timer: lists active Runs whose in-place retry is
@@ -2580,18 +2536,17 @@ export class FileSchedulerStoreAdapter {
                         return;
                     }
                     store.saveAgentRun(withProviderRetry(run, deferred));
-                    if (!store.listEvents(entry.taskId).some((event) => (event.type === "runtime.provider-retry-native-resume-unproven"
-                        && event.payload.runId === run.id))) {
-                        store.saveEvent(entry.taskId, createTaskEvent(store.nextEventId(entry.taskId), entry.taskId, "runtime.provider-retry-native-resume-unproven", {
+                    let attentionEvent = store.listEvents(entry.taskId).find((event) => (event.type === "runtime.provider-retry-native-resume-unproven"
+                        && event.payload.runId === run.id));
+                    if (attentionEvent === undefined) {
+                        attentionEvent = createTaskEvent(store.nextEventId(entry.taskId), entry.taskId, "runtime.provider-retry-native-resume-unproven", {
                             runId: run.id,
                             consecutiveFailures: String(run.providerRetry.consecutiveFailures),
                             dispatchedRetries: String(run.providerRetry.dispatchedRetries)
-                        }, now));
+                        }, now);
+                        store.saveEvent(entry.taskId, attentionEvent);
                     }
-                    enqueueWork(store, { kind: "operator" }, "provider-retry-native-resume-unproven", now, [
-                        { type: "task", id: entry.taskId },
-                        { type: "run", taskId: entry.taskId, id: run.id }
-                    ]);
+                    routeRoleEvent(store, attentionEvent, entry.roleName, "provider-retry-native-resume-unproven", now);
                     return;
                 }
                 if (hasUnsettledRuntimeOperations(store, entry.taskId, run.id)) {
@@ -3027,7 +2982,8 @@ export class FileSchedulerStoreAdapter {
                 && !runtimeHookMatchesReservation(store, owner, input.launchId)) {
                 throw new Error("Runtime turn completion does not match the global launch reservation.");
             }
-            const effectiveExisting = nativeTransitionExisting(store, owner, existing, input.nativeSessionId, input.launchId, "Runtime turn completion conflicts with the fixed global Role session.");
+            const nativeSessionId = globalCompletionNativeSessionId(existing, input);
+            const effectiveExisting = nativeTransitionExisting(store, owner, existing, nativeSessionId, input.launchId, "Runtime turn completion conflicts with the fixed global Role session.");
             const effective = globalSessionEffective(role, effectiveExisting);
             if (effective.agentId !== input.agentId || effective.adapterId !== input.adapterId) {
                 throw new Error("Runtime turn completion does not match the effective global launch identity.");
@@ -3039,7 +2995,7 @@ export class FileSchedulerStoreAdapter {
             current = recordRoleAgentSession(current, {
                 agentId: input.agentId,
                 adapterId: input.adapterId,
-                nativeSessionId: input.nativeSessionId,
+                nativeSessionId,
                 ...(input.launchId === undefined ? {} : { launchId: input.launchId }),
                 title: effectiveExisting?.title ?? input.title,
                 preview: effectiveExisting?.preview ?? (input.summary === undefined ? undefined : sessionPreview(input.summary)),
@@ -3047,7 +3003,7 @@ export class FileSchedulerStoreAdapter {
                 status: completedStatus,
                 effective
             }, now);
-            current = rememberRoleAgentCompletedTurn(current, input.agentId, input.nativeSessionId, input.turnId, now);
+            current = rememberRoleAgentCompletedTurn(current, input.agentId, nativeSessionId, input.turnId, now);
             store.saveGlobalRoleSessionSet(current);
             completeRuntimeHookReservation(store, owner, input.launchId);
             return current.sessions[input.agentId];
@@ -3066,9 +3022,10 @@ export class FileSchedulerStoreAdapter {
         if (existing === undefined
             && !runtimeHookMatchesReservation(this.store, owner, input.launchId))
             return "obsolete";
+        const nativeSessionId = globalCompletionNativeSessionId(existing, input);
         let effectiveExisting;
         try {
-            effectiveExisting = nativeTransitionExisting(this.store, owner, existing, input.nativeSessionId, input.launchId, "Runtime turn completion conflicts with the fixed global Role session.");
+            effectiveExisting = nativeTransitionExisting(this.store, owner, existing, nativeSessionId, input.launchId, "Runtime turn completion conflicts with the fixed global Role session.");
         }
         catch {
             return "obsolete";
@@ -3369,7 +3326,7 @@ function finalizeProviderRetryDeadline(store, run, summary, reason, now) {
     if (terminalization.disposition !== "applied" || terminalization.run === null)
         return false;
     const terminal = terminalization.run;
-    store.saveEvent(run.taskId, createTaskEvent(store.nextEventId(run.taskId), run.taskId, "runtime.provider-retry-exhausted", {
+    const exhaustionEvent = createTaskEvent(store.nextEventId(run.taskId), run.taskId, "runtime.provider-retry-exhausted", {
         runId: run.id,
         roleName: run.roleName,
         episodeId: retry.episodeId,
@@ -3377,7 +3334,8 @@ function finalizeProviderRetryDeadline(store, run, summary, reason, now) {
         consecutiveFailures: String(retry.consecutiveFailures),
         dispatchedRetries: String(retry.dispatchedRetries),
         elapsedMs: String(Math.max(0, now.getTime() - Date.parse(retry.firstFailureAt)))
-    }, now));
+    }, now);
+    store.saveEvent(run.taskId, exhaustionEvent);
     if (terminal.purpose === "execution" && terminal.workItemId !== undefined) {
         const item = store.getWorkItem(run.taskId, terminal.workItemId);
         if (item !== null
@@ -3392,15 +3350,8 @@ function finalizeProviderRetryDeadline(store, run, summary, reason, now) {
     }
     if (run.roleName === "leader") {
         store.saveLeaderFailure(recordLeaderFailure(run.taskId, retry.nativeSessionId ?? "(unproven)", summary, now, store.getLeaderFailure(run.taskId)));
-        store.saveOperatorNotification(createLeaderRecoveryNotification(run.taskId, summary, now, store.getOperatorNotification(run.taskId)));
-        enqueueWork(store, { kind: "operator" }, "provider-retry-exhausted", now, [
-            { type: "task", id: run.taskId },
-            { type: "run", taskId: run.taskId, id: run.id }
-        ]);
-    }
-    else {
-        enqueueWork(store, { kind: "role", taskId: run.taskId, roleName: "leader" }, "provider-retry-exhausted", now, [{ type: "run", taskId: run.taskId, id: run.id }]);
     }
+    routeRoleEvent(store, exhaustionEvent, run.roleName, "provider-retry-exhausted", now);
     return true;
 }
 function preparedDeliveryFailureSessionFenceMatches(sessions, session, input, expectedReceiptId) {
@@ -3475,7 +3426,7 @@ function recordTaskRuntimeNativeSession(store, input, now) {
     const effective = input.effective === undefined
         ? resolvedEffective
         : validateEffectiveLaunchSnapshot(input.effective);
-    if (!effectiveLaunchSnapshotsCompatibleForTaskMain(resolvedEffective, effective, store.getTaskWorkspace(input.taskId))) {
+    if (!effectiveLaunchSnapshotsCompatibleForTaskSession(resolvedEffective, effective)) {
         throw new Error("Reserved native Session effective launch changed before persistence.");
     }
     if (effective.agentId !== input.agentId || effective.adapterId !== input.adapterId) {
@@ -3536,6 +3487,17 @@ function nativeTransitionExisting(store, owner, existing, nativeSessionId, launc
     }
     throw new Error(conflictMessage);
 }
+function globalCompletionNativeSessionId(existing, input) {
+    // Codex app-server and its notify Hook expose different native IDs for the
+    // same launch. The launch generation remains the authoritative fence.
+    return input.adapterId === "codex"
+        && input.launchId !== undefined
+        && existing?.launchId === input.launchId
+        && existing.agentId === input.agentId
+        && existing.adapterId === input.adapterId
+        ? existing.nativeSessionId
+        : input.nativeSessionId;
+}
 function mapRole(store, role) {
     const binding = activeRoleAgentBinding(role);
     const item = store.listWorkItems(role.taskId).find((candidate) => (candidate.assignee === role.name
@@ -3581,8 +3543,7 @@ function taskSessionEffective(store, taskId, roleName, agentId, existing) {
             throw new Error(`Native Session registration does not match the effective Run Agent: ${taskId}/${roleName}.`);
         }
         if (existing !== undefined) {
-            const workspace = active.workspace ?? store.getTaskWorkspace(taskId);
-            if (!effectiveLaunchSnapshotsCompatibleForTaskMain(existing.effective, active.effective, workspace)) {
+            if (!effectiveLaunchSnapshotsCompatibleForTaskSession(existing.effective, active.effective)) {
                 throw new Error(`Native Session effective launch does not match the active Run: ${taskId}/${roleName}.`);
             }
             return existing.effective;
@@ -3788,11 +3749,10 @@ function runtimeObservationTelemetryEntry(input) {
     };
 }
 /**
- * Runtime observations are a current-state snapshot, not an append-only
- * semantic history. Retain active operations, one latest usage baseline, and
- * one latest confirmed activity boundary so a token stream remains
- * O(active operations) per Run without losing the delta that was already
- * proven before an unchanged later snapshot arrived.
+ * Usage observations and incomplete request boundaries are authoritative
+ * read-only history: retain each one so consecutive deltas remain projectable.
+ * Other activity observations are a current explicit boundary and may replace
+ * their predecessor. Token evidence never becomes lifecycle activity.
  */
 function compactedRuntimeObservationIds(events, incoming) {
     const existing = events.flatMap((event) => {
@@ -3809,9 +3769,10 @@ function compactedRuntimeObservationIds(events, incoming) {
     });
     const remove = ({ observation }) => {
         if (incoming.kind === "activity.observed") {
+            if (isRuntimeTokenEvidence(incoming))
+                return false;
             return observation.kind === "activity.observed"
-                && (observation.payload.usage === undefined)
-                    === (incoming.payload.usage === undefined);
+                && !isRuntimeTokenEvidence(observation);
         }
         if (incoming.kind === "operation.started") {
             return (observation.kind === "operation.started"
@@ -3854,7 +3815,6 @@ function recordStructuredProviderAcceptance(sessions, input, now) {
     if (current === null || attemptId === undefined || turnId === undefined)
         return sessions;
     if (current.turn?.attemptId === attemptId
-        && current.turn.turnId === turnId
         && ["accepted", "running", "completed", "failed", "cancelled"].includes(current.turn.status))
         return sessions;
     const binding = acceptProviderTurn(current, {
@@ -3864,6 +3824,20 @@ function recordStructuredProviderAcceptance(sessions, input, now) {
     });
     return updateTaskRoleProviderRuntime(sessions, binding, now);
 }
+/**
+ * A Provider may expose the same accepted input through more than one exact
+ * observation surface. Preserve the first native Turn identity bound to the
+ * durable attempt; a later transport alias may settle that same attempt but
+ * must neither replace nor strand the canonical identity.
+ */
+function canonicalStructuredProviderTurnId(sessions, observedTurnId, attemptId) {
+    const turn = sessions.providerBinding?.turn;
+    return attemptId !== undefined
+        && turn?.attemptId === attemptId
+        && turn.turnId !== undefined
+        ? turn.turnId
+        : observedTurnId;
+}
 function bindOrSupersedeProviderRuntime(sessions, input, now) {
     if (sessions.inFlight === null)
         return sessions;
@@ -3931,16 +3905,14 @@ function deferUnprovenProviderRecovery(store, run, roleName, reason, now) {
         return;
     }
     store.saveAgentRun(withProviderRetry(run, deferred));
-    store.saveEvent(run.taskId, createTaskEvent(store.nextEventId(run.taskId), run.taskId, "runtime.provider-recovery-attention", {
+    const attentionEvent = createTaskEvent(store.nextEventId(run.taskId), run.taskId, "runtime.provider-recovery-attention", {
         runId: run.id,
         roleName,
         reason,
         nextAttemptAt: deferred.nextAttemptAt ?? ""
-    }, now));
-    enqueueWork(store, { kind: "operator" }, "provider-recovery-attention", now, [
-        { type: "task", id: run.taskId },
-        { type: "run", taskId: run.taskId, id: run.id }
-    ]);
+    }, now);
+    store.saveEvent(run.taskId, attentionEvent);
+    routeRoleEvent(store, attentionEvent, roleName, "provider-recovery-attention", now);
 }
 function markSubmittingProviderTurnUnknown(store, target, delivery, now, reason) {
     if (target.kind !== "role"
@@ -3974,39 +3946,6 @@ function settleStructuredProviderTurn(sessions, turnId, status, now) {
         settledAt: now.toISOString()
     }), now);
 }
-function confirmedUsageActivityObservation(events, incoming) {
-    const usage = incoming.payload.usage;
-    if (incoming.kind !== "activity.observed" || usage === undefined)
-        return null;
-    const previous = events
-        .map(runtimeObservationFromTaskEvent)
-        .filter((observation) => (observation !== null
-        && observation.kind === "activity.observed"
-        && observation.payload.usage !== undefined
-        && runtimeObservationFenceMatches(observation.fence, incoming.fence)))
-        .sort(compareCanonicalObservationOrder)
-        .at(-1)?.payload.usage;
-    if (previous === undefined
-        || usage.inputTokens + usage.outputTokens
-            <= previous.inputTokens + previous.outputTokens)
-        return null;
-    const digest = createHash("sha256")
-        .update(`confirmed-runtime-activity\0${incoming.eventId}`)
-        .digest("hex");
-    return createRuntimeObservation({
-        schemaVersion: 2,
-        eventId: `runtime-activity-${digest}`,
-        semanticKey: `runtime-activity-${digest}`,
-        kind: "activity.observed",
-        authority: "controller",
-        receivedAt: incoming.receivedAt,
-        ...(incoming.observedAt === undefined ? {} : { observedAt: incoming.observedAt }),
-        ...(incoming.sequence === undefined ? {} : { sequence: incoming.sequence }),
-        ...(incoming.ordinal === undefined ? {} : { ordinal: incoming.ordinal }),
-        fence: incoming.fence,
-        payload: { activity: incoming.payload.activity ?? "model" }
-    });
-}
 function usageSnapshotIsSuperseded(events, incoming) {
     if (incoming.kind !== "activity.observed" || incoming.payload.usage === undefined) {
         return false;
@@ -4019,6 +3958,15 @@ function usageSnapshotIsSuperseded(events, incoming) {
         && runtimeObservationFenceMatches(observation.fence, incoming.fence)
         && observationIsStrictlyNewer(observation, incoming));
 }
+function hasPersistedRuntimeObservation(events, incoming) {
+    const usageIdentity = isRuntimeTokenEvidence(incoming)
+        ? incoming.eventId
+        : undefined;
+    return events.some((event) => (event.type === RUNTIME_OBSERVATION_TASK_EVENT
+        && (usageIdentity === undefined
+            ? event.payload.semanticKey === incoming.semanticKey
+            : event.payload.eventId === usageIdentity)));
+}
 function observationIsStrictlyNewer(left, right) {
     return compareCanonicalObservationOrder(left, right) > 0;
 }