@zq-silk/yui 0.15.12 → 0.16.0

package/dist/controller/clientRuntime.js

@@ -2,18 +2,18 @@ import { spawn } from "node:child_process";
 import { fileURLToPath } from "node:url";
 import { findLiveControllerProcessForHome, inspectLiveControllerProcess } from "../core/controllerProcessIdentity.js";
 import { readHomeFilesystemId } from "../core/homeFilesystemIdentity.js";
+import { AGENT_OPERATIONAL_ENVIRONMENT_NAMES, nativeAgentEnvironmentNames, operationalAgentEnvironment, selectEnvironment, YUI_MANAGED_RUNTIME_ENVIRONMENT_NAMES } from "../agent/launchEnvironment.js";
 import { callController, ControllerClientError, readControllerDiscovery, stopOrphanedFileTaskController } from "../core/controllerClient.js";
 import { FILE_TASK_CONTROLLER_PROTOCOL_VERSION } from "../core/protocol.js";
-import { AGENT_OPERATIONAL_ENVIRONMENT_NAMES, nativeAgentEnvironmentNames, operationalAgentEnvironment, selectEnvironment, YUI_MANAGED_RUNTIME_ENVIRONMENT_NAMES } from "../agent/launchEnvironment.js";
-import { openCurrentTaskStore } from "../storage/currentTaskStore.js";
+import { isForeignHandoverLockHeld } from "../release/runtimeRelease.js";
+import { WorkspaceCleanupBlockedError } from "../repository/taskWorkspacePreparer.js";
 import { hasRuntimeLifecycleWork } from "../runtime/lifecycleReservation.js";
 import { assertControllerStatusIdentity } from "../runtime/runtimeCoherence.js";
-import { EPHEMERAL_DOMAIN_ENVIRONMENT_NAMES } from "./domainIdentity.js";
+import { CONTROLLER_SHUTDOWN_TIMEOUT_MS, LIFECYCLE_REQUEST_TIMEOUT_MS } from "../runtime/runtimeDeadlines.js";
+import { openCurrentTaskStore } from "../storage/currentTaskStore.js";
 import { yuiVersionIdentity } from "../version.js";
+import { EPHEMERAL_DOMAIN_ENVIRONMENT_NAMES } from "./domainIdentity.js";
 import { SessionOwnerReconciliation } from "./sessionOwnerReconciliation.js";
-import { WorkspaceCleanupBlockedError } from "../repository/taskWorkspacePreparer.js";
-import { CONTROLLER_SHUTDOWN_TIMEOUT_MS, LIFECYCLE_REQUEST_TIMEOUT_MS } from "../runtime/runtimeDeadlines.js";
-import { isForeignHandoverLockHeld } from "../release/runtimeRelease.js";
 const STARTUP_TIMEOUT_MS = 5_000;
 const POLL_INTERVAL_MS = 50;
 const ENVIRONMENT_REFRESH_TIMEOUT_MS = 500;
@@ -166,7 +166,7 @@ function assertCompatibleControllerStatus(status, expectedVersion) {
         });
     }
 }
-function spawnDetachedFileTaskController(home, environment) {
+function spawnDetachedFileTaskController(_home, environment) {
     const child = spawn(process.execPath, [fileURLToPath(new URL("./controllerMain.js", import.meta.url))], {
         env: environment,
         detached: true,
@@ -439,9 +439,6 @@ export class FileTaskWorkflowRuntime {
         this.workspacePreparer = workspacePreparer;
         this.clientOptions = clientOptions;
     }
-    notifyStateChanged(taskId) {
-        void this.notifyMailboxChanged({ kind: "task", taskId });
-    }
     notifyMailboxChanged(target) {
         const pending = callFileTaskController(this.home, "scheduler.signal", { key: controllerMailboxKey(target) }, this.clientOptions).then(() => { });
         void pending.catch(this.clientOptions.onError ?? (() => { }));
@@ -577,6 +574,17 @@ export class FileTaskWorkflowRuntime {
             + blockers.map((entry) => (`${entry.owner.roleName}/${entry.nativeSessionId ?? "unknown-session"}`
                 + ` (pid ${entry.physical?.alive === true ? entry.physical.pid : "?"})`)).join("; "));
     }
+    /** Archive cleanup is stronger than a read-only proof that no process is live. */
+    async releaseTaskTerminals(taskId) {
+        await this.assertTaskPhysicalResourcesReleased(taskId);
+        // A Home's server is shared with other Tasks and the Operator. Remove only
+        // this Task's session group; exited panes still own scrollback memory.
+        await this.tmux.stopTaskAsync(taskId);
+        const remaining = this.tmux.inspectTaskRolePanes(taskId);
+        if (remaining.length > 0) {
+            throw new WorkspaceCleanupBlockedError("physical-resource-live", `task:${taskId}`, true, `Task terminals remain after cleanup: ${remaining.map(pane => pane.roleName).join(", ")}.`);
+        }
+    }
     async stopGlobalRoleSession(roleName) {
         if (this.store.getGlobalRole(roleName) === null) {
             throw new Error(`Global Role not found: ${roleName}.`);
@@ -678,11 +686,11 @@ function runtimeOwnerLabel(owner) {
 }
 const MANAGED_RUNTIME_ENVIRONMENT = new Set(YUI_MANAGED_RUNTIME_ENVIRONMENT_NAMES);
 function foregroundGlobalRoleEnvironment(store, roleName, source) {
-    const role = store.getGlobalRole?.(roleName);
-    if (role === null || role === undefined)
+    const role = store.getGlobalRole(roleName);
+    if (role === null)
         return undefined;
-    const agent = store.getConfiguredAgent?.(role.activeAgentId);
-    if (agent === null || agent === undefined)
+    const agent = store.getConfiguredAgent(role.activeAgentId);
+    if (agent === null)
         return undefined;
     const declaredSources = new Set(agent.environment.map((binding) => binding.sourceName));
     for (const name of MANAGED_RUNTIME_ENVIRONMENT)

package/dist/controller/controller.js

@@ -16,7 +16,6 @@ import { nearestDeadlineBatch } from "../coordination/deadlineScheduler.js";
 import { mailboxHasWork, nextPendingBatch } from "../coordination/workMailbox.js";
 import { hasRuntimeCleanupObligation } from "../runtime/lifecycleReservation.js";
 import { formatTaskRecordReference } from "../task/taskRecordReference.js";
-import { activationRequestIsControllerAdoptable } from "../task/taskActivation.js";
 import { parseDurableJobAcknowledgeParams, parseDurableJobCancelParams, parseDurableJobRefParams, parseDurableJobStartParams } from "./jobControl.js";
 const DEFAULT_RECONCILIATION_INTERVAL_MS = reconciliationIntervalMilliseconds();
 const DEFAULT_SIGNAL_WINDOW_MS = 100;
@@ -217,8 +216,7 @@ async function processSelectedRoleRuntimeCleanups(store, delivery, lifecycleHost
                 if (!await lifecycleHost.stopOwner(owner)) {
                     throw new Error(`Role runtime cleanup could not confirm the host stopped: ${runtimeOwnerLabel(owner)}.`);
                 }
-                if (store.completeRuntimeCleanup === undefined
-                    || !store.completeRuntimeCleanup(target, now)) {
+                if (!store.completeRuntimeCleanup(target, now)) {
                     throw new Error(`Role runtime cleanup mailbox changed: ${runtimeOwnerLabel(owner)}.`);
                 }
                 forgetPreparedRuntimeOwner(delivery, owner);
@@ -252,7 +250,7 @@ function selectedTaskIdsForBoundedPass(store, selection) {
     return new Set(selectedActiveSchedulerTasks(store, selection).map((task) => task.id));
 }
 function selectedReadyWorkMailboxes(store) {
-    return store.listReadyWorkMailboxes?.() ?? store.listWorkMailboxes();
+    return store.listReadyWorkMailboxes();
 }
 function selectedRuntimeLifecycleTargets(store, scope, blockedTaskIds = new Set()) {
     if (scope.kind === "full") {
@@ -456,9 +454,9 @@ export function compileReconcileSelection(scope) {
     };
 }
 /**
- * Adopts activation requests whose deferral has been released.
+ * Continues admitted activation requests once their execution boundaries allow it.
  *
- * The deferral is only ever released by the planning Turn ending, so this phase
+ * A planning deferral is released only by its Turn ending. This phase therefore
  * re-reads the request instead of trusting the signal that woke it: a request
  * cancelled, or a Task retired or stopped, while the Turn was still running is
  * left alone rather than replayed as historical intent. Adoption itself belongs
@@ -475,10 +473,7 @@ async function adoptReleasedTaskActivations(store, workspace, selection, onError
     if (workspace === undefined)
         return;
     const candidates = selection.full
-        ? (store.listPendingActivationRequestTaskIds?.()
-            ?? store.listTasks().flatMap((task) => (task.status === "draft" && task.activationRequest?.disposition === "pending"
-                ? [task.id]
-                : [])))
+        ? store.listPendingActivationRequestTaskIds()
         : selection.taskIds;
     for (const taskId of candidates) {
         if (selection.blockedTaskIds?.has(taskId))
@@ -489,20 +484,14 @@ async function adoptReleasedTaskActivations(store, workspace, selection, onError
         const request = task.activationRequest;
         if (request?.disposition !== "pending")
             continue;
-        // Continue only requests with a provable source: a released deferral, or an
-        // immediate request carrying a recognised origin (explicit action, or a
-        // develop submission accepted while unplanned). This admits legal
-        // Operator/user immediate requests the old actor filter dropped, while
-        // still refusing origin-less historical requests, which stay behind the
-        // explicit `yui task activate` boundary.
-        if (!activationRequestIsControllerAdoptable(request))
-            continue;
+        // The request was authorized at admission. Recheck its current execution
+        // and Session boundaries without a second provenance-based workflow gate.
         // Later Draft discussion is a Session notification, not another AgentRun.
         // Its durable activation intent is sufficient once the exact native input
         // is settled. Never create a synthetic Run merely to release that intent.
         if (store.getActiveRun(taskId, "leader") !== null)
             continue;
-        const provider = store.getTaskRoleSessionSet?.(taskId, "leader")?.providerBinding;
+        const provider = store.getTaskRoleSessionSet(taskId, "leader")?.providerBinding;
         if (provider?.run != null
             && ["submitting", "accepted", "delivery-unknown"].includes(provider.run.status))
             continue;
@@ -663,7 +652,6 @@ function mergeControllerSchedulerResults(results) {
 export class FileTaskController {
     store;
     delivery;
-    #startedAt;
     #intervalMs;
     #now;
     #onError;
@@ -724,7 +712,6 @@ export class FileTaskController {
         this.delivery = delivery;
         this.#intervalMs = positiveInteger(options.intervalMs, DEFAULT_RECONCILIATION_INTERVAL_MS, "Controller reconciliation interval");
         this.#now = options.now ?? (() => new Date());
-        this.#startedAt = this.#now();
         this.#onError = options.onError ?? (() => { });
         const workspacePreparer = options.workspacePreparer;
         this.#workspacePreparer = workspacePreparer === undefined ? undefined : {
@@ -1649,7 +1636,7 @@ export async function startFileTaskController(home, store, delivery, dispatcher,
                 }
                 if (method === "job.get") {
                     const ref = parseDurableJobRefParams(params);
-                    const job = control.getJob(ref.taskId, ref.jobId);
+                    const job = control.getJob(ref.taskId, ref.jobId, ref.caller);
                     if (job === null) {
                         throw controllerApplicationError("NOT_FOUND", `DurableJob not found: ${ref.taskId}/${ref.jobId}.`);
                     }

package/dist/controller/fileSchedulerStoreAdapter.js

@@ -1,47 +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 { RuntimeHookRunFenceError } from "./runtimeHookRunFence.js";
+import { deferProviderRetry, providerRetryPending, recordProviderFailure } from "../runtime/providerRetry.js";
+import { AgentHostObservationDeferred, recordAgentHostConnection, resolveAgentHostObservation } from "./agentHostObservation.js";
 import { admitOwnedProviderInput, ownedProviderInput } from "./providerRetryAdmission.js";
-import { recordProviderFailure, providerRetryPending, deferProviderRetry } from "../runtime/providerRetry.js";
-import { settleGlobalRetryInput } from "../message/globalProviderRetry.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 { RuntimeHookRunFenceError } from "./runtimeHookRunFence.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);
@@ -740,31 +739,24 @@ 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);
-                if (!providerRetryPending(store.getTaskRoleSessionSet(taskId, input.fence.roleName)?.providerBinding))
+                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")
@@ -855,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));
     }
@@ -1305,41 +1274,22 @@ 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" || providerRetryPending(updated))
+            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) {
@@ -1403,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,
@@ -1428,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") {
@@ -1492,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;
         });
     }
@@ -1797,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)
@@ -1822,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" };
@@ -1898,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);
@@ -1908,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) {
@@ -2132,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.
@@ -3210,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,