@zq-silk/yui 0.15.11 → 0.16.0

package/dist/controller/fileSchedulerStoreAdapter.js

@@ -1,44 +1,46 @@
 import { createHash, randomUUID } from "node:crypto";
-import { prepareMessageContinuations, interruptThenTerminalState } from "../message/messageContinuation.js";
-import { freezeRunContextSnapshot } from "../context/runContextPack.js";
-import { contextSnapshotRef } from "../context/contextSnapshot.js";
 import { isDeepStrictEqual } from "node:util";
+import { contextSnapshotRef } from "../context/contextSnapshot.js";
+import { freezeRunContextSnapshot } from "../context/runContextPack.js";
+import { settleGlobalRetryInput } from "../message/globalProviderRetry.js";
+import { interruptThenTerminalState, prepareMessageContinuations } from "../message/messageContinuation.js";
 import { assertExecutionEnvironmentCurrent } from "../runtime/executionEnvironment.js";
-import { resolveAgentHostObservation, recordAgentHostConnection, AgentHostObservationDeferred } from "./agentHostObservation.js";
+import { deferProviderRetry, providerRetryPending, recordProviderFailure } from "../runtime/providerRetry.js";
+import { AgentHostObservationDeferred, recordAgentHostConnection, resolveAgentHostObservation } from "./agentHostObservation.js";
+import { admitOwnedProviderInput, ownedProviderInput } from "./providerRetryAdmission.js";
 import { RuntimeHookRunFenceError } from "./runtimeHookRunFence.js";
-import { activeLiveRoleAgentSession, bindTaskRoleProviderRuntime, bindGlobalRoleProviderRuntime, createRoleSessionSet, recordRoleAgentSession, replaceTaskRoleAgentSession, recordTaskRoleNativeTurnBoundary, rememberRoleAgentCompletedTurn, detachRoleAgentSessionHost, updateRoleAgentSessionStatus, updateTaskRoleProviderRuntime, updateGlobalRoleProviderRuntime, selectNewTaskRoleSession, taskRoleControlTarget } from "../executor/agentExecutor.js";
-import { acceptProviderTurn, cancelQuiescentProviderInput, beginProviderTurn, createProviderRuntimeBinding, currentProviderConversation, managedProviderTurnId, clearProviderGoal, settleProviderTurnSubmission, settleProviderTurn, transferProviderAuthority, supersedeProviderConversation, updateProviderConversationRecoverability, updateProviderGoal } from "../runtime/providerRuntimeIdentity.js";
+import { appendRunInput, createRun, runPurposeAdmitsTaskState, withRunContextSnapshot } from "../agentRun/agentRun.js";
+import { createRunInput } from "../context/runInputContract.js";
+import { bindExecution, claimPending, completeProcessing, consumePendingBatch, mailboxHasWork, releaseProcessing } from "../coordination/workMailbox.js";
+import { enqueueWork, settleRoleRunDispatch as settleRoleRunDispatchMailbox } from "../coordination/workMailboxQueue.js";
+import { transportAgentResult } from "../domain/agentResultTransport.js";
 import { createTaskEvent } from "../event/taskEvent.js";
-import { operationalTaskRecords } from "../task/taskRecordRetirement.js";
-import { buildTaskWakeEnvelope } from "../context/wakeNotification.js";
-import { createTaskWake, fallbackWakeCursor, latestTaskWake, markTaskWakeConsumed } from "../scheduler/taskWake.js";
+import { activeLiveRoleAgentSession, bindGlobalRoleProviderRuntime, bindTaskRoleProviderRuntime, createRoleSessionSet, detachRoleAgentSessionHost, recordRoleAgentSession, recordTaskRoleNativeTurnBoundary, rememberRoleAgentCompletedTurn, replaceTaskRoleAgentSession, selectNewTaskRoleSession, taskRoleControlTarget, updateGlobalRoleProviderRuntime, updateRoleAgentSessionStatus, updateTaskRoleProviderRuntime } from "../executor/agentExecutor.js";
+import { effectiveLaunchWithTaskMainWorkspace, resolveEffectiveLaunch, roleSessionMayContinue, validateEffectiveLaunchSnapshot } from "../executor/effectiveLaunch.js";
 import { answerInputRequest } from "../input/inputRequest.js";
+import { createCanonicalLifecycleEvent, foldCanonicalLifecycleEvent } from "../lifecycle/canonicalLifecycleEvent.js";
+import { cancelQuiescentRoleRuns, terminalizeExactTaskRun } from "../lifecycle/exactRunTerminalization.js";
+import { markGlobalRoleMessageDelivered, markGlobalRoleMessageNotDelivered, recordTaskMessageControlOutcome } from "../message/message.js";
+import { snapshotExecutionLaneWorkspaceSync } from "../repository/executionLaneGitSnapshot.js";
 import { activeRoleAgentBinding } from "../role/role.js";
-import { effectiveLaunchWithTaskMainWorkspace, roleSessionMayContinue, resolveEffectiveLaunch, validateEffectiveLaunchSnapshot } from "../executor/effectiveLaunch.js";
 import { SYSTEM_OPERATOR_ROLE } from "../role/systemRoles.js";
-import { appendRunInput, createRun, withRunContextSnapshot, runPurposeAdmitsTaskState } from "../agentRun/agentRun.js";
-import { transportAgentResult } from "../domain/agentResultTransport.js";
-import { createRunInput } from "../context/runInputContract.js";
-import { recordTaskMessageControlOutcome, markGlobalRoleMessageDelivered, markGlobalRoleMessageNotDelivered } from "../message/message.js";
+import { standardAgentError } from "../runtime/agentError.js";
+import { recordTaskAgentError } from "./taskAgentError.js";
+import { builtinAgentDriverRegistry } from "../runtime/builtinAgentDrivers.js";
+import { RUNTIME_CLEANUP_REQUIRED_REASON, RUNTIME_HOST_DETACH_REQUIRED_REASON, RUNTIME_LIFECYCLE_OWNER, hasRuntimeCleanupObligation, hasRuntimeLifecycleWork, isRuntimeCleanupReason, runtimeCleanupDisposition, runtimeLifecycleTarget } from "../runtime/lifecycleReservation.js";
 import { classifyRuntimeProcessExit, validateRuntimeProcessExitObservation } from "../runtime/processExitObservation.js";
-import { terminalizeExactTaskRun, cancelQuiescentRoleRuns } from "../lifecycle/exactRunTerminalization.js";
-import { createCanonicalLifecycleEvent, foldCanonicalLifecycleEvent } from "../lifecycle/canonicalLifecycleEvent.js";
+import { providerContinuationKey } from "../runtime/providerContinuation.js";
+import { acceptProviderTurn, beginProviderTurn, cancelQuiescentProviderInput, clearProviderGoal, createProviderRuntimeBinding, currentProviderConversation, managedProviderTurnId, settleProviderTurn, settleProviderTurnSubmission, supersedeProviderConversation, transferProviderAuthority, updateProviderConversationRecoverability, updateProviderGoal } from "../runtime/providerRuntimeIdentity.js";
+import { projectProviderContinuations } from "../runtime/runtimeContinuationProjection.js";
+import { RUNTIME_OBSERVATION_TASK_EVENT, createRuntimeObservation, isRuntimeTokenEvidence, runtimeObservationFenceMatches, runtimeObservationFromTaskEvent, runtimeObservationRunFenceMatches, runtimeObservationTaskEventPayload } from "../runtime/runtimeObservation.js";
 import { recordLeaderFailure } from "../scheduler/leaderFailure.js";
-import { recordLeaderAttentionRequired, routeRoleEvent } from "../scheduler/operatorEvent.js";
-import { queueLeaderWakeup } from "../scheduler/wakeupQueue.js";
+import { enqueueSupervisorEvent, recordLeaderAttentionRequired, routeRoleEvent } from "../scheduler/operatorEvent.js";
+import { RUN_DIAGNOSTIC_FINISHED_EVENT, RUN_PROGRESS_EVENT, RUN_RECOVERED_EVENT, RUN_STALLED_EVENT, foldRunProgressFacts, isRoleRunStalled, latestRunDurableProgressAt, latestRunEventTime, latestStallEvidenceKey } from "../scheduler/roleRunStall.js";
+import { createTaskWake, latestTaskWake, markTaskWakeConsumed } from "../scheduler/taskWake.js";
 import { wakeReason } from "../scheduler/wakeReason.js";
-import { foldRunProgressFacts, latestRunDurableProgressAt, latestRunEventTime, latestStallEvidenceKey, isRoleRunStalled, RUN_PROGRESS_EVENT, RUN_DIAGNOSTIC_FINISHED_EVENT, RUN_RECOVERED_EVENT, RUN_STALLED_EVENT } from "../scheduler/roleRunStall.js";
+import { queueLeaderWakeup } from "../scheduler/wakeupQueue.js";
 import { pendingWakeupProjection } from "../storage/taskStore.js";
-import { projectProviderContinuations } from "../runtime/runtimeContinuationProjection.js";
-import { providerContinuationKey } from "../runtime/providerContinuation.js";
 import { formatRunReceiptId } from "../task/taskRecordReference.js";
-import { bindExecution, claimPending, completeProcessing, consumePendingBatch, mailboxHasWork, releaseProcessing } from "../coordination/workMailbox.js";
-import { enqueueWork, settleRoleRunDispatch as settleRoleRunDispatchMailbox } from "../coordination/workMailboxQueue.js";
-import { RUNTIME_CLEANUP_REQUIRED_REASON, RUNTIME_HOST_DETACH_REQUIRED_REASON, RUNTIME_LIFECYCLE_OWNER, hasRuntimeCleanupObligation, hasRuntimeLifecycleWork, isRuntimeCleanupReason, runtimeCleanupDisposition, runtimeLifecycleTarget } from "../runtime/lifecycleReservation.js";
-import { builtinAgentDriverRegistry } from "../runtime/builtinAgentDrivers.js";
-import { standardAgentError } from "../runtime/agentError.js";
-import { RUNTIME_OBSERVATION_TASK_EVENT, createRuntimeObservation, isRuntimeTokenEvidence, runtimeObservationFenceMatches, runtimeObservationFromTaskEvent, runtimeObservationRunFenceMatches, runtimeObservationTaskEventPayload } from "../runtime/runtimeObservation.js";
-import { snapshotExecutionLaneWorkspaceSync } from "../repository/executionLaneGitSnapshot.js";
 export class AgentHostProviderTurnFenceError extends Error {
     constructor(message) {
         super(message);
@@ -404,7 +406,9 @@ export class FileSchedulerStoreAdapter {
                 }
                 else if (binding.run?.status !== "accepted")
                     return "applied";
-                const message = store.listGlobalRoleMessages(fence.roleName).find(entry => receipt === `global-input:${fence.roleName}/${entry.id}`);
+                const message = store.listGlobalRoleMessages(fence.roleName).find(entry => receipt === `global-input:${fence.roleName}/${entry.id}`
+                    || binding?.retry?.currentAttemptId === receipt && binding.retry.input.kind === "message"
+                        && binding.retry.input.messageId === entry.id);
                 if (message !== undefined)
                     store.updateGlobalRoleMessage(markGlobalRoleMessageDelivered(message, new Date(at)));
             }
@@ -417,7 +421,9 @@ export class FileSchedulerStoreAdapter {
                 if (input.kind === "turn.completed" && binding.run != null
                     && ["submitting", "delivery-unknown"].includes(binding.run.status)) {
                     binding = acceptProviderTurn(binding, { attemptId: receipt, nativeTurnId: fence.nativeTurnId, acceptedAt: at });
-                    const message = store.listGlobalRoleMessages(fence.roleName).find(entry => receipt === `global-input:${fence.roleName}/${entry.id}`);
+                    const message = store.listGlobalRoleMessages(fence.roleName).find(entry => receipt === `global-input:${fence.roleName}/${entry.id}`
+                        || binding?.retry?.currentAttemptId === receipt && binding.retry.input.kind === "message"
+                            && binding.retry.input.messageId === entry.id);
                     if (message !== undefined)
                         store.updateGlobalRoleMessage(markGlobalRoleMessageDelivered(message, new Date(at)));
                 }
@@ -449,7 +455,13 @@ export class FileSchedulerStoreAdapter {
             else if (input.kind === "conversation.observed" && input.payload.recoverability !== undefined) {
                 binding = updateProviderConversationRecoverability(binding, input.payload.recoverability);
             }
+            if (input.kind === "turn.failed" && matches && input.payload.failure !== undefined) {
+                binding = recordProviderFailure(binding, {
+                    error: input.payload.failure.error, failureRef: input.eventId, at: now.getTime()
+                });
+            }
             store.saveGlobalRoleSessionSet(updateGlobalRoleProviderRuntime(sessions, binding, now));
+            settleGlobalRetryInput(store, fence.roleName, binding, now);
             return "applied";
         });
     }
@@ -727,31 +739,25 @@ export class FileSchedulerStoreAdapter {
                 const run = input.fence.runId === undefined
                     ? null
                     : store.getRun(taskId, input.fence.runId);
-                const errorEvent = createTaskEvent(store.nextEventId(taskId), taskId, "runtime.agent-error", {
-                    sourceEventId: input.eventId,
-                    observationEventId,
-                    runId: input.fence.runId ?? "",
-                    roleName: input.fence.roleName,
-                    agentId: input.fence.agentId,
-                    adapterId: run?.effective.adapterId ?? "unknown",
-                    driverId: input.fence.driverId,
-                    nativeSessionId: input.fence.nativeSessionId ?? "",
-                    nativeTurnId: input.fence.nativeTurnId ?? "",
-                    source: error.source,
-                    phase: error.phase,
-                    category: error.category,
-                    code: error.code,
-                    message: error.message,
-                    raw: error.raw,
-                    inputDisposition: error.inputDisposition,
-                    sessionDisposition: error.sessionDisposition,
-                    ...(error.retryAfterMs === undefined
-                        ? {}
-                        : { retryAfterMs: String(error.retryAfterMs) }),
-                    ...(failure.lastOutput === undefined ? {} : { lastOutput: failure.lastOutput })
+                const errorSessions = store.getTaskRoleSessionSet(taskId, input.fence.roleName);
+                const errorSession = [...Object.values(errorSessions?.sessions ?? {}), ...(errorSessions?.history ?? [])]
+                    .find(session => session.nativeSessionId === input.fence.nativeSessionId
+                    && session.agentId === input.fence.agentId);
+                const effective = run?.effective ?? errorSession?.effective;
+                const { event: errorEvent, created } = recordTaskAgentError(store, {
+                    taskId, roleName: input.fence.roleName, sourceEventId: input.eventId,
+                    agentId: input.fence.agentId, adapterId: effective?.adapterId ?? "unknown",
+                    driverId: input.fence.driverId, error, effective,
+                    evidence: {
+                        observationEventId,
+                        runId: input.fence.runId,
+                        nativeSessionId: input.fence.nativeSessionId,
+                        nativeTurnId: input.fence.nativeTurnId,
+                        lastOutput: failure.lastOutput
+                    },
                 }, now);
-                store.saveEvent(taskId, errorEvent);
-                routeRoleEvent(store, errorEvent, input.fence.roleName, wakeReason("agent-error", errorEvent.id), now);
+                if (created && !providerRetryPending(store.getTaskRoleSessionSet(taskId, input.fence.roleName)?.providerBinding))
+                    routeRoleEvent(store, errorEvent, input.fence.roleName, wakeReason("agent-error", errorEvent.id), now);
             }
             if ((input.kind === "operation.completed" || input.kind === "operation.failed")
                 && input.payload.operation === "subagent") {
@@ -841,29 +847,6 @@ export class FileSchedulerStoreAdapter {
     getTaskBrief(taskId) { return this.store.getTaskBrief(taskId); }
     listDecisions(taskId) { return this.store.listDecisions(taskId); }
     listMilestones(taskId) { return this.store.listMilestones(taskId); }
-    getTaskWakeEnvelope(taskId) {
-        return this.store.transaction((reader) => {
-            const pending = reader.getPendingWakeup(taskId);
-            if (pending === null)
-                return null;
-            const task = reader.getTask(taskId);
-            if (task === null)
-                return null;
-            const latest = latestTaskWake(reader.listTaskWakes(taskId));
-            const fromCursor = latest?.toCursor ?? fallbackWakeCursor({
-                taskCreatedAt: task.createdAt,
-                leaderRunCreatedAt: operationalTaskRecords(reader.listRuns(taskId), reader.listEvents(taskId), "run")
-                    .filter((run) => run.roleName === "leader")
-                    .at(-1)?.createdAt
-            });
-            return buildTaskWakeEnvelope(reader, {
-                taskId,
-                wakeId: reader.peekNextTaskWakeId(taskId),
-                reasons: pending.reasons,
-                fromCursor
-            });
-        });
-    }
     listRoles(taskId) {
         return this.store.listRoles(taskId).map((role) => mapRole(this.store, role));
     }
@@ -1092,7 +1075,7 @@ export class FileSchedulerStoreAdapter {
                     throw new AgentHostProviderTurnFenceError("Global Session admission is stopped.");
                 }
                 const sessions = store.getGlobalRoleSessionSet(input.roleName);
-                const binding = sessions?.providerBinding;
+                let binding = sessions?.providerBinding;
                 const session = sessions?.sessions[input.agentId];
                 if (sessions === null || binding == null || session === undefined
                     || sessions.activeAgentId !== input.agentId || session.status !== "active"
@@ -1104,8 +1087,10 @@ export class FileSchedulerStoreAdapter {
                     throw new AgentHostProviderTurnFenceError("Global input carries a stale Session or writer fence.");
                 }
                 const turn = binding.run;
-                if (turn?.attemptId === input.attemptId && turn.status === "submitting")
+                if (turn?.attemptId === input.attemptId && turn.status === "submitting") {
+                    admitOwnedProviderInput(store, binding, input);
                     return;
+                }
                 if (turn != null && ["submitting", "accepted", "delivery-unknown"].includes(turn.status)) {
                     throw new AgentHostProviderSessionBusyError("Global Conversation has an unsettled input.");
                 }
@@ -1139,7 +1124,10 @@ export class FileSchedulerStoreAdapter {
                             receiptId: input.attemptId, outcome: "pending", observedAt: input.now.toISOString()
                         } });
                 }
+                binding = admitOwnedProviderInput(store, binding, input);
                 store.saveGlobalRoleSessionSet(updateGlobalRoleProviderRuntime(sessions, beginProviderTurn(binding, { attemptId: input.attemptId,
+                    input: binding.retry?.currentAttemptId === input.attemptId ? binding.retry.input : ownedProviderInput(input),
+                    retrySupported: input.retrySupported,
                     authorityEpoch: input.authorityEpoch, submittedAt: input.now.toISOString() }), input.now));
             });
             return;
@@ -1157,7 +1145,7 @@ export class FileSchedulerStoreAdapter {
             }
             const sessions = store.getTaskRoleSessionSet(input.taskId, input.roleName);
             const session = sessions?.sessions[input.agentId];
-            const binding = sessions?.providerBinding;
+            let binding = sessions?.providerBinding;
             const active = store.getActiveRun(input.taskId, input.roleName);
             if (sessions === null || sessions === undefined || binding === null || binding === undefined || (input.runId !== undefined && (active?.id !== input.runId || active.effective.agentId !== input.agentId)) || session === undefined || session.nativeSessionId !== input.nativeSessionId || currentProviderConversation(binding).conversationId !== input.nativeSessionId || binding.authority.owner !== input.authorityOwner || binding.authority.epoch !== input.authorityEpoch || binding.authority.holderId !== input.holderId) {
                 throw new AgentHostProviderTurnFenceError("Agent Host Provider Turn carries a stale durable writer fence. Release and reacquire Provider authority before retrying input.");
@@ -1214,11 +1202,14 @@ export class FileSchedulerStoreAdapter {
                     }
                 }
             }
+            binding = admitOwnedProviderInput(store, binding, input);
             store.saveTaskRoleSessionSet(updateTaskRoleProviderRuntime(sessions, beginProviderTurn(binding, {
                 ...(input.runId === undefined ? {} : { runId: input.runId }),
                 attemptId: input.attemptId,
                 authorityEpoch: input.authorityEpoch,
-                submittedAt: input.now.toISOString()
+                submittedAt: input.now.toISOString(),
+                input: binding.retry?.currentAttemptId === input.attemptId ? binding.retry.input : ownedProviderInput(input),
+                retrySupported: input.retrySupported
             }), input.now));
         });
     }
@@ -1230,8 +1221,11 @@ export class FileSchedulerStoreAdapter {
                 if (input.runId !== undefined || sessions == null || binding?.run?.attemptId !== input.attemptId) {
                     throw new Error("Global input submission is no longer current.");
                 }
-                store.saveGlobalRoleSessionSet(updateGlobalRoleProviderRuntime(sessions, settleProviderTurnSubmission(binding, { attemptId: input.attemptId, status: input.status,
-                    reason: input.reason, resolvedAt: input.now.toISOString() }), input.now));
+                let resolved = settleProviderTurnSubmission(binding, { attemptId: input.attemptId, status: input.status,
+                    reason: input.reason, resolvedAt: input.now.toISOString() });
+                resolved = this.retrySubmissionResolution(resolved, input, sessions.sessions[sessions.activeAgentId]?.adapterId);
+                store.saveGlobalRoleSessionSet(updateGlobalRoleProviderRuntime(sessions, resolved, input.now));
+                settleGlobalRetryInput(store, input.roleName, resolved, input.now);
                 const message = store.listGlobalRoleMessages(input.roleName).find(entry => input.attemptId === `global-input:${input.roleName}/${entry.id}`);
                 if (message !== undefined && message.delivery?.via !== "provider") {
                     const outcome = input.status === "delivery-unknown" ? "delivery-unknown" : "rejected";
@@ -1239,7 +1233,7 @@ export class FileSchedulerStoreAdapter {
                             requestId: message.inputControl?.requestId ?? message.interruptThen.requestId,
                             receiptId: input.attemptId, outcome, observedAt: input.now.toISOString()
                         } };
-                    store.updateGlobalRoleMessage(input.status === "rejected" && updated.delivery === undefined
+                    store.updateGlobalRoleMessage(input.status === "rejected" && updated.delivery === undefined && !providerRetryPending(resolved)
                         ? markGlobalRoleMessageNotDelivered(updated, input.reason, input.now) : updated);
                 }
             });
@@ -1257,20 +1251,18 @@ export class FileSchedulerStoreAdapter {
                 || binding.run?.attemptId !== input.attemptId) {
                 throw new Error("Agent Host Provider Turn submission is no longer current.");
             }
-            const updated = settleProviderTurnSubmission(binding, {
+            let updated = settleProviderTurnSubmission(binding, {
                 attemptId: input.attemptId,
                 status: input.status,
                 reason: input.reason,
                 resolvedAt: input.now.toISOString()
             });
+            updated = this.retrySubmissionResolution(updated, input, sessions.sessions[sessions.activeAgentId]?.adapterId);
             store.saveTaskRoleSessionSet(updateTaskRoleProviderRuntime(sessions, updated, input.now));
-            if (input.runId === undefined)
-                return;
-            const run = store.getRun(input.taskId, input.runId);
+            const run = input.runId === undefined ? null : store.getRun(input.taskId, input.runId);
             const session = sessions.sessions[sessions.activeAgentId];
-            const driver = run === null
-                ? null
-                : this.drivers.findByAdapterId(run.effective.adapterId);
+            const adapterId = run?.effective.adapterId ?? session?.adapterId;
+            const driver = adapterId === undefined ? null : this.drivers.findByAdapterId(adapterId);
             const error = standardAgentError({
                 source: "driver",
                 phase: "turn-submit",
@@ -1282,41 +1274,46 @@ export class FileSchedulerStoreAdapter {
                 raw: input.raw,
                 inputDisposition: input.status === "delivery-unknown" ? "unknown" : "not-accepted"
             });
-            const errorEvent = createTaskEvent(store.nextEventId(input.taskId), input.taskId, "runtime.agent-error", {
-                sourceEventId: input.attemptId,
-                runId: input.runId,
-                roleName: input.roleName,
+            const { event: errorEvent, created } = recordTaskAgentError(store, {
+                taskId: input.taskId, roleName: input.roleName, sourceEventId: input.attemptId,
                 agentId: run?.effective.agentId ?? sessions.activeAgentId,
-                adapterId: run?.effective.adapterId ?? session?.adapterId ?? "unknown",
-                driverId: driver?.id ?? "unknown",
-                // No native Turn exists at submission resolution, and the Session
-                // facts may be absent. An unknown fact is an absent key: an empty
-                // string reads back as a real value and cannot be told apart from
-                // one the Provider genuinely reported.
-                ...optionalEventFields({
+                adapterId: adapterId ?? "unknown", driverId: driver?.id ?? "unknown",
+                error, effective: run?.effective ?? session?.effective,
+                evidence: {
+                    attemptId: input.attemptId,
+                    runId: input.runId,
                     nativeSessionId: session?.nativeSessionId
-                }),
-                source: error.source,
-                phase: error.phase,
-                category: error.category,
-                code: error.code,
-                message: error.message,
-                raw: error.raw,
-                inputDisposition: error.inputDisposition,
-                sessionDisposition: error.sessionDisposition
+                }
             }, input.now);
-            store.saveEvent(input.taskId, errorEvent);
-            if (input.status === "deferred")
+            if (!created || input.status === "deferred" || providerRetryPending(updated))
                 return;
-            const route = input.roleName === "leader"
-                ? { kind: "operator" }
-                : { kind: "role", taskId: input.taskId, roleName: "leader" };
-            enqueueWork(store, route, input.roleName === "leader"
+            enqueueSupervisorEvent(store, errorEvent, input.roleName === "leader" ? "operator" : "leader", input.roleName === "leader"
                 ? "leader-turn-submission-error"
-                : wakeReason("agent-error", errorEvent.id), input.now, [{ type: "event", taskId: input.taskId, id: errorEvent.id }], {
-                source: driver?.id ?? "agent-host",
-                dedupeKey: `agent-error:${input.taskId}:${input.attemptId}`
-            });
+                : wakeReason("agent-error", errorEvent.id), input.now);
+        });
+    }
+    retrySubmissionResolution(binding, input, adapterId) {
+        if (input.status === "deferred")
+            return deferProviderRetry(binding, input.now.getTime());
+        const driver = adapterId === undefined ? null : this.drivers.findByAdapterId(adapterId);
+        const classification = driver?.runtime.mapError({ message: input.reason, raw: input.raw });
+        const error = standardAgentError({
+            source: "driver", phase: "turn-submit", classification,
+            message: input.reason, raw: input.raw,
+            inputDisposition: input.status === "delivery-unknown" ? "unknown" : "not-accepted"
+        });
+        // Native preflight issued no mutation. Transient metadata failures may
+        // cool down within the same deadline; unavailable proof needs an Agent.
+        const noProviderWrite = input.status === "rejected" && input.noProviderWrite === true;
+        if (noProviderWrite && classification?.retryable !== true) {
+            const recorded = binding.run === null ? binding : {
+                ...binding, run: { ...binding.run, failure: { error, ref: input.attemptId } }
+            };
+            return deferProviderRetry(recorded, input.now.getTime(), input.reason);
+        }
+        return recordProviderFailure(binding, {
+            error,
+            failureRef: input.attemptId, at: input.now.getTime(), noProviderWrite
         });
     }
     getProviderAuthorityFence(input) {
@@ -1356,15 +1353,19 @@ export class FileSchedulerStoreAdapter {
     }
     recordAgentError(input, now) {
         return this.store.transaction((store) => {
-            const run = store.getRun(input.taskId, input.runId);
+            if (input.runId === undefined && input.attemptId === undefined) {
+                throw new Error("An Agent error needs an exact Run or notification attempt.");
+            }
+            const run = input.runId === undefined ? null : store.getRun(input.taskId, input.runId);
             const sessionSet = store.getTaskRoleSessionSet(input.taskId, input.roleName);
-            const sessionAgentId = run?.effective.agentId ?? sessionSet?.activeAgentId;
+            const effective = input.effective ?? run?.effective;
+            const sessionAgentId = effective?.agentId ?? sessionSet?.activeAgentId;
             const session = sessionAgentId === undefined
                 ? undefined
                 : sessionSet?.sessions[sessionAgentId];
-            const driver = run === null
+            const driver = effective === undefined
                 ? null
-                : this.drivers.findByAdapterId(run.effective.adapterId);
+                : this.drivers.findByAdapterId(effective.adapterId);
             const error = standardAgentError({
                 source: input.source,
                 phase: input.phase,
@@ -1381,57 +1382,22 @@ export class FileSchedulerStoreAdapter {
                     ? {}
                     : { sessionDisposition: input.sessionDisposition })
             });
-            const duplicate = [...store.listEvents(input.taskId)].reverse().find((event) => (event.type === "runtime.agent-error"
-                && event.payload.runId === input.runId
-                && event.payload.roleName === input.roleName
-                && event.payload.phase === input.phase
-                && event.payload.attemptId === input.attemptId
-                && event.payload.source === error.source
-                && event.payload.inputDisposition === error.inputDisposition
-                && event.payload.sessionDisposition === error.sessionDisposition
-                && event.payload.registrationDisposition === input.registrationDisposition
-                && event.payload.hostState === input.hostState
-                && (input.attemptId === undefined
-                    ? event.payload.raw === error.raw
-                    : event.payload.message === error.message
-                        && event.payload.errorName === input.errorName
-                        && event.payload.causeName === input.causeName)));
-            // Re-reading one failed attempt may add a different caller stack, not a
-            // new execution fact. Preserve its first full cause without multiplying
-            // notifications; changed disposition/identity/diagnostic remains visible.
-            if (duplicate !== undefined)
-                return duplicate.id;
-            const event = createTaskEvent(store.nextEventId(input.taskId), input.taskId, "runtime.agent-error", {
-                sourceEventId: `${input.runId}:${input.phase}${input.attemptId === undefined ? "" : `:${input.attemptId}`}`,
-                runId: input.runId,
-                roleName: input.roleName,
-                agentId: run?.effective.agentId ?? session?.agentId ?? "unknown",
-                adapterId: run?.effective.adapterId ?? session?.adapterId ?? "unknown",
-                driverId: driver?.id ?? "unknown",
-                source: error.source,
-                phase: error.phase,
-                category: error.category,
-                code: error.code,
-                message: error.message,
-                raw: error.raw,
-                inputDisposition: error.inputDisposition,
-                sessionDisposition: error.sessionDisposition,
-                // Structured facts from the failing operation. Absent keys stay
-                // absent rather than becoming an empty string, so a reader can tell
-                // "the Host did not report this" from "the Host reported nothing".
-                // The Session identities follow the same rule: this failure can
-                // happen before any Session record exists, and there is no native
-                // AgentRun to name at all.
-                ...optionalEventFields({
-                    nativeSessionId: session?.nativeSessionId,
-                    errorName: input.errorName,
-                    causeName: input.causeName,
-                    hostState: input.hostState,
-                    attemptId: input.attemptId,
+            const { event, created } = recordTaskAgentError(store, {
+                taskId: input.taskId, roleName: input.roleName,
+                sourceEventId: `${input.runId ?? input.attemptId}:${input.phase}${input.runId === undefined || input.attemptId === undefined ? "" : `:${input.attemptId}`}`,
+                agentId: effective?.agentId ?? session?.agentId ?? "unknown",
+                adapterId: effective?.adapterId ?? session?.adapterId ?? "unknown",
+                driverId: driver?.id ?? "unknown", error, effective,
+                evidence: {
+                    runId: input.runId, attemptId: input.attemptId, nativeSessionId: session?.nativeSessionId,
+                    errorName: input.errorName, causeName: input.causeName, hostState: input.hostState,
                     registrationDisposition: input.registrationDisposition
-                })
+                }
             }, now);
-            store.saveEvent(input.taskId, event);
+            if (!created)
+                return event.id;
+            if (store.getTask(input.taskId)?.status === "archived")
+                return event.id;
             if (input.phase === "turn-submit" && error.inputDisposition === "unknown"
                 && input.attemptId !== undefined && sessionSet?.providerBinding?.run?.attemptId === input.attemptId
                 && sessionSet.providerBinding.run.status === "submitting") {
@@ -1445,18 +1411,7 @@ export class FileSchedulerStoreAdapter {
                 return event.id;
             const leaderCannotReceive = input.roleName === "leader"
                 && ["host-start", "session-start", "session-restore", "turn-submit"].includes(input.phase);
-            if (!leaderCannotReceive) {
-                enqueueWork(store, { kind: "role", taskId: input.taskId, roleName: "leader" }, wakeReason("agent-error", event.id), now, [{ type: "event", taskId: input.taskId, id: event.id }], {
-                    source: driver?.id ?? input.source,
-                    dedupeKey: `agent-error:${input.taskId}:${input.runId}:${input.phase}:${event.id}`
-                });
-            }
-            if (leaderCannotReceive) {
-                enqueueWork(store, { kind: "operator" }, "leader-agent-error", now, [{ type: "event", taskId: input.taskId, id: event.id }], {
-                    source: driver?.id ?? input.source,
-                    dedupeKey: `leader-agent-error:${input.taskId}:${input.runId}:${event.id}`
-                });
-            }
+            enqueueSupervisorEvent(store, event, leaderCannotReceive ? "operator" : "leader", leaderCannotReceive ? "leader-agent-error" : wakeReason("agent-error", event.id), now);
             return event.id;
         });
     }
@@ -1750,6 +1705,13 @@ export class FileSchedulerStoreAdapter {
             const task = store.getTask(taskId);
             if (task == null || !["active", "draft"].includes(task.status) || task.executionGate.state !== "enabled")
                 return null;
+            // Admission refuses input while this Session is being cleaned up.
+            // Leave the original batch pending for its successor instead of
+            // claiming a notification that cannot legally reach the Provider.
+            if (hasRuntimeCleanupObligation(store.getWorkMailbox(runtimeLifecycleTarget({
+                scope: "task", taskId, roleName: "leader"
+            }))))
+                return null;
             const target = { kind: "role", taskId, roleName: "leader" };
             let mailbox = store.getWorkMailbox(target);
             if (mailbox === null)
@@ -1775,8 +1737,10 @@ export class FileSchedulerStoreAdapter {
                     return null;
                 }
                 if (native?.status === "rejected" || previous?.payload.outcome === "rejected") {
-                    this.settleLeaderNotification(taskId, attemptId, "rejected", now);
-                    return null;
+                    if (previous?.payload.outcome !== "rejected") {
+                        this.settleLeaderNotification(taskId, attemptId, "rejected", now);
+                    }
+                    return { wakeId, attemptId, disposition: "rejected" };
                 }
                 if (native?.status === "submitting")
                     return { wakeId, attemptId, disposition: "pending" };
@@ -1851,7 +1815,7 @@ export class FileSchedulerStoreAdapter {
             return { wakeId, attemptId, disposition: "submit" };
         });
     }
-    settleLeaderNotification(taskId, attemptId, outcome, now, detail) {
+    settleLeaderNotification(taskId, attemptId, outcome, now, detail, failure) {
         this.store.transaction((store) => {
             const target = { kind: "role", taskId, roleName: "leader" };
             const mailbox = store.getWorkMailbox(target);
@@ -1861,19 +1825,35 @@ export class FileSchedulerStoreAdapter {
                 return;
             if (!store.listEvents(taskId).some((event) => event.type === "notification.delivery"
                 && event.payload.attemptId === attemptId && event.payload.outcome === outcome)) {
-                store.saveEvent(taskId, createTaskEvent(store.nextEventId(taskId), taskId, "notification.delivery", { attemptId, outcome, ...(detail === undefined ? {} : { detail }) }, now));
+                // Native ingress may already have persisted the same rejection. Reuse
+                // that original failure rather than reporting it twice from the caller.
+                const existing = store.listEventsByType(taskId, ["runtime.agent-error"])
+                    .find(event => event.payload.roleName === "leader"
+                    && (event.payload.attemptId === attemptId || event.payload.sourceEventId === attemptId));
+                const errorEventId = existing?.id ?? (failure !== undefined
+                    && (outcome === "rejected" || outcome === "unknown")
+                    ? this.recordAgentError({
+                        taskId, roleName: "leader", attemptId, effective: failure.effective,
+                        source: "host", phase: failure.phase,
+                        message: detail ?? `Notification ${outcome}.`, raw: failure.raw,
+                        inputDisposition: outcome === "unknown" ? "unknown" : "not-accepted",
+                        ...(failure.phase === "session-start" ? { registrationDisposition: "not-committed" } : {})
+                    }, now) : undefined);
+                store.saveEvent(taskId, createTaskEvent(store.nextEventId(taskId), taskId, "notification.delivery", { attemptId, outcome, ...(detail === undefined ? {} : { detail }),
+                    ...(errorEventId === undefined ? {} : { errorEventId }) }, now));
             }
             if (store.getTask(taskId)?.status === "archived")
                 return;
-            if (outcome !== "accepted" && outcome !== "rejected")
+            // Rejection proves nondelivery, not consumption of the original input.
+            // Keep the exact claim as the existing recovery/completion boundary.
+            // An explicit retry or Session replacement can release it later.
+            if (outcome !== "accepted")
                 return;
             store.saveWorkMailbox(completeProcessing(mailbox, attemptId));
-            if (outcome === "accepted") {
-                const wakeId = processing.owner.slice("leader-notification:".length);
-                const wake = store.listTaskWakes(taskId).find((entry) => entry.id === wakeId);
-                if (wake !== undefined)
-                    store.saveTaskWake(taskId, markTaskWakeConsumed(wake, now));
-            }
+            const wakeId = processing.owner.slice("leader-notification:".length);
+            const wake = store.listTaskWakes(taskId).find((entry) => entry.id === wakeId);
+            if (wake !== undefined)
+                store.saveTaskWake(taskId, markTaskWakeConsumed(wake, now));
         });
     }
     saveRoleRunPrepared(input) {
@@ -2085,12 +2065,6 @@ export class FileSchedulerStoreAdapter {
             let sessions = store.getTaskRoleSessionSet(input.taskId, input.roleName)
                 ?? createRoleSessionSet({ scope: "task", taskId: input.taskId, roleName: input.roleName }, input.agentId, now);
             const canonicalRunId = input.nativeTurnId ?? resolved.nativeTurnId;
-            const existing = sessions.sessions[input.agentId];
-            const owner = {
-                scope: "task",
-                taskId: input.taskId,
-                roleName: input.roleName
-            };
             assertConsistentTerminal(store, input, observedRun);
             // A historical operation failure stays failed. The immutable terminal
             // observation retains the late report for explicit Leader adoption.
@@ -2140,6 +2114,12 @@ export class FileSchedulerStoreAdapter {
                 && sessions.providerBinding !== null) {
                 sessions = updateTaskRoleProviderRuntime(sessions, updateProviderConversationRecoverability(sessions.providerBinding, "unrecoverable"), now);
             }
+            if (input.observation?.kind === "turn.failed" && input.observation.payload.failure !== undefined
+                && sessions.providerBinding !== null) {
+                sessions = updateTaskRoleProviderRuntime(sessions, recordProviderFailure(sessions.providerBinding, {
+                    error: input.observation.payload.failure.error, failureRef: input.observation.eventId, at: now.getTime()
+                }), now);
+            }
             store.saveTaskRoleSessionSet(sessions);
             let terminalRun;
             if (recordedProviderTurn && observedRun?.status === "active") {
@@ -2482,6 +2462,14 @@ export class FileSchedulerStoreAdapter {
                         return "obsolete";
                     }
                     store.saveTaskRoleSessionSet(recordStructuredProviderAcceptance(sessions, input, now));
+                    const retry = binding.retry;
+                    if (retry?.currentAttemptId === ordinaryAttemptId && retry.input.kind === "wake") {
+                        const originalWakeId = retry.input.wakeId;
+                        const original = store.listTaskWakes(input.fence.taskId).find(w => w.id === originalWakeId);
+                        if (original !== undefined && original.status !== "consumed") {
+                            store.saveTaskWake(input.fence.taskId, markTaskWakeConsumed(original, now));
+                        }
+                    }
                     return "applied";
                 }
             }
@@ -3149,28 +3137,6 @@ function requireRole(store, taskId, roleName) {
         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}`,
-        component: run.effective.component,
-        effectiveRevision: String(run.effective.sourceDesiredRevision),
-        profileAccess: run.effective.profileAccess,
-        effectivePermission: run.effective.permission.strategy,
-        writeProjectIds: run.effective.writeProjectIds.join(",") || "none"
-    };
-}
-/**
- * Keeps only the fields the caller actually knew. Event payloads are a
- * string map, so an unknown fact has to be an absent key: writing `""` would
- * claim the Host reported an empty value.
- */
-function optionalEventFields(fields) {
-    return Object.fromEntries(Object.entries(fields).filter((entry) => typeof entry[1] === "string" && entry[1].trim().length > 0));
-}
 function runtimeObservationTelemetryEntry(input) {
     return {
         taskId: input.fence.taskId,