@zq-silk/yui 2.16.0 → 2.18.0

package/dist/controller/fileSchedulerStoreAdapter.js

@@ -3,6 +3,7 @@ import { assertJobRoleRunnable } from "../job/agentRoleScope.js";
 import { recordJobAgentObservation } from "../job/agentJobObservation.js";
 import { isDeepStrictEqual } from "node:util";
 import { nonReplayableMessageWake, pinMessageRevisions, taskMessageInboxReceipt, unfinishedLeaderInbox } from "../message/taskInboxOwnership.js";
+import { ControllerWorkObserver, compactWorkObservation } from "../core/controllerTelemetry.js";
 import { contextSnapshotRef } from "../context/contextSnapshot.js";
 import { freezeRunContextSnapshot } from "../context/runContextPack.js";
 import { taskNotificationPresentation } from "../interaction/notificationPresentation.js";
@@ -34,6 +35,8 @@ import { recordTaskAgentError } from "./taskAgentError.js";
 import { recordGlobalRuntimeAttention, recordGlobalRuntimeFailure, recordGlobalRuntimeRecovery } from "./globalRuntimeAttention.js";
 import { checkInboxTurn } from "./inboxTurnCheck.js";
 import { queueOperatorNotification } from "./operatorNotification.js";
+import { reconcileProjectSync } from "../job/projectSync.js";
+import { serializeError } from "../core/boundedRpc.js";
 import { claimOperatorAttention } from "../scheduler/operatorEvent.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";
@@ -65,6 +68,26 @@ export class FileSchedulerStoreAdapter {
     telemetry;
     drivers;
     snapshotExecutionLaneWorkspace;
+    #reads = new ControllerWorkObserver();
+    #projectionCache = { hits: 0, rebuilds: 0, invalidations: 0 };
+    readObservationMetrics() {
+        return { ...this.#reads.snapshot(), projectionCache: { ...this.#projectionCache } };
+    }
+    compactReadObservationMetrics() {
+        return compactWorkObservation(this.#reads);
+    }
+    #observeRead(phase, target, read) {
+        const finish = this.#reads.start(phase, target);
+        try {
+            const result = read();
+            finish();
+            return result;
+        }
+        catch (error) {
+            finish(true);
+            throw error;
+        }
+    }
     /** Diagnostic telemetry is optional and never participates in runtime truth. */
     constructor(store, telemetry = null, drivers = builtinAgentDriverRegistry(), snapshotExecutionLaneWorkspace = snapshotExecutionLaneWorkspaceSync) {
         this.store = store;
@@ -72,6 +95,12 @@ export class FileSchedulerStoreAdapter {
         this.drivers = drivers;
         this.snapshotExecutionLaneWorkspace = snapshotExecutionLaneWorkspace;
     }
+    /** Registry maintenance only; this never executes a Job or starts a process. */
+    reconcileProjectSync(now) {
+        const errors = [];
+        reconcileProjectSync(this.store, now, error => errors.push(serializeError(error)));
+        return errors;
+    }
     observeAgentHostObservation(event, now = new Date()) {
         // Match canonical ingress: archive and Host fact settlement share the
         // same write boundary, including the original transport envelope.
@@ -168,7 +197,7 @@ export class FileSchedulerStoreAdapter {
                     && sessions?.sessions[input.fence.agentId]?.nativeSessionId === input.fence.nativeSessionId;
                 if (!runFolded && !(isSteer && input.fence.runId === undefined))
                     return "obsolete";
-                if (runFolded && !hasPersistedRuntimeObservation(store.listEvents(taskId), input) && run.status === "active") {
+                if (runFolded && !hasPersistedRuntimeObservation(store, input) && run.status === "active") {
                     const updated = appendRunInput(run, createRunInput({
                         source: input.fence.receiptId.startsWith("native-input:")
                             ? { type: "provider", channel: "visible-input" }
@@ -196,7 +225,7 @@ export class FileSchedulerStoreAdapter {
         if ((input.kind === "input.rejected" || input.kind === "input.delivery-unknown")
             && input.fence.receiptId?.startsWith("steer:") === true) {
             return this.store.transaction((store) => {
-                if (hasPersistedRuntimeObservation(store.listEvents(taskId), input))
+                if (hasPersistedRuntimeObservation(store, input))
                     return "applied";
                 const recorded = this.recordSteerControlOutcome(store, input.fence.receiptId, input.kind === "input.rejected" ? "rejected" : "delivery-unknown", now);
                 if (!recorded) {
@@ -217,7 +246,7 @@ export class FileSchedulerStoreAdapter {
         // together, including a retry after a previously interrupted fold.
         if (!isRunTerminalObservation(input)
             && input.kind !== "turn.accepted" && input.kind !== "input.accepted"
-            && hasPersistedRuntimeObservation(this.store.listEvents(taskId), input))
+            && hasPersistedRuntimeObservation(this.store, input))
             return "applied";
         let outcome;
         switch (input.kind) {
@@ -330,7 +359,7 @@ export class FileSchedulerStoreAdapter {
                 recordCanonicalObservationObsolete(store, input, "steer-receipt-fence-mismatch", now);
                 return "obsolete";
             }
-            if (hasPersistedRuntimeObservation(store.listEvents(taskId), input))
+            if (hasPersistedRuntimeObservation(store, input))
                 return "applied";
             const target = { kind: "role", taskId, roleName: "leader" };
             const mailbox = store.getWorkMailbox(target);
@@ -408,7 +437,7 @@ export class FileSchedulerStoreAdapter {
             }
             if (input.kind === "turn.accepted") {
                 if (input.authority === "transport" && matches) {
-                    const message = store.listGlobalRoleMessages(fence.roleName).find(entry => receipt === `global-input:${fence.roleName}/${entry.id}`);
+                    const message = globalMessageForReceipt(store, fence.roleName, receipt);
                     if (message !== undefined)
                         store.updateGlobalRoleMessage(markGlobalRoleMessageDelivered(message, new Date(at), "transport"));
                     return "applied";
@@ -428,9 +457,8 @@ 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}`
-                    || binding?.retry?.currentAttemptId === receipt && binding.retry.input.kind === "message"
-                        && binding.retry.input.messageId === entry.id);
+                const message = globalMessageForReceipt(store, fence.roleName, receipt, "global-input", binding?.retry?.currentAttemptId === receipt && binding.retry.input.kind === "message"
+                    ? binding.retry.input.messageId : undefined);
                 if (message !== undefined)
                     store.updateGlobalRoleMessage(markGlobalRoleMessageDelivered(message, new Date(at)));
             }
@@ -443,9 +471,8 @@ 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}`
-                        || binding?.retry?.currentAttemptId === receipt && binding.retry.input.kind === "message"
-                            && binding.retry.input.messageId === entry.id);
+                    const message = globalMessageForReceipt(store, fence.roleName, receipt, "global-input", binding?.retry?.currentAttemptId === receipt && binding.retry.input.kind === "message"
+                        ? binding.retry.input.messageId : undefined);
                     if (message !== undefined)
                         store.updateGlobalRoleMessage(markGlobalRoleMessageDelivered(message, new Date(at)));
                 }
@@ -466,7 +493,7 @@ export class FileSchedulerStoreAdapter {
                 if (input.authority !== "provider-structured" || binding.run?.nativeTurnId !== fence.nativeTurnId
                     || binding.run?.status !== "accepted")
                     return "obsolete";
-                const message = store.listGlobalRoleMessages(fence.roleName).find(entry => receipt === `steer:${fence.roleName}/${entry.id}`);
+                const message = globalMessageForReceipt(store, fence.roleName, receipt, "steer");
                 if (message !== undefined && message.inputControl !== undefined) {
                     const outcome = input.kind === "input.accepted" ? "accepted"
                         : input.kind === "input.rejected" ? "rejected" : "delivery-unknown";
@@ -548,7 +575,7 @@ export class FileSchedulerStoreAdapter {
     }
     validateCanonicalRunObservation(input, now) {
         return this.store.transaction((store) => {
-            if (hasPersistedRuntimeObservation(store.listEvents(input.fence.taskId), input)) {
+            if (hasPersistedRuntimeObservation(store, input)) {
                 return "applied";
             }
             const run = input.fence.runId === undefined ? null : store.getRun(input.fence.taskId, input.fence.runId);
@@ -565,7 +592,7 @@ export class FileSchedulerStoreAdapter {
                     ? "applied" : "obsolete";
             }
             const knownContinuation = (input.kind.startsWith("continuation.") || input.kind === "observer.health")
-                && projectProviderContinuations(store.listEvents(input.fence.taskId)).some((entry) => (entry.runId === input.fence.runId
+                && projectProviderContinuations(store.listEventsByType(input.fence.taskId, [RUNTIME_OBSERVATION_TASK_EVENT])).some((entry) => (entry.runId === input.fence.runId
                     && entry.identity.providerNamespace === input.fence.driverId
                     && entry.identity.accountScope === input.fence.agentId
                     && entry.identity.conversationId === input.fence.conversationId
@@ -647,7 +674,7 @@ export class FileSchedulerStoreAdapter {
             const status = "ended";
             let updatedSessions = updateRoleAgentSessionStatus(sessions, input.fence.agentId, status, now, input.kind === "session.failed" ? "failed" : "stopped");
             store.saveTaskRoleSessionSet(updatedSessions);
-            for (const continuation of projectProviderContinuations(store.listEvents(input.fence.taskId))) {
+            for (const continuation of projectProviderContinuations(store.listEventsByType(input.fence.taskId, [RUNTIME_OBSERVATION_TASK_EVENT]))) {
                 if (continuation.runId !== input.fence.runId || continuation.identity.conversationId
                     !== (input.fence.conversationId ?? input.fence.nativeSessionId) || continuation.execution === "quiescent" || continuation.attachment === "detached")
                     continue;
@@ -721,9 +748,9 @@ export class FileSchedulerStoreAdapter {
     persistRuntimeObservation(input, now, notifyGoal = true) {
         this.store.transaction((store) => {
             const taskId = input.fence.taskId;
-            const events = store.listEvents(taskId);
-            if (hasPersistedRuntimeObservation(events, input))
+            if (hasPersistedRuntimeObservation(store, input))
                 return;
+            const events = store.listEventsByType(taskId, [RUNTIME_OBSERVATION_TASK_EVENT]);
             if (usageSnapshotIsSuperseded(events, input))
                 return;
             const removable = compactedRuntimeObservationIds(events, input);
@@ -851,43 +878,53 @@ export class FileSchedulerStoreAdapter {
         return "obsolete";
     }
     /**
-     * Revision-scoped read projection. Keyed by the store's durable revision;
-     * any committed mutation (ours or an external writer's) advances it and the
-     * next read rebuilds. A store without getStateRevision disables caching.
+     * Task-scoped cache tokens cover the exact source tables across connections.
+     * Unrelated Tasks/Global traffic do not invalidate these projections. Retain
+     * only the 16 most recently read Tasks; eviction changes cost, never truth.
      */
-    #readProjection = null;
-    #taskReadProjection(taskId) {
-        const revision = typeof this.store.getStateRevision === "function"
-            ? this.store.getStateRevision()
-            : Number.NaN;
-        if (this.#readProjection === null
-            || this.#readProjection.revision !== revision) {
-            this.#readProjection = { revision, tasks: new Map() };
-        }
-        const tasks = this.#readProjection.tasks;
-        let task = tasks.get(taskId);
-        if (task === undefined) {
-            const events = this.store.listEvents(taskId);
-            task = {
-                events,
-                runFacts: foldRunProgressFacts(events),
-                runs: this.store.listRuns(taskId),
-                workItems: this.store.listWorkItems(taskId),
-                reviewRounds: this.store.listReviewRounds(taskId),
-                changeSets: this.store.listChangeSets(taskId),
-                integrationAttempts: this.store.listIntegrationAttempts(taskId),
-                inputRequests: this.store.listInputRequests(taskId),
-                durableJobs: this.store.listDurableJobs(taskId),
-                messages: this.store.listMessages(taskId)
-            };
-            tasks.set(taskId, task);
+    #readProjection = new Map();
+    #projected(taskId, family, read) {
+        const observed = this.store.getTaskReadRevision(taskId);
+        const previous = this.#readProjection.get(taskId);
+        const hit = previous?.revision === observed ? previous.value[family] : undefined;
+        if (hit !== undefined) {
+            // The token read is the read's snapshot point. A cache hit needs no new
+            // transaction: its value was built under that exact committed token.
+            this.#projectionCache.hits++;
+            this.#readProjection.delete(taskId);
+            this.#readProjection.set(taskId, previous);
+            return hit;
         }
-        return task;
+        // Pin and recheck misses before reading any source rows: an external writer
+        // may have advanced the token after the optimistic lookup above.
+        return this.store.readTransaction(() => {
+            const revision = this.store.getTaskReadRevision(taskId);
+            let task = this.#readProjection.get(taskId);
+            if (task === undefined || task.revision !== revision) {
+                if (task !== undefined)
+                    this.#projectionCache.invalidations++;
+                this.#projectionCache.rebuilds++;
+                task = { revision, value: {} };
+            }
+            this.#readProjection.delete(taskId);
+            this.#readProjection.set(taskId, task);
+            if (this.#readProjection.size > 16) {
+                this.#readProjection.delete(this.#readProjection.keys().next().value);
+            }
+            const cached = task.value[family];
+            if (cached !== undefined) {
+                this.#projectionCache.hits++;
+                return cached;
+            }
+            const value = this.#observeRead(`task-${family}-read`, taskId, read);
+            task.value[family] = value;
+            return value;
+        });
     }
     withRuntimeEventTransaction(execute) {
         return this.store.withRuntimeEventTransaction(execute);
     }
-    listTasks() { return this.store.listTasks(); }
+    listTasks() { return this.#observeRead("list-tasks", "home", () => this.store.listTasks()); }
     listActiveTaskIds() {
         return [...this.store.listActiveTaskIds()].sort((left, right) => (left.localeCompare(right, undefined, { numeric: true })));
     }
@@ -980,51 +1017,48 @@ export class FileSchedulerStoreAdapter {
         return this.store.getTaskRoleSessionSet(taskId, roleName);
     }
     listEvents(taskId) {
-        return this.#taskReadProjection(taskId).events;
+        return this.#projected(taskId, "events", () => this.store.listEvents(taskId));
     }
     listRuns(taskId) {
-        return this.#taskReadProjection(taskId).runs;
+        return this.#projected(taskId, "runs", () => this.store.listRuns(taskId));
     }
     listWorkItems(taskId) {
-        return this.#taskReadProjection(taskId).workItems;
+        return this.#projected(taskId, "workItems", () => this.store.listWorkItems(taskId));
     }
     listReviewRounds(taskId) {
-        return this.#taskReadProjection(taskId).reviewRounds;
+        return this.#projected(taskId, "reviewRounds", () => this.store.listReviewRounds(taskId));
     }
     listIntegrationAttempts(taskId) {
-        return this.#taskReadProjection(taskId).integrationAttempts;
+        return this.#projected(taskId, "integrationAttempts", () => this.store.listIntegrationAttempts(taskId));
     }
     listDurableJobs(taskId) {
-        return this.#taskReadProjection(taskId).durableJobs;
+        return this.#projected(taskId, "durableJobs", () => this.store.listDurableJobs(taskId));
     }
     listInputRequests(taskId) {
-        return this.#taskReadProjection(taskId).inputRequests;
+        return this.#projected(taskId, "inputRequests", () => this.store.listInputRequests(taskId));
     }
     listMessages(taskId) {
-        return this.#taskReadProjection(taskId).messages;
+        return this.#projected(taskId, "messages", () => this.store.listMessages(taskId));
     }
     getRunProgressFacts(taskId, runId) {
-        return this.#taskReadProjection(taskId).runFacts.get(runId);
+        return this.#projected(taskId, "runFacts", () => foldRunProgressFacts(this.listEvents(taskId))).get(runId);
     }
     getRunDurableProgress(taskId, roleName, runId) {
-        const projected = this.#taskReadProjection(taskId);
-        // Serve the related-record fold from the same revision's projection: the
-        // event history and the WorkItem/Review/ChangeSet/Integration/Input lists
-        // are read once per Task per revision, and the per-AgentRun checkpoint/activity
-        // facts come from the one-pass fold instead of per-candidate scans.
-        const view = {
-            getRun: (id, runId) => this.store.getRun(id, runId),
-            listEvents: () => projected.events,
-            getWorkItem: (id, workItemId) => this.store.getWorkItem(id, workItemId),
-            listReviewRounds: () => projected.reviewRounds,
-            listChangeSets: () => projected.changeSets,
-            listIntegrationAttempts: () => projected.integrationAttempts,
-            listInputRequests: () => projected.inputRequests
-        };
-        // A missing fold entry is an authoritative empty fold, not a signal to
-        // re-scan the whole history. Pass {} so latestTurnDurableProgressAt treats
-        // the fold as present and skips the per-candidate fallback scans.
-        return latestRunDurableProgressAt(view, taskId, roleName, runId, projected.runFacts.get(runId) ?? {});
+        return this.store.readTransaction(() => {
+            // Pin related reads to one snapshot while loading only required families.
+            const view = {
+                getRun: (id, runId) => this.store.getRun(id, runId),
+                listEvents: () => this.listEvents(taskId),
+                getWorkItem: (id, workItemId) => this.store.getWorkItem(id, workItemId),
+                listReviewRounds: () => this.listReviewRounds(taskId),
+                listChangeSets: () => this.#projected(taskId, "changeSets", () => this.store.listChangeSets(taskId)),
+                listIntegrationAttempts: () => this.listIntegrationAttempts(taskId),
+                listInputRequests: () => this.listInputRequests(taskId)
+            };
+            // A missing fold entry is authoritative empty evidence, not permission
+            // to fall back to a per-candidate full-history scan.
+            return latestRunDurableProgressAt(view, taskId, roleName, runId, this.getRunProgressFacts(taskId, runId) ?? {});
+        });
     }
     recordRoleRunDiagnostic(input) {
         return this.store.transaction((store) => {
@@ -1160,12 +1194,11 @@ export class FileSchedulerStoreAdapter {
                 if (turn != null && ["submitting", "accepted", "delivery-unknown"].includes(turn.status)) {
                     throw new AgentHostProviderSessionBusyError("Global Conversation has an unsettled input.");
                 }
-                const message = store.listGlobalRoleMessages(input.roleName).find(entry => input.attemptId === `global-input:${input.roleName}/${entry.id}`);
-                const reserved = store.listGlobalRoleMessages(input.roleName).find(entry => entry.delivery === undefined && entry.notDelivered === undefined
-                    && entry.interruptThen?.targetNativeSessionId === input.nativeSessionId
-                    && entry.interruptThen.targetAgentId === input.agentId
-                    && entry.interruptThen.targetAuthorityEpoch === input.authorityEpoch
-                    && entry.interruptThen.targetAuthorityHolderId === input.holderId);
+                const message = globalMessageForReceipt(store, input.roleName, input.attemptId);
+                const reserved = store.queryGlobalRoleMessages(input.roleName, {
+                    limit: 1, reservedThen: { nativeSessionId: input.nativeSessionId,
+                        agentId: input.agentId, authorityEpoch: input.authorityEpoch, holderId: input.holderId }
+                }).messages[0];
                 if (reserved !== undefined && reserved.id !== message?.id) {
                     throw new AgentHostProviderSessionBusyError("The next Global input belongs to an explicit then handoff.");
                 }
@@ -1285,7 +1318,7 @@ export class FileSchedulerStoreAdapter {
             // This shares the exact writer/session admission and its transaction.
             if ((input.authorityOwner === "human" || input.attemptId.startsWith(`human:${input.holderId}:`)) && input.roleName === "leader"
                 && input.runId === undefined && input.boundedText !== undefined) {
-                const prior = store.listEvents(input.taskId).find(event => event.type === "message.native-user-input" && event.payload.attemptId === input.attemptId);
+                const prior = store.listEventsByType(input.taskId, ["message.native-user-input"]).find(event => event.payload.attemptId === input.attemptId);
                 if (prior !== undefined) {
                     const message = store.listMessages(input.taskId).find(entry => entry.id === prior.payload.messageId);
                     if (message?.body !== input.boundedText || prior.payload.nativeSessionId !== input.nativeSessionId) {
@@ -1344,7 +1377,7 @@ export class FileSchedulerStoreAdapter {
                         unknown: "External effects are not established by submission settlement."
                     }, input.now);
                 }
-                const message = store.listGlobalRoleMessages(input.roleName).find(entry => input.attemptId === `global-input:${input.roleName}/${entry.id}`);
+                const message = globalMessageForReceipt(store, input.roleName, input.attemptId);
                 if (message !== undefined && message.delivery?.via !== "provider") {
                     const outcome = input.status === "delivery-unknown" ? "delivery-unknown" : "rejected";
                     const updated = { ...message, control: {
@@ -1890,9 +1923,9 @@ export class FileSchedulerStoreAdapter {
                     return null;
                 const wakeId = processing.owner.slice("leader-notification:".length);
                 const attemptId = processing.batchId;
-                const previous = store.listEvents(taskId).filter((event) => event.type === "notification.delivery" && event.payload.attemptId === attemptId).at(-1);
+                const previous = store.listEventsByType(taskId, ["notification.delivery"]).filter((event) => event.payload.attemptId === attemptId).at(-1);
                 const native = provider?.attemptId === attemptId ? provider : undefined;
-                const accepted = store.listEvents(taskId).some((event) => {
+                const accepted = store.listEventsByType(taskId, [RUNTIME_OBSERVATION_TASK_EVENT]).some((event) => {
                     const observation = runtimeObservationFromTaskEvent(event);
                     return observation?.fence.roleName === "leader"
                         && observation.fence.receiptId === attemptId
@@ -2016,8 +2049,7 @@ export class FileSchedulerStoreAdapter {
             if (mailbox == null || processing == null || processing.batchId !== attemptId
                 || !processing.owner.startsWith("leader-notification:"))
                 return;
-            if (!store.listEvents(taskId).some((event) => event.type === "notification.delivery"
-                && event.payload.attemptId === attemptId && event.payload.outcome === outcome)) {
+            if (!store.listEventsByType(taskId, ["notification.delivery"]).some((event) => event.payload.attemptId === attemptId && event.payload.outcome === outcome)) {
                 // 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"])
@@ -2083,7 +2115,7 @@ export class FileSchedulerStoreAdapter {
                         nativeSessionId: input.session.nativeSessionId
                     }, "active", input.now);
                 }
-                if (!defersConversationReplacement && !store.listEvents(input.task.id).some((event) => event.type === "run.session-prepared" && event.payload.runId === input.run.id
+                if (!defersConversationReplacement && !store.listEventsByType(input.task.id, ["run.session-prepared"]).some((event) => event.payload.runId === input.run.id
                     && event.payload.nativeSessionId === input.session.nativeSessionId)) {
                     store.saveEvent(input.task.id, createTaskEvent(store.nextEventId(input.task.id), input.task.id, "run.session-prepared", { runId: input.run.id, roleName: role.name,
                         nativeSessionId: input.session.nativeSessionId }, input.now));
@@ -2235,7 +2267,7 @@ export class FileSchedulerStoreAdapter {
             && preparedRun.executionLaneId !== undefined
             && preparedRun.workspace !== undefined
             && input.outcome.status === "completed"
-            ? this.snapshotExecutionLaneWorkspace(this.store, preparedRun.workspace)
+            ? this.#observeRead("git-workspace-snapshot", preparedRun.taskId, () => this.snapshotExecutionLaneWorkspace(this.store, preparedRun.workspace))
             : undefined;
         return this.store.transaction((store) => {
             const task = store.getTask(input.taskId);
@@ -2476,7 +2508,7 @@ export class FileSchedulerStoreAdapter {
     observeProviderGoal(input, now) {
         return this.store.transaction((store) => {
             const taskId = input.fence.taskId;
-            if (hasPersistedRuntimeObservation(store.listEvents(taskId), input))
+            if (hasPersistedRuntimeObservation(store, input))
                 return "applied";
             const sessions = store.getTaskRoleSessionSet(taskId, input.fence.roleName);
             const binding = sessions?.providerBinding;
@@ -2798,7 +2830,7 @@ export class FileSchedulerStoreAdapter {
             ...(boundNativeSessionId === undefined ? {} : { nativeSessionId: boundNativeSessionId })
         };
         const driverId = this.drivers.requireByAdapterId(run.effective.adapterId).id;
-        const lifecycleEvents = store.listEvents(fence.taskId).flatMap((event) => {
+        const lifecycleEvents = store.listEventsByType(fence.taskId, [RUNTIME_OBSERVATION_TASK_EVENT]).flatMap((event) => {
             const observation = runtimeObservationFromTaskEvent(event);
             return observation !== null && (observation.kind === "session.started" || observation.kind === "session.ready") && observation.fence.roleName === fence.roleName && observation.fence.agentId === run.effective.agentId && observation.fence.driverId === driverId && observation.fence.nativeSessionId === (boundNativeSessionId ?? fence.nativeSessionId)
                 ? [observation]
@@ -2966,7 +2998,7 @@ function runtimeReceiptBelongsToRun(store, input) {
         && sessions?.sessions[input.fence.agentId]?.nativeSessionId === input.fence.nativeSessionId) {
         return true;
     }
-    return store.listEvents(taskId).some((event) => {
+    return store.listEventsByType(taskId, [RUNTIME_OBSERVATION_TASK_EVENT]).some((event) => {
         const accepted = runtimeObservationFromTaskEvent(event);
         return accepted?.kind === "turn.accepted" && accepted.fence.runId === runId && accepted.fence.roleName === input.fence.roleName && accepted.fence.agentId === input.fence.agentId && accepted.fence.nativeSessionId === input.fence.nativeSessionId && accepted.fence.receiptId === receiptId;
     });
@@ -2988,8 +3020,7 @@ function recordCanonicalObservationObsolete(store, input, reason, now) {
     }, reason, now);
 }
 function recordObsoleteRuntimeEvent(store, input, reason, now) {
-    if (store.listEvents(input.taskId).some((event) => (event.type === "runtime.event-obsolete"
-        && (event.payload.dedupeKey ?? event.payload.eventId) === (input.dedupeKey ?? input.eventId))))
+    if (store.listEventsByType(input.taskId, ["runtime.event-obsolete"]).some((event) => ((event.payload.dedupeKey ?? event.payload.eventId) === (input.dedupeKey ?? input.eventId))))
         return;
     store.saveEvent(input.taskId, createTaskEvent(store.nextEventId(input.taskId), input.taskId, "runtime.event-obsolete", {
         eventId: input.eventId,
@@ -3145,9 +3176,9 @@ function recordTaskRuntimeNativeSession(store, input, now) {
     if (task.status === "archived") {
         throw new Error(`Cannot register a native session for archived Task: ${input.taskId}.`);
     }
-    // A Draft registers a Session only for its planning Turn. Admission is decided
-    // by the active Turn's purpose through the one shared invariant, so a Draft
-    // still cannot open an execution Session before activation.
+    // A Draft admits its first planning Run, restoration of that exact Session,
+    // or the selected successor's initialization after verified replacement.
+    // Ordinary Draft notifications and native hooks cannot create a Session.
     const admittingRun = store.getActiveRun(input.taskId, input.roleName);
     const existingPlanning = activeLiveRoleAgentSession(store.getTaskRoleSessionSet(input.taskId, input.roleName));
     if (!(admittingRun !== null
@@ -3156,6 +3187,9 @@ function recordTaskRuntimeNativeSession(store, input, now) {
         && !(task.status === "draft" && task.executionGate.state === "enabled" && input.roleName === "leader"
             && existingPlanning?.effective.executionAuthority === "planning"
             && existingPlanning.nativeSessionId === input.nativeSessionId)
+        && !(task.status === "draft" && task.executionGate.state === "enabled" && input.roleName === "leader"
+            && input.effective?.executionAuthority === "planning"
+            && draftReplacementInitializationIsCurrent(store, input.taskId, input.agentId))
         && (task.status !== "active" || task.executionGate.state !== "enabled")) {
         throw new Error(`Cannot register a native session for a Task that is not active: ${input.taskId}.`);
     }
@@ -3191,6 +3225,32 @@ function recordTaskRuntimeNativeSession(store, input, now) {
     store.saveRoleSessionSet(updated);
     return updated.sessions[input.agentId];
 }
+/** The existing initialization wake is the launch authority, not historical
+ * planning success or an arbitrary "session-replaced" reason. It is retained
+ * on startup rejection for the normal explicit wake retry/replacement path. */
+function draftReplacementInitializationIsCurrent(store, taskId, agentId) {
+    const sessions = store.getTaskRoleSessionSet(taskId, "leader");
+    if (sessions === null || sessions.activeAgentId !== agentId
+        || sessions.sessions[agentId] !== undefined || sessions.providerBinding !== null
+        || hasRuntimeCleanupObligation(store.getWorkMailbox(runtimeLifecycleTarget({
+            scope: "task", taskId, roleName: "leader"
+        }))))
+        return false;
+    const processing = store.getWorkMailbox({ kind: "role", taskId, roleName: "leader" })?.processing;
+    if (!processing?.owner.startsWith("leader-notification:"))
+        return false;
+    const wake = store.getTaskWake(taskId, processing.owner.slice("leader-notification:".length));
+    if (wake === null || !wake.reasons.includes("session-replaced"))
+        return false;
+    const events = store.listEventsByType(taskId, ["runtime.session-replaced", "notification.delivery"]);
+    const replacement = events.filter(event => event.type === "runtime.session-replaced"
+        && event.payload.roleName === "leader").at(-1);
+    return replacement !== undefined
+        && (wake.refs ?? []).some(ref => ref.type === "event" && ref.taskId === taskId && ref.id === replacement.id)
+        && !events.some(event => event.type === "notification.delivery"
+            && event.payload.attemptId === processing.batchId
+            && event.payload.outcome !== "deferred");
+}
 function recordGlobalRuntimeNativeSession(store, input, now) {
     const role = store.getGlobalRole(input.roleName);
     if (role === null)
@@ -3271,6 +3331,7 @@ function mapRole(store, role) {
     return {
         taskId: role.taskId,
         name: role.name,
+        enabled: role.enabled !== false,
         activeAgentId: role.activeAgentId,
         adapterId: binding.adapterId,
         ...(binding.config.model === undefined ? {} : { model: binding.config.model }),
@@ -3307,8 +3368,9 @@ function taskSessionEffective(store, taskId, roleName, agentId, existing) {
         ?? store.getTaskWorkspace(taskId)
         ?? undefined;
     const effective = resolveEffectiveLaunch({
+        store,
         role,
-        purpose: "execution",
+        purpose: store.getTask(taskId)?.status === "draft" && roleName === "leader" ? "planning" : "execution",
         ...(workspace === undefined ? {} : { workspace }),
         ...(item === null ? {} : { workItemWriteProjectIds: item.writeProjectIds })
     });
@@ -3482,7 +3544,7 @@ function resolveTerminalExecution(store, input) {
     const session = sessions?.sessions[input.agentId];
     const binding = sessions?.providerBinding;
     const pending = binding?.run;
-    const evidence = store.listEvents(input.taskId).map(runtimeObservationFromTaskEvent)
+    const evidence = store.listEventsByType(input.taskId, [RUNTIME_OBSERVATION_TASK_EVENT]).map(runtimeObservationFromTaskEvent)
         .filter((event) => event !== null
         && (event.kind === "turn.accepted" || isRunTerminalObservation(event)));
     if (input.attemptId !== undefined && evidence.some((event) => (event.fence.roleName === input.roleName
@@ -3543,7 +3605,7 @@ function isRunTerminalObservation(input) {
     return ["turn.completed", "turn.failed", "turn.cancelled"].includes(input.kind);
 }
 function assertConsistentTerminal(store, input, run) {
-    const previous = store.listEvents(input.taskId).map(runtimeObservationFromTaskEvent)
+    const previous = store.listEventsByType(input.taskId, [RUNTIME_OBSERVATION_TASK_EVENT]).map(runtimeObservationFromTaskEvent)
         .filter((event) => event !== null
         && isRunTerminalObservation(event)
         && event.fence.roleName === input.roleName
@@ -3669,14 +3731,21 @@ function usageSnapshotIsSuperseded(events, incoming) {
         && runtimeObservationFenceMatches(observation.fence, incoming.fence)
         && observationIsStrictlyNewer(observation, incoming));
 }
-function hasPersistedRuntimeObservation(events, incoming) {
+function hasPersistedRuntimeObservation(store, incoming) {
     const usageIdentity = isRuntimeUsageEvidence(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)));
+    return store.hasRuntimeObservation(incoming.fence.taskId, usageIdentity === undefined
+        ? { semanticKey: incoming.semanticKey } : { eventId: usageIdentity });
+}
+function globalMessageForReceipt(store, roleName, receipt, kind = "global-input", retryMessageId) {
+    const prefix = `${kind}:${roleName}/`;
+    const id = receipt?.startsWith(prefix) ? receipt.slice(prefix.length) : undefined;
+    // A retry references the original Message, not a second input. Preserve the
+    // old numeric-id ordering if both explicit identities name different rows.
+    return [...new Set([id, retryMessageId].filter((value) => value !== undefined))]
+        .flatMap(id => store.queryGlobalRoleMessages(roleName, { id, limit: 1 }).messages)
+        .sort((left, right) => left.id.localeCompare(right.id, undefined, { numeric: true }))[0];
 }
 function observationIsStrictlyNewer(left, right) {
     return compareCanonicalObservationOrder(left, right) > 0;

package/dist/controller/globalInputDelivery.js

@@ -1,9 +1,10 @@
+import { isEnabled } from "../role/availability.js";
 import { sendAgentHostRunControl, reconcileAgentHostTurn, AGENT_HOST_CONTROL_PROTOCOL } from "../runtime/agentHost.js";
 import { currentProviderConversation } from "../runtime/providerRuntimeIdentity.js";
 import { hasRuntimeCleanupObligation, runtimeLifecycleTarget } from "../runtime/lifecycleReservation.js";
 import { markGlobalRoleMessageNotDelivered } from "../message/message.js";
 import { providerRetryPending } from "../runtime/providerRetry.js";
-import { settleGlobalRetryInput } from "../message/globalProviderRetry.js";
+import { globalRetryInputSettlement, settleGlobalRetryInput } from "../message/globalProviderRetry.js";
 import { globalMessagePresentation } from "../interaction/notificationPresentation.js";
 import { recordGlobalRuntimeAttention, recordGlobalRuntimeRecovery } from "./globalRuntimeAttention.js";
 import { globalInboxRecovery } from "../message/globalInboxRecovery.js";
@@ -25,14 +26,6 @@ export async function deliverGlobalInputs(home, store, ensure, onError, options
             if (sessions !== null && selected?.status !== "active"
                 && !(role.jobOwner && selected === undefined))
                 continue;
-            if (sessions?.providerBinding?.retry !== undefined && !providerRetryPending(sessions.providerBinding)) {
-                store.transaction(tx => settleGlobalRetryInput(tx, role.name, tx.getGlobalRoleSessionSet(role.name)?.providerBinding, new Date()));
-                pending = store.queryGlobalRoleMessages(role.name, { pending: true, unclaimed: true, limit: 64 }).messages;
-                if (pending.length === 0)
-                    continue;
-            }
-            if (providerRetryPending(sessions?.providerBinding))
-                continue;
             let current = sessions?.providerBinding?.run;
             const bindingBefore = sessions?.providerBinding;
             if (options.reconcile && current != null
@@ -95,6 +88,23 @@ export async function deliverGlobalInputs(home, store, ensure, onError, options
                 if (pending.length === 0)
                     continue;
             }
+            // Availability blocks new work, not observation of the original writer's
+            // exact terminal. Re-read after the asynchronous reconciliation above.
+            const currentRole = store.getGlobalRole(role.name);
+            if (currentRole === null || !isEnabled(currentRole))
+                continue;
+            if (sessions?.providerBinding?.retry !== undefined && !providerRetryPending(sessions.providerBinding)) {
+                const now = options.now ?? new Date();
+                // Retained terminal retry history is not new write work each pass.
+                const settlement = store.readTransaction(tx => globalRetryInputSettlement(tx, role.name, tx.getGlobalRoleSessionSet(role.name)?.providerBinding, now));
+                if (settlement !== undefined)
+                    store.transaction(tx => settleGlobalRetryInput(tx, role.name, tx.getGlobalRoleSessionSet(role.name)?.providerBinding, now));
+                pending = store.queryGlobalRoleMessages(role.name, { pending: true, unclaimed: true, limit: 64 }).messages;
+                if (pending.length === 0)
+                    continue;
+            }
+            if (providerRetryPending(sessions?.providerBinding))
+                continue;
             const recovery = globalInboxRecovery(store, role.name, options.now ?? new Date());
             const recovering = recovery !== undefined && recovery.inbox === undefined && recovery.delivery === undefined
                 && recovery.notDelivered === undefined && recovery.control === undefined;