@yielded/agent-platform-cloudflare 0.1.0-beta.174 → 0.1.0-beta.176

package/src/Alarm.ts

@@ -217,7 +217,7 @@ type MaintenanceCheckpoint = {
   readonly mutations: Parameters<
     Parameters<ThreadMaintenanceAlarm["Service"]["transaction"]>[0]
   >[0];
-  readonly requireActive: Effect.Effect<void, DurableAlarmError>;
+  readonly isActive: (fiber: Fiber.Fiber<unknown, unknown>) => boolean;
 };
 
 const CurrentCheckpoint = Context.Reference<MaintenanceCheckpoint | undefined>(
@@ -232,31 +232,27 @@ const makeAlarmOperation = Effect.gen(function* () {
   const { ctx } = yield* DurableObjectContext;
   const queue = DueQueue.make(ctx.storage);
 
-  const transaction: SqlClient["withTransaction"] = (body) =>
+  const transaction = <A, E, R>(
+    body: (owner: Fiber.Fiber<unknown, unknown>) => Effect.Effect<A, E, R>,
+  ): Effect.Effect<A, E | SqlError, R> =>
     alarms
       .transaction(
         (mutations) =>
           Effect.withFiber((owner) => {
             let active = true;
 
-            const requireActive = Effect.withFiber((fiber) =>
-              active && fiber === owner
-                ? Effect.void
-                : Effect.fail(
-                    DurableAlarmError.make({
-                      operation: "enroll maintenance source",
-                      message: "Source intent requires its active transaction callback's fiber",
-                    }),
-                  ),
-            );
-
-            return body.pipe(
-              Effect.provideService(CurrentCheckpoint, { mutations, requireActive }),
-              Effect.ensuring(
-                Effect.sync(() => {
-                  active = false;
+            return Effect.onExitPrimitive(
+              body(owner).pipe(
+                Effect.provideService(CurrentCheckpoint, {
+                  mutations,
+                  isActive: (fiber) => active && fiber === owner,
                 }),
               ),
+              () => {
+                active = false;
+
+                return undefined;
+              },
             );
           }),
         { sqlClient: sql },
@@ -276,7 +272,9 @@ const makeAlarmOperation = Effect.gen(function* () {
       );
 
   const withTransaction = <A, E, R>(body: Effect.Effect<A, E, R>) =>
-    Effect.flatMap(Effect.serviceOption(sql.transactionService), (ambient) => {
+    Effect.withFiber((fiber) => {
+      const ambient = Context.getOption(fiber.context, sql.transactionService);
+
       if (ambient._tag === "Some" && !DueQueue.ownsTransaction(ctx.storage, ambient.value[1]))
         return Effect.fail(
           SqlError.make({
@@ -287,53 +285,53 @@ const makeAlarmOperation = Effect.gen(function* () {
             }),
           }),
         );
+      let frame: ReturnType<typeof queue.begin> | undefined;
 
       return Effect.uninterruptibleMask((restore) =>
-        Effect.suspend(() => {
-          let frame: ReturnType<typeof queue.begin> | undefined;
+        Effect.onExitPrimitive(
+          transaction((owner) => {
+            const current = Context.getOption(owner.context, sql.transactionService);
 
-          return transaction(
-            Effect.flatMap(Effect.serviceOption(sql.transactionService), (transaction) =>
-              Effect.gen(function* () {
-                if (transaction._tag === "None")
-                  return yield* SqlError.make({
+            if (current._tag === "None")
+              return SqlError.make({
+                reason: UnknownError.make({
+                  operation: "begin maintenance source transaction",
+                  message: "SQL transaction unavailable",
+                  cause: "SQL transaction unavailable",
+                }),
+              });
+            const started = queue.begin(current.value[1]);
+
+            frame = started;
+
+            return Effect.flatMap(restore(body), (value) =>
+              Effect.try({
+                try: () => {
+                  queue.flush(started);
+
+                  return value;
+                },
+                catch: (cause) =>
+                  SqlError.make({
                     reason: UnknownError.make({
-                      operation: "begin maintenance source transaction",
-                      message: "SQL transaction unavailable",
-                      cause: "SQL transaction unavailable",
+                      cause,
+                      operation: "flush maintenance due queue",
+                      message: "Maintenance intent could not commit",
                     }),
-                  });
-                frame = queue.begin(transaction.value[1]);
-              }),
-            ).pipe(
-              Effect.andThen(restore(body)),
-              Effect.tap(() =>
-                Effect.try({
-                  try: () => {
-                    if (frame !== undefined) queue.flush(frame);
-                  },
-                  catch: (cause) =>
-                    SqlError.make({
-                      reason: UnknownError.make({
-                        cause,
-                        operation: "flush maintenance due queue",
-                        message: "Maintenance intent could not commit",
-                      }),
-                    }),
-                }),
-              ),
-            ),
-          ).pipe(
-            Effect.onExit((exit) =>
-              Effect.sync(() => {
-                if (frame !== undefined) queue.finish(frame, Exit.isSuccess(exit));
+                  }),
               }),
-            ),
-            // A released permit can resume another transaction. Do not auto-yield
-            // between the driver's settlement and removing this transaction's frame.
-            Effect.provideService(Scheduler.PreventSchedulerYield, true),
-          );
-        }),
+            );
+          }),
+          (exit) => {
+            if (frame !== undefined) queue.finish(frame, Exit.isSuccess(exit));
+
+            return undefined;
+          },
+        ).pipe(
+          // A released permit can resume another transaction. Do not auto-yield
+          // between the driver's settlement and removing this transaction's frame.
+          Effect.provideService(Scheduler.PreventSchedulerYield, true),
+        ),
       );
     }).pipe(Effect.provideService(SqlClient, sql));
 
@@ -352,32 +350,33 @@ const makeAlarmOperation = Effect.gen(function* () {
           }),
         );
 
-      return tx.requireActive.pipe(
-        Effect.andThen(
-          Effect.suspend(() => {
-            let checkpoint: ReturnType<DurableObjectAlarm.AlarmScheduler["scheduleAlarm"]> =
-              Effect.void;
+      if (!tx.isActive(fiber))
+        return Effect.fail(
+          DurableAlarmError.make({
+            operation: "enroll maintenance source",
+            message: "Source intent requires its active transaction callback's fiber",
+          }),
+        );
 
-            const intent: CheckpointIntent = {
-              at: (at) => {
-                checkpoint = tx.mutations.scheduleAlarm(maintenanceAlarmInput(at));
-              },
-              earlier: (at) => {
-                checkpoint = tx.mutations.scheduleAlarmEarlier(maintenanceAlarmInput(at));
-              },
-              cancel: () => {
-                checkpoint = tx.mutations.cancelAlarm(maintenanceAlarmRef);
-              },
-            };
+      let checkpoint: ReturnType<DurableObjectAlarm.AlarmScheduler["scheduleAlarm"]> = Effect.void;
 
-            // The SQL/alarm callback already owns the native transaction; KV uses the same storage.
-            return Effect.tryPromise({
-              try: () => execute(ctx.storage, intent),
-              catch: alarmFailure(operation),
-            }).pipe(Effect.tap(() => checkpoint));
-          }),
-        ),
-      );
+      const intent: CheckpointIntent = {
+        at: (at) => {
+          checkpoint = tx.mutations.scheduleAlarm(maintenanceAlarmInput(at));
+        },
+        earlier: (at) => {
+          checkpoint = tx.mutations.scheduleAlarmEarlier(maintenanceAlarmInput(at));
+        },
+        cancel: () => {
+          checkpoint = tx.mutations.cancelAlarm(maintenanceAlarmRef);
+        },
+      };
+
+      // The SQL/alarm callback already owns the native transaction; KV uses the same storage.
+      return Effect.tryPromise({
+        try: () => execute(ctx.storage, intent),
+        catch: alarmFailure(operation),
+      }).pipe(Effect.tap(() => checkpoint));
     });
 
     return Effect.withFiber((fiber) => {
@@ -388,7 +387,7 @@ const makeAlarmOperation = Effect.gen(function* () {
 
       // Preserve eager writes and invalidation for an unwrapped host SQL transaction.
       return ambient._tag === "Some" && !DueQueue.buffering(ctx.storage)
-        ? transaction(commit).pipe(
+        ? transaction(() => commit).pipe(
             Effect.ensuring(Effect.sync(() => DueQueue.invalidate(ctx.storage))),
           )
         : withTransaction(commit);
@@ -734,6 +733,25 @@ interface NativeDispatch {
   scanRevision?: number;
 }
 
+/** Observe already-owned waves without creating one waiter fiber for each wave. */
+const awaitAnyCompletion = Effect.fnUntraced(function* (
+  fibers: ReadonlyArray<Fiber.Fiber<unknown, MaintenancePassFailure>>,
+  revision: number,
+) {
+  const mutations = yield* ThreadMutationGate;
+
+  return yield* Effect.acquireUseRelease(
+    Effect.sync<Array<() => void>>(() => []),
+    (observers) =>
+      Effect.callback<"completed" | "scan">((resume) => {
+        observers.push(mutations.observeChange(revision, () => resume(Effect.succeed("scan"))));
+        for (const fiber of fibers)
+          observers.push(fiber.addObserver(() => resume(Effect.succeed("completed"))));
+      }),
+    (observers) => Effect.sync(() => observers.forEach((remove) => remove())),
+  );
+});
+
 /** Post-native delivery shares a finite connection budget across independent host lanes. */
 const afterNativeDispatchConcurrency = 2;
 
@@ -914,6 +932,8 @@ export class ThreadMutationGate extends Context.Service<
     readonly activeLanes: Effect.Effect<ReadonlySet<string>>;
     readonly revision: Effect.Effect<number>;
     readonly awaitChange: (revision: number) => Effect.Effect<void>;
+    /** Register an incarnation-local observer; its caller must detach it on completion. */
+    readonly observeChange: (revision: number, notify: () => void) => () => void;
     readonly withSnapshot: <A, E, R>(
       body: (active: number) => Effect.Effect<A, E, R>,
     ) => Effect.Effect<A, E, R>;
@@ -934,14 +954,27 @@ export class ThreadMutationGate extends Context.Service<
       const activeLanes = new Map<string, number>();
       const generationGate = yield* Semaphore.make(1);
       let revision = 0;
-      let changed = yield* Deferred.make<void>();
+      const listeners = new Set<() => void>();
 
-      const notify = Effect.gen(function* () {
-        const previous = changed;
+      const observeChange = (observed: number, listener: () => void): (() => void) => {
+        if (observed !== revision) {
+          listener();
+
+          return () => {};
+        }
+        listeners.add(listener);
 
-        changed = yield* Deferred.make<void>();
+        return () => {
+          listeners.delete(listener);
+        };
+      };
+
+      const notify = Effect.sync(() => {
         revision++;
-        yield* Deferred.succeed(previous, undefined);
+        const pending = [...listeners];
+
+        listeners.clear();
+        for (const listener of pending) listener();
       });
 
       const minimumAlarmDelay = Math.max(1, Math.ceil(config.alarmBackoffBase / 2));
@@ -1182,8 +1215,13 @@ export class ThreadMutationGate extends Context.Service<
         recordProgress,
         activeLanes: Effect.sync(() => new Set(activeLanes.keys())),
         revision: Effect.sync(() => revision),
+        observeChange,
         awaitChange: (observed) =>
-          Effect.suspend(() => (observed === revision ? Deferred.await(changed) : Effect.void)),
+          Effect.callback((resume) => {
+            const remove = observeChange(observed, () => resume(Effect.void));
+
+            return Effect.sync(remove);
+          }),
         withSnapshot: (body) =>
           generationGate.withPermit(Effect.flatMap(Ref.get(activeMutations), body)),
       });
@@ -1259,6 +1297,7 @@ export class ThreadMaintenance extends Context.Service<
       const runtime = yield* DurableAgentRuntime;
       const recoveryConfig = yield* DurableRuntimeConfig;
       const ledger = yield* SubmissionLedger;
+      const listNonterminal = ledger.listNonterminal ?? Stream.runCollect(ledger.scanNonterminal);
       const wakes = yield* WakeScheduler;
       const hints = yield* DurableAlarmService;
       const alarms = yield* ThreadMaintenanceAlarm;
@@ -1280,6 +1319,8 @@ export class ThreadMaintenance extends Context.Service<
       const messages = yield* ThreadMessageDelivery;
       const host = yield* ThreadHostMaintenance;
       const framework = yield* ThreadNativeMaintenance;
+      const placement = yield* Effect.serviceOption(ThreadObjectPlacement);
+      const nativeThread = Option.isSome(placement) ? placement.value.threadId : undefined;
 
       const nativeDispatchConcurrency = () => (framework.singleThreadRuntime === runtime ? 1 : 2);
 
@@ -1564,9 +1605,7 @@ export class ThreadMaintenance extends Context.Service<
         const now = yield* Clock.currentTimeMillis;
 
         // Fault-only discovery uses control state even when retained payloads cannot decode.
-        const submissions =
-          current ??
-          (result.blocked.length === 0 ? [] : yield* Stream.runCollect(ledger.scanNonterminal));
+        const submissions = current ?? (result.blocked.length === 0 ? [] : yield* listNonterminal);
 
         yield* failpoint.hit("maintenance:recovery-status:before");
 
@@ -1681,7 +1720,11 @@ export class ThreadMaintenance extends Context.Service<
 
         do {
           const result = yield* runtime
-            .runRecovery({ threadId, ...(cursor === undefined ? {} : { cursor }) })
+            .runRecovery({
+              threadId,
+              deferUnclaimedAdmissions: true,
+              ...(cursor === undefined ? {} : { cursor }),
+            })
             .pipe(Effect.provideService(CurrentNativeSource, true));
 
           // Persist each bounded pass before a claim; eviction resumes past consumed metadata.
@@ -2124,19 +2167,31 @@ export class ThreadMaintenance extends Context.Service<
 
             return {
               scannedGeneration: state.dirty,
-              afterWorkThread: state.lastRecoveredThreadId,
+              // Single-Thread placement would immediately wrap past its own cursor.
+              afterWorkThread:
+                framework.singleThreadRuntime === runtime &&
+                state.lastRecoveredThreadId === nativeThread
+                  ? undefined
+                  : state.lastRecoveredThreadId,
             };
           },
         );
 
-        const current = yield* Stream.runCollect(ledger.scanNonterminal);
-
-        let workOwners = yield* runtime
-          .discoverWorkThreads({
-            limit: 32,
-            ...(afterWorkThread === undefined ? {} : { afterThreadId: afterWorkThread }),
-          })
-          .pipe(Effect.provideService(CurrentNativeSource, true));
+        const current = yield* listNonterminal;
+
+        // A current admission proves this native placement is materialized. Empty Objects
+        // still discover retained canonical obligations without inventing a recovery owner.
+        let workOwners =
+          framework.singleThreadRuntime === runtime &&
+          nativeThread !== undefined &&
+          current.some((submission) => submission.threadId === nativeThread)
+            ? { threadIds: [nativeThread], afterThreadId: undefined }
+            : yield* runtime
+                .discoverWorkThreads({
+                  limit: 32,
+                  ...(afterWorkThread === undefined ? {} : { afterThreadId: afterWorkThread }),
+                })
+                .pipe(Effect.provideService(CurrentNativeSource, true));
 
         if (workOwners.threadIds.length === 0 && afterWorkThread !== undefined)
           workOwners = yield* runtime
@@ -2398,7 +2453,7 @@ export class ThreadMaintenance extends Context.Service<
           };
         }
 
-        const remaining = yield* Stream.runCollect(ledger.scanNonterminal);
+        const remaining = yield* listNonterminal;
         const waitingHeads = new Map<ThreadId, boolean>();
 
         // Selected recovery must finish before its generation can be acknowledged: terminal
@@ -2565,12 +2620,22 @@ export class ThreadMaintenance extends Context.Service<
         dispatchUntil: DateTime.Utc,
         observed: MaintenanceObservation,
       ) {
+        const leanSelection =
+          framework.singleThreadRuntime === runtime &&
+          publication === emptyPublication &&
+          host.lanes.length === 0 &&
+          framework.lanes.length === 0;
+
         // Subscribe before the first snapshot. Durable enrollment recovers eviction;
         // producer completion and wake hints make work visible during this incarnation.
-        const notified = (yield* Stream.toPull(wakes.wakes)).pipe(
-          Effect.asVoid,
-          Effect.catch(() => Effect.never),
-        );
+        // Native source mutations already notify the revision waiter below. A replacement
+        // or shared runtime keeps the generic wake stream; hints confer no authority.
+        const notified = leanSelection
+          ? Effect.never
+          : (yield* Stream.toPull(wakes.wakes)).pipe(
+              Effect.asVoid,
+              Effect.catch(() => Effect.never),
+            );
 
         // A wake may observe temporary backoff while this event's recovery is still running.
         // Its completion must retain the original actionable observation for acknowledgement.
@@ -2622,56 +2687,8 @@ export class ThreadMaintenance extends Context.Service<
           discoveryPending: false,
         };
 
-        const recoveryFiber = yield* fork(
-          Effect.gen(function* () {
-            for (const threadId of yield* Deferred.await(recovery.queue)) {
-              yield* failpoint.hit("maintenance:select:before");
-              yield* runTransaction("select old recovery lane", () =>
-                dueQueue.transaction(async (transaction) => {
-                  const { state } = await readMaintenanceState(transaction);
-
-                  await transaction.put(
-                    MAINTENANCE_STATE_KEY,
-                    encodeMaintenanceState(
-                      ThreadMaintenanceState.make({
-                        ...state,
-                        lastRecoveredThreadId: threadId,
-                      }),
-                    ),
-                  );
-                }),
-              );
-              yield* failpoint.hit("maintenance:select:after");
-              yield* recoverThread(threadId, recovery);
-              recovery.pending.delete(threadId);
-              if (!recovery.faults.has(threadId)) yield* wakes.notify(threadId);
-            }
-          }),
-        );
-
-        // Backfill is one disposable wave; native and host work keep their own opportunities.
-        const backfill = yield* fork(
-          Effect.gen(function* () {
-            if ((yield* mutations.activeLanes).has(DueQueue.Projection)) return;
-            const row = (yield* queueSnapshot).find((row) => row.id === DueQueue.Projection);
-
-            if (
-              row?.dueAt === null ||
-              row === undefined ||
-              row.dueAt > (yield* Clock.currentTimeMillis)
-            )
-              return;
-
-            return yield* runQueued(
-              row,
-              projection.drain.pipe(Effect.andThen(projection.pendingDeadline)),
-              observed,
-            ).pipe(Effect.timeoutOption(config.projectionDispatchTimeoutMillis));
-          }),
-        );
-
-        let backfillObserved = false;
-        let recoveryObserved = false;
+        let recoveryFiber: Fiber.Fiber<void, MaintenancePassFailure> | undefined;
+        let backfill: Fiber.Fiber<void, DurableAlarmError | ThreadProjectionError> | undefined;
 
         const dispatch: NativeDispatch = {
           scope: auxiliaryScope,
@@ -2683,18 +2700,79 @@ export class ThreadMaintenance extends Context.Service<
           needsCheckpoint: false,
         };
 
-        let native: Fiber.Fiber<NativePassResult, MaintenancePassFailure> | undefined = yield* fork(
-          advance(started, yieldAfter, observed, recovery, dispatch),
-        );
+        // Selection is bounded local work, not an independently owned wave. It opens
+        // actual Attempt scopes, then returns; empty lanes create no fibers.
+        let native: Fiber.Fiber<NativePassResult, MaintenancePassFailure> | undefined;
+        let result: NativePassResult;
+        let backlog: ReadonlyArray<ThreadId> | undefined;
 
-        let result: NativePassResult = {
-          phase: "caught-up",
-          nonterminal: started.nonterminal,
-          nextAttemptAt: undefined,
-        };
+        if (leanSelection) {
+          result = yield* advance(started, yieldAfter, observed, recovery, dispatch);
+          recovery.started = true;
+          yield* Deferred.succeed(recovery.queue, []);
+          backlog = yield* Deferred.await(recovery.queue);
+        } else {
+          // Required publication and arbitrary host lanes keep independent opportunities
+          // while selection is suspended in an application callback.
+          native = yield* fork(advance(started, yieldAfter, observed, recovery, dispatch));
+          result = {
+            phase: "caught-up",
+            nonterminal: started.nonterminal,
+            nextAttemptAt: undefined,
+          };
+        }
+
+        if (backlog === undefined || backlog.length > 0) {
+          recoveryFiber = yield* fork(
+            Effect.gen(function* () {
+              for (const threadId of backlog ?? (yield* Deferred.await(recovery.queue))) {
+                yield* failpoint.hit("maintenance:select:before");
+                yield* runTransaction("select old recovery lane", () =>
+                  dueQueue.transaction(async (transaction) => {
+                    const { state } = await readMaintenanceState(transaction);
+
+                    await transaction.put(
+                      MAINTENANCE_STATE_KEY,
+                      encodeMaintenanceState(
+                        ThreadMaintenanceState.make({
+                          ...state,
+                          lastRecoveredThreadId: threadId,
+                        }),
+                      ),
+                    );
+                  }),
+                );
+                yield* failpoint.hit("maintenance:select:after");
+                yield* recoverThread(threadId, recovery);
+                recovery.pending.delete(threadId);
+                if (!recovery.faults.has(threadId)) yield* wakes.notify(threadId);
+              }
+            }),
+          );
+        }
+        const projectionRow = (yield* queueSnapshot).find((row) => row.id === DueQueue.Projection);
+
+        if (
+          projectionRow !== undefined &&
+          projectionRow.dueAt !== null &&
+          projectionRow.dueAt <= (yield* Clock.currentTimeMillis) &&
+          !(yield* mutations.activeLanes).has(DueQueue.Projection)
+        ) {
+          backfill = yield* fork(
+            runQueued(
+              projectionRow,
+              projection.drain.pipe(Effect.andThen(projection.pendingDeadline)),
+              observed,
+            ).pipe(Effect.timeoutOption(config.projectionDispatchTimeoutMillis), Effect.asVoid),
+          );
+        }
 
         let phase = result.phase;
-        let nativeCheck = false;
+
+        let nativeCheck =
+          result.dispatched === true && dispatch.active.size < nativeDispatchConcurrency();
+
+        observed.nativeOnly = dispatch.active.size > 0;
         const until = DateTime.toEpochMillis(yieldAfter);
         const dispatchEnd = DateTime.toEpochMillis(dispatchUntil);
 
@@ -2725,19 +2803,17 @@ export class ThreadMaintenance extends Context.Service<
             if (exit.value === 0) dispatch.deferred.add(threadId);
             nativeCheck = true;
           }
-          if (!recoveryObserved && recoveryFiber.pollUnsafe() !== undefined) {
+          if (recoveryFiber?.pollUnsafe() !== undefined) {
             yield* Fiber.join(recoveryFiber);
-            recoveryObserved = true;
+            recoveryFiber = undefined;
             dispatch.scanGeneration = undefined;
             nativeCheck ||= recovery.needsCheckpoint;
           }
-          if (!backfillObserved) {
-            const exit = backfill.pollUnsafe();
+          const backfillExit = backfill?.pollUnsafe();
 
-            if (exit !== undefined) {
-              backfillObserved = true;
-              if (Exit.isFailure(exit)) failure ??= exit.cause;
-            }
+          if (backfillExit !== undefined) {
+            backfill = undefined;
+            if (Exit.isFailure(backfillExit)) failure ??= backfillExit.cause;
           }
           for (const lane of lanes) {
             const exit = lane.fiber?.pollUnsafe();
@@ -2844,9 +2920,9 @@ export class ThreadMaintenance extends Context.Service<
           if (
             native === undefined &&
             dispatch.active.size === 0 &&
-            recoveryObserved &&
+            recoveryFiber === undefined &&
             !recovery.needsCheckpoint &&
-            backfillObserved &&
+            backfill === undefined &&
             delivery === undefined &&
             lanes.every((lane) => lane.fiber === undefined)
           )
@@ -2859,7 +2935,9 @@ export class ThreadMaintenance extends Context.Service<
           ) {
             nativeCheck = false;
             const nativeCheckpoint = dispatch.needsCheckpoint && dispatch.active.size === 0;
-            const checkpoint = (recoveryObserved && recovery.needsCheckpoint) || nativeCheckpoint;
+
+            const checkpoint =
+              (recoveryFiber === undefined && recovery.needsCheckpoint) || nativeCheckpoint;
 
             if (checkpoint) recovery.needsCheckpoint = false;
             // Keep this opportunity's reservations across beginNative's storage awaits.
@@ -2894,26 +2972,39 @@ export class ThreadMaintenance extends Context.Service<
           );
 
           const completing = [
-            ...(native === undefined ? [] : [native]),
+            native,
             ...dispatch.active.values(),
-            ...(recoveryObserved ? [] : [recoveryFiber]),
-            ...(backfillObserved ? [] : [backfill]),
-            ...(delivery === undefined ? [] : [delivery]),
-            ...lanes.flatMap((lane) => (lane.fiber === undefined ? [] : [lane.fiber])),
-          ];
-
-          const ready = yield* Effect.raceAllFirst([
-            ...completing.map((fiber) =>
-              Fiber.await<unknown, MaintenancePassFailure>(fiber).pipe(
-                Effect.as("completed" as const),
-              ),
-            ),
-            Effect.raceAllFirst([
-              notified,
-              mutations.awaitChange(queueRevision),
-              Effect.sleep(Math.max(0, next - now)),
-            ]).pipe(Effect.as("scan" as const)),
-          ]);
+            recoveryFiber,
+            backfill,
+            delivery,
+            ...lanes.map((lane) => lane.fiber),
+          ].filter((fiber) => fiber !== undefined);
+
+          const changed = awaitAnyCompletion(completing, queueRevision);
+
+          // An occupied native-only slot cannot admit another Attempt. With no auxiliary
+          // wake before yield, the timer would only switch to joining that same Attempt.
+          // Incoming work still wakes this callback; all new waves recheck the deadline.
+          const joiningNative =
+            leanSelection &&
+            native === undefined &&
+            dispatch.active.size === 1 &&
+            completing.length === 1 &&
+            !queued.some(
+              (row) =>
+                row.id !== DueQueue.Native &&
+                row.dueAt !== null &&
+                row.dueAt > now &&
+                row.dueAt < until,
+            );
+
+          const ready = yield* joiningNative
+            ? changed
+            : Effect.raceAllFirst([
+                changed,
+                ...(leanSelection ? [] : [notified.pipe(Effect.as("scan" as const))]),
+                Effect.sleep(Math.max(0, next - now)).pipe(Effect.as("scan" as const)),
+              ]);
 
           if (ready === "scan") {
             nativeCheck = true;
@@ -2939,9 +3030,10 @@ export class ThreadMaintenance extends Context.Service<
         for (const fiber of [
           recoveryFiber,
           backfill,
-          ...(delivery === undefined ? [] : [delivery]),
-          ...lanes.flatMap((lane) => (lane.fiber === undefined ? [] : [lane.fiber])),
+          delivery,
+          ...lanes.map((lane) => lane.fiber),
         ]) {
+          if (fiber === undefined) continue;
           // Await exits without failing fast: every admitted wave owns its original
           // bounded allowance and cleanup even if another wave has already failed.
           const exit = yield* Fiber.await<unknown, MaintenancePassFailure>(fiber);
@@ -2964,7 +3056,9 @@ export class ThreadMaintenance extends Context.Service<
         observed: MaintenanceObservation,
       ): Effect.fn.Return<MaintenancePassReport, MaintenancePassFailure, Scope.Scope> {
         const concurrent = yield* Effect.exit(
-          Effect.scoped(dispatch(yieldAfter, dispatchUntil, observed)),
+          Effect.scoped(dispatch(yieldAfter, dispatchUntil, observed)).pipe(
+            Effect.provideService(ThreadMutationGate, mutations),
+          ),
         );
 
         // Closing the concurrent scope first releases every native Attempt and its resources.