@bastani/atomic 0.9.43 → 0.9.44-alpha.2

package/dist/builtin/workflows/src/extension/index.bundle.mjs

@@ -1858,7 +1858,13 @@ function createStoreContext(state = createStoreState()) {
     }
     return cachedGraphSnapshot;
   }
+  let batchDepth = 0;
+  let batchedNotification = false;
   function notify() {
+    if (batchDepth > 0) {
+      batchedNotification = true;
+      return;
+    }
     observation.capture();
     for (const fn of state.invalidationListeners) {
       try {
@@ -1878,6 +1884,18 @@ function createStoreContext(state = createStoreState()) {
     state.version++;
     notify();
   }
+  function batch(update) {
+    batchDepth++;
+    try {
+      return update();
+    } finally {
+      batchDepth--;
+      if (batchDepth === 0 && batchedNotification) {
+        batchedNotification = false;
+        notify();
+      }
+    }
+  }
   function findRun(runId) {
     return state.runs.find((r) => r.id === runId);
   }
@@ -1931,6 +1949,7 @@ function createStoreContext(state = createStoreState()) {
     snapshot,
     graphSnapshot,
     notify,
+    batch,
     bumpAndNotify,
     findRun,
     findStage,
@@ -3867,6 +3886,9 @@ function createRunStoreMethods(context) {
     subscribeInvalidation(fn) {
       state.invalidationListeners.add(fn);
       return () => state.invalidationListeners.delete(fn);
+    },
+    batch(update) {
+      return context.batch(update);
     }
   };
 }
@@ -5840,22 +5862,37 @@ function childScopedEvidenceExists(checkpoints, boundaryReplayKey, childRunId) {
 }
 function retainReachableRunGroups(grouped, rootRunId) {
   const reachable = new Set([rootRunId]);
-  const pending = [rootRunId];
+  const settled = new Set;
+  const pending = [{ runId: rootRunId, live: true }];
   while (pending.length > 0) {
-    const drafts = grouped.get(pending.pop());
+    const { runId, live } = pending.pop();
+    const drafts = grouped.get(runId);
     if (drafts === undefined)
       continue;
     for (const draft of drafts) {
-      const childRunId = childRunIdFromDraft(draft);
-      if (childRunId === undefined || reachable.has(childRunId) || !grouped.has(childRunId))
+      const childRunId = workflowChildFromDraft(draft)?.runId ?? draft.topology?.boundary?.child.runId;
+      if (childRunId === undefined || !grouped.has(childRunId))
         continue;
-      reachable.add(childRunId);
-      pending.push(childRunId);
+      if (live && childRunIdFromDraft(draft) !== undefined) {
+        if (reachable.has(childRunId))
+          continue;
+        reachable.add(childRunId);
+        pending.push({ runId: childRunId, live: true });
+      } else if (!settled.has(childRunId)) {
+        settled.add(childRunId);
+        pending.push({ runId: childRunId, live: false });
+      }
     }
   }
-  for (const runId of grouped.keys())
-    if (!reachable.has(runId))
-      grouped.delete(runId);
+  let complete = true;
+  for (const runId of grouped.keys()) {
+    if (reachable.has(runId))
+      continue;
+    if (!settled.has(runId))
+      complete = false;
+    grouped.delete(runId);
+  }
+  return complete;
 }
 function childRunIdFromDraft(draft) {
   const boundary = draft.topology?.boundary;
@@ -6771,6 +6808,13 @@ function removeProcessExitCleanup(cleanup) {
   if (processExitCleanups.delete(cleanup) && processExitCleanups.size === 0)
     process.off("exit", runProcessExitCleanups);
 }
+function snapshotNeedsHistory(tail) {
+  const event = tail.snapshot.event;
+  if (event.type !== RUN_EVENT_TYPES.messageQueued)
+    return false;
+  const payload = event.payload;
+  return hasPendingStageDeliveryDelta(payload.pendingStageMessages);
+}
 function* invoke(action) {
   try {
     const result = action();
@@ -6886,8 +6930,11 @@ class JournalDurableBackend {
       this.projection.applyWorkflowSnapshot(event.payload.handle);
       this.prompts.set(entry.runId, new PromptReservationState(event.payload.handle.pendingPrompts, event.payload.prompts));
     } else {
-      const handle = event.payload;
       const previous = this.projection.getWorkflow(entry.runId);
+      const handle = event.type === RUN_EVENT_TYPES.messageQueued && hasPendingStageDeliveryDelta(event.payload.pendingStageMessages) ? {
+        ...event.payload,
+        pendingStageMessages: decodePendingStageDeliveries(previous?.pendingStageMessages ?? [], event.payload.pendingStageMessages ?? [])
+      } : event.payload;
       this.projection.applyWorkflowSnapshot(handle);
       if (event.type === RUN_EVENT_TYPES.runStarted || previous?.pendingPrompts !== handle.pendingPrompts)
         this.prompts.delete(entry.runId);
@@ -7183,11 +7230,23 @@ class JournalDurableBackend {
     for (const message of messages)
       if (message.runId !== logicalRunId)
         throw new JournalMessageScopeError(logicalRunId, message.runId);
-    yield* this.snapshot({
+    const next = {
       ...handle,
       pendingStageMessages: replacePendingStageMessagesForRun(handle.pendingStageMessages ?? [], logicalRunId, messages),
       updatedAt: Math.max(Date.now(), handle.updatedAt + 1)
-    }, RUN_EVENT_TYPES.messageQueued);
+    };
+    const encoded = encodePendingStageDeliveries(handle.pendingStageMessages ?? [], next.pendingStageMessages ?? []);
+    const base = this.sequences.get(runId);
+    if (encoded !== undefined && base !== undefined) {
+      try {
+        yield* this.append(runId, { type: RUN_EVENT_TYPES.messageQueued, payload: { ...next, pendingStageMessages: encoded } }, { expectSeq: base });
+        return true;
+      } catch (error) {
+        if (!(error instanceof JournalCasConflictError))
+          throw error;
+      }
+    }
+    yield* this.snapshot(next, RUN_EVENT_TYPES.messageQueued);
     return true;
   }
   async archivePendingStageMessage(runId, message) {
@@ -7281,7 +7340,7 @@ class JournalDurableBackend {
       if (summarized !== undefined && summarized.seq === version.seq && summarized.at === version.at)
         return;
       const tail = yield* invoke(() => journal.snapshotTail(runId));
-      if (tail !== undefined)
+      if (tail !== undefined && !snapshotNeedsHistory(tail))
         return this.summarize(runId, tail);
       if (summarized === undefined && version.seq === 0)
         return;
@@ -7507,6 +7566,69 @@ class JournalDurableBackend {
     }
   }
 }
+function identity(message) {
+  return JSON.stringify([message.runId, message.id]);
+}
+function uniqueByIdentity(messages) {
+  const result = new Map;
+  const repeated = new Set;
+  for (const message of messages) {
+    const key = identity(message);
+    if (result.has(key))
+      repeated.add(key);
+    result.set(key, message);
+  }
+  for (const key of repeated)
+    result.delete(key);
+  return result;
+}
+function isDeltaEncoded(message) {
+  return message.deliveryDelta !== undefined;
+}
+function encodePendingStageDeliveries(previous, next) {
+  const bases = uniqueByIdentity(previous);
+  const nextIdentities = uniqueByIdentity(next);
+  let encodedAny = false;
+  const encoded = next.map((message) => {
+    const base = bases.get(identity(message))?.deliveries;
+    const deliveries = message.deliveries;
+    if (base === undefined || deliveries === undefined || !nextIdentities.has(identity(message)))
+      return message;
+    const drop = [];
+    let kept = 0;
+    base.forEach((delivery, index) => {
+      if (kept < deliveries.length && JSON.stringify(delivery) === JSON.stringify(deliveries[kept]))
+        kept++;
+      else
+        drop.push(index);
+    });
+    const add = deliveries.slice(kept);
+    if (drop.length + add.length >= deliveries.length)
+      return message;
+    encodedAny = true;
+    const { deliveries: _full, ...rest } = message;
+    return { ...rest, deliveryDelta: drop.length === 0 ? { add } : { drop, add } };
+  });
+  return encodedAny ? encoded : undefined;
+}
+function decodePendingStageDeliveries(previous, messages) {
+  if (!messages.some(isDeltaEncoded))
+    return messages;
+  const bases = uniqueByIdentity(previous);
+  return messages.map((message) => {
+    if (!isDeltaEncoded(message))
+      return message;
+    const base = bases.get(identity(message))?.deliveries;
+    if (base === undefined)
+      throw new Error(`atomic-workflows: journal delivery change for ${identity(message)} has no base entry`);
+    const { deliveryDelta, ...rest } = message;
+    const dropped = new Set(deliveryDelta.drop ?? []);
+    return { ...rest, deliveries: [...base.filter((_, index) => !dropped.has(index)), ...deliveryDelta.add] };
+  });
+}
+function hasPendingStageDeliveryDelta(messages) {
+  return messages?.some(isDeltaEncoded) === true;
+}
 var PROCESS_HOLDER_ID, processExitCleanups, JournalOwnershipError, JournalBackendClosedError, JournalOperationAbortedError, JournalExecutionRetiredError, JournalMessageScopeError;
 var init_journal_backend = __esm(() => {
   init_workflow_instance_ownership_error();
@@ -15531,7 +15653,7 @@ class ConcurrencyLimiter {
   }
 }
 function createRunLimiter(defaultConcurrency) {
-  return new ConcurrencyLimiter(defaultConcurrency ?? 3);
+  return new ConcurrencyLimiter(defaultConcurrency ?? 1000);
 }
 
 // dist/builtin/workflows/src/shared/possible-stages.ts
@@ -17023,7 +17145,7 @@ function kebabCase(name) {
 function errorMessage2(error) {
   return error instanceof Error ? error.message : String(error);
 }
-var DEFAULT_MAX_DEPTH = 4, BUILTIN_BARREL_SPECIFIERS, BUILTIN_SUBPATH_PREFIXES, TRACKED_NODE_METHODS;
+var DEFAULT_MAX_DEPTH = 3, BUILTIN_BARREL_SPECIFIERS, BUILTIN_SUBPATH_PREFIXES, TRACKED_NODE_METHODS;
 var init_possible_stages = __esm(() => {
   BUILTIN_BARREL_SPECIFIERS = new Set(["@bastani/atomic/workflows/builtin"]);
   BUILTIN_SUBPATH_PREFIXES = ["@bastani/atomic/workflows/builtin/"];
@@ -60578,6 +60700,44 @@ class GraphFrontierTracker {
   }
 }
 
+// dist/builtin/workflows/src/shared/external-run-routes.ts
+function claimExternalRunRoute(store, runId, owner) {
+  let owners = registry.owners.get(store);
+  if (owners === undefined) {
+    owners = new Map;
+    registry.owners.set(store, owners);
+  }
+  owners.set(runId, owner);
+  return () => {
+    const current = registry.owners.get(store);
+    if (current?.get(runId) !== owner)
+      return;
+    current.delete(runId);
+    if (current.size === 0)
+      registry.owners.delete(store);
+  };
+}
+function externalRunRouteOwner(store, runId) {
+  return registry.owners.get(store)?.get(runId);
+}
+function registerPendingStageMessageRouter(store, router) {
+  registry.routers.set(store, router);
+  return () => {
+    if (registry.routers.get(store) === router)
+      registry.routers.delete(store);
+  };
+}
+function pendingStageMessageRouter(store) {
+  return registry.routers.get(store);
+}
+var registryKey, processState, registry;
+var init_external_run_routes = __esm(() => {
+  registryKey = Symbol.for("atomic-workflows/external-run-routes@1");
+  processState = globalThis;
+  registry = processState[registryKey] ?? { owners: new WeakMap, routers: new WeakMap };
+  processState[registryKey] = registry;
+});
+
 // dist/builtin/workflows/src/shared/pending-stage-route-capability.ts
 import { randomUUID as randomUUID11 } from "node:crypto";
 function capabilitiesFor(store) {
@@ -60602,12 +60762,12 @@ function rotateWorkflowPendingStageRouteCapability(store, runId) {
   capabilitiesFor(store).set(runId, capability);
   return capability;
 }
-var routeCapabilitiesKey, processState, routeCapabilities;
+var routeCapabilitiesKey, processState2, routeCapabilities;
 var init_pending_stage_route_capability = __esm(() => {
   routeCapabilitiesKey = Symbol.for("atomic-workflows/pending-stage-route-capabilities@1");
-  processState = globalThis;
-  routeCapabilities = processState[routeCapabilitiesKey] ?? new WeakMap;
-  processState[routeCapabilitiesKey] = routeCapabilities;
+  processState2 = globalThis;
+  routeCapabilities = processState2[routeCapabilitiesKey] ?? new WeakMap;
+  processState2[routeCapabilitiesKey] = routeCapabilities;
 });
 
 // dist/builtin/workflows/src/shared/pending-stage-route-readiness.ts
@@ -60639,12 +60799,12 @@ function hasWorkflowPendingStageRouteOwner(store) {
 function workflowPendingStageRouteReady(store, runId) {
   return owners.get(store)?.ready(runId);
 }
-var routeOwnersKey, processState2, owners;
+var routeOwnersKey, processState3, owners;
 var init_pending_stage_route_readiness = __esm(() => {
   routeOwnersKey = Symbol.for("atomic-workflows/pending-stage-route-owners@1");
-  processState2 = globalThis;
-  owners = processState2[routeOwnersKey] ?? new WeakMap;
-  processState2[routeOwnersKey] = owners;
+  processState3 = globalThis;
+  owners = processState3[routeOwnersKey] ?? new WeakMap;
+  processState3[routeOwnersKey] = owners;
 });
 
 // dist/builtin/workflows/src/shared/sticky-stage-delivery-status.ts
@@ -60769,6 +60929,9 @@ function registerPendingStageIntercomBridge(pi, activeStore, ownsRun = () => tru
       notificationId,
       reason
     };
+    const external = externalRunRouteOwner(activeStore, entry.runId);
+    if (external !== undefined)
+      return external.notifyUndeliverable(payload);
     pi.events?.emit?.(PENDING_STAGE_UNDELIVERABLE_EVENT, payload);
     return payload.handled && await payload.completion === true;
   };
@@ -60780,19 +60943,29 @@ function registerPendingStageIntercomBridge(pi, activeStore, ownsRun = () => tru
       return;
     const ownedRunIds = new Set;
     const runs = activeStore.runs();
+    const runById = new Map(runs.map((run) => [run.id, run]));
+    const childrenByBoundary = new Map;
+    for (const run of runs) {
+      if (run.parentRunId === undefined || run.parentStageId === undefined)
+        continue;
+      const key = JSON.stringify([run.parentRunId, run.parentStageId]);
+      const children = childrenByBoundary.get(key) ?? [];
+      children.push(run);
+      childrenByBoundary.set(key, children);
+    }
     const resolveBoundarySegments = createWorkflowBoundarySegmentsResolver(runs);
     for (const run of runs) {
-      if (!ownsRun(run.id))
+      if (externalRunRouteOwner(activeStore, run.id) !== undefined || !ownsRun(run.id))
         continue;
-      const rootRunId = durableRootRunIdForRun(runs, run.id);
+      const rootRunId = reciprocalWorkflowRootRunId(runById, run.id);
       if (rootRunId === undefined)
         continue;
       ownedRunIds.add(run.id);
-      const parentRun = runs.find((candidate) => candidate.id === run.parentRunId);
+      const parentRun = run.parentRunId === undefined ? undefined : runById.get(run.parentRunId);
       const boundary = parentRun?.stages.find((stage) => stage.id === run.parentStageId);
       const parent = parentRun === undefined || boundary === undefined ? undefined : {
         runId: parentRun.id,
-        stageKeys: [boundary.id, boundary.name].filter((key) => resolveChildRun(runs, parentRun, key)?.id === run.id)
+        stageKeys: [boundary.id, boundary.name].filter((key) => resolveIndexedChildRun(childrenByBoundary, parentRun, key)?.id === run.id)
       };
       const announcement = {
         runId: run.id,
@@ -60933,16 +61106,22 @@ function registerPendingStageIntercomBridge(pi, activeStore, ownsRun = () => tru
     payload.handled = true;
     payload.completion = queueAndPersist(activeStore, resolvedEvent, workflowInvocationIntercomGroup(rootRunId), stage.pendingStageDeliveryAvailable === true);
   };
-  const subscription = pi.events?.on?.(PENDING_STAGE_MESSAGE_EVENT, (payload) => outsideWorkflowExecutions(() => routePendingStageMessage(payload)));
-  const stickySubscription = pi.events?.on?.(STICKY_LIVE_DELIVERED_EVENT, (payload) => {
+  const routeStickyLiveDelivered = (payload) => {
     if (disposed || !isStickyLiveDeliveredEvent(payload) || payload.handled)
       return;
     payload.handled = true;
     payload.completion = outsideWorkflowExecutions(() => recordConfirmedStickyDeliveries(activeStore, payload));
+  };
+  const subscription = pi.events?.on?.(PENDING_STAGE_MESSAGE_EVENT, (payload) => outsideWorkflowExecutions(() => routePendingStageMessage(payload)));
+  const stickySubscription = pi.events?.on?.(STICKY_LIVE_DELIVERED_EVENT, routeStickyLiveDelivered);
+  const disposeRouter = registerPendingStageMessageRouter(activeStore, {
+    route: (payload) => outsideWorkflowExecutions(() => routePendingStageMessage(payload)),
+    sticky: routeStickyLiveDelivered
   });
   const dispose = () => {
     disposed = true;
     disposeReadiness();
+    disposeRouter();
     routeCompletions.clear();
     unsubscribeStore();
     if (typeof subscription === "function")
@@ -61068,6 +61247,12 @@ function isMaterializedNonAgentTarget(runs, target) {
     return false;
   return nonAgentNodes(run).some((node) => node.id === stageKey || node.name === stageKey);
 }
+function resolveIndexedChildRun(childrenByBoundary, parent, segment) {
+  const boundariesById = parent.stages.filter((stage) => stage.id === segment);
+  const boundaries = boundariesById.length > 0 ? boundariesById : parent.stages.filter((stage) => stage.name === segment);
+  const children = boundaries.flatMap((boundary) => childrenByBoundary.get(JSON.stringify([parent.id, boundary.id])) ?? []);
+  return children.length === 1 ? children[0] : undefined;
+}
 function resolveChildRun(runs, parent, segment) {
   const boundariesById = parent.stages.filter((stage) => stage.id === segment);
   const boundaries = boundariesById.length > 0 ? boundariesById : parent.stages.filter((stage) => stage.name === segment);
@@ -61407,6 +61592,7 @@ var init_pending_stage_intercom = __esm(() => {
   init_execution_context_boundary();
   init_run_owner_backend();
   init_store_backend();
+  init_external_run_routes();
   init_intercom_group();
   init_pending_stage_route_capability();
   init_pending_stage_route_readiness();
@@ -61546,7 +61732,8 @@ function buildSendSignature(to, options) {
     attachments: canonicalizeAttachmentsForSendSignature(options.attachments) ?? [],
     replyTo: options.replyTo ?? null,
     expectsReply: options.expectsReply ?? false,
-    replyError: options.replyError ?? null
+    replyError: options.replyError ?? null,
+    ...options.delivery === undefined || options.delivery === "steer" ? {} : { delivery: options.delivery }
   });
 }
 
@@ -61732,6 +61919,8 @@ function isMessage(value2) {
     return false;
   if (message.expectsReply !== undefined && typeof message.expectsReply !== "boolean")
     return false;
+  if (message.delivery !== undefined && message.delivery !== "steer" && message.delivery !== "followUp" && message.delivery !== "interrupt")
+    return false;
   if (message.replyError !== undefined && typeof message.replyError !== "string")
     return false;
   if (message.source !== undefined && !isMessageSource(message.source))
@@ -61865,7 +62054,7 @@ function isWorkflowFutureStageRosterEntries(value2) {
 function isWorkflowStageRosterEntries(value2) {
   return Array.isArray(value2) && value2.every((entry) => typeof entry === "object" && entry !== null && entry.kind === "workflow-stage" && typeof entry.runId === "string" && typeof entry.stageId === "string" && typeof entry.stageName === "string" && typeof entry.target === "string" && (entry.lifecycle === "pending" || entry.lifecycle === "running") && typeof entry.group === "string" && (entry.sessionId === undefined || typeof entry.sessionId === "string"));
 }
-var BROKER_SOCKET, BROKER_CONNECT_TIMEOUT_MS = 1e4, PENDING_STAGE_ROUTE_ACK_TIMEOUT_MS = 1e4, GROUP_REQUEST_TIMEOUT_MS = 5000, PRESENCE_ACK_TIMEOUT_MS = 5000, RESTORING_RECIPIENT_REQUEST_TIMEOUT_MS = 5000, HELD_SEND_GRACE_MS = 5000, IntercomClient;
+var BROKER_SOCKET, BROKER_CONNECT_TIMEOUT_MS = 1e4, PENDING_STAGE_ROUTE_ACK_TIMEOUT_MS = 1e4, GROUP_REQUEST_TIMEOUT_MS = 5000, PRESENCE_ACK_TIMEOUT_MS = 5000, RESTORING_RECIPIENT_REQUEST_TIMEOUT_MS = 5000, HELD_SEND_GRACE_MS = 5000, IntercomPendingStageRouteRefusedError, PENDING_STAGE_ROUTE_REFUSAL_CODES, IntercomClient;
 var init_client = __esm(() => {
   init_paths();
   init_pending_send_registry();
@@ -61874,6 +62063,21 @@ var init_client = __esm(() => {
   init_live_route_refusal();
   init_retry_policy();
   BROKER_SOCKET = getBrokerSocketPath();
+  IntercomPendingStageRouteRefusedError = class IntercomPendingStageRouteRefusedError extends Error {
+    connectionKept;
+    code;
+    constructor(reason, refusal = { connectionKept: false }) {
+      super(reason);
+      this.name = "IntercomPendingStageRouteRefusedError";
+      this.connectionKept = refusal.connectionKept;
+      this.code = refusal.code;
+    }
+  };
+  PENDING_STAGE_ROUTE_REFUSAL_CODES = new Set([
+    "not_authorized",
+    "invalid_stage_roster",
+    "invalid_possible_stage_roster"
+  ]);
   IntercomClient = class IntercomClient extends EventEmitter {
     returnAddress;
     preferredSessionId;
@@ -61881,6 +62085,8 @@ var init_client = __esm(() => {
     connectTimeoutMs;
     brokerAcknowledgesReceipt = false;
     brokerAcknowledgesPendingStageRoutes = false;
+    multiplexesPendingStageRoutes;
+    brokerRefusesPendingStageRoutesInPlace = false;
     brokerAnswersStatus = false;
     socket = null;
     _sessionId = null;
@@ -61946,6 +62152,7 @@ var init_client = __esm(() => {
       this.preferredSessionId = options.preferredSessionId;
       this.acknowledgesReceipt = options.acknowledgesReceipt === true;
       this.connectTimeoutMs = options.connectTimeoutMs ?? BROKER_CONNECT_TIMEOUT_MS;
+      this.multiplexesPendingStageRoutes = options.multiplexesPendingStageRoutes === true;
     }
     failPending(error) {
       this.pendingSends.rejectAll(error);
@@ -62058,6 +62265,7 @@ var init_client = __esm(() => {
           this._supervisorSessionId = null;
           this.brokerAcknowledgesReceipt = false;
           this.brokerAcknowledgesPendingStageRoutes = false;
+          this.brokerRefusesPendingStageRoutesInPlace = false;
           this.brokerAnswersStatus = false;
           this._messageSource = undefined;
           this.disconnectError = null;
@@ -62136,7 +62344,7 @@ var init_client = __esm(() => {
       }
       switch (brokerMessage.type) {
         case "registered": {
-          if (typeof brokerMessage.sessionId !== "string" || brokerMessage.supervisorSessionId !== undefined && typeof brokerMessage.supervisorSessionId !== "string" || brokerMessage.acknowledgesReceipt !== undefined && brokerMessage.acknowledgesReceipt !== true || brokerMessage.acknowledgesPendingStageRoutes !== undefined && brokerMessage.acknowledgesPendingStageRoutes !== true || brokerMessage.brokerStatus !== undefined && brokerMessage.brokerStatus !== true) {
+          if (typeof brokerMessage.sessionId !== "string" || brokerMessage.supervisorSessionId !== undefined && typeof brokerMessage.supervisorSessionId !== "string" || brokerMessage.acknowledgesReceipt !== undefined && brokerMessage.acknowledgesReceipt !== true || brokerMessage.acknowledgesPendingStageRoutes !== undefined && brokerMessage.acknowledgesPendingStageRoutes !== true || brokerMessage.refusesPendingStageRoutesInPlace !== undefined && brokerMessage.refusesPendingStageRoutesInPlace !== true || brokerMessage.brokerStatus !== undefined && brokerMessage.brokerStatus !== true) {
             throw new Error("Invalid registered message");
           }
           if (this._sessionId !== null) {
@@ -62146,6 +62354,7 @@ var init_client = __esm(() => {
           this._supervisorSessionId = typeof brokerMessage.supervisorSessionId === "string" ? brokerMessage.supervisorSessionId : null;
           this.brokerAcknowledgesReceipt = this.acknowledgesReceipt && brokerMessage.acknowledgesReceipt === true;
           this.brokerAcknowledgesPendingStageRoutes = brokerMessage.acknowledgesPendingStageRoutes === true;
+          this.brokerRefusesPendingStageRoutesInPlace = brokerMessage.refusesPendingStageRoutesInPlace === true;
           this.brokerAnswersStatus = brokerMessage.brokerStatus === true;
           this.emit("_registered", { type: "registered", sessionId: brokerMessage.sessionId });
           break;
@@ -62158,6 +62367,12 @@ var init_client = __esm(() => {
             this.emit("_registration_failed", refusal);
             break;
           }
+          const refusedRouteId = typeof brokerMessage.requestId === "string" ? brokerMessage.requestId : "";
+          const refusedRoute = this.pendingStageRouteRegistrations.get(refusedRouteId);
+          if (refusedRoute !== undefined) {
+            this.pendingStageRouteRegistrations.delete(refusedRouteId);
+            refusedRoute.reject(new IntercomPendingStageRouteRefusedError(brokerMessage.reason));
+          }
           this.disconnectError ??= refusal;
           this.failPending(this.disconnectError);
           this.socket?.destroy();
@@ -62283,6 +62498,21 @@ var init_client = __esm(() => {
           this.emit("pending_stage_route_revoked", { runId });
           break;
         }
+        case "pending_stage_route_refused": {
+          const { requestId, runId, code, reason } = brokerMessage;
+          if (typeof requestId !== "string" || typeof runId !== "string" || typeof reason !== "string" || typeof code !== "string") {
+            throw new Error("Invalid pending-stage route refusal");
+          }
+          const pending = this.pendingStageRouteRegistrations.get(requestId);
+          if (!pending)
+            return;
+          this.pendingStageRouteRegistrations.delete(requestId);
+          pending.reject(new IntercomPendingStageRouteRefusedError(reason, {
+            connectionKept: true,
+            ...PENDING_STAGE_ROUTE_REFUSAL_CODES.has(code) ? { code } : {}
+          }));
+          break;
+        }
         case "pending_stage_route_registered": {
           const { requestId } = brokerMessage;
           if (typeof requestId !== "string")
@@ -62786,7 +63016,8 @@ var init_client = __esm(() => {
             stages,
             possibleStages,
             ...parent === undefined ? {} : { parent },
-            ...dormant === true ? { dormant: true } : {}
+            ...dormant === true ? { dormant: true } : {},
+            ...this.multiplexesPendingStageRoutes && this.brokerRefusesPendingStageRoutesInPlace ? { refusalKeepsConnection: true } : {}
           });
         } catch (error) {
           clearTimeout(timeout);
@@ -62899,6 +63130,7 @@ var init_client = __esm(() => {
         timestamp: Date.now(),
         replyTo: options.replyTo,
         expectsReply: options.expectsReply,
+        ...options.delivery === undefined || options.delivery === "steer" ? {} : { delivery: options.delivery },
         replyError: options.replyError,
         source: this._messageSource,
         content: { text: options.text, attachments: options.attachments }
@@ -63520,120 +63752,165 @@ var init_reconnect_backoff = __esm(() => {
   BACKOFF_MS = [1000, 2000, 5000, 1e4, 30000];
 });
 
-// dist/builtin/intercom/route-connect-gate.ts
-function createConcurrencyGate(limit) {
-  let active = 0;
-  const waiting = [];
-  const release = () => {
-    const next = waiting.shift();
-    if (next === undefined)
-      active -= 1;
-    else
-      next();
-  };
-  return {
-    async run(operation) {
-      if (active < limit)
-        active += 1;
-      else
-        await new Promise((resolve) => waiting.push(resolve));
-      try {
-        return await operation();
-      } finally {
-        release();
-      }
-    }
-  };
-}
-var ROUTE_CLIENT_CONNECT_CONCURRENCY = 4;
-
 // dist/builtin/intercom/workflow-route-owner.ts
 import { randomUUID as randomUUID14 } from "node:crypto";
 import { createEventBus, getBuiltinPackagePaths } from "@bastani/atomic";
+function closedError() {
+  return new Error("Workflow Intercom route owner closed");
+}
 function createWorkflowRouteOwner(cwd) {
   const events = createEventBus();
   const config = loadConfig();
   const id = randomUUID14();
   const routes = new Map;
-  const gate = createConcurrencyGate(ROUTE_CLIENT_CONNECT_CONCURRENCY);
+  const connections = new Map;
+  const isCurrent = (state) => routes.get(state.route.runId) === state;
+  const connectionKey = (state) => state.isolated ? state.route.runId : state.route.group;
+  function connectionOf(state) {
+    const key = connectionKey(state);
+    let connection = connections.get(key);
+    if (connection === undefined) {
+      connection = { key, group: state.route.group, acknowledged: false, routes: new Map };
+      connections.set(key, connection);
+    }
+    connection.routes.set(state.route.runId, state);
+    return connection;
+  }
+  function detach(state) {
+    const key = connectionKey(state);
+    const connection = connections.get(key);
+    connection?.routes.delete(state.route.runId);
+    if (!state.isolated || connection === undefined)
+      return;
+    connections.delete(key);
+    connection.client?.disconnect().catch(() => {});
+  }
+  function settle(state, registered) {
+    state.registered = registered;
+    if (!registered && isCurrent(state))
+      return;
+    for (const waiter of state.waiters)
+      waiter(registered);
+    state.waiters.clear();
+  }
   function scheduleRetry(state) {
-    if (state.closed || state.retry !== undefined)
+    if (!isCurrent(state) || state.retry !== undefined)
       return;
     state.retry = setTimeout(() => {
       state.retry = undefined;
-      publish(state, state.route).catch(() => scheduleRetry(state));
+      publish(state, state.route).catch(() => {});
     }, jitteredReconnectDelayMs(state.attempt++));
     state.retry.unref();
   }
-  async function connect(state) {
-    if (state.client?.isConnected())
-      return state.client;
-    const [extensionDir] = getBuiltinPackagePaths({
-      workflows: false,
-      subagents: false,
-      mcp: false,
-      "web-access": false
-    });
-    if (extensionDir === undefined)
-      throw new Error("Intercom builtin package is unavailable");
-    await spawnBrokerIfNeeded(config.brokerCommand, config.brokerArgs, undefined, extensionDir);
-    if (state.closed)
-      throw new Error("Workflow Intercom route owner closed");
-    const client = new IntercomClient(`${id}:pending-stage-route:${state.route.runId}`);
-    state.client = client;
-    client.on("error", () => {});
-    client.on("disconnected", () => {
-      if (state.client !== client)
-        return;
-      state.client = undefined;
-      scheduleRetry(state);
-    });
-    client.on("pending_stage_message", (request) => {
-      if (state.closed || state.client !== client)
-        return;
-      const event = { ...request, handled: false };
-      events.emit("atomic:workflow-pending-stage-message", event);
-      const completion = event.handled && event.completion !== undefined ? event.completion : Promise.resolve({ outcome: "refused", reason: "Session not found" });
-      completion.catch((error) => ({ outcome: "refused", reason: error.message })).then((result) => client.respondPendingStageMessage(request.requestId, result)).catch(() => {});
-    });
-    client.on("sticky_live_delivered", (notice) => {
-      if (state.closed || state.client !== client)
-        return;
-      events.emit("atomic:workflow-sticky-live-delivered", { ...notice, handled: false });
-    });
-    await client.connect({
-      cwd,
-      model: "workflow",
-      pid: process.pid,
-      startedAt: Date.now(),
-      lastActivity: Date.now(),
-      group: state.route.group,
-      groups: [state.route.group],
-      recipientPurpose: "control"
+  function drop(connection, client) {
+    if (connection.client === client) {
+      connection.client = undefined;
+      connection.acknowledged = false;
+      for (const state of connection.routes.values()) {
+        settle(state, false);
+        scheduleRetry(state);
+      }
+    }
+    client.disconnect().catch(() => {});
+  }
+  function connect(connection) {
+    if (connection.client?.isConnected())
+      return Promise.resolve(connection.client);
+    connection.connecting ??= (async () => {
+      const [extensionDir] = getBuiltinPackagePaths({
+        workflows: false,
+        subagents: false,
+        mcp: false,
+        "web-access": false
+      });
+      if (extensionDir === undefined)
+        throw new Error("Intercom builtin package is unavailable");
+      await spawnBrokerIfNeeded(config.brokerCommand, config.brokerArgs, undefined, extensionDir);
+      if (connections.get(connection.key) !== connection)
+        throw closedError();
+      const client = new IntercomClient(`${id}:pending-stage-route:${connection.key}`, {
+        multiplexesPendingStageRoutes: true
+      });
+      connection.client = client;
+      connection.acknowledged = false;
+      client.on("error", () => {});
+      client.on("disconnected", () => drop(connection, client));
+      client.on("pending_stage_message", (request) => {
+        if (connection.client !== client)
+          return;
+        const event = { ...request, handled: false };
+        events.emit("atomic:workflow-pending-stage-message", event);
+        const completion = event.handled && event.completion !== undefined ? event.completion : Promise.resolve({ outcome: "refused", reason: "Session not found" });
+        completion.catch((error) => ({ outcome: "refused", reason: error.message })).then((result) => client.respondPendingStageMessage(request.requestId, result)).catch(() => {});
+      });
+      client.on("sticky_live_delivered", (notice) => {
+        if (connection.client !== client)
+          return;
+        events.emit("atomic:workflow-sticky-live-delivered", { ...notice, handled: false });
+      });
+      try {
+        await client.connect({
+          cwd,
+          model: "workflow",
+          pid: process.pid,
+          startedAt: Date.now(),
+          lastActivity: Date.now(),
+          group: connection.group,
+          groups: [connection.group],
+          recipientPurpose: "control"
+        });
+        if (connections.get(connection.key) !== connection)
+          throw closedError();
+      } catch (error) {
+        drop(connection, client);
+        throw error;
+      }
+      for (const state of connection.routes.values()) {
+        if (state.registered || state.retry === undefined)
+          continue;
+        clearTimeout(state.retry);
+        state.retry = undefined;
+        publish(state, state.route).catch(() => {});
+      }
+      return client;
+    })().finally(() => {
+      connection.connecting = undefined;
     });
-    return client;
+    return connection.connecting;
   }
   function publish(state, route) {
-    const completion = state.tail.catch(() => {}).then(() => gate.run(async () => {
-      if (state.closed)
-        throw new Error("Workflow Intercom route owner closed");
-      const establishedClient = state.client?.isConnected() ? state.client : undefined;
+    const completion = state.tail.catch(() => {}).then(async () => {
+      if (!isCurrent(state))
+        throw closedError();
+      const connection = connectionOf(state);
+      const established = connection.acknowledged && connection.client?.isConnected() ? connection.client : undefined;
+      let client;
       try {
-        const client = await connect(state);
+        client = await connect(connection);
         await client.registerPendingStageRouteAcknowledged(route.runId, route.group, route.capability, route.stages, route.possibleStages, route.parent);
+        if (connection.client !== client || !isCurrent(state))
+          return;
+        connection.acknowledged = true;
         state.attempt = 0;
         clearTimeout(state.retry);
         state.retry = undefined;
+        settle(state, true);
       } catch (error) {
-        const client = state.client;
-        if (client !== establishedClient || !client?.isConnected()) {
-          state.client = undefined;
-          await client?.disconnect();
+        if (error instanceof IntercomPendingStageRouteRefusedError && error.connectionKept) {
+          scheduleRetry(state);
+          throw error;
         }
+        if (error instanceof IntercomPendingStageRouteRefusedError && !state.isolated && isCurrent(state)) {
+          detach(state);
+          state.isolated = true;
+          connectionOf(state);
+        }
+        if (client !== undefined && (client !== established || !client.isConnected()))
+          drop(connection, client);
         scheduleRetry(state);
         throw error;
       }
-    }));
+    });
     state.tail = completion;
     completion.catch(() => {});
     return completion;
@@ -63642,10 +63919,15 @@ function createWorkflowRouteOwner(cwd) {
     const route = payload;
     let state = routes.get(route.runId);
     if (state === undefined) {
-      state = { route, tail: Promise.resolve(), attempt: 0, closed: false };
+      state = { route, tail: Promise.resolve(), attempt: 0, registered: false, isolated: false, waiters: new Set };
       routes.set(route.runId, state);
+    } else if (state.route.group !== route.group) {
+      detach(state);
+      state.isolated = false;
+      settle(state, false);
     }
     state.route = route;
+    connectionOf(state);
     route.completion = publish(state, route);
   });
   events.on("atomic:workflow-pending-stage-undeliverable", (payload) => {
@@ -63656,7 +63938,7 @@ function createWorkflowRouteOwner(cwd) {
     event.handled = true;
     event.completion = (async () => {
       await publish(state, state.route);
-      const client = state.client;
+      const client = connections.get(connectionKey(state))?.client;
       if (client === undefined || !client.isConnected())
         return false;
       const text = `Pending workflow stage could not receive intercom message: ${event.reason}`;
@@ -63666,18 +63948,33 @@ function createWorkflowRouteOwner(cwd) {
   });
   return {
     events,
+    registered(runId) {
+      const state = routes.get(runId);
+      if (state === undefined)
+        return Promise.resolve(false);
+      if (state.registered)
+        return Promise.resolve(true);
+      return new Promise((resolve) => state.waiters.add(resolve));
+    },
     async closeGroup(group) {
       const closing = [...routes.values()].filter((state) => state.route.group === group);
+      const closingConnections = [...connections.values()].filter((connection) => connection.group === group);
+      for (const connection of closingConnections) {
+        connections.delete(connection.key);
+        connection.routes.clear();
+      }
       for (const state of closing) {
-        state.closed = true;
-        clearTimeout(state.retry);
         routes.delete(state.route.runId);
+        clearTimeout(state.retry);
+        state.retry = undefined;
+        settle(state, false);
       }
-      await Promise.all(closing.map(async (state) => {
-        await state.client?.disconnect();
-        await state.tail.catch(() => {});
-        await state.client?.disconnect();
+      await Promise.all(closingConnections.map(async (connection) => {
+        await connection.client?.disconnect();
+        await connection.connecting?.catch(() => {});
       }));
+      await Promise.all(closing.map((state) => state.tail.catch(() => {})));
+      await Promise.all(closingConnections.map((connection) => connection.client?.disconnect()));
     }
   };
 }
@@ -63860,7 +64157,7 @@ var init_workflow_infrastructure_error = __esm(() => {
     [/Local worker (?:process )?cleanup (?:was not confirmed|unconfirmed)/, "worker_cleanup_unconfirmed"],
     [/Local worker retry limit/, "worker_retry_limit"],
     [/Local worker (?:startup timed out|exited before readiness)/, "worker_startup_failed"],
-    [/Worker exited before delivery acknowledgement/, "worker_lost"],
+    [/Worker exited before delivery acknowledgement|Local worker pool coordinator exited/, "worker_lost"],
     [/Stale work lease/, "stale_work_lease"],
     [/Intercom runtime no longer active/, "intercom_unavailable"],
     [/Storage unavailable/, "storage_unavailable"]
@@ -64159,7 +64456,7 @@ var init_definitions = __esm(() => {
 // dist/builtin/workflows/src/durable/journal/pool-mutations.ts
 import { StorageProvider as StorageProvider2 } from "@bastani/atomic/storage";
 async function validatePoolMutation(tx, journal, root, work, mutation) {
-  if (!["checkpoint", "session-create", "session-append", "session-replace"].includes(mutation.kind))
+  if (!["checkpoint", "session-create", "session-replace"].includes(mutation.kind))
     throw new Error("Invalid pool mutation");
   const checkpoint = mutation.checkpoint;
   const prefix = `${work.scope}:`;
@@ -64227,10 +64524,18 @@ async function sessionStore(tx, prefix) {
   return new StorageProvider2().openSessionStore({ kind: "database", database, prefix }, { agentDir: "", domain: "sessions" });
 }
 async function applyPoolSession(tx, prefix, workId, mutation) {
+  const owners = `${prefix}session_owners`;
+  if (mutation.kind === "session-append") {
+    if (typeof mutation.sessionId !== "string" || mutation.sessionId === "")
+      throw new Error("Pool sessions require database identity");
+    const owner = await tx.get(`SELECT work FROM ${owners} WHERE session = ?`, mutation.sessionId);
+    if (owner?.work !== workId)
+      throw new Error("Pool session scope mismatch");
+    return withSessionStore(tx, prefix, (store) => store.append(mutation.sessionId, mutation.entries, { expectSeq: mutation.expectSeq }));
+  }
   const { sessionId, replayKey } = mutation.checkpoint;
   if (!sessionId || mutation.checkpoint.sessionFile !== undefined)
     throw new Error("Pool sessions require database identity");
-  const owners = `${prefix}session_owners`;
   if (mutation.kind === "session-create") {
     if (mutation.header.id !== sessionId)
       throw new Error("Pool session identity mismatch");
@@ -64240,10 +64545,12 @@ async function applyPoolSession(tx, prefix, workId, mutation) {
     if (owner?.work !== workId || owner.replay_key !== replayKey)
       throw new Error("Pool session scope mismatch");
   }
+  return withSessionStore(tx, prefix, (store) => mutation.kind === "session-create" ? store.create(mutation.header, mutation.entries) : store.replace(sessionId, mutation.header, mutation.entries, { expectSeq: mutation.expectSeq }));
+}
+async function withSessionStore(tx, prefix, write) {
   const store = await sessionStore(tx, prefix);
   try {
-    const result = mutation.kind === "session-create" ? await store.create(mutation.header, mutation.entries) : mutation.kind === "session-append" ? await store.append(sessionId, mutation.entries, { expectSeq: mutation.expectSeq }) : await store.replace(sessionId, mutation.header, mutation.entries, { expectSeq: mutation.expectSeq });
-    return result.lastSeq;
+    return (await write(store)).lastSeq;
   } finally {
     await store.close();
   }
@@ -64291,8 +64598,11 @@ var init_pool_stage_usage = __esm(() => {
 });
 
 // dist/builtin/workflows/src/durable/journal/sql-pool-queue.ts
-import { randomUUID as randomUUID16 } from "node:crypto";
+import { createHash as createHash4, randomUUID as randomUUID16 } from "node:crypto";
 import { assertStorageSchemaVersion as assertStorageSchemaVersion2 } from "@bastani/atomic/storage";
+function requestIdentity(request) {
+  return createHash4("sha256").update(request).digest("hex");
+}
 function fromRow(row) {
   return {
     ...JSON.parse(row.descriptor),
@@ -64348,10 +64658,11 @@ class SqlPoolQueue {
       const versions = await tx.all(`SELECT version FROM ${pool.meta}`);
       if (versions.length > 1)
         throw new Error("Corrupt pool schema metadata");
-      if (versions.length === 0)
-        await tx.run(`INSERT INTO ${pool.meta} VALUES (1)`);
-      else
-        assertStorageSchemaVersion2("journal", versions[0].version, 1);
+      const version = versions[0]?.version;
+      if (version === undefined)
+        await tx.run(`INSERT INTO ${pool.meta} VALUES (?)`, POOL_SCHEMA_VERSION);
+      else if (version !== 1)
+        assertStorageSchemaVersion2("journal", version, POOL_SCHEMA_VERSION);
       await tx.exec(`
 				CREATE TABLE IF NOT EXISTS ${pool.roots}(root TEXT PRIMARY KEY REFERENCES ${journal.runs}(run_id) ON DELETE CASCADE, timeout INTEGER NOT NULL);
 				CREATE TABLE IF NOT EXISTS ${pool.work}(
@@ -64382,9 +64693,23 @@ class SqlPoolQueue {
 				state TEXT NOT NULL DEFAULT 'running', revision INTEGER NOT NULL DEFAULT 0
 			)`);
       await tx.exec(poolUsageSchema(journal.runs));
+      if (version === 1)
+        await pool.migrateFromVersion1(tx);
     });
     return pool;
   }
+  async migrateFromVersion1(tx) {
+    await tx.run(`DELETE FROM ${this.operations} WHERE substr(request, 1, 1) = '['`);
+    for (let after = 0;; ) {
+      const rows = await tx.all(`SELECT rowid, request FROM ${this.operations} WHERE rowid > ? ORDER BY rowid LIMIT 256`, after);
+      if (rows.length === 0)
+        break;
+      for (const row of rows)
+        await tx.run(`UPDATE ${this.operations} SET request = ? WHERE rowid = ?`, requestIdentity(String(row.request)), row.rowid);
+      after = Number(rows.at(-1).rowid);
+    }
+    await tx.run(`UPDATE ${this.meta} SET version = ?`, POOL_SCHEMA_VERSION);
+  }
   async authority(tx, lease, timeout) {
     const row = await tx.get(`SELECT l.*, r.status, p.timeout, ${STORE_NOW2} AS now FROM ${this.journal.leases} l JOIN ${this.journal.runs} r ON r.run_id = l.run_id LEFT JOIN ${this.roots} p ON p.root = l.run_id WHERE l.run_id = ?`, lease.runId);
     if (row?.timeout === null && timeout === undefined)
@@ -64525,31 +64850,18 @@ class SqlPoolQueue {
       throw new Error(STALE_WORK_LEASE);
     return row;
   }
-  async renew(lease, token, operationId, durationMs) {
+  async renew(lease, token, durationMs) {
     positive(durationMs);
     lease = snapshotLease(lease);
     token = { ...token };
-    validateText("key", operationId);
-    const request = JSON.stringify([token.epoch, token.generation, token.worker, durationMs]);
     return this.transaction(async (tx) => {
       const { now } = await this.authority(tx, lease);
       const row = await this.current(tx, lease, token);
       if (row.epoch !== lease.epoch || row.expires_at < now)
         throw new Error(STALE_WORK_LEASE);
-      const previous = await tx.get(`SELECT * FROM ${this.operations} WHERE work = ? AND generation = ? AND operation = ?`, token.id, token.generation, operationId);
-      if (previous) {
-        if (previous.request !== request)
-          throw new Error("Pool operation identity conflict");
-        return JSON.parse(previous.receipt);
-      }
-      const receipt = {
-        ...fromRow(row),
-        expiresAt: Math.max(Number(row.expires_at), expiry(now, durationMs)),
-        renewedAt: now
-      };
-      await tx.run(`UPDATE ${this.work} SET expires_at = ?, renewed_at = ? WHERE id = ?`, receipt.expiresAt, now, row.id);
-      await tx.run(`INSERT INTO ${this.operations} VALUES (?, ?, ?, ?, ?)`, row.id, token.generation, operationId, request, JSON.stringify(receipt));
-      return receipt;
+      const expiresAt = Math.max(Number(row.expires_at), expiry(now, durationMs));
+      await tx.run(`UPDATE ${this.work} SET expires_at = ?, renewed_at = ? WHERE id = ?`, expiresAt, now, row.id);
+      return { ...fromRow(row), expiresAt, renewedAt: now };
     });
   }
   async commit(lease, token, operationId, mutation) {
@@ -64558,6 +64870,7 @@ class SqlPoolQueue {
     validateText("key", operationId);
     assertWorkflowSerializableObject(mutation, "Pool mutation");
     const request = serializeJson({ epoch: token.epoch, worker: token.worker, mutation });
+    const identity = requestIdentity(request);
     mutation = JSON.parse(request).mutation;
     return this.transaction(async (tx) => {
       const { now, status } = await this.authority(tx, lease);
@@ -64566,7 +64879,7 @@ class SqlPoolQueue {
         throw new Error(STALE_WORK_LEASE);
       const previous = await tx.get(`SELECT * FROM ${this.operations} WHERE work = ? AND generation = ? AND operation = ?`, token.id, token.generation, operationId);
       if (previous) {
-        if (previous.request !== request)
+        if (previous.request !== identity)
           throw new Error("Pool operation identity conflict");
         return JSON.parse(previous.receipt);
       }
@@ -64574,34 +64887,41 @@ class SqlPoolQueue {
         throw new Error(STALE_WORK_LEASE);
       if (!await this.admitsAttemptWrites(tx, lease, status))
         throw new Error("Pool root is not running");
-      const checkpoint = mutation.checkpoint;
-      await validatePoolMutation(tx, this.journal, lease.runId, fromRow(row), mutation);
-      if (checkpoint.completedAt > Math.max(now, Date.now()) + MAX_WORKER_CLOCK_SKEW_MS)
-        throw new Error("Pool checkpoint timestamp is in the future");
-      assertWorkflowSerializableObject(checkpoint, "Pool checkpoint");
-      const key = JSON.stringify([RUN_EVENT_TYPES.checkpointRecorded, checkpoint.kind, checkpoint.checkpointId]);
-      const payload = serializeJson(checkpoint);
-      const existing = await tx.get(`SELECT seq, at, payload FROM ${this.journal.events} WHERE run_id = ? AND key = ?`, lease.runId, key);
-      if (existing && existing.payload !== payload)
-        throw new Error("Pool checkpoint identity conflict");
-      if (existing && mutation.kind !== "checkpoint")
-        throw new Error("Pool session checkpoint identity conflict");
-      const lastSeq = mutation.kind === "checkpoint" ? undefined : await applyPoolSession(tx, `${this.journal.runs}_pool_`, row.id, mutation);
-      const latest = await tx.get(`SELECT COALESCE(MAX(seq), 0) AS seq FROM ${this.journal.events} WHERE run_id = ?`, lease.runId);
-      const receipt = existing ? { seq: Number(existing.seq), at: Number(existing.at) } : {
-        seq: journalCounter(lease.runId, "seq", Number(latest.seq) + 1, "overflow"),
-        at: now,
-        ...lastSeq === undefined ? {} : { lastSeq }
-      };
-      if (!existing)
-        await tx.run(`INSERT INTO ${this.journal.events} VALUES (?, ?, ?, ?, ?, ?, ?)`, lease.runId, receipt.seq, lease.epoch, key, RUN_EVENT_TYPES.checkpointRecorded, payload, now);
-      const billed = poolCheckpointUsage(checkpoint);
-      if (billed && !existing)
-        await upsertPoolUsage(tx, this.journal.runs, row.id, token.generation, billed.key, billed.usage);
-      await tx.run(`INSERT INTO ${this.operations} VALUES (?, ?, ?, ?, ?)`, token.id, token.generation, operationId, request, JSON.stringify(receipt));
+      const receipt = mutation.kind === "session-append" ? await this.appendSession(tx, row, mutation, now) : await this.recordCheckpoint(tx, lease, token, row, mutation, now);
+      await tx.run(`INSERT INTO ${this.operations} VALUES (?, ?, ?, ?, ?)`, token.id, token.generation, operationId, identity, JSON.stringify(receipt));
       return receipt;
     });
   }
+  async appendSession(tx, row, mutation, now) {
+    return { at: now, lastSeq: await applyPoolSession(tx, `${this.journal.runs}_pool_`, row.id, mutation) };
+  }
+  async recordCheckpoint(tx, lease, token, row, mutation, now) {
+    const checkpoint = mutation.checkpoint;
+    await validatePoolMutation(tx, this.journal, lease.runId, fromRow(row), mutation);
+    if (checkpoint.completedAt > Math.max(now, Date.now()) + MAX_WORKER_CLOCK_SKEW_MS)
+      throw new Error("Pool checkpoint timestamp is in the future");
+    assertWorkflowSerializableObject(checkpoint, "Pool checkpoint");
+    const key = JSON.stringify([RUN_EVENT_TYPES.checkpointRecorded, checkpoint.kind, checkpoint.checkpointId]);
+    const payload = serializeJson(checkpoint);
+    const existing = await tx.get(`SELECT seq, at, payload FROM ${this.journal.events} WHERE run_id = ? AND key = ?`, lease.runId, key);
+    if (existing && existing.payload !== payload)
+      throw new Error("Pool checkpoint identity conflict");
+    if (existing && mutation.kind !== "checkpoint")
+      throw new Error("Pool session checkpoint identity conflict");
+    const lastSeq = mutation.kind === "checkpoint" ? undefined : await applyPoolSession(tx, `${this.journal.runs}_pool_`, row.id, mutation);
+    const latest = await tx.get(`SELECT COALESCE(MAX(seq), 0) AS seq FROM ${this.journal.events} WHERE run_id = ?`, lease.runId);
+    const receipt = existing ? { seq: Number(existing.seq), at: Number(existing.at) } : {
+      seq: journalCounter(lease.runId, "seq", Number(latest.seq) + 1, "overflow"),
+      at: now,
+      ...lastSeq === undefined ? {} : { lastSeq }
+    };
+    if (!existing)
+      await tx.run(`INSERT INTO ${this.journal.events} VALUES (?, ?, ?, ?, ?, ?, ?)`, lease.runId, receipt.seq, lease.epoch, key, RUN_EVENT_TYPES.checkpointRecorded, payload, now);
+    const billed = poolCheckpointUsage(checkpoint);
+    if (billed && !existing)
+      await upsertPoolUsage(tx, this.journal.runs, row.id, token.generation, billed.key, billed.usage);
+    return receipt;
+  }
   async complete(lease, token, result) {
     lease = snapshotLease(lease);
     token = { ...token };
@@ -64688,7 +65008,7 @@ function openSqlPoolQueue(journal) {
     return Promise.reject(new Error("Worker pool requires a SQL run journal"));
   return SqlPoolQueue.open(storage);
 }
-var STORE_NOW2 = "CAST(unixepoch('subsec') * 1000 AS INTEGER)", MAX_WORKER_CLOCK_SKEW_MS = 1000, STALE_WORK_LEASE = "Stale work lease";
+var STORE_NOW2 = "CAST(unixepoch('subsec') * 1000 AS INTEGER)", MAX_WORKER_CLOCK_SKEW_MS = 1000, POOL_SCHEMA_VERSION = 2, STALE_WORK_LEASE = "Stale work lease";
 var init_sql_pool_queue = __esm(() => {
   init_serializable();
   init_boundary_topology();
@@ -64700,6 +65020,15 @@ var init_sql_pool_queue = __esm(() => {
   init_values();
 });
 
+// dist/builtin/workflows/src/workers/coordinator-protocol.ts
+var POOL_COORDINATOR_ROLE = "pool-coordinator", POOL_SUMMARY_INTERVAL_MS = 250;
+
+// dist/builtin/workflows/src/workers/host-options.ts
+var hostWorkerBindings;
+var init_host_options = __esm(() => {
+  hostWorkerBindings = Symbol("host-worker-bindings");
+});
+
 // dist/builtin/workflows/src/durable/journal/sql-pool-usage.ts
 function validate(report) {
   validateText("key", report.key);
@@ -64770,10 +65099,844 @@ var init_sql_pool_usage = __esm(() => {
   init_values();
 });
 
-// dist/builtin/workflows/src/workers/host-options.ts
-var hostWorkerBindings;
-var init_host_options = __esm(() => {
-  hostWorkerBindings = Symbol("host-worker-bindings");
+// dist/builtin/workflows/src/workers/pool-coordinator.ts
+import { fork } from "node:child_process";
+import { randomUUID as randomUUID17 } from "node:crypto";
+import { createWriteStream } from "node:fs";
+import { mkdir as mkdir6, rm as rm3, rmdir } from "node:fs/promises";
+import { dirname as dirname14, join as join29, resolve as resolve13 } from "node:path";
+import { setTimeout as delay2 } from "node:timers/promises";
+function workerLogDirectory(journalPath, root) {
+  return join29(dirname14(resolve13(journalPath)), "worker-logs", encodeURIComponent(root).replaceAll(".", "%2E"));
+}
+function token(work) {
+  return {
+    id: work.id,
+    generation: work.generation,
+    worker: work.worker,
+    epoch: work.epoch,
+    renewedAt: work.renewedAt,
+    expiresAt: work.expiresAt
+  };
+}
+function outside(runId) {
+  return new Error(`Pool stage publication is outside the work subtree: ${runId}`);
+}
+function isLiveStage(stage) {
+  return (stage.sessionId !== undefined || stage.sessionFile !== undefined) && stage.status !== "completed" && stage.status !== "failed" && stage.status !== "skipped";
+}
+function projectRootRun(run) {
+  return {
+    id: run.id,
+    name: run.name,
+    status: run.status,
+    startedAt: run.startedAt,
+    stages: run.stages.map((stage) => ({
+      id: stage.id,
+      name: stage.name,
+      status: stage.status,
+      parentIds: [],
+      toolEvents: [],
+      ...stage.replayKey === undefined ? {} : { replayKey: stage.replayKey },
+      ...stage.intercomGroup === undefined ? {} : { intercomGroup: stage.intercomGroup },
+      ...stage.workflowChildRun === undefined ? {} : { workflowChildRun: stage.workflowChildRun },
+      ...stage.workflowChild === undefined ? {} : { workflowChild: { ...stage.workflowChild, outputs: {} } }
+    }))
+  };
+}
+
+class PooledRoutes {
+  root;
+  owner;
+  mirror = createStore();
+  owners = new Map;
+  attempts = new Map;
+  activated = false;
+  bridge;
+  constructor(root, owner) {
+    this.root = root;
+    this.owner = owner;
+  }
+  static async open(root, cwd, rootRun, forward) {
+    await Promise.resolve().then(() => init_workflow_route_owner());
+    const owner = createWorkflowRouteOwner(cwd);
+    const routes = new PooledRoutes(root, owner);
+    if (rootRun !== undefined)
+      routes.updateRoot(rootRun);
+    routes.bridge = registerPendingStageIntercomBridge({
+      events: {
+        emit: (event, payload) => owner.events.emit(event, payload),
+        on: (event, listener) => event === PENDING_STAGE_MESSAGE_EVENT2 || event === STICKY_LIVE_DELIVERED_EVENT2 ? undefined : owner.events.on(event, listener)
+      }
+    }, routes.mirror, (runId) => routes.activated && routes.owners.has(runId));
+    for (const [event, kind] of [
+      [PENDING_STAGE_MESSAGE_EVENT2, "pending-stage-message"],
+      [STICKY_LIVE_DELIVERED_EVENT2, "sticky-live-delivered"]
+    ])
+      owner.events.on(event, (payload) => {
+        const claimed = payload;
+        if (claimed.handled !== false)
+          return;
+        claimed.handled = true;
+        const { handled: _handled, completion: _completion, ...forwarded } = claimed;
+        claimed.completion = forward({ kind, payload: forwarded });
+      });
+    return routes;
+  }
+  updateRoot(rootRun) {
+    this.mirror.recordRunStart({ ...rootRun, inputs: {}, toolNodes: [], rootRunId: this.root });
+  }
+  accept(entries) {
+    this.mirror.batch(() => {
+      for (const { work, runs } of entries) {
+        let attempt = this.attempts.get(work.id);
+        if (attempt !== undefined && work.generation < attempt.generation)
+          continue;
+        if (attempt === undefined || attempt.generation !== work.generation) {
+          if (attempt !== undefined)
+            this.release(attempt);
+          attempt = { generation: work.generation, runs: attempt?.runs ?? new Set, fenced: false };
+          this.attempts.set(work.id, attempt);
+        }
+        if (attempt.fenced)
+          continue;
+        for (const run of runs) {
+          attempt.runs.add(run.id);
+          this.owners.set(run.id, work.id);
+          const { pendingStageMessages: _messages, ...published } = run;
+          this.mirror.recordRunStart({ ...published, rootRunId: this.root });
+          if (run.stages.some((stage) => stage.pendingStageDeliveryAvailable === true))
+            this.activated = true;
+        }
+      }
+    });
+  }
+  fence(work) {
+    const attempt = this.attempts.get(work.id);
+    if (attempt === undefined || attempt.generation > work.generation)
+      return;
+    if (attempt.generation < work.generation) {
+      this.release(attempt);
+      this.attempts.set(work.id, { generation: work.generation, runs: attempt.runs, fenced: true });
+      return;
+    }
+    this.release(attempt);
+    attempt.fenced = true;
+  }
+  async route(work, runId) {
+    this.requireOwned(work, runId);
+    const readiness = workflowPendingStageRouteReady(this.mirror, runId);
+    await readiness?.completion.catch(() => {});
+    readiness?.assertCurrent();
+    const waiting = new AbortController;
+    await Promise.race([
+      this.owner.registered(runId),
+      delay2(ROUTE_REGISTRATION_WAIT_MS, undefined, { signal: waiting.signal, ref: false }).catch(() => {})
+    ]);
+    waiting.abort();
+    this.requireOwned(work, runId);
+    return workflowPendingStageRouteCapability(this.mirror, runId);
+  }
+  async undeliverable(payload) {
+    const event = { ...payload, handled: false };
+    this.owner.events.emit(PENDING_STAGE_UNDELIVERABLE_EVENT2, event);
+    return event.handled && await event.completion === true;
+  }
+  async close() {
+    const bridge = this.bridge;
+    if (bridge === undefined)
+      return;
+    this.bridge = undefined;
+    try {
+      await bridge.flush();
+    } finally {
+      bridge.refresh();
+      bridge();
+      await this.owner.closeGroup(workflowInvocationIntercomGroup(this.root));
+    }
+  }
+  requireOwned(work, runId) {
+    const attempt = this.attempts.get(work.id);
+    if (attempt === undefined || attempt.generation !== work.generation || attempt.fenced)
+      throw new Error(STALE_WORK_LEASE);
+    if (!attempt.runs.has(runId))
+      throw outside(runId);
+  }
+  release(attempt) {
+    this.mirror.batch(() => {
+      for (const id of attempt.runs) {
+        rotateWorkflowPendingStageRouteCapability(this.mirror, id);
+        const run = this.mirror.runs().find((candidate) => candidate.id === id);
+        if (run?.stages.some(isLiveStage) !== true)
+          continue;
+        this.mirror.recordRunStart({
+          ...run,
+          stages: run.stages.map((stage) => {
+            if (!isLiveStage(stage))
+              return stage;
+            const { sessionId: _session, sessionFile: _file, ...rest } = stage;
+            return { ...rest, attachable: false, attached: false };
+          })
+        });
+      }
+    });
+  }
+}
+
+class PoolCoordinator {
+  port;
+  children = new Set;
+  incarnations = new Map;
+  readyWorkers = new Set;
+  logs = new Map;
+  cleanups = new Set;
+  controlAcks = new Map;
+  lastHeard = new Map;
+  pendingActivity = new Map;
+  batches = new Map;
+  publicationFailures = new Map;
+  requests = new Map;
+  deliveryRequests = new Map;
+  inflight = new Set;
+  lastTick = performance.now();
+  stalledMs = 0;
+  ticker;
+  recoveryTimer;
+  flushTimer;
+  lastFlushAt = 0;
+  batchSequence = 0;
+  requestSequence = 0;
+  usageChanged = false;
+  budgetBlocked = false;
+  desiredControl;
+  root;
+  lease;
+  options;
+  journal;
+  queue;
+  usageLedger;
+  usageTotal;
+  admission;
+  routes;
+  publishing = false;
+  sources = [];
+  logDirectory;
+  starting;
+  recovering;
+  nextRecoveryAt = 0;
+  cleanupFailure;
+  closed = false;
+  closing;
+  replacements = 0;
+  constructor(port) {
+    this.port = port;
+    port.onMessage((message) => this.receive(message));
+    this.ticker = setInterval(() => this.observeResponsiveness(), TICK_INTERVAL_MS).unref();
+  }
+  async shutdown() {
+    await this.closing?.catch(() => {});
+    while (this.inflight.size > 0)
+      await Promise.allSettled([...this.inflight]);
+    await this.journal?.close().catch(() => {});
+  }
+  receive(message) {
+    if (message.kind === "request-reply") {
+      const pending = this.requests.get(message.id);
+      this.requests.delete(message.id);
+      if (message.error !== undefined)
+        pending?.reject(new Error(message.error));
+      else
+        pending?.resolve(message.value);
+      return;
+    }
+    if ("id" in message) {
+      const command = message;
+      const handled = this.execute(command).then((value2) => this.port.send({ kind: "reply", id: command.id, value: value2 }), (error) => this.port.send({ kind: "reply", id: command.id, error: error.message }));
+      this.inflight.add(handled);
+      handled.finally(() => this.inflight.delete(handled));
+      return;
+    }
+    this.notice(message);
+  }
+  notice(notice) {
+    if (notice.kind === "budget")
+      this.budgetBlocked = notice.blocked;
+    else if (notice.kind === "root")
+      this.routes?.updateRoot(notice.rootRun);
+    else {
+      const batch = this.batches.get(notice.batch);
+      this.batches.delete(notice.batch);
+      const rejected = new Map(notice.rejected.map((entry) => [entry.workId, entry]));
+      for (const entry of rejected.values())
+        this.publicationFailures.set(entry.workId, { generation: entry.generation, error: entry.error });
+      this.routes?.accept((batch?.entries ?? []).filter((entry) => rejected.get(entry.work.id)?.generation !== entry.work.generation));
+      batch?.settle();
+    }
+  }
+  async execute(command) {
+    switch (command.kind) {
+      case "prepare":
+        return this.prepare(command.root, command.lease, command.options, command.control);
+      case "control":
+        return this.control(command.state);
+      case "start":
+        this.starting ??= this.start(command.sources, command.cwd, command.publish, command.rootRun);
+        return this.starting;
+      case "enqueue":
+        return this.enqueue(command);
+      case "transport":
+        return this.transport(command.request, command);
+      case "undeliverable":
+        return await this.routes?.undeliverable(command.payload) ?? false;
+      case "close":
+        this.closing ??= this.close();
+        return this.closing;
+    }
+  }
+  async prepare(root, lease, options, control) {
+    if (this.closed)
+      throw new Error("Local worker pool is closed");
+    if (this.root !== undefined && this.root !== root)
+      throw new Error("Local worker pool belongs to another root");
+    this.root = root;
+    this.options = options;
+    this.desiredControl ??= control;
+    this.journal ??= await resolveRunJournal({ journal: { path: options.journalPath } });
+    this.usageLedger ??= await openSqlPoolUsage(this.journal);
+    this.usageTotal = await this.usageLedger.total(root);
+    this.lease = lease;
+    const queue = await openSqlPoolQueue(this.journal);
+    await queue.initialize(lease, COORDINATOR_LEASE_MS);
+    await queue.releasePreviousIncarnations(lease);
+    for (;; ) {
+      const intended = this.desiredControl ?? "running";
+      await queue.setControl(lease, intended);
+      if (intended === (this.desiredControl ?? "running"))
+        break;
+    }
+    this.queue = queue;
+    return this.usageTotal;
+  }
+  async control(state) {
+    this.desiredControl = state;
+    if (!this.queue || !this.lease)
+      return;
+    const control = await this.queue.setControl(this.lease, state);
+    const deadline = Date.now() + CONTROL_ACKNOWLEDGEMENT_TIMEOUT_MS;
+    while ([...this.readyWorkers].some((worker) => (this.controlAcks.get(worker) ?? -1) < control.revision)) {
+      if (this.desiredControl !== state)
+        return;
+      if (Date.now() >= deadline) {
+        if (state === "quit")
+          break;
+        throw new Error("Worker control acknowledgement unresolved");
+      }
+      await delay2(25);
+    }
+    this.flush();
+  }
+  async start(sources, cwd, publish, rootRun) {
+    if (this.closed)
+      throw new Error("Local worker pool is closed");
+    const root = this.root;
+    if (!this.queue || !this.lease || !this.options || root === undefined || this.lease.runId !== root)
+      throw new Error("Local worker pool requires root preparation");
+    this.sources = sources;
+    this.publishing = publish;
+    if (publish) {
+      this.routes = await PooledRoutes.open(root, cwd, rootRun, (request) => this.request(request));
+      if (this.closed) {
+        await this.routes.close();
+        throw new Error("Local worker pool is closed");
+      }
+    }
+    if (this.options.admission)
+      this.admission = await SqlResourceAdmission.open(this.journal, {
+        ...this.options.admission,
+        root,
+        holder: "coordinator"
+      });
+    this.logDirectory = workerLogDirectory(this.options.journalPath, root);
+    await mkdir6(this.logDirectory, { recursive: true }).catch(() => {
+      return;
+    });
+    this.recoveryTimer = setInterval(() => {
+      this.recoverExpired().catch((error) => this.fail(error));
+    }, RECOVERY_INTERVAL_MS).unref();
+    const workers = Array.from({ length: this.options.workers }, () => this.spawn());
+    try {
+      await Promise.any(workers);
+    } catch (error) {
+      throw error.errors[0];
+    }
+  }
+  async enqueue(command) {
+    if (!this.queue || !this.lease || this.root === undefined)
+      throw new Error("Local worker pool requires root preparation");
+    if (command.rootRun !== undefined)
+      this.routes?.updateRoot(command.rootRun);
+    const work = await this.queue.enqueue(this.lease, command.descriptor, command.boundary);
+    const result = await this.queue.result(this.root, work.id);
+    return { work, ...result === undefined ? {} : { result } };
+  }
+  async transport(request, payload) {
+    const target = this.deliveryRequests.get(request);
+    if (target === undefined || !this.incarnations.has(target.slot.worker))
+      throw new Error("Worker exited before delivery acknowledgement");
+    const { slot, workerRequest } = target;
+    await new Promise((resolve, reject) => {
+      const id = randomUUID17();
+      slot.deliveries.set(id, { resolve, reject });
+      slot.child.send({ id: workerRequest, delivery: { id, from: payload.from, message: payload.message } }, (error) => {
+        if (error) {
+          slot.deliveries.delete(id);
+          reject(error);
+        }
+      });
+    });
+  }
+  request(body) {
+    const id = ++this.requestSequence;
+    return new Promise((resolve, reject) => {
+      this.requests.set(id, { resolve, reject });
+      this.port.send({ kind: "request", id, request: body });
+    });
+  }
+  fail(error) {
+    this.port.send({ kind: "failure", error: error.message });
+  }
+  publish(work, runs) {
+    const failure = this.publicationFailures.get(work.id);
+    if (failure?.generation === work.generation)
+      throw new Error(failure.error);
+    if (!this.publishing)
+      return;
+    this.pendingActivity.set(work.id, { work: token(work), runs });
+    this.scheduleFlush();
+  }
+  scheduleFlush() {
+    if (this.flushTimer !== undefined || this.closed)
+      return;
+    const wait = Math.max(0, this.lastFlushAt + POOL_SUMMARY_INTERVAL_MS - performance.now());
+    this.flushTimer = setTimeout(() => {
+      this.flushTimer = undefined;
+      if (this.batches.size > 0) {
+        this.lastFlushAt = performance.now();
+        this.scheduleFlush();
+        return;
+      }
+      this.flush();
+    }, wait);
+  }
+  flush() {
+    clearTimeout(this.flushTimer);
+    this.flushTimer = undefined;
+    if (this.pendingActivity.size === 0 && !this.usageChanged) {
+      const last = [...this.batches.values()].at(-1);
+      return last === undefined ? Promise.resolve() : new Promise((resolve) => this.chainSettle(last, resolve));
+    }
+    this.lastFlushAt = performance.now();
+    const batch = ++this.batchSequence;
+    const entries = [...this.pendingActivity.values()];
+    this.pendingActivity.clear();
+    const usage = this.usageChanged ? this.usageTotal : undefined;
+    this.usageChanged = false;
+    const settled = new Promise((resolve) => this.batches.set(batch, { entries, settle: resolve }));
+    this.port.send({ kind: "activity", batch, entries, ...usage === undefined ? {} : { usage } });
+    return settled;
+  }
+  chainSettle(batch, resolve) {
+    const settle = batch.settle;
+    batch.settle = () => {
+      settle();
+      resolve();
+    };
+  }
+  noteUsage(usage) {
+    this.usageTotal = usage;
+    this.usageChanged = true;
+    this.scheduleFlush();
+  }
+  async sendResult(workId) {
+    const result = await this.queue.result(this.root, workId);
+    if (result === undefined)
+      return false;
+    this.flush();
+    this.port.send({
+      kind: "result",
+      workId,
+      result,
+      ...this.usageTotal === undefined ? {} : { usage: this.usageTotal }
+    });
+    return true;
+  }
+  fence(work) {
+    this.pendingActivity.delete(work.id);
+    this.routes?.fence(work);
+    this.port.send({ kind: "fence", work: { id: work.id, generation: work.generation } });
+  }
+  spawn() {
+    if (this.closed)
+      return Promise.reject(new Error("Local worker pool is closed"));
+    const root = this.root;
+    const options = this.options;
+    const child = fork(options.workerEntry ?? process.argv[1], [
+      JSON.stringify({
+        journalPath: options.journalPath,
+        root,
+        definitions: this.sources,
+        admission: options.admission
+      })
+    ], { stdio: ["ignore", "ignore", "pipe", "ipc"], execArgv: [] });
+    const disconnected = new Promise((resolve) => child.once("disconnect", () => resolve()));
+    this.children.add(child);
+    if (child.pid !== undefined)
+      this.port.send({ kind: "spawned", pid: child.pid });
+    const worker = randomUUID17();
+    this.incarnations.set(worker, child);
+    const slot = { worker, child, deliveries: new Map };
+    let ready = false;
+    let serial = Promise.resolve();
+    const logPath = join29(this.logDirectory, `${worker}.log`);
+    this.logs.set(child, logPath);
+    let logFailure;
+    const log = createWriteStream(logPath, { flags: "a" });
+    log.on("error", (error) => {
+      logFailure = error.message;
+    });
+    let stderr = "";
+    child.stderr?.on("data", (chunk) => {
+      stderr = (stderr + chunk.toString()).slice(-STDERR_TAIL_CHARACTERS);
+    });
+    child.stderr?.on("error", (error) => {
+      logFailure ??= error.message;
+      log.end();
+    });
+    child.stderr?.pipe(log);
+    const diagnosed = (summary) => new Error(`${summary} (worker stderr log: ${logFailure === undefined ? logPath : `unavailable, ${logFailure}`})${stderr ? `: ${stderr}` : ""}`);
+    const startupTimeoutMs = options.startupTimeoutMs;
+    let timedOut = false;
+    let terminated = false;
+    const terminate = () => {
+      if (terminated)
+        return;
+      terminated = true;
+      child.kill("SIGKILL");
+    };
+    const replied = (error) => {
+      if (error)
+        terminate();
+    };
+    return new Promise((resolve, reject) => {
+      const startup = setTimeout(() => {
+        timedOut = true;
+        terminate();
+      }, startupTimeoutMs);
+      child.on("error", (error) => {
+        clearTimeout(startup);
+        reject(error);
+        terminate();
+      });
+      const closed = new Promise((resolve) => child.once("close", () => resolve()));
+      child.once("exit", () => {
+        Promise.race([closed, delay2(STDERR_DRAIN_GRACE_MS)]).then(() => reject(diagnosed(timedOut ? `Local worker startup timed out after ${startupTimeoutMs} ms` : "Local worker exited before readiness")));
+        this.children.delete(child);
+        this.logs.delete(child);
+        if (child.pid !== undefined)
+          this.port.send({ kind: "exited", pid: child.pid });
+        clearTimeout(startup);
+        this.incarnations.delete(worker);
+        this.readyWorkers.delete(worker);
+        this.controlAcks.delete(worker);
+        this.lastHeard.delete(worker);
+        if (slot.work)
+          this.fence(slot.work);
+        for (const delivery of slot.deliveries.values())
+          delivery.reject(new Error("Worker exited before delivery acknowledgement"));
+        slot.deliveries.clear();
+        const cleanup = disconnected.then(() => serial).then(async () => {
+          try {
+            if (await this.admission?.releaseStoppedSessions(worker))
+              throw new Error("Local worker process cleanup unconfirmed; permits quarantined");
+          } catch (error) {
+            this.cleanupFailure = error instanceof Error ? error : new Error(String(error));
+            throw this.cleanupFailure;
+          }
+        }).then(async () => {
+          if (this.closed || !ready || this.desiredControl === "quit")
+            return;
+          let work = slot.work;
+          if (work && await this.sendResult(work.id)) {
+            work = undefined;
+            slot.work = undefined;
+            this.replacements = 0;
+          }
+          if (this.closed)
+            return;
+          if (work)
+            await this.queue.releaseExited(this.lease, work);
+          const exhausted = work ? work.generation >= 3 : ++this.replacements > 3;
+          if (exhausted)
+            this.fail(diagnosed("Local worker retry limit"));
+          else
+            await this.spawn();
+        }).catch((error) => {
+          this.fail(error);
+        });
+        this.cleanups.add(cleanup);
+        cleanup.finally(() => this.cleanups.delete(cleanup));
+      });
+      child.on("message", (message) => {
+        this.observeResponsiveness();
+        this.lastHeard.set(worker, { at: performance.now(), stalled: this.stalledMs });
+        if (message.kind === "delivery-ack") {
+          const pending = slot.deliveries.get(message.deliveryId);
+          slot.deliveries.delete(message.deliveryId);
+          if (message.error)
+            pending?.reject(new Error(message.error));
+          else
+            pending?.resolve();
+          return;
+        }
+        let routeReady;
+        const handled = serial.then(async () => {
+          if (message.kind === "ready") {
+            if (terminated)
+              return;
+            ready = true;
+            this.readyWorkers.add(worker);
+            clearTimeout(startup);
+            resolve();
+            return;
+          }
+          await this.starting;
+          const queue = this.queue;
+          const lease = this.lease;
+          if (message.kind === "control")
+            return queue.control(lease);
+          if (message.kind === "controlled") {
+            const control = await queue.control(lease);
+            if (message.revision > control.revision)
+              throw new Error("Unknown control revision");
+            this.controlAcks.set(worker, Math.max(this.controlAcks.get(worker) ?? -1, message.revision));
+            return;
+          }
+          if (message.kind === "claim") {
+            if (slot.work)
+              throw new Error("Worker already holds an attempt");
+            if (this.budgetBlocked)
+              return;
+            await this.recoverExpired();
+            slot.work = await queue.claim(lease, worker, this.sources.map((source) => ({
+              definition: `${source.path}#${source.exportName}`,
+              digest: source.digest
+            })), options.leaseMs);
+            return slot.work;
+          }
+          let work = slot.work;
+          if (!work)
+            throw new Error("Worker has no active attempt");
+          if (message.kind === "renew" || work.expiresAt - Date.now() < options.leaseMs / 2) {
+            work = await queue.extend(lease, work, options.leaseMs);
+            slot.work = work;
+          }
+          if (message.kind === "activity")
+            return this.publish(work, message.runs);
+          if (message.kind === "route") {
+            if (this.routes === undefined)
+              return;
+            await this.flush();
+            this.assertPublished(work);
+            routeReady = this.routes.route(work, message.runId);
+            return;
+          }
+          if (message.kind === "delivery-ready") {
+            if (!this.publishing)
+              return;
+            await this.flush();
+            this.assertPublished(work);
+            return this.request({
+              kind: "ready",
+              work: token(work),
+              runId: message.runId,
+              stageId: message.stageId,
+              stageName: message.stageName,
+              ...message.sessionId === undefined ? {} : { sessionId: message.sessionId }
+            });
+          }
+          if (message.kind === "delivery") {
+            if (!message.recipient)
+              throw new Error("Worker delivery requires a session identity");
+            if (!this.publishing)
+              return;
+            await this.flush();
+            this.assertPublished(work);
+            const id = ++this.requestSequence;
+            this.deliveryRequests.set(id, { slot, workerRequest: message.id });
+            try {
+              return await new Promise((resolve, reject) => {
+                this.requests.set(id, { resolve, reject });
+                this.port.send({
+                  kind: "request",
+                  id,
+                  request: {
+                    kind: "deliver",
+                    work: token(work),
+                    runId: message.runId,
+                    stageId: message.stageId,
+                    stageName: message.stageName,
+                    recipient: message.recipient
+                  }
+                });
+              });
+            } finally {
+              this.deliveryRequests.delete(id);
+            }
+          }
+          if (message.kind === "renew")
+            return;
+          if (message.kind === "commit") {
+            const receipt = await queue.commit(lease, work, message.operation, message.mutation);
+            this.noteUsage(await this.usageLedger.total(root));
+            return receipt;
+          }
+          if (message.kind === "usage") {
+            this.noteUsage(await this.usageLedger.report(lease, work, message.reports));
+            return;
+          }
+          if (message.kind === "budget") {
+            await queue.assertCurrent(lease, work);
+            if (this.budgetBlocked)
+              throw new Error("Root workflow budget exhausted");
+            return queue.control(lease);
+          }
+          if (message.kind !== "complete")
+            throw new Error("Invalid worker operation");
+          await queue.complete(lease, work, message.result);
+          this.replacements = 0;
+          slot.work = undefined;
+          await this.sendResult(work.id);
+        });
+        const response = handled.then((value2) => routeReady ?? value2);
+        if (message.kind !== "delivery" && message.kind !== "delivery-ready")
+          serial = handled.then(() => {}, () => {});
+        response.then((value2) => child.send({ id: message.id, value: value2 }, replied), (error) => child.send({ id: message.id, error: error.message }, replied));
+      });
+    });
+  }
+  assertPublished(work) {
+    const failure = this.publicationFailures.get(work.id);
+    if (failure?.generation === work.generation)
+      throw new Error(failure.error);
+  }
+  recoverExpired() {
+    if (this.recovering)
+      return this.recovering;
+    const root = this.root;
+    if (this.closed || root === undefined || !this.queue || performance.now() < this.nextRecoveryAt)
+      return Promise.resolve();
+    const queue = this.queue;
+    const lease = this.lease;
+    const leaseMs = this.options.leaseMs;
+    this.recovering = (async () => {
+      await new Promise((resolve) => setImmediate(resolve));
+      await this.admission?.reconcile();
+      const expiredBefore = Date.now();
+      for (const work of await queue.inspect(root)) {
+        if (work.state !== "leased" || work.expiresAt >= expiredBefore)
+          continue;
+        const child = work.worker === null ? undefined : this.incarnations.get(work.worker);
+        if (child && work.worker !== null && this.isLive(work.worker, child)) {
+          await queue.extend(lease, work, leaseMs).catch((error) => {
+            if (error.message !== STALE_WORK_LEASE)
+              throw error;
+          });
+          continue;
+        }
+        if (child && !await this.stop(child).then(() => true, () => false))
+          continue;
+        await queue.expire(lease, work);
+      }
+    })().finally(() => {
+      this.recovering = undefined;
+      this.nextRecoveryAt = performance.now() + RECOVERY_INTERVAL_MS;
+    });
+    return this.recovering;
+  }
+  observeResponsiveness() {
+    const now = performance.now();
+    const gap = now - this.lastTick;
+    if (gap > STALL_THRESHOLD_MS)
+      this.stalledMs += gap - TICK_INTERVAL_MS;
+    this.lastTick = now;
+  }
+  isLive(worker, child) {
+    this.observeResponsiveness();
+    const heard = this.lastHeard.get(worker);
+    return child.exitCode === null && child.signalCode === null && child.connected && heard !== undefined && performance.now() - heard.at - (this.stalledMs - heard.stalled) < this.options.leaseMs;
+  }
+  stop(child) {
+    if (child.pid === undefined || child.exitCode !== null || child.signalCode !== null)
+      return Promise.resolve();
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => reject(new Error("Local worker cleanup was not confirmed")), 5000);
+      child.once("exit", () => {
+        clearTimeout(timeout);
+        resolve();
+      });
+      child.kill("SIGKILL");
+    });
+  }
+  async close() {
+    this.closed = true;
+    clearInterval(this.ticker);
+    clearInterval(this.recoveryTimer);
+    let failure;
+    let stopping = [];
+    try {
+      await this.recovering?.catch(() => {});
+      stopping = [...this.children].map((child) => ({ child, log: this.logs.get(child) }));
+      await Promise.all(stopping.map(({ child }) => this.stop(child)));
+      await Promise.all([...this.cleanups]);
+      if (this.cleanupFailure)
+        throw this.cleanupFailure;
+    } catch (error) {
+      failure = error;
+    }
+    if (failure === undefined) {
+      const stopped = stopping.flatMap(({ child, log }) => log !== undefined && (child.exitCode !== null || child.signalCode !== null) ? [log] : []);
+      await Promise.all(stopped.map((log) => rm3(log, { force: true }).catch(() => {})));
+      if (this.logDirectory !== undefined)
+        await rmdir(this.logDirectory).catch(() => {});
+    }
+    this.flush();
+    try {
+      await this.routes?.close();
+    } catch (error) {
+      failure ??= error;
+    }
+    for (const batch of this.batches.values())
+      batch.settle();
+    this.batches.clear();
+    for (const pending of this.requests.values())
+      pending.reject(new Error("Local worker pool is closed"));
+    this.requests.clear();
+    if (failure !== undefined)
+      throw failure;
+  }
+}
+var CONTROL_ACKNOWLEDGEMENT_TIMEOUT_MS = 5000, RECOVERY_INTERVAL_MS = 500, TICK_INTERVAL_MS = 100, STALL_THRESHOLD_MS = 500, COORDINATOR_LEASE_MS, STDERR_TAIL_CHARACTERS = 8192, STDERR_DRAIN_GRACE_MS = 1000, ROUTE_REGISTRATION_WAIT_MS = 120000, PENDING_STAGE_MESSAGE_EVENT2 = "atomic:workflow-pending-stage-message", STICKY_LIVE_DELIVERED_EVENT2 = "atomic:workflow-sticky-live-delivered", PENDING_STAGE_UNDELIVERABLE_EVENT2 = "atomic:workflow-pending-stage-undeliverable";
+var init_pool_coordinator = __esm(() => {
+  init_resolution();
+  init_sql_pool_queue();
+  init_sql_pool_usage();
+  init_pending_stage_intercom();
+  init_intercom_group();
+  init_pending_stage_route_capability();
+  init_pending_stage_route_readiness();
+  init_store();
+  init_resource_admission();
+  COORDINATOR_LEASE_MS = 3 * STAGE_SESSION_HEARTBEAT_INTERVAL_MS;
 });
 
 // dist/builtin/workflows/src/workers/protocol.ts
@@ -65023,21 +66186,26 @@ class PoolStageHandoff {
   store;
   queue;
   lease;
+  claimRun;
   attempts = new Map;
   owners = new Map;
   publications = new Map;
   drains = new Map;
-  constructor(backend, store, queue, lease) {
+  constructor(backend, store, queue, lease, claimRun) {
     this.backend = backend;
     this.store = store;
     this.queue = queue;
     this.lease = lease;
+    this.claimRun = claimRun;
   }
   publish(work, runs) {
     const previous = this.publications.get(work.id) ?? Promise.resolve();
     const publication = previous.catch(() => {
       return;
-    }).then(() => this.apply(work, runs));
+    }).then(async () => {
+      const commit = await this.prepare(work, runs);
+      this.store.batch(commit);
+    });
     const settled = publication.catch(() => {
       return;
     });
@@ -65048,6 +66216,21 @@ class PoolStageHandoff {
     });
     return publication;
   }
+  async publishBatch(publications) {
+    const prepared = [];
+    for (const { work, runs } of publications)
+      prepared.push(await this.prepare(work, runs).catch((error) => error));
+    return this.store.batch(() => prepared.map((commit) => {
+      if (commit instanceof Error)
+        return commit;
+      try {
+        commit();
+        return;
+      } catch (error) {
+        return error instanceof Error ? error : new Error(String(error));
+      }
+    }));
+  }
   async route(work, runId) {
     this.requireOwned(await this.begin(work), runId);
     const readiness = workflowPendingStageRouteReady(this.store, runId);
@@ -65098,7 +66281,7 @@ class PoolStageHandoff {
     const result = await this.queue.result(root, work.id);
     if (result === undefined)
       return;
-    await this.backend.hydrateWorkflow(root);
+    await this.backend.catchUpWorkflow(root);
     const terminals = new Map;
     for (const checkpoint of this.backend.listCheckpoints(root)) {
       const boundary = checkpoint.kind === "stage" ? checkpoint.topology?.boundary : undefined;
@@ -65108,6 +66291,9 @@ class PoolStageHandoff {
       if (child?.runId === boundary.child.runId)
         terminals.set(child.runId, { status: child.status, outputs: child.outputs });
     }
+    this.store.batch(() => this.settle(work, result, terminals));
+  }
+  settle(work, result, terminals) {
     for (const run of this.store.runs()) {
       if (run.endedAt !== undefined || this.owners.get(run.id) !== work.id)
         continue;
@@ -65131,22 +66317,31 @@ class PoolStageHandoff {
     if (current !== undefined && current.generation > work.generation)
       return;
     const attempt = current?.generation === work.generation ? current : this.start(work, current);
-    this.release(attempt);
+    this.store.batch(() => this.release(attempt));
     attempt.fenced = true;
   }
-  async apply(work, runs) {
+  async prepare(work, runs) {
     const subtree = this.subtree(work, runs);
     const root = this.lease.runId;
-    const known = new Map(this.store.runs().map((run) => [run.id, run]));
-    for (const run of subtree) {
-      const existing = known.get(run.id);
-      const owner = this.owners.get(run.id);
-      if (owner !== undefined && owner !== work.id || owner === undefined && existing !== undefined && (existing.parentRunId !== run.parentRunId || existing.parentStageId !== run.parentStageId))
-        throw outside(run.id);
-    }
-    if (subtree.some((run) => known.get(run.id) === undefined))
-      await this.backend.hydrateWorkflow(root);
+    const owned = (known) => {
+      for (const run of subtree) {
+        const existing = known.get(run.id);
+        const owner = this.owners.get(run.id);
+        if (owner !== undefined && owner !== work.id || owner === undefined && existing !== undefined && (existing.parentRunId !== run.parentRunId || existing.parentStageId !== run.parentStageId))
+          throw outside2(run.id);
+      }
+    };
+    const before = new Map(this.store.runs().map((run) => [run.id, run]));
+    owned(before);
+    if (subtree.some((run) => before.get(run.id) === undefined))
+      await this.backend.catchUpWorkflow(root);
     await this.queue.assertCurrent(this.lease, work);
+    return () => this.commit(work, subtree, owned);
+  }
+  commit(work, subtree, owned) {
+    const root = this.lease.runId;
+    const known = new Map(this.store.runs().map((run) => [run.id, run]));
+    owned(known);
     const attempt = this.enter(work);
     const execution = {
       worker: work.worker ?? "",
@@ -65158,11 +66353,13 @@ class PoolStageHandoff {
       ...run,
       rootRunId: root,
       pendingStageMessages: [
-        ...this.store.runs().find((current) => current.id === run.id)?.pendingStageMessages ?? pendingStageMessagesForDurableRun(this.backend, run.id, root)
+        ...known.get(run.id)?.pendingStageMessages ?? pendingStageMessagesForDurableRun(this.backend, run.id, root)
       ],
       stages: run.stages.map((stage) => ({ ...stage, workerExecution: execution }))
     }));
     const changed = published.some((run) => activity(known.get(run.id)) !== activity(run));
+    for (const run of published)
+      this.claimRun?.(run.id);
     for (const run of published) {
       attempt.runs.add(run.id);
       this.owners.set(run.id, work.id);
@@ -65187,7 +66384,7 @@ class PoolStageHandoff {
     const byId = new Map;
     for (const run of runs) {
       if (run.id === root || byId.has(run.id))
-        throw outside(run.id);
+        throw outside2(run.id);
       byId.set(run.id, run);
     }
     if (runs.length === 0)
@@ -65200,25 +66397,25 @@ class PoolStageHandoff {
     const top = byId.get(work.childRunId);
     if (top !== undefined) {
       if (top.parentRunId !== root || top.parentStageId !== work.boundaryId)
-        throw outside(top.id);
+        throw outside2(top.id);
       const pending = [top];
       for (let run = pending.shift();run !== undefined; run = pending.shift()) {
         if (run.rootRunId !== undefined && run.rootRunId !== root)
-          throw outside(run.id);
+          throw outside2(run.id);
         ordered.push(run);
         for (const child of runs) {
           if (child.parentRunId !== run.id)
             continue;
           const parentStage = run.stages.find((stage) => stage.id === child.parentStageId);
           if (authoritativeWorkflowChildRunId(parentStage) !== child.id)
-            throw outside(child.id);
+            throw outside2(child.id);
           pending.push(child);
         }
       }
     }
     const stray = runs.find((run) => !ordered.includes(run));
     if (stray !== undefined)
-      throw outside(stray.id);
+      throw outside2(stray.id);
     return ordered;
   }
   async begin(work) {
@@ -65273,7 +66470,7 @@ class PoolStageHandoff {
   }
   requireOwned(attempt, runId) {
     if (!attempt.runs.has(runId))
-      throw outside(runId);
+      throw outside2(runId);
   }
   delivery(attempt, work, runId, stageId, stageName) {
     const key = JSON.stringify([runId, stageId]);
@@ -65291,7 +66488,7 @@ class PoolStageHandoff {
     return delivery;
   }
 }
-function outside(runId) {
+function outside2(runId) {
   return new Error(`Pool stage publication is outside the work subtree: ${runId}`);
 }
 function isLive(stage) {
@@ -65316,33 +66513,122 @@ var init_stage_handoff = __esm(() => {
 });
 
 // dist/builtin/workflows/src/workers/local-pool.ts
-import { fork } from "node:child_process";
-import { randomUUID as randomUUID17 } from "node:crypto";
-import { createWriteStream } from "node:fs";
-import { mkdir as mkdir6, rm as rm3, rmdir } from "node:fs/promises";
-import { dirname as dirname14, join as join29, resolve as resolve13 } from "node:path";
-import { setTimeout as delay2 } from "node:timers/promises";
+import { fork as fork2 } from "node:child_process";
+import { resolve as resolve14 } from "node:path";
+import { setTimeout as delay3 } from "node:timers/promises";
 import { fileURLToPath as fileURLToPath6 } from "node:url";
 import { isBunBinary as isBunBinary2 } from "@bastani/atomic";
-function workerLogDirectory(journalPath, root) {
-  return join29(dirname14(resolve13(journalPath)), "worker-logs", encodeURIComponent(root).replaceAll(".", "%2E"));
+function defaultWorkerEntry() {
+  return isBunBinary2 ? INTERNAL_WORKFLOW_WORKER_ARG : fileURLToPath6(new URL("./local-worker-entry.mjs", import.meta.url));
+}
+function launchCoordinatorProcess() {
+  const child = fork2(defaultWorkerEntry(), [JSON.stringify({ role: POOL_COORDINATOR_ROLE })], {
+    stdio: ["ignore", "ignore", "pipe", "ipc"],
+    execArgv: []
+  });
+  let stderr = "";
+  child.stderr?.on("data", (chunk) => {
+    stderr = (stderr + chunk.toString()).slice(-COORDINATOR_STDERR_TAIL_CHARACTERS);
+  });
+  const listeners = [];
+  let lostReason;
+  const lose = (reason) => {
+    if (lostReason !== undefined)
+      return;
+    lostReason = reason;
+    for (const listener of listeners)
+      listener(reason);
+  };
+  const exited = new Promise((resolve) => child.once("exit", () => resolve()));
+  child.on("error", lose);
+  child.once("exit", (code, signal) => lose(new Error(`Local worker pool coordinator exited (${signal ?? `code ${code}`})${stderr ? `: ${stderr.trim()}` : ""}`)));
+  return {
+    pid: child.pid,
+    port: {
+      send(message) {
+        if (lostReason !== undefined || !child.connected)
+          return;
+        child.send(message, (error) => {
+          if (error)
+            lose(error);
+        });
+      },
+      onMessage(listener) {
+        child.on("message", (message) => listener(message));
+      },
+      onClose(listener) {
+        if (lostReason !== undefined)
+          listener(lostReason);
+        else
+          listeners.push(listener);
+      },
+      async close() {
+        if (child.connected)
+          child.disconnect();
+        if (child.exitCode !== null || child.signalCode !== null)
+          return;
+        const timedOut = await Promise.race([exited.then(() => false), delay3(COORDINATOR_EXIT_GRACE_MS, true)]);
+        if (timedOut) {
+          child.kill("SIGKILL");
+          await exited;
+        }
+      }
+    }
+  };
+}
+function launchCoordinatorInProcess() {
+  const mainListeners = [];
+  const coordinatorListeners = [];
+  const copy = (message) => JSON.parse(JSON.stringify(message));
+  const coordinator = new PoolCoordinator({
+    send(message) {
+      const copied = copy(message);
+      setImmediate(() => {
+        for (const listener of mainListeners)
+          listener(copied);
+      });
+    },
+    onMessage(listener) {
+      coordinatorListeners.push(listener);
+    },
+    onClose() {},
+    async close() {}
+  });
+  return {
+    pid: process.pid,
+    port: {
+      send(message) {
+        const copied = copy(message);
+        setImmediate(() => {
+          for (const listener of coordinatorListeners)
+            listener(copied);
+        });
+      },
+      onMessage(listener) {
+        mainListeners.push(listener);
+      },
+      onClose() {},
+      async close() {
+        coordinator.shutdown();
+      }
+    }
+  };
 }
 
 class LocalWorkerPool {
   backend;
   options;
-  children = new Set;
-  incarnations = new Map;
-  readyWorkers = new Set;
-  logs = new Map;
-  logDirectory;
-  cleanups = new Set;
-  recovering;
-  nextRecoveryAt = 0;
-  controlAcks = new Map;
-  lastHeard = new Map;
-  lastTick = performance.now();
-  rootStalledMs = 0;
+  pids = new Set;
+  coordinator;
+  coordinatorLost;
+  commands = new Map;
+  commandSequence = 0;
+  inbound = Promise.resolve();
+  works = new Map;
+  attempts = new Map;
+  results = new Map;
+  changed = Promise.withResolvers();
+  waiting = 0;
   ticker;
   leaseMs;
   desiredControl;
@@ -65350,18 +66636,17 @@ class LocalWorkerPool {
   store;
   handoff;
   releaseRoutes;
+  routeClaims = new Map;
   sources = [];
   queue;
   lease;
-  admission;
-  usageLedger;
   usageTotal;
   rootBudget;
+  budgetBlocked = false;
+  rootSignature;
   starting;
-  cleanupFailure;
   failure;
   closed = false;
-  replacements = 0;
   releaseBinding;
   constructor(backend, options) {
     this.backend = backend;
@@ -65376,10 +66661,12 @@ class LocalWorkerPool {
     this.releaseBinding = bindChildWorkerDispatcher(backend, this, options.rootId);
     if (options.admission && options.rootId === undefined)
       workflowResourceAdmission.set(backend, options.admission);
-    this.ticker = setInterval(() => this.observeResponsiveness(), ROOT_TICK_INTERVAL_MS).unref();
   }
   get workerPids() {
-    return [...this.children].flatMap((child) => child.pid === undefined ? [] : [child.pid]);
+    return [...this.pids];
+  }
+  get coordinatorPid() {
+    return this.coordinator?.pid;
   }
   usage() {
     return this.usageTotal;
@@ -65387,47 +66674,39 @@ class LocalWorkerPool {
   async prepare(root, store) {
     if (this.closed)
       throw new Error("Local worker pool is closed");
-    if (!(this.backend.journal instanceof SqlRunJournal) || resolve13(this.options.journalPath) !== resolve13(this.backend.journal.path) || sqlPoolStorage(this.backend.journal)?.tables.runs !== "wf_runs")
+    if (!(this.backend.journal instanceof SqlRunJournal) || resolve14(this.options.journalPath) !== resolve14(this.backend.journal.path) || sqlPoolStorage(this.backend.journal)?.tables.runs !== "wf_runs")
       throw new Error("Local workers require the same default-prefix SQLite journal");
     if (this.root !== undefined && this.root !== root)
       throw new Error("Local worker pool belongs to another root");
     this.root = root;
     if (store)
       this.store = store;
-    this.usageLedger ??= await openSqlPoolUsage(this.backend.journal);
-    this.usageTotal = await this.usageLedger.total(root);
     const state = await this.backend.journal.leaseState(root);
     if (!state || state.holderId !== this.backend.holderId)
       throw new Error("Local worker pool requires the root owner");
     this.lease = { runId: root, holderId: state.holderId, epoch: state.epoch };
-    const queue = await openSqlPoolQueue(this.backend.journal);
-    await queue.initialize(this.lease, COORDINATOR_LEASE_MS);
-    await queue.releasePreviousIncarnations(this.lease);
-    for (;; ) {
-      const intended = this.desiredControl ?? "running";
-      await queue.setControl(this.lease, intended);
-      if (intended === (this.desiredControl ?? "running"))
-        break;
-    }
-    this.queue = queue;
+    const workerEntry = this.options.workerEntry ?? (isBunBinary2 || this.options.coordinator === "in-process" ? defaultWorkerEntry() : undefined);
+    this.usageTotal = await this.command({
+      kind: "prepare",
+      root,
+      lease: this.lease,
+      options: {
+        journalPath: this.options.journalPath,
+        workers: this.options.workers,
+        leaseMs: this.leaseMs,
+        startupTimeoutMs: this.options.startupTimeoutMs ?? DEFAULT_STARTUP_TIMEOUT_MS,
+        ...this.options.admission === undefined ? {} : { admission: this.options.admission },
+        ...workerEntry === undefined ? {} : { workerEntry }
+      },
+      ...this.desiredControl === undefined ? {} : { control: this.desiredControl }
+    });
+    this.queue ??= await openSqlPoolQueue(this.backend.journal);
   }
   async control(state) {
     this.desiredControl = state;
     try {
-      if (!this.queue || !this.lease)
-        return;
-      const control = await this.queue.setControl(this.lease, state);
-      const deadline = Date.now() + CONTROL_ACKNOWLEDGEMENT_TIMEOUT_MS;
-      while ([...this.readyWorkers].some((worker) => (this.controlAcks.get(worker) ?? -1) < control.revision)) {
-        if (this.desiredControl !== state)
-          return;
-        if (Date.now() >= deadline) {
-          if (state === "quit")
-            break;
-          throw new Error("Worker control acknowledgement unresolved");
-        }
-        await delay2(25);
-      }
+      if (this.coordinator !== undefined)
+        await this.command({ kind: "control", state });
     } finally {
       if (state === "quit")
         await this.close();
@@ -65473,290 +66752,61 @@ class LocalWorkerPool {
         throw new Error(`Worker definition is not importable: ${binding.exportName}`);
       return source;
     }));
-    if (this.store) {
-      this.releaseRoutes = await acquireStandaloneIntercom(this.store, root, String(this.backend.getWorkflow(root)?.invocationCwd ?? process.cwd()));
+    const cwd = String(this.backend.getWorkflow(root)?.invocationCwd ?? process.cwd());
+    const store = this.store;
+    if (store) {
+      this.releaseRoutes = await acquireStandaloneIntercom(store, root, cwd);
       if (this.closed) {
         await this.releaseRoutes();
         this.releaseRoutes = undefined;
         throw new Error("Local worker pool is closed");
       }
-      this.handoff = new PoolStageHandoff(this.backend, this.store, this.queue, this.lease);
-    }
-    if (this.options.admission)
-      this.admission = await SqlResourceAdmission.open(this.backend.journal, {
-        ...this.options.admission,
-        root,
-        holder: "coordinator"
+      const routeOwner = {
+        notifyUndeliverable: async (payload) => !this.closed && await this.command({ kind: "undeliverable", payload }) === true
+      };
+      this.handoff = new PoolStageHandoff(this.backend, store, this.queueView(), this.lease, (runId) => {
+        this.routeClaims.set(runId, claimExternalRunRoute(store, runId, routeOwner));
       });
-    this.logDirectory = workerLogDirectory(this.options.journalPath, root);
-    await mkdir6(this.logDirectory, { recursive: true }).catch(() => {
-      return;
-    });
-    const workers = Array.from({ length: this.options.workers }, () => this.spawn(root));
-    try {
-      await Promise.any(workers);
-    } catch (error) {
-      throw error.errors[0];
     }
-  }
-  spawn(root) {
-    if (this.closed)
-      return Promise.reject(new Error("Local worker pool is closed"));
-    const child = fork(isBunBinary2 ? INTERNAL_WORKFLOW_WORKER_ARG : fileURLToPath6(new URL("./local-worker-entry.mjs", import.meta.url)), [
-      JSON.stringify({
-        journalPath: this.options.journalPath,
-        root,
-        definitions: this.sources,
-        admission: this.options.admission
-      })
-    ], { stdio: ["ignore", "ignore", "pipe", "ipc"], execArgv: [] });
-    const disconnected = new Promise((resolve) => child.once("disconnect", () => resolve()));
-    this.children.add(child);
-    const worker = randomUUID17();
-    this.incarnations.set(worker, child);
-    let ready = false;
-    let serial = Promise.resolve();
-    let work;
-    const deliveries = new Map;
-    const logPath = join29(this.logDirectory, `${worker}.log`);
-    this.logs.set(child, logPath);
-    let logFailure;
-    const log = createWriteStream(logPath, { flags: "a" });
-    log.on("error", (error) => {
-      logFailure = error.message;
-    });
-    let stderr = "";
-    child.stderr?.on("data", (chunk) => {
-      stderr = (stderr + chunk.toString()).slice(-STDERR_TAIL_CHARACTERS);
-    });
-    child.stderr?.on("error", (error) => {
-      logFailure ??= error.message;
-      log.end();
-    });
-    child.stderr?.pipe(log);
-    const diagnosed = (summary) => new Error(`${summary} (worker stderr log: ${logFailure === undefined ? logPath : `unavailable, ${logFailure}`})${stderr ? `: ${stderr}` : ""}`);
-    const startupTimeoutMs = this.options.startupTimeoutMs ?? DEFAULT_STARTUP_TIMEOUT_MS;
-    let timedOut = false;
-    let terminated = false;
-    const terminate = () => {
-      if (terminated)
-        return;
-      terminated = true;
-      child.kill("SIGKILL");
-    };
-    const replied = (error) => {
-      if (error)
-        terminate();
-    };
-    return new Promise((resolve, reject) => {
-      const startup = setTimeout(() => {
-        timedOut = true;
-        terminate();
-      }, startupTimeoutMs);
-      child.on("error", (error) => {
-        clearTimeout(startup);
-        reject(error);
-        terminate();
-      });
-      const closed = new Promise((resolve) => child.once("close", () => resolve()));
-      child.once("exit", () => {
-        Promise.race([closed, delay2(STDERR_DRAIN_GRACE_MS)]).then(() => reject(diagnosed(timedOut ? `Local worker startup timed out after ${startupTimeoutMs} ms` : "Local worker exited before readiness")));
-        this.children.delete(child);
-        this.logs.delete(child);
-        clearTimeout(startup);
-        this.incarnations.delete(worker);
-        this.readyWorkers.delete(worker);
-        this.controlAcks.delete(worker);
-        this.lastHeard.delete(worker);
-        if (work)
-          this.handoff?.fence(work);
-        for (const delivery of deliveries.values())
-          delivery.reject(new Error("Worker exited before delivery acknowledgement"));
-        deliveries.clear();
-        const cleanup = disconnected.then(() => serial).then(async () => {
-          try {
-            if (await this.admission?.releaseStoppedSessions(worker))
-              throw new Error("Local worker process cleanup unconfirmed; permits quarantined");
-          } catch (error) {
-            this.cleanupFailure = error instanceof Error ? error : new Error(String(error));
-            throw this.cleanupFailure;
-          }
-        }).then(async () => {
-          if (this.closed || !ready || this.desiredControl === "quit")
-            return;
-          if (work && await this.queue.result(root, work.id)) {
-            work = undefined;
-            this.replacements = 0;
-          }
-          if (this.closed)
-            return;
-          if (work)
-            await this.queue.releaseExited(this.lease, work);
-          const exhausted = work ? work.generation >= 3 : ++this.replacements > 3;
-          if (exhausted)
-            this.failure = diagnosed("Local worker retry limit");
-          else
-            await this.spawn(root);
-        }).catch((error) => {
-          this.failure = error;
-        });
-        this.cleanups.add(cleanup);
-        cleanup.finally(() => this.cleanups.delete(cleanup));
-      });
-      child.on("message", (message) => {
-        this.observeResponsiveness();
-        this.lastHeard.set(worker, { at: performance.now(), rootStalled: this.rootStalledMs });
-        if (message.kind === "delivery-ack") {
-          const pending = deliveries.get(message.deliveryId);
-          deliveries.delete(message.deliveryId);
-          if (message.error)
-            pending?.reject(new Error(message.error));
-          else
-            pending?.resolve();
-          return;
-        }
-        const response = serial.then(async () => {
-          if (message.kind === "ready") {
-            if (terminated)
-              return;
-            ready = true;
-            this.readyWorkers.add(worker);
-            clearTimeout(startup);
-            resolve();
-            return;
-          }
-          await this.starting;
-          const queue = this.queue;
-          const lease = this.lease;
-          if (message.kind === "control")
-            return queue.control(lease);
-          if (message.kind === "controlled") {
-            const control = await queue.control(lease);
-            if (message.revision > control.revision)
-              throw new Error("Unknown control revision");
-            this.controlAcks.set(worker, Math.max(this.controlAcks.get(worker) ?? -1, message.revision));
-            return;
-          }
-          if (message.kind === "claim") {
-            if (work)
-              throw new Error("Worker already holds an attempt");
-            const decision = this.rootBudget?.checkpoint();
-            if (decision?.kind === "exhausted" || decision?.kind === "wrap_up")
-              return;
-            await this.recoverExpired(root);
-            work = await queue.claim(lease, worker, this.sources.map((source) => ({
-              definition: `${source.path}#${source.exportName}`,
-              digest: source.digest
-            })), this.leaseMs);
-            return work;
-          }
-          if (!work)
-            throw new Error("Worker has no active attempt");
-          if (message.kind === "renew" || work.expiresAt - Date.now() < this.leaseMs / 2)
-            work = await queue.extend(lease, work, this.leaseMs);
-          if (message.kind === "activity")
-            return this.handoff?.publish(work, message.runs);
-          if (message.kind === "route")
-            return this.handoff?.route(work, message.runId);
-          if (message.kind === "delivery-ready")
-            return this.handoff?.ready(work, message.runId, message.stageId, message.stageName, message.sessionId);
-          if (message.kind === "delivery") {
-            if (!message.recipient)
-              throw new Error("Worker delivery requires a session identity");
-            return this.handoff?.deliver(work, message.runId, message.stageId, message.stageName, message.recipient, (from, payload) => new Promise((resolve, reject) => {
-              const id = randomUUID17();
-              deliveries.set(id, { resolve, reject });
-              child.send({ id: message.id, delivery: { id, from, message: payload } }, (error) => {
-                if (error) {
-                  deliveries.delete(id);
-                  reject(error);
-                }
-              });
-            }));
-          }
-          if (message.kind === "renew")
-            return;
-          if (message.kind === "commit") {
-            const receipt = await queue.commit(lease, work, message.operation, message.mutation);
-            this.usageTotal = await this.usageLedger.total(root);
-            return receipt;
-          }
-          if (message.kind === "usage") {
-            this.usageTotal = await this.usageLedger.report(lease, work, message.reports);
-            return;
-          }
-          if (message.kind === "budget") {
-            await queue.assertCurrent(lease, work);
-            const decision = this.rootBudget?.checkpoint();
-            if (decision?.kind === "exhausted" || decision?.kind === "wrap_up")
-              throw new Error("Root workflow budget exhausted");
-            return queue.control(lease);
-          }
-          if (message.kind !== "complete")
-            throw new Error("Invalid worker operation");
-          await queue.complete(lease, work, message.result);
-          this.replacements = 0;
-          work = undefined;
-        });
-        if (message.kind !== "delivery" && message.kind !== "delivery-ready")
-          serial = response.then(() => {}, () => {});
-        response.then((value2) => child.send({ id: message.id, value: value2 }, replied), (error) => child.send({ id: message.id, error: error.message }, replied));
-      });
+    await this.command({
+      kind: "start",
+      sources: this.sources,
+      cwd,
+      publish: store !== undefined,
+      ...this.rootRun()
     });
   }
-  recoverExpired(root) {
-    if (this.recovering)
-      return this.recovering;
-    if (this.closed || performance.now() < this.nextRecoveryAt)
-      return Promise.resolve();
-    this.recovering = (async () => {
-      await new Promise((resolve) => setImmediate(resolve));
-      await this.admission?.reconcile();
-      const expiredBefore = Date.now();
-      for (const work of await this.queue.inspect(root)) {
-        if (work.state !== "leased" || work.expiresAt >= expiredBefore)
-          continue;
-        const child = work.worker === null ? undefined : this.incarnations.get(work.worker);
-        if (child && work.worker !== null && this.isLive(work.worker, child)) {
-          await this.queue.extend(this.lease, work, this.leaseMs).catch((error) => {
-            if (error.message !== STALE_WORK_LEASE)
-              throw error;
-          });
-          continue;
-        }
-        if (child && !await this.stop(child).then(() => true, () => false))
-          continue;
-        await this.queue.expire(this.lease, work);
-      }
-    })().finally(() => {
-      this.recovering = undefined;
-      this.nextRecoveryAt = performance.now() + RECOVERY_INTERVAL_MS;
-    });
-    return this.recovering;
+  queueView() {
+    return {
+      assertCurrent: async (_lease, work) => {
+        const current = this.attempts.get(work.id);
+        if (current === undefined || current.fenced || current.generation !== work.generation || current.worker !== work.worker || current.epoch !== work.epoch)
+          throw new Error(STALE_WORK_LEASE);
+      },
+      withCurrentAppend: (lease, work, assertSession, action) => this.queue.withCurrentAppend(lease, work, assertSession, action),
+      result: async (root, id) => this.results.get(id) ?? this.queue.result(root, id)
+    };
   }
-  observeResponsiveness() {
-    const now = performance.now();
-    const gap = now - this.lastTick;
-    if (gap > ROOT_STALL_THRESHOLD_MS)
-      this.rootStalledMs += gap - ROOT_TICK_INTERVAL_MS;
-    this.lastTick = now;
+  rootProjection() {
+    const run = this.store?.runs().find((candidate) => candidate.id === this.root);
+    return run === undefined ? undefined : projectRootRun(run);
   }
-  isLive(worker, child) {
-    this.observeResponsiveness();
-    const heard = this.lastHeard.get(worker);
-    return child.exitCode === null && child.signalCode === null && child.connected && heard !== undefined && performance.now() - heard.at - (this.rootStalledMs - heard.rootStalled) < this.leaseMs;
+  rootRun() {
+    const rootRun = this.rootProjection();
+    if (rootRun === undefined)
+      return {};
+    this.rootSignature = JSON.stringify(rootRun);
+    return { rootRun };
   }
-  stop(child) {
-    if (child.pid === undefined || child.exitCode !== null || child.signalCode !== null)
-      return Promise.resolve();
-    return new Promise((resolve, reject) => {
-      const timeout = setTimeout(() => reject(new Error("Local worker cleanup was not confirmed")), 5000);
-      child.once("exit", () => {
-        clearTimeout(timeout);
-        resolve();
-      });
-      child.kill("SIGKILL");
-    });
+  refreshRootRun() {
+    const rootRun = this.rootProjection();
+    if (rootRun === undefined)
+      return;
+    const signature = JSON.stringify(rootRun);
+    if (signature === this.rootSignature)
+      return;
+    this.rootSignature = signature;
+    this.notice({ kind: "root", rootRun });
   }
   async run(definition, inputs, options) {
     try {
@@ -65789,7 +66839,7 @@ class LocalWorkerPool {
     const selectedSource = this.sources[index];
     if (await definitionDigest(selectedSource.path) !== selectedSource.digest)
       throw new Error("Worker definition compatibility error");
-    await this.backend.hydrateWorkflow(root);
+    await this.backend.catchUpWorkflow(root);
     const boundary = this.backend.listCheckpoints(root).find((entry) => entry.kind === "stage" && entry.topology?.boundary?.event === "start" && entry.topology.stageId === options.parentRun.stageId);
     if (boundary?.kind !== "stage")
       throw new Error("Missing durable child boundary");
@@ -65800,39 +66850,232 @@ class LocalWorkerPool {
       config: options.config,
       executionMode: options.executionMode
     }));
-    const work = await this.queue.enqueue(this.lease, {
-      boundaryId: options.parentRun.stageId,
-      childRunId: options.runId,
-      scope: options.durableScope.scopePrefix,
-      definition: `${selectedSource.path}#${selectedSource.exportName}`,
-      digest: selectedSource.digest,
-      inputs,
-      execution
-    }, boundary);
-    for (;; ) {
-      options.signal?.throwIfAborted();
-      if (this.closed) {
+    this.evaluateBudget();
+    const enqueued = await this.command({
+      kind: "enqueue",
+      descriptor: {
+        boundaryId: options.parentRun.stageId,
+        childRunId: options.runId,
+        scope: options.durableScope.scopePrefix,
+        definition: `${selectedSource.path}#${selectedSource.exportName}`,
+        digest: selectedSource.digest,
+        inputs,
+        execution
+      },
+      boundary,
+      ...this.rootRun()
+    });
+    const work = enqueued.work;
+    this.works.set(work.id, work);
+    if (enqueued.result !== undefined && !this.results.has(work.id))
+      this.results.set(work.id, enqueued.result);
+    this.waiting++;
+    this.ticker ??= setInterval(() => {
+      this.evaluateBudget();
+      this.signalChange();
+    }, POOL_SUMMARY_INTERVAL_MS).unref();
+    try {
+      for (;; ) {
+        options.signal?.throwIfAborted();
+        if (this.closed) {
+          if (this.failure)
+            throw this.failure;
+          if (this.desiredControl === "quit")
+            throw new WorkflowGracefulQuitError(root, "worker pool teardown");
+          throw new Error("Local worker pool is closed");
+        }
+        const result = this.results.get(work.id);
+        if (result) {
+          await this.inbound;
+          await this.backend.catchUpWorkflow(root);
+          await this.handoff?.complete(work);
+          return result;
+        }
         if (this.failure)
           throw this.failure;
-        if (this.desiredControl === "quit")
-          throw new WorkflowGracefulQuitError(root, "worker pool teardown");
-        throw new Error("Local worker pool is closed");
+        if (this.budgetBlocked)
+          await this.rootBudget.stopAtBoundaryAsync(definition.name);
+        await this.nextChange(options.signal);
       }
-      const result = await this.queue.result(root, work.id);
-      if (result) {
-        await this.backend.hydrateWorkflow(root);
-        await this.handoff?.complete(work);
-        return result;
+    } finally {
+      if (--this.waiting === 0) {
+        clearInterval(this.ticker);
+        this.ticker = undefined;
       }
-      if (this.failure)
-        throw this.failure;
-      const decision = this.rootBudget?.checkpoint();
-      if (decision?.kind === "exhausted" || decision?.kind === "wrap_up")
-        await this.rootBudget.stopAtBoundaryAsync(definition.name);
-      await this.recoverExpired(root);
-      await delay2(25, undefined, { signal: options.signal });
     }
   }
+  evaluateBudget() {
+    const decision = this.rootBudget?.checkpoint();
+    const blocked = decision?.kind === "exhausted" || decision?.kind === "wrap_up";
+    if (blocked === this.budgetBlocked)
+      return;
+    this.budgetBlocked = blocked;
+    this.notice({ kind: "budget", blocked });
+  }
+  signalChange() {
+    const changed = this.changed;
+    this.changed = Promise.withResolvers();
+    changed.resolve();
+  }
+  nextChange(signal) {
+    const changed = this.changed.promise;
+    if (signal === undefined)
+      return changed;
+    return new Promise((resolve, reject) => {
+      const abort = () => reject(signal.reason);
+      signal.addEventListener("abort", abort, { once: true });
+      changed.then(() => {
+        signal.removeEventListener("abort", abort);
+        resolve();
+      });
+    });
+  }
+  connect() {
+    if (this.coordinator !== undefined)
+      return this.coordinator;
+    const coordinator = this.options.coordinator === "in-process" ? launchCoordinatorInProcess() : launchCoordinatorProcess();
+    this.coordinator = coordinator;
+    coordinator.port.onMessage((event) => {
+      this.inbound = this.inbound.then(() => this.receive(event)).catch(() => {});
+    });
+    coordinator.port.onClose((reason) => {
+      this.coordinatorLost = reason;
+      this.inbound = this.inbound.then(() => this.lost(reason));
+    });
+    return coordinator;
+  }
+  lost(reason) {
+    this.pids.clear();
+    if (!this.closed)
+      this.failure ??= reason;
+    for (const pending of this.commands.values())
+      pending.reject(reason);
+    this.commands.clear();
+    this.signalChange();
+  }
+  command(body) {
+    const coordinator = this.connect();
+    if (this.coordinatorLost !== undefined)
+      return Promise.reject(this.coordinatorLost);
+    const id = ++this.commandSequence;
+    return new Promise((resolve, reject) => {
+      this.commands.set(id, { resolve, reject });
+      coordinator.port.send({ ...body, id });
+    });
+  }
+  notice(notice) {
+    this.coordinator?.port.send(notice);
+  }
+  async receive(event) {
+    switch (event.kind) {
+      case "reply": {
+        const pending = this.commands.get(event.id);
+        this.commands.delete(event.id);
+        if (event.error !== undefined)
+          pending?.reject(new Error(event.error));
+        else
+          pending?.resolve(event.value);
+        return;
+      }
+      case "activity":
+        return this.applyActivity(event.batch, event.entries, event.usage);
+      case "spawned":
+        this.pids.add(event.pid);
+        return;
+      case "exited":
+        this.pids.delete(event.pid);
+        return;
+      case "fence": {
+        const current = this.attempts.get(event.work.id);
+        if (current?.generation === event.work.generation)
+          current.fenced = true;
+        this.handoff?.fence(event.work);
+        return;
+      }
+      case "result":
+        if (event.usage !== undefined)
+          this.usageTotal = event.usage;
+        this.results.set(event.workId, event.result);
+        this.signalChange();
+        return;
+      case "failure":
+        this.failure ??= new Error(event.error);
+        this.signalChange();
+        return;
+      case "request":
+        this.serve(event.id, event.request);
+        return;
+    }
+  }
+  async applyActivity(batch, entries, usage) {
+    if (usage !== undefined)
+      this.usageTotal = usage;
+    const rejected = [];
+    const handoff = this.handoff;
+    if (handoff !== undefined) {
+      const publications = entries.flatMap((entry) => {
+        const work = this.track(entry.work);
+        if (work !== undefined)
+          return [{ work, runs: entry.runs }];
+        rejected.push({ workId: entry.work.id, generation: entry.work.generation, error: STALE_WORK_LEASE });
+        return [];
+      });
+      const outcomes = await handoff.publishBatch(publications);
+      outcomes.forEach((error, index) => {
+        const { work } = publications[index];
+        if (error !== undefined)
+          rejected.push({ workId: work.id, generation: work.generation, error: error.message });
+      });
+    }
+    this.notice({ kind: "published", batch, rejected });
+    this.refreshRootRun();
+  }
+  track(attempt) {
+    const work = this.works.get(attempt.id);
+    if (work === undefined)
+      return;
+    const current = this.attempts.get(attempt.id);
+    if (current === undefined || attempt.generation > current.generation)
+      this.attempts.set(attempt.id, { ...attempt, fenced: false });
+    return { ...work, ...attempt, state: "leased" };
+  }
+  async serve(id, request) {
+    try {
+      const value2 = await this.answer(id, request);
+      this.coordinator?.port.send({ kind: "request-reply", id, ...value2 === undefined ? {} : { value: value2 } });
+    } catch (error) {
+      this.coordinator?.port.send({
+        kind: "request-reply",
+        id,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  async answer(id, request) {
+    if (request.kind === "pending-stage-message" || request.kind === "sticky-live-delivered") {
+      const router = this.store === undefined ? undefined : pendingStageMessageRouter(this.store);
+      const event = {
+        ...request.payload,
+        handled: false
+      };
+      if (request.kind === "pending-stage-message")
+        router?.route(event);
+      else
+        router?.sticky(event);
+      if (event.handled && event.completion !== undefined)
+        return await event.completion;
+      return request.kind === "pending-stage-message" ? { outcome: "refused", reason: "Session not found" } : undefined;
+    }
+    const handoff = this.handoff;
+    const work = this.track(request.work);
+    if (handoff === undefined || work === undefined)
+      throw new Error(STALE_WORK_LEASE);
+    if (request.kind === "ready")
+      return handoff.ready(work, request.runId, request.stageId, request.stageName, request.sessionId);
+    return handoff.deliver(work, request.runId, request.stageId, request.stageName, request.recipient, async (from, message) => {
+      await this.command({ kind: "transport", request: id, from, message });
+    });
+  }
   closing;
   close() {
     this.closing ??= this.dispose();
@@ -65841,27 +67084,28 @@ class LocalWorkerPool {
   async dispose() {
     this.closed = true;
     clearInterval(this.ticker);
+    this.ticker = undefined;
     this.releaseBinding();
     if (this.options.rootId === undefined)
       workflowResourceAdmission.delete(this.backend);
+    this.signalChange();
     let failure;
-    let stopping = [];
-    try {
-      await this.recovering?.catch(() => {});
-      stopping = [...this.children].map((child) => ({ child, log: this.logs.get(child) }));
-      await Promise.all(stopping.map(({ child }) => this.stop(child)));
-      await Promise.all([...this.cleanups]);
-      if (this.cleanupFailure)
-        throw this.cleanupFailure;
-    } catch (error) {
-      failure = error;
-    }
-    if (failure === undefined) {
-      const stopped = stopping.flatMap(({ child, log }) => log !== undefined && (child.exitCode !== null || child.signalCode !== null) ? [log] : []);
-      await Promise.all(stopped.map((log) => rm3(log, { force: true }).catch(() => {})));
-      if (this.logDirectory !== undefined)
-        await rmdir(this.logDirectory).catch(() => {});
+    const coordinator = this.coordinator;
+    if (coordinator !== undefined) {
+      if (this.coordinatorLost === undefined) {
+        try {
+          await this.command({ kind: "close" });
+        } catch (error) {
+          failure = error;
+        }
+      }
+      await this.inbound;
+      await coordinator.port.close();
+      this.pids.clear();
     }
+    for (const release of this.routeClaims.values())
+      release();
+    this.routeClaims.clear();
     try {
       await this.releaseRoutes?.();
     } catch (error) {
@@ -65871,27 +67115,26 @@ class LocalWorkerPool {
       throw failure;
   }
 }
-var INTERNAL_WORKFLOW_WORKER_ARG = "--internal-workflow-worker", DEFAULT_WORK_LEASE_MS = 30000, MINIMUM_WORK_LEASE_MS, CONTROL_ACKNOWLEDGEMENT_TIMEOUT_MS = 5000, RECOVERY_INTERVAL_MS = 500, ROOT_TICK_INTERVAL_MS = 100, ROOT_STALL_THRESHOLD_MS = 500, COORDINATOR_LEASE_MS, DEFAULT_STARTUP_TIMEOUT_MS = 30000, MAX_TIMER_DELAY_MS = 2147483647, STDERR_TAIL_CHARACTERS = 8192, STDERR_DRAIN_GRACE_MS = 1000;
+var INTERNAL_WORKFLOW_WORKER_ARG = "--internal-workflow-worker", DEFAULT_WORK_LEASE_MS = 30000, MINIMUM_WORK_LEASE_MS, DEFAULT_STARTUP_TIMEOUT_MS = 30000, MAX_TIMER_DELAY_MS = 2147483647, COORDINATOR_STDERR_TAIL_CHARACTERS = 8192, COORDINATOR_EXIT_GRACE_MS = 5000;
 var init_local_pool = __esm(() => {
   init_internal();
   init_sql_pool_queue();
-  init_sql_pool_usage();
   init_sql_run_journal();
   init_workflow_tool_abort();
   init_sdk_intercom();
+  init_external_run_routes();
   init_workflow_infrastructure_error();
   init_admission_binding();
   init_definitions();
   init_dispatch();
   init_host_options();
-  init_resource_admission();
+  init_pool_coordinator();
   init_stage_handoff();
   MINIMUM_WORK_LEASE_MS = 2 * WORKER_HEARTBEAT_INTERVAL_MS;
-  COORDINATOR_LEASE_MS = 3 * STAGE_SESSION_HEARTBEAT_INTERVAL_MS;
 });
 
 // dist/builtin/workflows/src/workers/public-pool.ts
-import { resolve as resolve14 } from "node:path";
+import { resolve as resolve15 } from "node:path";
 import { isDeepStrictEqual as isDeepStrictEqual2 } from "node:util";
 function withWorkerSettings(options, settings) {
   const configured = settings?.workflows;
@@ -65940,11 +67183,11 @@ async function activatePublicPool(backend, options) {
     ...options.localWorkers,
     startupTimeoutMs: undefined,
     leaseMs: undefined,
-    definitions: options.localWorkers.definitions.map((source) => ({ ...source, path: resolve14(cwd, source.path) }))
+    definitions: options.localWorkers.definitions.map((source) => ({ ...source, path: resolve15(cwd, source.path) }))
   };
   const admission = options.admission && {
     ...options.admission,
-    ...options.admission.userDatabase ? { userDatabase: resolve14(cwd, options.admission.userDatabase) } : {}
+    ...options.admission.userDatabase ? { userDatabase: resolve15(cwd, options.admission.userDatabase) } : {}
   };
   const sources = localWorkers && await Promise.all(localWorkers.definitions.map(async (source) => ({ ...source, digest: await definitionDigest(source.path) })));
   const resources = JSON.parse(JSON.stringify({
@@ -72552,9 +73795,9 @@ var init_stage_runner_controller = __esm(() => {
 });
 
 // dist/builtin/workflows/src/runs/foreground/stage-runner-output.ts
-import { createHash as createHash4 } from "node:crypto";
+import { createHash as createHash5 } from "node:crypto";
 import { mkdir as mkdir7, writeFile as writeFile10 } from "node:fs/promises";
-import { basename as basename5, dirname as dirname15, isAbsolute as isAbsolute11, join as join30, resolve as resolve15 } from "node:path";
+import { basename as basename5, dirname as dirname15, isAbsolute as isAbsolute11, join as join30, resolve as resolve16 } from "node:path";
 function normalizeMaxOutput2(maxOutput) {
   return {
     bytes: maxOutput?.bytes ?? DEFAULT_MAX_OUTPUT_BYTES,
@@ -72616,7 +73859,7 @@ function formatByteSize(bytes) {
   return `${value2.toFixed(1)} ${units[unitIndex]}`;
 }
 function transcriptPath(runId, outputPath) {
-  const digest = createHash4("sha256").update(outputPath).digest("hex").slice(0, 16);
+  const digest = createHash5("sha256").update(outputPath).digest("hex").slice(0, 16);
   return join30(workflowArtifactRunPath(runId), "transcripts", `${digest}-${basename5(outputPath)}.transcript.md`);
 }
 function appendContent(lines, content) {
@@ -72662,7 +73905,7 @@ function renderTranscript(messages, fallbackOutput) {
 `);
 }
 function savedOutputReference(outputPath, fullOutput, transcriptPathValue, transcriptText, transcriptAvailable, warning) {
-  const absolutePath = resolve15(outputPath);
+  const absolutePath = resolve16(outputPath);
   const bytes = Buffer.byteLength(fullOutput, "utf8");
   const lines = countLines(fullOutput);
   const transcriptBytes = Buffer.byteLength(transcriptText, "utf8");
@@ -72677,8 +73920,8 @@ function resolveOutputPath(output, runtimeCwd, requestedCwd) {
     return;
   if (isAbsolute11(output))
     return output;
-  const baseCwd = requestedCwd === undefined ? runtimeCwd : isAbsolute11(requestedCwd) ? requestedCwd : resolve15(runtimeCwd, requestedCwd);
-  return resolve15(baseCwd, output);
+  const baseCwd = requestedCwd === undefined ? runtimeCwd : isAbsolute11(requestedCwd) ? requestedCwd : resolve16(runtimeCwd, requestedCwd);
+  return resolve16(baseCwd, output);
 }
 function degenerateWarning(fullOutput) {
   return fullOutput.trim().length === 0 ? "WARNING: the stage artifact is empty; search the companion transcript for this stage's work." : undefined;
@@ -73687,7 +74930,7 @@ async function run(def, inputs, opts = {}) {
   if (!isWorkflowDefinition(def))
     throw new Error(workflowDefinitionRequirementMessage("run(definition, inputs)", def));
   const depth = opts.depth ?? 0;
-  const maxDepth = opts.config?.maxDepth ?? 4;
+  const maxDepth = opts.config?.maxDepth ?? 3;
   if (depth >= maxDepth) {
     return {
       runId: opts.runId ?? crypto.randomUUID(),
@@ -75141,9 +76384,9 @@ var init_sdk_owner_release = __esm(() => {
 
 // dist/builtin/workflows/src/durable/sdk-recovery-scope.ts
 import { realpathSync as realpathSync5 } from "node:fs";
-import { resolve as resolve16 } from "node:path";
+import { resolve as resolve17 } from "node:path";
 function canonicalDirectory(path) {
-  const absolute = resolve16(path);
+  const absolute = resolve17(path);
   try {
     const canonical = realpathSync5.native(absolute);
     return process.platform === "win32" ? canonical.toLowerCase() : canonical;
@@ -75880,9 +77123,7 @@ function runSnapshotsFromCheckpoints(checkpoints, rootRunId, rootRunName, fallba
   }
   for (const group of grouped.values())
     group.sort(compareDraftSourceOrder);
-  const groupedCount = grouped.size;
-  retainReachableRunGroups(grouped, rootRunId);
-  if (policy.failOnUnreachable && grouped.size !== groupedCount)
+  if (!retainReachableRunGroups(grouped, rootRunId) && policy.failOnUnreachable)
     return [];
   if (!validateRunGroups(grouped, rootRunId, toolCheckpoints, checkpoints, policy.retainActive))
     return [];
@@ -87496,7 +88737,7 @@ async function withDormantRunWrite(store, runId, write) {
 
 // dist/builtin/workflows/src/extension/dormant-run-intercom.ts
 var PENDING_STAGE_ROUTE_EVENT2 = "atomic:workflow-pending-stage-route";
-var PENDING_STAGE_MESSAGE_EVENT2 = "atomic:workflow-pending-stage-message";
+var PENDING_STAGE_MESSAGE_EVENT3 = "atomic:workflow-pending-stage-message";
 var PENDING_STAGE_ROUTE_REVOKED_EVENT = "atomic:workflow-pending-stage-route-revoked";
 var DORMANT_RUN_SUBAGENT_HOLD_EVENT = "atomic:workflow-dormant-run-subagent-hold";
 var DORMANT_RUN_RECHECK_MS = 15000;
@@ -87672,7 +88913,7 @@ function registerDormantRunIntercomRoutes(pi, activeStore, deps) {
       ...event.senderRegistrationName === undefined ? {} : { senderRegistrationName: event.senderRegistrationName },
       ...event.senderReturnAddress === undefined ? {} : { senderReturnAddress: event.senderReturnAddress }
     };
-    pi.events?.emit?.(PENDING_STAGE_MESSAGE_EVENT2, forwarded);
+    pi.events?.emit?.(PENDING_STAGE_MESSAGE_EVENT3, forwarded);
     if (forwarded.handled && forwarded.completion !== undefined)
       return await forwarded.completion;
     return { outcome: "refused", reason: "Session not found" };
@@ -87692,7 +88933,7 @@ function registerDormantRunIntercomRoutes(pi, activeStore, deps) {
     }
     return isLive(run.runId) ? await redispatch(event) : { outcome: "refused", reason: `Workflow run ${run.runId} is no longer resumable from this session` };
   };
-  const messages = pi.events?.on?.(PENDING_STAGE_MESSAGE_EVENT2, (payload) => {
+  const messages = pi.events?.on?.(PENDING_STAGE_MESSAGE_EVENT3, (payload) => {
     if (disposed || !isDormantMessageEvent(payload) || payload.handled || payload.live === true)
       return;
     const target = parseWorkflowStageTarget(payload.target);
@@ -89610,8 +90851,8 @@ function mergeConfigs(base, override) {
   };
 }
 var WORKFLOW_CONFIG_DEFAULTS = {
-  maxDepth: 4,
-  defaultConcurrency: 3,
+  maxDepth: 3,
+  defaultConcurrency: 1000,
   persistRuns: true,
   statusFile: false,
   resumeInFlight: "never",
@@ -91378,7 +92619,7 @@ init_registry();
 // dist/builtin/workflows/src/extension/discovery-loaders.ts
 init_workflow_module_loader();
 import { readdir as readdir2, stat as stat2 } from "node:fs/promises";
-import { extname, isAbsolute as isAbsolute13, join as join32, resolve as resolve17 } from "node:path";
+import { extname, isAbsolute as isAbsolute13, join as join32, resolve as resolve18 } from "node:path";
 async function scanWorkflowDir(dir) {
   try {
     const entries = await readdir2(dir, { withFileTypes: true });
@@ -91422,7 +92663,7 @@ async function loadFromPaths(pathsOrMap, kind, baseCwd, diagnostics, getWorkflow
   const all = [];
   const entries = Array.isArray(pathsOrMap) ? pathsOrMap.map((p) => ({ rawPath: p })) : Object.entries(pathsOrMap).map(([name, p]) => ({ rawPath: p, configuredName: name }));
   for (const { rawPath, configuredName } of entries) {
-    const absPath = isAbsolute13(rawPath) ? rawPath : resolve17(baseCwd, rawPath);
+    const absPath = isAbsolute13(rawPath) ? rawPath : resolve18(baseCwd, rawPath);
     let pathStats;
     try {
       pathStats = await stat2(absPath);
@@ -98180,7 +99421,7 @@ var DEFAULT_PROMPT_GUIDANCE = [
   - Bounded loops must create distinct tracked work for every iteration; never reopen an ancestor below its downstream work. Stacked implementation slices are unrolled, not looped: each slice gets a fresh child boundary and distinct tracked nodes, and no slice may add an edge back to the current frontier, itself, or an ancestor. If a retained session receives follow-up without new dependency work, keep it as non-topological activity metadata rather than adding a back-edge. Before launch, sketch nodes and dependencies for every branch and loop and reject any proposed parent edge to the node itself or an ancestor.
   - Treat dynamic graph validation during execution, replay, and journal reconstruction as the authoritative cycle boundary. If runtime topology code changes, require incremental edge checks and reconstruction validation; prompt guidance and TypeScript types cannot replace those runtime checks.
   - Every workflow invocation receives the stable control group \`workflow:<rootRunId>\`. Stages inherit it unless an intentional explicit group is authored. Named groups and \`group: true\` become invocation-owned subgroups under \`workflow:<rootRunId>/...\`, so repeated names cannot collide across runs. The invocation context may list and exactly send/ask live stages in its owned subgroups and queue send to known pending stages; this authority is directional and does not let subgroup siblings see or reach each other. \`intercom list\` also shows possible future targets, and the invocation context may queue sticky sends to their path patterns. Pending and pattern ask remain unsupported. A \`workflow:<rootRunId>/**\` send broadcasts to all live stages and remains sticky for future descendants until root termination. \`group: "default"\` is the explicit non-owned shared-group escape and does not receive pending invocation routing. Do not mint root group names manually.
-  - Stages in the same invocation group are peers, not only steerable targets. A live stage can \`intercom list\` its siblings and \`send\`/\`ask\` them directly to debate a finding with evidence, hand off paths and reproductions, claim shared files or expensive steps, or learn what a sibling already verified; it can queue \`send\` to a known pending sibling and \`ask\` a completed sibling that retains a valid conversation, which reopens it for a post-mortem turn. Delegated subagents inside a stage inherit the same group. Named subgroups isolate their members from sibling subgroups. Stages do not coordinate spontaneously: when parallel stages should exchange evidence, say so in each prompt, name the peers or the pattern to discover them, bound the exchange (for example one evidence round), and require each stage to return its own structured result; keep scope and acceptance decisions with the supervisor or a \`ctx.ui\` gate.
+  - Stages in the same invocation group are peers, not only steerable targets. A live stage can \`intercom list\` its siblings and \`send\`/\`ask\` them directly to debate a finding with evidence, hand off paths and reproductions, claim shared files or expensive steps, or learn what a sibling already verified; it can queue \`send\` to a known pending sibling and \`ask\` a completed sibling that retains a valid conversation, which reopens it for a post-mortem turn. Delegated subagents inside a stage inherit the same group. Named subgroups isolate their members from sibling subgroups. Default to peer-to-peer (swarm) exchange; the supervisor is not a message relay. There are no limits on communication between agents; it is encouraged whenever you need to. Stages proactively discover peers and broadcast, debate, claim, hand off, and ask each other directly, and each stage still returns its own structured result. Scale the swarm with the task: for very complex work or when the user asks for heavy parallelism, run hundreds or thousands of agents that self-organize into teams (named subgroups, per-stage subagent sets, child workflows) and coordinate peer-to-peer like an organization.
   - Prefer \`ctx.tool(name, args, fn)\` for workflow-owned TypeScript operations with side effects, such as filesystem writes, network mutations, and external API actions. It creates a tracked, non-attachable durable graph node before invoking \`fn\`; it may be used before, between, after, or without model stages. A completed \`ctx.tool\` call is durably checkpointed with its serializable result, so resume replays that result without rerunning \`fn\`. For checks that may fail during a bounded repair loop, opt into \`failureMode: "return"\`, branch on the typed outcome, and pass only the needed error fields to the repair stage or artifact yourself; Atomic does not inject failure evidence into later prompts. Retries do not bound a hung callback, so every \`ctx.tool\` callback that starts a child process or performs network I/O MUST set an explicit positive finite \`timeoutMs\` and forward the supplied \`signal\` to cancellable work. A timeout applies per attempt, aborts that attempt's signal, and gives retries a fresh deadline and signal. Cancellation and storage faults still throw. Keep pure computation and side-effect-free transformations as ordinary TypeScript. Do not wrap agent-stage internals or every function call indiscriminately; this rule applies to side effects orchestrated directly by the workflow definition.
   - Pass large stage context through files/artifacts and \`reads\` with an explicit \`Read the file at <path>...\` prompt rather than large \`previous\` payloads or injected session history.
   - Wrap critical stage-prompt content in \`<keepContext>\` / \`</keepContext>\`. Tagged content survives compression verbatim regardless of the compression ratio, and every line of the span including the tag lines is protected. A long-running stage will be compacted, and compaction ranks lines individually: an objective is verbose and restated while the constraint that narrows it is usually one line, so the constraint is the cheaper deletion and what survives reads as broader permission than intended. Tag role constraints that bound a stage to part of the work, acceptance criteria and immutable contracts, explicit prohibitions, and identifiers a stage must not lose such as a target branch, worktree path, or run ID. Do not tag bulk context: protected lines count against the keep target rather than raising it, so a large protected span makes the surrounding transcript compress harder — tag the constraint, not the material it applies to.