@yielded/agent-platform-cloudflare 0.1.0-beta.167 → 0.1.0-beta.169

package/dist/{Alarm-B0ODr1NE.mjs → Alarm-BMEAZo3p.mjs}

@@ -2,6 +2,7 @@ import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
 import { DurableObjectContext } from "./CloudflareBindings.mjs";
 import { AuxiliaryDispatchMillis, CloudflareDurableRuntimeConfig } from "./CloudflareConfig.mjs";
 import { r as safeCauseMessage } from "./boundary-BguazVkh.mjs";
+import { CurrentNativeSource } from "@yielded/agent-storage-cloudflare/port-routing";
 import "@yielded/agent/agent-registration";
 import { DurableAgentRuntime, DurableRuntimeConfig, RecoveryBlocked, RecoveryFailure, RecoverySweepResult, isolateRecovery } from "@yielded/agent/durable-agent-runtime";
 import { SubmissionId, ThreadId } from "@yielded/agent/identifiers";
@@ -9,7 +10,7 @@ import { AbortIntentRequest, SubmissionLedger } from "@yielded/agent/submission-
 import { ThreadProjectionMaintenance } from "@yielded/agent/thread-projection-maintenance";
 import { WakeScheduler } from "@yielded/agent/wake-scheduler";
 import { Cause, Clock, Context, DateTime, Deferred, Effect, ErrorReporter, Exit, Fiber, Layer, Option, Random, Ref, Result, Scheduler, Schema, Scope, Semaphore, Stream, Struct } from "effect";
-import { DurableObjectStorage } from "effect-cf";
+import { DurableObjectAlarm, DurableObjectStorage } from "effect-cf";
 import { SqlClient } from "effect/sql/SqlClient";
 import { SqlError, UnknownError } from "effect/sql/SqlError";
 //#region src/internal/due-queue.ts
@@ -134,34 +135,6 @@ const make = (storage) => {
 		const changes = [...current.changes.values()].filter(({ before, after }) => before === void 0 || !equivalent(before, after));
 		for (let offset = 0; offset < changes.length; offset += 11) write(changes.slice(offset, offset + 11));
 	};
-	/** Own the flush inside the source transaction without changing the SQL service.
-	* Acquire its shared connection permit through Effect requirements. Cleanup follows
-	* native settlement, including commit rejection or interruption. */
-	const withTransaction = (body) => Effect.flatMap(SqlClient, (client) => Effect.flatMap(Effect.serviceOption(client.transactionService), (ambient) => {
-		if (ambient._tag === "Some" && !ownsTransaction(storage, ambient.value[1])) return Effect.fail(SqlError.make({ reason: UnknownError.make({
-			operation: "begin maintenance source transaction",
-			message: "Use ThreadMutationGate.withTransaction at the outermost source transaction",
-			cause: /* @__PURE__ */ new Error("Unwrapped SQL transaction cannot own buffered maintenance intent")
-		}) }));
-		return Effect.uninterruptibleMask((restore) => Effect.suspend(() => {
-			let frame;
-			return client.withTransaction(Effect.flatMap(Effect.serviceOption(client.transactionService), (transaction) => Effect.sync(() => {
-				if (transaction._tag === "None") throw new Error("SQL transaction unavailable");
-				frame = begin(transaction.value[1]);
-			})).pipe(Effect.andThen(restore(body)), Effect.tap(() => Effect.try({
-				try: () => {
-					if (frame !== void 0) 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 !== void 0) finish(frame, Exit.isSuccess(exit));
-			})), Effect.provideService(Scheduler.PreventSchedulerYield, true));
-		}));
-	}));
 	const transaction = async (body) => {
 		let frame;
 		try {
@@ -308,7 +281,9 @@ const make = (storage) => {
 	return {
 		initialize,
 		withView,
-		withTransaction,
+		begin,
+		flush,
+		finish,
 		transaction,
 		read,
 		dirty,
@@ -329,6 +304,7 @@ var Alarm_exports = /* @__PURE__ */ __exportAll({
 	MaintenancePassReport: () => MaintenancePassReport,
 	ThreadHostMaintenance: () => ThreadHostMaintenance,
 	ThreadMaintenance: () => ThreadMaintenance,
+	ThreadMaintenanceAlarm: () => ThreadMaintenanceAlarm,
 	ThreadMaintenanceFailpoint: () => ThreadMaintenanceFailpoint,
 	ThreadMessageDelivery: () => ThreadMessageDelivery,
 	ThreadMutationGate: () => ThreadMutationGate,
@@ -339,10 +315,8 @@ var Alarm_exports = /* @__PURE__ */ __exportAll({
 	publishCommitted: () => publishCommitted
 });
 /**
-* The single multiplexed Durable Object alarm (decision D-P6-2). A Durable Object has ONE
-* alarm slot; due work (lease expiry, settlement
-* and abort re-checks, retry backoff) multiplexes into one idempotent maintenance pass, and
-* the slot always holds the EARLIEST deadline any caller asked for.
+* The maintenance queue owns lease expiry, settlement, retries and dirty generations.
+* Its manual effect-cf alarm shares the native slot with other registered alarms.
 *
 * The alarm invariant (plan §1.4): every committed actionable mutation carries a newer durable
 * maintenance generation and a committed alarm. Stable externally-driven waits may be
@@ -382,41 +356,123 @@ const makeStorageOperation = Effect.map(makeStorageEffect, (run) => (operation,
 	try: execute,
 	catch: alarmFailure(operation)
 })));
-/** Native `ctx.storage` alarm slot owned by ThreadMaintenance; storage is truth. */
+/** One manual alarm for the entire consumer-owned maintenance queue. */
+var ThreadMaintenanceAlarm = class extends DurableObjectAlarm.Tag()("@yielded/agent/thread-maintenance", { "@yielded/agent/thread-maintenance": {
+	payload: Schema.Null,
+	lifecycle: "manual"
+} }) {};
+const maintenanceAlarmRef = {
+	tag: "@yielded/agent/thread-maintenance",
+	id: "queue"
+};
+const maintenanceAlarmInput = (deadline) => ({
+	...maintenanceAlarmRef,
+	payload: null,
+	runAt: DateTime.makeUnsafe(deadline)
+});
+/** Named maintenance checkpoint; the library owns the shared native alarm slot. */
 var DurableAlarmService = class DurableAlarmService extends Context.Service()("@effect-agent/platform-cloudflare/DurableAlarmService") {
 	static layer = Layer.effect(DurableAlarmService)(Effect.gen(function* () {
+		const alarms = yield* ThreadMaintenanceAlarm;
 		const { ctx } = yield* DurableObjectContext;
-		/**
-		* In-memory pass bookkeeping — a pure CACHE, never state: a fresh incarnation has no
-		* running pass, and a deferred wake lost to eviction was only ever a promptness hint
-		* on top of the already-committed pre-armed alarm.
-		*/
-		const runningPasses = yield* Ref.make(0);
-		const storageOperation = yield* makeStorageOperation;
-		const scheduled = storageOperation("get alarm", () => ctx.storage.getAlarm()).pipe(Effect.map((deadline) => deadline === null ? Option.none() : Option.some(deadline)));
-		const scheduleAt = (epochMillis) => storageOperation("set alarm", () => ctx.storage.setAlarm(epochMillis));
-		const ensureScheduledBy = (epochMillis) => storageOperation("ensure alarm", () => ctx.storage.transaction(async (transaction) => {
-			const existing = await transaction.getAlarm();
-			if (existing === null || existing > epochMillis) await transaction.setAlarm(epochMillis);
-		}));
-		const armNow = Clock.currentTimeMillis.pipe(Effect.flatMap((now) => storageOperation("wake maintenance lanes", () => ctx.storage.transaction(async (transaction) => {
-			const next$7 = next(make(ctx.storage).read());
-			if (Number.isFinite(next$7)) await ensureTransactionAlarmBy(transaction, Math.max(now, next$7));
-		}))));
-		const scheduleNow = Ref.get(runningPasses).pipe(Effect.flatMap((passes) => passes > 0 ? Effect.void : armNow));
-		const withWakesDeferred = (body) => Ref.update(runningPasses, (passes) => passes + 1).pipe(Effect.andThen(body), Effect.ensuring(Ref.update(runningPasses, (passes) => passes - 1)));
-		const cancel = storageOperation("delete alarm", () => ctx.storage.deleteAlarm());
+		const run = yield* makeStorageEffect;
+		const inlineWork = yield* Ref.make(0);
+		const wrap = (operation, effect) => run(operation, effect.pipe(Effect.mapError(alarmFailure(operation))));
 		return DurableAlarmService.of({
-			scheduled,
-			scheduleAt,
-			ensureScheduledBy,
-			scheduleNow,
-			withWakesDeferred,
-			cancel
+			scheduled: wrap("read maintenance checkpoint", alarms.getAlarmStatus(maintenanceAlarmRef)).pipe(Effect.map((at) => at === void 0 ? Option.none() : Option.some(DateTime.toEpochMillis(at.runAt)))),
+			scheduleAt: (at) => wrap("replace maintenance checkpoint", alarms.scheduleAlarm(maintenanceAlarmInput(at))),
+			ensureScheduledBy: (at) => wrap("advance maintenance checkpoint", alarms.scheduleAlarmEarlier(maintenanceAlarmInput(at))),
+			scheduleNow: Ref.get(inlineWork).pipe(Effect.flatMap((active) => active > 0 ? Effect.void : wrap("hint maintenance checkpoint", alarms.transaction((tx) => Effect.gen(function* () {
+				const now = yield* Clock.currentTimeMillis;
+				const next$4 = next(make(ctx.storage).read());
+				if (Number.isFinite(next$4)) yield* tx.scheduleAlarmEarlier(maintenanceAlarmInput(Math.max(now, next$4)));
+			}))))),
+			withHintsDeferred: (body) => Effect.acquireUseRelease(Ref.update(inlineWork, (active) => active + 1), () => body, () => Ref.update(inlineWork, (active) => active - 1)),
+			cancel: wrap("cancel maintenance checkpoint", alarms.cancelAlarm(maintenanceAlarmRef))
 		});
 	}));
 };
-/** What one maintenance pass did — auditable evidence mirroring `NodeDurableHost`'s report. */
+const CurrentCheckpoint = Context.Reference("@yielded/agent/cloudflare/CurrentCheckpoint", { defaultValue: () => void 0 });
+/** One source transaction owns queue intent and the library checkpoint through commit. */
+const makeAlarmOperation = Effect.gen(function* () {
+	const alarms = yield* ThreadMaintenanceAlarm;
+	const sql = yield* SqlClient;
+	const { ctx } = yield* DurableObjectContext;
+	const queue = make(ctx.storage);
+	const transaction = (body) => 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;
+		})));
+	}), { sqlClient: sql }).pipe(Effect.mapError((cause) => cause instanceof DurableObjectStorage.StorageOperationError ? SqlError.make({ reason: UnknownError.make({
+		operation: "commit maintenance checkpoint",
+		message: "Source facts and maintenance checkpoint could not commit",
+		cause
+	}) }) : cause));
+	const withTransaction = (body) => Effect.flatMap(Effect.serviceOption(sql.transactionService), (ambient) => {
+		if (ambient._tag === "Some" && !ownsTransaction(ctx.storage, ambient.value[1])) return Effect.fail(SqlError.make({ reason: UnknownError.make({
+			operation: "begin maintenance source transaction",
+			message: "Use ThreadMutationGate.withTransaction at the outermost source transaction",
+			cause: /* @__PURE__ */ new Error("Unwrapped SQL transaction cannot own buffered maintenance intent")
+		}) }));
+		return Effect.uninterruptibleMask((restore) => Effect.suspend(() => {
+			let frame;
+			return transaction(Effect.flatMap(Effect.serviceOption(sql.transactionService), (transaction) => Effect.sync(() => {
+				if (transaction._tag === "None") throw new Error("SQL transaction unavailable");
+				frame = queue.begin(transaction.value[1]);
+			})).pipe(Effect.andThen(restore(body)), Effect.tap(() => Effect.try({
+				try: () => {
+					if (frame !== void 0) 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 !== void 0) queue.finish(frame, Exit.isSuccess(exit));
+			})), Effect.provideService(Scheduler.PreventSchedulerYield, true));
+		}));
+	}).pipe(Effect.provideService(SqlClient, sql));
+	const run = (operation, execute) => {
+		const commit = Effect.flatMap(CurrentCheckpoint, (tx) => {
+			if (tx === void 0) return Effect.die(/* @__PURE__ */ new Error("Maintenance checkpoint transaction unavailable"));
+			return tx.requireActive.pipe(Effect.andThen(Effect.suspend(() => {
+				let checkpoint = Effect.void;
+				const intent = {
+					at: (at) => {
+						checkpoint = tx.mutations.scheduleAlarm(maintenanceAlarmInput(at));
+					},
+					earlier: (at) => {
+						checkpoint = tx.mutations.scheduleAlarmEarlier(maintenanceAlarmInput(at));
+					},
+					cancel: () => {
+						checkpoint = tx.mutations.cancelAlarm(maintenanceAlarmRef);
+					}
+				};
+				return Effect.tryPromise({
+					try: () => execute(ctx.storage, intent),
+					catch: alarmFailure(operation)
+				}).pipe(Effect.tap(() => checkpoint));
+			})));
+		});
+		return Effect.gen(function* () {
+			if ((yield* CurrentCheckpoint) !== void 0) return yield* commit;
+			return yield* (yield* Effect.serviceOption(sql.transactionService))._tag === "Some" && !buffering(ctx.storage) ? transaction(commit).pipe(Effect.ensuring(Effect.sync(() => invalidate(ctx.storage)))) : withTransaction(commit);
+		}).pipe(Effect.uninterruptible, Effect.mapError(alarmFailure(operation)));
+	};
+	return {
+		run,
+		withTransaction
+	};
+});
 var MaintenancePassReport = class extends Schema.Class("@effect-agent/platform-cloudflare/MaintenancePassReport")({
 	/** `caught-up` ran no runtime work (publication may be pending); `actionable` ran recovery. */
 	phase: Schema.Literals(["caught-up", "actionable"]),
@@ -490,6 +546,8 @@ const decodeRecoveryEvent = Schema.decodeUnknownSync(ThreadRecoveryFaultEvent);
 * Object and sequence; callbacks may repeat after interruption. This is a trusted host hook,
 * not pre-authorized UI data: the host owns recipient authorization and safe presentation.
 * Capture services in the Layer. Do not call producers or write the raw alarm slot.
+* Without this service, maintenance acknowledges and discards transitions. Install the
+* handler before the first maintenance pass if the application needs that event stream.
 */
 var ThreadRecoveryEvents = class extends Context.Service()("@effect-agent/platform-cloudflare/ThreadRecoveryEvents") {};
 var BindingWait = class extends Schema.Class("BindingWait")({
@@ -549,9 +607,13 @@ const recoveryEvent = (fault, submissionId, transition, occurredAt) => ({
 	firstFailedAt: fault.firstFailedAt,
 	failure: fault.failure
 });
-const nativeDispatchConcurrency = 2;
 /** Post-native delivery shares a finite connection budget across independent host lanes. */
 const afterNativeDispatchConcurrency = 2;
+const NativeWorkCursor = Schema.Struct({
+	threadId: ThreadId,
+	cursor: Schema.NonEmptyString.check(Schema.isMaxLength(8192))
+});
+const workCursorKey = (threadId) => `effect-agent:work-recovery-cursor:v1:${threadId}`;
 var MaintenanceRetry = class extends Schema.Class("MaintenanceRetry")({
 	generation: MaintenanceGeneration,
 	notBefore: Schema.Finite,
@@ -597,10 +659,6 @@ const readMaintenanceState = async (transaction) => {
 		initialized: true
 	};
 };
-const ensureTransactionAlarmBy = async (transaction, deadline) => {
-	const scheduled = await transaction.getAlarm();
-	if (scheduled === null || scheduled > deadline) await transaction.setAlarm(deadline);
-};
 const stableExternalWait = (snapshot, reports) => {
 	const report = reports.get(snapshot.submissionId);
 	if (report?.decision._tag === "SettleAborted") return false;
@@ -612,9 +670,7 @@ const stableExternalWait = (snapshot, reports) => {
 		case "input-applied":
 		case "joining":
 		case "ready":
-		case "running":
-		case "settled":
-		case "terminalizing": return false;
+		case "settled": return false;
 	}
 };
 /**
@@ -623,7 +679,6 @@ const stableExternalWait = (snapshot, reports) => {
 * Layers must reuse that instance; a second gate cannot observe the native producers' activity.
 */
 const CurrentMutationLanes = Context.Reference("@effect-agent/platform-cloudflare/CurrentMutationLanes", { defaultValue: () => [] });
-const CurrentNativeSource = Context.Reference("@effect-agent/platform-cloudflare/CurrentNativeSource", { defaultValue: () => false });
 var ThreadMutationGate = class ThreadMutationGate extends Context.Service()("@effect-agent/platform-cloudflare/internal/ThreadMutationGate") {
 	static layer = Layer.effect(this)(Effect.gen(function* () {
 		const { ctx } = yield* DurableObjectContext;
@@ -644,6 +699,7 @@ var ThreadMutationGate = class ThreadMutationGate extends Context.Service()("@ef
 		});
 		const minimumAlarmDelay = Math.max(1, Math.ceil(config.alarmBackoffBase / 2));
 		const runTransaction = yield* makeStorageOperation;
+		const { run: runAlarmTransaction, withTransaction } = yield* makeAlarmOperation;
 		const validateSourceBoundary = Effect.flatMap(Effect.serviceOption(sql.transactionService), (current) => current._tag === "Some" && buffering(ctx.storage) && !ownsTransaction(ctx.storage, current.value[1]) ? Effect.fail(DurableAlarmError.make({
 			operation: "enroll maintenance source",
 			message: "Nested source scheduling requires ThreadMutationGate.withTransaction"
@@ -652,11 +708,10 @@ var ThreadMutationGate = class ThreadMutationGate extends Context.Service()("@ef
 			dueQueue.initialize();
 			dueQueue.register(Native);
 		});
-		const schedule = Effect.fn("ThreadMutationGate.schedule")(function* (id, dueAt, progressCursor) {
+		const schedule = Effect.fnUntraced(function* (id, dueAt, progressCursor) {
 			yield* validateSourceBoundary;
 			const now = yield* Clock.currentTimeMillis;
-			const current = yield* Effect.serviceOption(sql.transactionService);
-			const enroll = async (transaction) => {
+			const enroll = async (transaction, checkpoint) => {
 				if (progressCursor === void 0) dueQueue.dirty(id, dueAt);
 				else if (dueQueue.progress(id, dueAt, progressCursor) && (id === "effect-agent:native" || id === "effect-agent:publication")) {
 					if (id === "effect-agent:publication") dueQueue.dirty(Native, dueAt, true);
@@ -666,32 +721,31 @@ var ThreadMutationGate = class ThreadMutationGate extends Context.Service()("@ef
 						dirty: state.dirty + 1n
 					})));
 				}
-				const next$2 = next(dueQueue.read());
-				if (Number.isFinite(next$2)) await ensureTransactionAlarmBy(transaction, Math.max(next$2, now + minimumAlarmDelay));
+				const next$6 = next(dueQueue.read());
+				if (Number.isFinite(next$6)) checkpoint.earlier(Math.max(next$6, now + minimumAlarmDelay));
 			};
-			yield* runTransaction("schedule maintenance lane", () => Option.isSome(current) ? enroll(ctx.storage) : dueQueue.transaction(enroll));
+			yield* runAlarmTransaction("schedule maintenance lane", enroll);
 			yield* notify;
 		});
-		const beginMutation = Effect.fn("ThreadMaintenance.beginMutation")(function* (invalidatesRecovery, lanes) {
+		const beginMutation = Effect.fnUntraced(function* (invalidatesRecovery, lanes) {
 			yield* failpoint.hit("maintenance:dirty:before");
 			const now = yield* Clock.currentTimeMillis;
 			const nativeSource = yield* CurrentNativeSource;
 			const publicationRequired = yield* requiresPublication;
-			if (invalidatesRecovery || lanes.length > 0) yield* runTransaction("advance maintenance generation", () => dueQueue.transaction(async (transaction) => {
+			if (invalidatesRecovery || lanes.length > 0) yield* runAlarmTransaction("advance maintenance generation", async (transaction, checkpoint) => {
 				const { state, initialized } = await readMaintenanceState(transaction);
 				if (invalidatesRecovery) {
 					dueQueue.dirty(Native, now);
 					if (publicationRequired) dueQueue.dirty(Publication, now);
 				}
 				for (const id of lanes) dueQueue.dirty(id, now, false);
-				const next$1 = ThreadMaintenanceState.make({
+				if (!initialized || invalidatesRecovery && !nativeSource) await transaction.put(MAINTENANCE_STATE_KEY, encodeMaintenanceState(ThreadMaintenanceState.make({
 					...state,
 					dirty: state.dirty + (invalidatesRecovery && !nativeSource ? 1n : 0n)
-				});
-				if (invalidatesRecovery || !initialized) await transaction.put(MAINTENANCE_STATE_KEY, encodeMaintenanceState(next$1));
+				})));
 				const deadline = next(dueQueue.read());
-				if (Number.isFinite(deadline)) await ensureTransactionAlarmBy(transaction, Math.max(deadline, now + minimumAlarmDelay));
-			}));
+				if (Number.isFinite(deadline)) checkpoint.earlier(Math.max(deadline, now + minimumAlarmDelay));
+			});
 			yield* failpoint.hit("maintenance:dirty:after");
 			yield* Ref.update(activeMutations, (active) => active + 1);
 			const enrolled = /* @__PURE__ */ new Set([...lanes, ...invalidatesRecovery ? [Native, ...publicationRequired ? [Publication] : []] : []]);
@@ -712,7 +766,7 @@ var ThreadMutationGate = class ThreadMutationGate extends Context.Service()("@ef
 			operation: "prearm maintenance mutation",
 			message: "Run withMutation outside the source SQL transaction so prearming commits first"
 		})) : Effect.acquireUseRelease(generationGate.withPermit(beginMutation(options?.invalidatesRecovery ?? true, options?.lanes ?? [])), (enrolled) => failpoint.hit("maintenance:mutation:armed").pipe(Effect.andThen(Effect.flatMap(CurrentMutationLanes, (current) => body.pipe(Effect.provideService(CurrentMutationLanes, [.../* @__PURE__ */ new Set([...current, ...enrolled])])))), Effect.tap(() => releaseLanes(enrolled, true).pipe(Effect.andThen(notify))), Effect.tap(() => failpoint.hit("maintenance:mutation:finished"))), (enrolled) => endMutation(enrolled).pipe(Effect.andThen(notify))));
-		const recordProgress = Effect.fn("ThreadMutationGate.recordProgress")(function* (lanes) {
+		const recordProgress = Effect.fnUntraced(function* (lanes) {
 			yield* validateSourceBoundary;
 			if (Option.isNone(yield* Effect.serviceOption(sql.transactionService))) return yield* DurableAlarmError.make({
 				operation: "record source progress",
@@ -724,21 +778,21 @@ var ThreadMutationGate = class ThreadMutationGate extends Context.Service()("@ef
 			if (affected.size === 0) return;
 			const now = yield* Clock.currentTimeMillis;
 			const nativeSource = yield* CurrentNativeSource;
-			yield* runTransaction("record maintenance producer progress", async () => {
+			yield* runAlarmTransaction("record maintenance producer progress", async (transaction, checkpoint) => {
 				for (const id of affected) dueQueue.dirty(id, now, true);
 				if (affected.has("effect-agent:native")) {
-					const { state } = await readMaintenanceState(ctx.storage);
-					await ctx.storage.put(MAINTENANCE_STATE_KEY, encodeMaintenanceState(ThreadMaintenanceState.make({
+					const { state, initialized } = await readMaintenanceState(transaction);
+					if (!initialized || !nativeSource || state.retry !== void 0) await transaction.put(MAINTENANCE_STATE_KEY, encodeMaintenanceState(ThreadMaintenanceState.make({
 						...Struct.omit(state, ["retry"]),
 						dirty: state.dirty + (nativeSource ? 0n : 1n)
 					})));
 				}
-				await ensureTransactionAlarmBy(ctx.storage, now + minimumAlarmDelay);
+				checkpoint.earlier(now + minimumAlarmDelay);
 			});
 			yield* notify;
 		});
 		return ThreadMutationGate.of({
-			withTransaction: (body) => dueQueue.withTransaction(body).pipe(Effect.provideService(SqlClient, sql)),
+			withTransaction,
 			withMutation,
 			schedule,
 			recordProgress,
@@ -759,7 +813,8 @@ var ThreadMutationGate = class ThreadMutationGate extends Context.Service()("@ef
 * 2. Reconcile before each head Attempt, then checkpoint only the observed generation. A racing
 *    producer keeps its generation dirty and immediately eligible. Quiescent native retries
 *    retain their durable backoff.
-* 3. Admit at most two independent Thread Attempts, one active head per Thread.
+* 3. Admit one Attempt for a single-Thread runtime, or at most two independent Thread
+*    Attempts for a shared host, with one active head per Thread.
 *    Keep native and delivery admission open together while finite waves remain active, so
 *    fresh replies and abort controls can progress during unrelated cleanup. Close atomically
 *    at quiescence, or at the original ten-minute yield deadline, then join admitted waves.
@@ -775,7 +830,8 @@ var ThreadMaintenance = class ThreadMaintenance extends Context.Service()("@effe
 		const recoveryConfig = yield* DurableRuntimeConfig;
 		const ledger = yield* SubmissionLedger;
 		const wakes = yield* WakeScheduler;
-		const alarm = yield* DurableAlarmService;
+		const hints = yield* DurableAlarmService;
+		const alarms = yield* ThreadMaintenanceAlarm;
 		const config = yield* CloudflareDurableRuntimeConfig;
 		const { ctx } = yield* DurableObjectContext;
 		const dueQueue = make(ctx.storage);
@@ -789,12 +845,14 @@ var ThreadMaintenance = class ThreadMaintenance extends Context.Service()("@effe
 		const messages = yield* ThreadMessageDelivery;
 		const host = yield* ThreadHostMaintenance;
 		const framework = yield* ThreadNativeMaintenance;
+		const nativeDispatchConcurrency = () => framework.singleThreadRuntime === runtime ? 1 : 2;
 		for (const lane of host.lanes) yield* Schema.decodeEffect(HostLaneId)(lane.id).pipe(Effect.mapError(alarmFailure("maintenance lane ID")));
 		const recoveryEvents = Option.getOrElse(yield* Effect.serviceOption(ThreadRecoveryEvents), () => ThreadRecoveryEvents.of({ publish: () => Effect.void }));
 		let recoveryEventsPending = false;
 		const maintenancePassGate = yield* Semaphore.make(1);
 		const minimumAlarmDelay = Math.max(1, Math.ceil(config.alarmBackoffBase / 2));
 		const runTransaction = yield* makeStorageOperation;
+		const { run: runAlarmTransaction } = yield* makeAlarmOperation;
 		const queueSnapshot = runTransaction("read maintenance due queue", async () => dueQueue.read());
 		const reportParked = Effect.gen(function* () {
 			if (!(yield* queueSnapshot).some((row) => row.state === "parked" && row.reported === 0)) return;
@@ -834,13 +892,13 @@ var ThreadMaintenance = class ThreadMaintenance extends Context.Service()("@effe
 			let charged = false;
 			return Effect.gen(function* () {
 				const now = yield* Clock.currentTimeMillis;
-				const claimed = yield* runTransaction("charge maintenance attempt", () => dueQueue.transaction(async (transaction) => {
+				const claimed = yield* runAlarmTransaction("charge maintenance attempt", async (_transaction, checkpoint) => {
 					const claimed = dueQueue.claim(selected, now);
-					const next$5 = next(dueQueue.read());
-					if (Number.isFinite(next$5)) await transaction.setAlarm(Math.max(now + minimumAlarmDelay, next$5));
-					else await transaction.deleteAlarm();
+					const next$1 = next(dueQueue.read());
+					if (Number.isFinite(next$1)) checkpoint.at(Math.max(now + minimumAlarmDelay, next$1));
+					else checkpoint.cancel();
 					return claimed;
-				}));
+				});
 				if (claimed === void 0) return Option.none();
 				row = claimed;
 				charged = true;
@@ -922,9 +980,11 @@ var ThreadMaintenance = class ThreadMaintenance extends Context.Service()("@effe
 				return recoveryEventsPending ? Option.some(0) : Option.none();
 			})
 		};
-		const recordRecoveryFaults = Effect.fn("ThreadMaintenance.recordRecoveryFaults")(function* (result, recovery, current) {
+		const recordRecoveryFaults = Effect.fnUntraced(function* (result, recovery, current, selectedThread) {
 			const threads = /* @__PURE__ */ new Map();
+			if (selectedThread !== void 0) threads.set(selectedThread, void 0);
 			for (const report of result.reports) threads.set(report.threadId, void 0);
+			for (const report of result.workReports ?? []) threads.set(report.threadId, void 0);
 			for (const blocked of result.blocked) threads.set(blocked.threadId, blocked.failure);
 			if (threads.size === 0) return /* @__PURE__ */ new Map();
 			const now = yield* Clock.currentTimeMillis;
@@ -985,14 +1045,35 @@ var ThreadMaintenance = class ThreadMaintenance extends Context.Service()("@effe
 			for (const fault of retained.newlyBlocked) yield* Effect.logError("Native Thread recovery blocked; accepted work remains pending", fault.failure.reason === "defect" ? Cause.die(fault.failure) : Cause.fail(fault.failure)).pipe(Effect.annotateLogs({ threadId: fault.threadId }));
 			return retained.faults;
 		});
-		const recoverThread = Effect.fn("ThreadMaintenance.recoverThread")(function* (threadId, recovery) {
-			const result = yield* runtime.runRecovery({ threadId }).pipe(Effect.provideService(CurrentNativeSource, true));
-			const faults = yield* recordRecoveryFaults(result, recovery);
-			for (const report of result.reports) recovery.reports.set(report.submissionId, report);
-			recovery.faults.delete(threadId);
-			for (const [id, fault] of faults) recovery.faults.set(id, fault);
-			recovery.recovered += result.reports.length + result.blocked.length;
-			recovery.repaired ||= result.reports.some((report) => report.disposition === "repaired");
+		const recoverThread = Effect.fnUntraced(function* (threadId, recovery) {
+			let cursor = yield* runTransaction("read work recovery cursor", async () => {
+				const retained = await ctx.storage.get(workCursorKey(threadId));
+				if (retained === void 0) return void 0;
+				const decoded = Schema.decodeUnknownSync(NativeWorkCursor)(retained);
+				if (decoded.threadId !== threadId) throw new Error("Work cursor belongs to another Thread");
+				return decoded.cursor;
+			});
+			do {
+				const result = yield* runtime.runRecovery({
+					threadId,
+					...cursor === void 0 ? {} : { cursor }
+				}).pipe(Effect.provideService(CurrentNativeSource, true));
+				const faults = yield* recordRecoveryFaults(result, recovery, void 0, threadId);
+				yield* runTransaction("checkpoint work recovery cursor", async () => {
+					if (result.cursor === void 0) await ctx.storage.delete(workCursorKey(threadId));
+					else await ctx.storage.put(workCursorKey(threadId), Schema.encodeSync(NativeWorkCursor)({
+						threadId,
+						cursor: result.cursor
+					}));
+				});
+				for (const report of result.reports) recovery.reports.set(report.submissionId, report);
+				recovery.faults.delete(threadId);
+				for (const [id, fault] of faults) recovery.faults.set(id, fault);
+				recovery.recovered += (result.workReports?.length ?? result.reports.length) + result.blocked.length;
+				recovery.repaired ||= (result.workReports ?? result.reports).some((report) => report.disposition === "repaired");
+				for (const report of result.workReports ?? []) if (report.retryAtMillis !== void 0) recovery.retryAtMillis = Math.min(recovery.retryAtMillis ?? Infinity, report.retryAtMillis);
+				cursor = result.blocked.length > 0 ? void 0 : result.cursor;
+			} while (cursor !== void 0);
 		});
 		const readCurrentMaintenanceState = async (transaction) => {
 			const current = await readMaintenanceState(transaction);
@@ -1010,10 +1091,10 @@ var ThreadMaintenance = class ThreadMaintenance extends Context.Service()("@effe
 				initialized: true
 			};
 		};
-		const ensureAlarm = Effect.fn("ThreadMaintenance.ensureAlarm")(function* () {
+		const ensureAlarm = Effect.fnUntraced(function* () {
 			yield* failpoint.hit("maintenance:ensure:before");
 			const now = yield* Clock.currentTimeMillis;
-			yield* runTransaction("ensure maintenance alarm", () => dueQueue.transaction(async (transaction) => {
+			yield* runAlarmTransaction("ensure maintenance alarm", async (transaction, checkpoint) => {
 				const { state, initialized } = await readCurrentMaintenanceState(transaction);
 				recoveryEventsPending = hasRecoveryEvents(state);
 				const rows = dueQueue.read();
@@ -1022,14 +1103,14 @@ var ThreadMaintenance = class ThreadMaintenance extends Context.Service()("@effe
 				const native = state.dirty > state.processed ? state.retry?.generation === state.dirty ? state.retry.notBefore : rows.find((row) => row.id === "effect-agent:native")?.dueAt ?? now + minimumAlarmDelay : null;
 				dueQueue.checkpointNative(native);
 				const next$3 = next(dueQueue.read());
-				if (Number.isFinite(next$3)) await ensureTransactionAlarmBy(transaction, Math.max(now + minimumAlarmDelay, next$3));
-			}));
+				if (Number.isFinite(next$3)) checkpoint.earlier(Math.max(now + minimumAlarmDelay, next$3));
+			});
 			yield* failpoint.hit("maintenance:ensure:after");
 		});
-		const beginPass = Effect.fn("ThreadMaintenance.beginPass")(function* (observed) {
+		const beginPass = Effect.fnUntraced(function* (observed) {
 			yield* failpoint.hit("maintenance:begin:before");
 			const now = yield* Clock.currentTimeMillis;
-			const result = yield* runTransaction("begin maintenance pass", () => dueQueue.transaction(async (transaction) => {
+			const result = yield* runAlarmTransaction("begin maintenance pass", async (transaction, checkpoint) => {
 				const { state, initialized } = await readCurrentMaintenanceState(transaction);
 				recoveryEventsPending = hasRecoveryEvents(state);
 				observed.generation = state.dirty;
@@ -1050,8 +1131,8 @@ var ThreadMaintenance = class ThreadMaintenance extends Context.Service()("@effe
 				observed.queue.set(Native, charged);
 				observed.charged.set(Native, charged.revision);
 				const deadline = next(dueQueue.read());
-				if (Number.isFinite(deadline)) await transaction.setAlarm(Math.max(now + minimumAlarmDelay, deadline));
-				else await transaction.deleteAlarm();
+				if (Number.isFinite(deadline)) checkpoint.at(Math.max(now + minimumAlarmDelay, deadline));
+				else checkpoint.cancel();
 				return {
 					_tag: "Actionable",
 					generation: state.dirty,
@@ -1059,7 +1140,7 @@ var ThreadMaintenance = class ThreadMaintenance extends Context.Service()("@effe
 					nonterminal: state.nonterminal,
 					stalls: charged.stalls
 				};
-			}));
+			});
 			yield* failpoint.hit("maintenance:begin:after");
 			return result;
 		});
@@ -1067,17 +1148,17 @@ var ThreadMaintenance = class ThreadMaintenance extends Context.Service()("@effe
 			const backoff = Math.min(config.alarmBackoffCap, config.alarmBackoffBase * 2 ** Math.min(priorStalls, 30));
 			return Math.ceil(backoff / 2 + backoff / 2 * jitter);
 		};
-		const rearmDelay = Effect.fn("ThreadMaintenance.rearmDelay")(function* (progressed, priorStalls) {
+		const rearmDelay = Effect.fnUntraced(function* (progressed, priorStalls) {
 			return progressed ? config.alarmBackoffBase : backoffDelay(priorStalls, yield* Random.next);
 		});
-		const rearmFailure = Effect.fn("ThreadMaintenance.rearmFailure")(function* (observed) {
+		const rearmFailure = Effect.fnUntraced(function* (observed) {
 			const { generation, nativeOnly } = observed;
 			if (generation === void 0) return;
 			yield* failpoint.hit("maintenance:retry:before");
 			yield* mutations.withSnapshot((active) => Effect.gen(function* () {
 				const now = yield* Clock.currentTimeMillis;
 				const jitter = yield* Random.next;
-				yield* runTransaction("back off failed maintenance", () => dueQueue.transaction(async (transaction) => {
+				yield* runAlarmTransaction("back off failed maintenance", async (transaction, checkpoint) => {
 					const { state } = await readMaintenanceState(transaction);
 					const previous = state.retry?.generation === generation && state.retry.nativeOnly === nativeOnly ? state.retry : void 0;
 					const retry = state.retry?.generation === generation && state.retry.nativeOnly ? state.retry : MaintenanceRetry.make({
@@ -1096,27 +1177,25 @@ var ThreadMaintenance = class ThreadMaintenance extends Context.Service()("@effe
 						const charged = observed.charged.get(row.id) === row.revision ? row : dueQueue.claim(row, now);
 						if (charged !== void 0) dueQueue.complete(charged, now + backoffDelay(charged.stalls, jitter));
 					}
-					const next$4 = next(dueQueue.read());
-					if (Number.isFinite(next$4)) await transaction.setAlarm(Math.max(now + minimumAlarmDelay, next$4));
-					else await transaction.deleteAlarm();
-				}));
+					const next$5 = next(dueQueue.read());
+					if (Number.isFinite(next$5)) checkpoint.at(Math.max(now + minimumAlarmDelay, next$5));
+					else checkpoint.cancel();
+				});
 			}));
 			yield* failpoint.hit("maintenance:retry:after");
 		});
-		const beginNative = Effect.fn("ThreadMaintenance.beginNative")(function* (observed) {
-			return yield* mutations.withSnapshot((activeAtStart) => Effect.gen(function* () {
-				const generation = yield* beginPass(observed);
-				if (activeAtStart === 0) {
-					const native = (yield* queueSnapshot).find((row) => row.id === Native);
-					if (native !== void 0) observed.available.set(native.id, native.revision);
-				}
-				return {
-					...generation,
-					activeAtStart
-				};
-			}));
-		});
-		const attemptSelected = Effect.fn("ThreadMaintenance.attemptSelected")(function* (selected, previousWaits, yieldAfter, recovery) {
+		const beginNative = (observed) => mutations.withSnapshot((activeAtStart) => Effect.gen(function* () {
+			const generation = yield* beginPass(observed);
+			if (activeAtStart === 0) {
+				const native = (yield* queueSnapshot).find((row) => row.id === Native);
+				if (native !== void 0) observed.available.set(native.id, native.revision);
+			}
+			return {
+				...generation,
+				activeAtStart
+			};
+		}));
+		const attemptSelected = Effect.fnUntraced(function* (selected, previousWaits, yieldAfter, recovery) {
 			yield* recoverThread(selected.threadId, recovery);
 			let bindingFailure;
 			const settlement = recovery.faults.has(selected.threadId) ? Option.none() : yield* runtime.processThreadHead(selected.threadId, { yieldAfter }).pipe(Effect.provideService(CurrentNativeSource, true), Effect.catchTag("BindingUnavailable", (failure) => {
@@ -1148,7 +1227,7 @@ var ThreadMaintenance = class ThreadMaintenance extends Context.Service()("@effe
 			}
 			return Option.isSome(settlement) ? 1 : 0;
 		});
-		const advance = Effect.fn("ThreadMaintenance.advance")(function* (started, yieldAfter, observed, recovery, native, dispatch = true, reserved = new Set(native.active.keys())) {
+		const advance = Effect.fnUntraced(function* (started, yieldAfter, observed, recovery, native, dispatch = true, reserved = new Set(native.active.keys())) {
 			let publicationRow = (yield* queueSnapshot).find((row) => row.id === Publication);
 			if (publicationRow !== void 0 && publicationRow.dueAt !== null && publicationRow.dueAt <= (yield* Clock.currentTimeMillis)) {
 				yield* runQueued(publicationRow, mutations.withSnapshot((active) => started._tag === "Actionable" && active === 0 ? publication.prepareGeneration(started.generation) : Effect.void).pipe(Effect.andThen(publication.drain)), observed);
@@ -1186,7 +1265,20 @@ var ThreadMaintenance = class ThreadMaintenance extends Context.Service()("@effe
 				generation: started.generation,
 				activeAtStart: started.activeAtStart
 			};
+			const { scannedGeneration, afterWorkThread } = yield* runTransaction("read work discovery position", async () => {
+				const { state } = await readMaintenanceState(ctx.storage);
+				return {
+					scannedGeneration: state.dirty,
+					afterWorkThread: state.lastRecoveredThreadId
+				};
+			});
 			const current = yield* Stream.runCollect(ledger.scanNonterminal);
+			let workOwners = yield* runtime.discoverWorkThreads({
+				limit: 32,
+				...afterWorkThread === void 0 ? {} : { afterThreadId: afterWorkThread }
+			}).pipe(Effect.provideService(CurrentNativeSource, true));
+			if (workOwners.threadIds.length === 0 && afterWorkThread !== void 0) workOwners = yield* runtime.discoverWorkThreads({ limit: 32 }).pipe(Effect.provideService(CurrentNativeSource, true));
+			recovery.discoveryPending ||= workOwners.afterThreadId !== void 0;
 			const selectionTime = yield* Clock.currentTimeMillis;
 			const submissionsByThread = /* @__PURE__ */ new Map();
 			for (const row of current) {
@@ -1194,6 +1286,7 @@ var ThreadMaintenance = class ThreadMaintenance extends Context.Service()("@effe
 				ids.push(row.submissionId);
 				submissionsByThread.set(row.threadId, ids);
 			}
+			for (const threadId of workOwners.threadIds) if (!submissionsByThread.has(threadId)) submissionsByThread.set(threadId, []);
 			yield* runTransaction("read Thread recovery deadlines", async () => {
 				for (const [threadId, ids] of submissionsByThread) {
 					if (!recovery.loaded.has(threadId)) {
@@ -1265,13 +1358,13 @@ var ThreadMaintenance = class ThreadMaintenance extends Context.Service()("@effe
 				const waits = (state.bindingWaits ?? []).filter((retry) => heads.get(retry.threadId)?.submissionId === retry.submissionId);
 				const runnable = eligible.filter((threadId) => !reserved.has(threadId) && !native.active.has(threadId) && !native.deferred.has(threadId) && !waits.some((wait) => wait.threadId === threadId));
 				const pivot = Math.max(0, runnable.findIndex((threadId) => state.lastServedThreadId === void 0 || threadId > state.lastServedThreadId));
-				const selected = dispatch ? [...runnable.slice(pivot), ...runnable.slice(0, pivot)].slice(0, nativeDispatchConcurrency - reserved.size) : [];
+				const selected = dispatch ? [...runnable.slice(pivot), ...runnable.slice(0, pivot)].slice(0, nativeDispatchConcurrency() - reserved.size) : [];
 				const next = selected.at(-1);
 				if (next !== void 0) await transaction.put(MAINTENANCE_STATE_KEY, encodeMaintenanceState(ThreadMaintenanceState.make({
 					...state,
 					lastServedThreadId: next
 				})));
-				const backlog = recovery.started ? [] : [...heads.keys()].filter((threadId) => {
+				const backlog = recovery.started ? [] : [.../* @__PURE__ */ new Set([...heads.keys(), ...workOwners.threadIds])].filter((threadId) => {
 					const fault = recoveryFaults.get(threadId);
 					return !eligible.includes(threadId) && (fault === void 0 || fault.retryAt <= selectionTime);
 				});
@@ -1280,13 +1373,15 @@ var ThreadMaintenance = class ThreadMaintenance extends Context.Service()("@effe
 				return {
 					selected,
 					waits,
-					backlog: [...after, ...before]
+					backlog: [...after, ...before].slice(0, 32),
+					discoveryPending: backlog.length > 32
 				};
 			}));
 			yield* failpoint.hit("maintenance:select:after");
 			if (!recovery.started) {
 				recovery.started = true;
 				recovery.needsCheckpoint = selection.backlog.length > 0;
+				recovery.discoveryPending ||= selection.discoveryPending;
 				for (const threadId of selection.backlog) recovery.pending.add(threadId);
 				yield* Deferred.succeed(recovery.queue, selection.backlog);
 			}
@@ -1302,10 +1397,9 @@ var ThreadMaintenance = class ThreadMaintenance extends Context.Service()("@effe
 				nextAttemptAt: void 0,
 				dispatched: selection.selected.length > 0
 			};
-			const scannedGeneration = yield* runTransaction("observe native source generation", async () => (await readMaintenanceState(ctx.storage)).state.dirty);
 			const remaining = yield* Stream.runCollect(ledger.scanNonterminal);
 			const waitingHeads = /* @__PURE__ */ new Map();
-			const autonomous = remaining.some((snapshot) => {
+			const autonomous = recovery.pending.size > 0 || recovery.discoveryPending || recoveryFaults.size > 0 || recovery.retryAtMillis !== void 0 || remaining.some((snapshot) => {
 				if (snapshot.state === "unknown" && waiting(snapshot)) return false;
 				const headWaiting = waitingHeads.get(snapshot.threadId);
 				if (headWaiting === void 0) waitingHeads.set(snapshot.threadId, waiting(snapshot));
@@ -1316,13 +1410,14 @@ var ThreadMaintenance = class ThreadMaintenance extends Context.Service()("@effe
 			const now = yield* Clock.currentTimeMillis;
 			const ordinaryDelay = autonomous ? yield* rearmDelay(progressed, started.stalls) : 0;
 			const nextEligible = [...recoveryFaults.values()].map((fault) => fault.retryAt).concat(eligible.filter((threadId) => !selection.waits.some((wait) => wait.threadId === threadId)).map(() => now));
+			if (recovery.retryAtMillis !== void 0) nextEligible.push(recovery.retryAtMillis);
 			const retryDelay = nextEligible.length === 0 ? 0 : Math.max(0, Math.min(...nextEligible) - now);
 			const delay = Math.max(ordinaryDelay, retryDelay);
 			yield* failpoint.hit("maintenance:checkpoint:before");
 			const nextAttemptAt = yield* mutations.withSnapshot((active) => runTransaction("checkpoint native maintenance", () => dueQueue.transaction(async (transaction) => {
 				const { state } = await readMaintenanceState(transaction);
 				const mutationOverlap = observation.activeAtStart > 0 || started.activeAtStart > 0 || active > 0;
-				const generation = remaining.length === 0 && !mutationOverlap && state.dirty === scannedGeneration ? scannedGeneration : observation.generation;
+				const generation = remaining.length === 0 && workOwners.threadIds.length === 0 && !mutationOverlap && state.dirty === scannedGeneration ? scannedGeneration : observation.generation;
 				const processed = autonomous || mutationOverlap ? state.processed : state.processed > generation ? state.processed : generation;
 				const canBackoff = !mutationOverlap && state.dirty === started.generation;
 				const next = ThreadMaintenanceState.make({
@@ -1343,7 +1438,10 @@ var ThreadMaintenance = class ThreadMaintenance extends Context.Service()("@effe
 				return dueAt ?? void 0;
 			})));
 			yield* failpoint.hit("maintenance:checkpoint:after");
-			if (remaining.length === 0 && recovery.pending.size === 0) delete recovery.observation;
+			if (remaining.length === 0 && recovery.pending.size === 0) recovery.observation = {
+				generation: observation.generation,
+				activeAtStart: 0
+			};
 			native.deferred.clear();
 			native.progressed = false;
 			native.needsCheckpoint = false;
@@ -1353,7 +1451,7 @@ var ThreadMaintenance = class ThreadMaintenance extends Context.Service()("@effe
 				nextAttemptAt
 			};
 		});
-		const validateLanes = Effect.fn("ThreadMaintenance.validateLanes")(function* (lanes, queued) {
+		const validateLanes = Effect.fnUntraced(function* (lanes, queued) {
 			const ids = /* @__PURE__ */ new Set([
 				Native,
 				Publication,
@@ -1373,7 +1471,7 @@ var ThreadMaintenance = class ThreadMaintenance extends Context.Service()("@effe
 				message: `No handler registered for scheduled lane: ${row.id}`
 			});
 		});
-		const dispatch = Effect.fn("ThreadMaintenance.dispatch")(function* (yieldAfter, dispatchUntil, observed) {
+		const dispatch = Effect.fnUntraced(function* (yieldAfter, dispatchUntil, observed) {
 			const notified = (yield* Stream.toPull(wakes.wakes)).pipe(Effect.asVoid, Effect.catch(() => Effect.never));
 			const started = yield* beginNative(observed);
 			yield* mutations.withSnapshot(() => Effect.gen(function* () {
@@ -1408,7 +1506,8 @@ var ThreadMaintenance = class ThreadMaintenance extends Context.Service()("@effe
 				started: false,
 				needsCheckpoint: false,
 				recovered: 0,
-				repaired: false
+				repaired: false,
+				discoveryPending: false
 			};
 			const recoveryFiber = yield* fork(Effect.gen(function* () {
 				for (const threadId of yield* Deferred.await(recovery.queue)) {
@@ -1459,7 +1558,7 @@ var ThreadMaintenance = class ThreadMaintenance extends Context.Service()("@effe
 					native = void 0;
 					if (result.phase === "actionable") phase = "actionable";
 					observed.nativeOnly = dispatch.active.size > 0;
-					if (result.dispatched === true && dispatch.active.size < nativeDispatchConcurrency) {
+					if (result.dispatched === true && dispatch.active.size < nativeDispatchConcurrency()) {
 						dispatch.scanGeneration = void 0;
 						nativeCheck = true;
 					}
@@ -1548,7 +1647,7 @@ var ThreadMaintenance = class ThreadMaintenance extends Context.Service()("@effe
 					}), observed).pipe(Effect.asVoid));
 				}
 				if (native === void 0 && dispatch.active.size === 0 && recoveryObserved && !recovery.needsCheckpoint && backfillObserved && delivery === void 0 && lanes.every((lane) => lane.fiber === void 0)) break;
-				if (native === void 0 && nativeCheck && dispatch.active.size < nativeDispatchConcurrency) {
+				if (native === void 0 && nativeCheck && dispatch.active.size < nativeDispatchConcurrency()) {
 					nativeCheck = false;
 					const nativeCheckpoint = dispatch.needsCheckpoint && dispatch.active.size === 0;
 					const checkpoint = recoveryObserved && recovery.needsCheckpoint || nativeCheckpoint;
@@ -1610,7 +1709,7 @@ var ThreadMaintenance = class ThreadMaintenance extends Context.Service()("@effe
 				settled: dispatch.settled
 			};
 		});
-		const pass = Effect.fn("ThreadMaintenance.pass")(function* (yieldAfter, dispatchUntil, observed) {
+		const pass = Effect.fnUntraced(function* (yieldAfter, dispatchUntil, observed) {
 			const concurrent = yield* Effect.exit(Effect.scoped(dispatch(yieldAfter, dispatchUntil, observed)));
 			const afterNative = yield* Effect.gen(function* () {
 				const lanes = [
@@ -1678,18 +1777,18 @@ var ThreadMaintenance = class ThreadMaintenance extends Context.Service()("@effe
 			yield* failpoint.hit("maintenance:finish:before");
 			const disposition = yield* mutations.withSnapshot((active) => Effect.gen(function* () {
 				const now = yield* Clock.currentTimeMillis;
-				return yield* runTransaction("finish maintenance event", () => dueQueue.transaction(async (transaction) => {
+				return yield* runAlarmTransaction("finish maintenance event", async (transaction, checkpoint) => {
 					const { state } = await readMaintenanceState(transaction);
 					const native = active > 0 || state.dirty > state.processed ? state.retry?.generation === state.dirty && active === 0 ? Math.max(now + minimumAlarmDelay, state.retry.notBefore) : state.dirty === observed.generation && active === 0 ? result.nextAttemptAt ?? now + minimumAlarmDelay : now + minimumAlarmDelay : Infinity;
 					dueQueue.checkpointNative(Number.isFinite(native) ? native : null);
-					const next$6 = next(dueQueue.read());
-					if (Number.isFinite(next$6)) {
-						await transaction.setAlarm(Math.max(now + minimumAlarmDelay, next$6));
+					const next$2 = next(dueQueue.read());
+					if (Number.isFinite(next$2)) {
+						checkpoint.at(Math.max(now + minimumAlarmDelay, next$2));
 						return "rearmed";
 					}
-					await transaction.deleteAlarm();
+					checkpoint.cancel();
 					return "cleared";
-				}));
+				});
 			}));
 			yield* failpoint.hit("maintenance:finish:after");
 			const report = MaintenancePassReport.make({
@@ -1719,7 +1818,10 @@ var ThreadMaintenance = class ThreadMaintenance extends Context.Service()("@effe
 					charged: /* @__PURE__ */ new Map(),
 					available: /* @__PURE__ */ new Map()
 				};
-				return yield* alarm.withWakesDeferred(maintenancePassGate.withPermit(dueQueue.withView(Effect.scoped(pass(yieldAfter, dispatchUntil, observed))).pipe(Effect.onErrorIf(() => true, () => rearmFailure(observed)))));
+				return yield* alarms.deferWakes(maintenancePassGate.withPermit(dueQueue.withView(Effect.scoped(pass(yieldAfter, dispatchUntil, observed))).pipe(Effect.onErrorIf(() => true, () => rearmFailure(observed))))).pipe(hints.withHintsDeferred, Effect.catchTags({
+					StorageOperationError: (error) => alarmFailure("defer maintenance wakes")(error),
+					InvalidScheduleConfigurationError: (error) => alarmFailure("defer maintenance wakes")(error)
+				}));
 			}).pipe(Effect.timeoutOrElse({
 				duration: "14 minutes",
 				orElse: () => DurableAlarmError.make({
@@ -1733,6 +1835,6 @@ var ThreadMaintenance = class ThreadMaintenance extends Context.Service()("@effe
 	}));
 };
 //#endregion
-export { Messages as _, ThreadHostMaintenance as a, Publication as b, ThreadMessageDelivery as c, ThreadPublication as d, ThreadRecoveryEvents as f, Lifecycle as g, HostLaneId as h, MaintenancePassReport as i, ThreadMutationGate as l, publishCommitted as m, DurableAlarmError as n, ThreadMaintenance as o, ThreadRecoveryFaultEvent as p, DurableAlarmService as r, ThreadMaintenanceFailpoint as s, Alarm_exports as t, ThreadNativeMaintenance as u, Native as v, Projection as y };
+export { Lifecycle as _, ThreadHostMaintenance as a, Projection as b, ThreadMaintenanceFailpoint as c, ThreadNativeMaintenance as d, ThreadPublication as f, HostLaneId as g, publishCommitted as h, MaintenancePassReport as i, ThreadMessageDelivery as l, ThreadRecoveryFaultEvent as m, DurableAlarmError as n, ThreadMaintenance as o, ThreadRecoveryEvents as p, DurableAlarmService as r, ThreadMaintenanceAlarm as s, Alarm_exports as t, ThreadMutationGate as u, Messages as v, Publication as x, Native as y };
 
-//# sourceMappingURL=Alarm-B0ODr1NE.mjs.map
+//# sourceMappingURL=Alarm-BMEAZo3p.mjs.map