@bastani/atomic 0.9.43 → 0.9.44-alpha.1

package/dist/builtin/workflows/src/extension/local-worker-entry.mjs

@@ -8030,7 +8030,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 {
@@ -8050,6 +8056,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);
   }
@@ -8103,6 +8121,7 @@ function createStoreContext(state = createStoreState()) {
     snapshot,
     graphSnapshot,
     notify,
+    batch,
     bumpAndNotify,
     findRun,
     findStage,
@@ -8918,6 +8937,9 @@ function createRunStoreMethods(context) {
     subscribeInvalidation(fn) {
       state.invalidationListeners.add(fn);
       return () => state.invalidationListeners.delete(fn);
+    },
+    batch(update) {
+      return context.batch(update);
     }
   };
 }
@@ -13403,7 +13425,7 @@ class ConcurrencyLimiter {
   }
 }
 function createRunLimiter(defaultConcurrency) {
-  return new ConcurrencyLimiter(defaultConcurrency ?? 3);
+  return new ConcurrencyLimiter(defaultConcurrency ?? 1000);
 }
 
 // dist/builtin/workflows/src/shared/abort.ts
@@ -57173,6 +57195,44 @@ var init_executor = __esm(() => {
   init_executor_run();
 });
 
+// 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 randomUUID10 } from "node:crypto";
 function capabilitiesFor(store) {
@@ -57197,12 +57257,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
@@ -57234,12 +57294,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/workflow-stage-path-matching.ts
@@ -57540,6 +57600,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;
   };
@@ -57551,19 +57614,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,
@@ -57704,16 +57777,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")
@@ -57839,6 +57918,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);
@@ -58178,6 +58263,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();
@@ -58636,7 +58722,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();
@@ -58645,6 +58731,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;
@@ -58652,6 +58753,8 @@ var init_client = __esm(() => {
     connectTimeoutMs;
     brokerAcknowledgesReceipt = false;
     brokerAcknowledgesPendingStageRoutes = false;
+    multiplexesPendingStageRoutes;
+    brokerRefusesPendingStageRoutesInPlace = false;
     brokerAnswersStatus = false;
     socket = null;
     _sessionId = null;
@@ -58717,6 +58820,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);
@@ -58829,6 +58933,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;
@@ -58907,7 +59012,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) {
@@ -58917,6 +59022,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;
@@ -58929,6 +59035,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();
@@ -59054,6 +59166,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")
@@ -59557,7 +59684,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);
@@ -60291,120 +60419,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 randomUUID13 } 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 = randomUUID13();
   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;
@@ -60413,10 +60586,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) => {
@@ -60427,7 +60605,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}`;
@@ -60437,18 +60615,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()));
     }
   };
 }
@@ -60631,7 +60824,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"]
@@ -60889,7 +61082,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}:`;
@@ -60957,10 +61150,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");
@@ -60970,10 +61171,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();
   }
@@ -61021,8 +61224,11 @@ var init_pool_stage_usage = __esm(() => {
 });
 
 // dist/builtin/workflows/src/durable/journal/sql-pool-queue.ts
-import { randomUUID as randomUUID15 } from "node:crypto";
+import { createHash as createHash4, randomUUID as randomUUID15 } 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),
@@ -61078,10 +61284,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}(
@@ -61112,9 +61319,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)
@@ -61255,31 +61476,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) {
@@ -61288,6 +61496,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);
@@ -61296,7 +61505,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);
       }
@@ -61304,34 +61513,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 };
@@ -61418,7 +61634,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();
@@ -61430,6 +61646,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);
@@ -61500,10 +61725,870 @@ 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 randomUUID16 } from "node:crypto";
+import { createWriteStream } from "node:fs";
+import { mkdir as mkdir6, rm as rm3, rmdir } from "node:fs/promises";
+import { dirname as dirname12, join as join28, resolve as resolve11 } from "node:path";
+import { setTimeout as delay2 } from "node:timers/promises";
+function workerLogDirectory(journalPath, root) {
+  return join28(dirname12(resolve11(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 = randomUUID16();
+      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 = randomUUID16();
+    this.incarnations.set(worker, child);
+    const slot = { worker, child, deliveries: new Map };
+    let ready = false;
+    let serial = Promise.resolve();
+    const logPath = join28(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;
+  }
+}
+function processPort() {
+  return {
+    send(message) {
+      if (process.connected)
+        process.send?.(message, () => {});
+    },
+    onMessage(listener) {
+      process.on("message", (message) => listener(message));
+    },
+    onClose(listener) {
+      process.once("disconnect", () => listener(new Error("Root host disconnected")));
+    },
+    async close() {
+      if (process.connected)
+        process.disconnect();
+    }
+  };
+}
+function runPoolCoordinator() {
+  if (typeof process.send !== "function")
+    throw new Error("Local worker pool coordinator requires an IPC channel");
+  const port = processPort();
+  const coordinator = new PoolCoordinator(port);
+  port.onClose(() => process.exit(0));
+  return coordinator;
+}
+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
@@ -61753,21 +62838,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;
     });
@@ -61778,6 +62868,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);
@@ -61828,7 +62933,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;
@@ -61838,6 +62943,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;
@@ -61861,22 +62969,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 ?? "",
@@ -61888,11 +63005,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);
@@ -61917,7 +63036,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)
@@ -61930,25 +63049,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) {
@@ -62003,7 +63122,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]);
@@ -62021,7 +63140,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) {
@@ -62046,33 +63165,122 @@ var init_stage_handoff = __esm(() => {
 });
 
 // dist/builtin/workflows/src/workers/local-pool.ts
-import { fork } from "node:child_process";
-import { randomUUID as randomUUID16 } from "node:crypto";
-import { createWriteStream } from "node:fs";
-import { mkdir as mkdir6, rm as rm3, rmdir } from "node:fs/promises";
-import { dirname as dirname12, join as join28, resolve as resolve11 } from "node:path";
-import { setTimeout as delay2 } from "node:timers/promises";
+import { fork as fork2 } from "node:child_process";
+import { resolve as resolve12 } from "node:path";
+import { setTimeout as delay3 } from "node:timers/promises";
 import { fileURLToPath as fileURLToPath5 } from "node:url";
 import { isBunBinary as isBunBinary2 } from "@bastani/atomic";
-function workerLogDirectory(journalPath, root) {
-  return join28(dirname12(resolve11(journalPath)), "worker-logs", encodeURIComponent(root).replaceAll(".", "%2E"));
+function defaultWorkerEntry() {
+  return isBunBinary2 ? INTERNAL_WORKFLOW_WORKER_ARG : fileURLToPath5(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;
@@ -62080,18 +63288,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;
@@ -62106,10 +63313,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;
@@ -62117,47 +63326,39 @@ class LocalWorkerPool {
   async prepare(root, store) {
     if (this.closed)
       throw new Error("Local worker pool is closed");
-    if (!(this.backend.journal instanceof SqlRunJournal) || resolve11(this.options.journalPath) !== resolve11(this.backend.journal.path) || sqlPoolStorage(this.backend.journal)?.tables.runs !== "wf_runs")
+    if (!(this.backend.journal instanceof SqlRunJournal) || resolve12(this.options.journalPath) !== resolve12(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();
@@ -62203,290 +63404,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 : fileURLToPath5(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 = randomUUID16();
-    this.incarnations.set(worker, child);
-    let ready = false;
-    let serial = Promise.resolve();
-    let work;
-    const deliveries = new Map;
-    const logPath = join28(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 = randomUUID16();
-              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 {
@@ -62519,7 +63491,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");
@@ -62530,39 +63502,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();
@@ -62571,27 +63736,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) {
@@ -62601,27 +63767,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 resolve12 } from "node:path";
+import { resolve as resolve13 } from "node:path";
 import { isDeepStrictEqual as isDeepStrictEqual2 } from "node:util";
 async function restoreWorkerOptions(backend, options) {
   const source = options.continuation?.source.id ?? options.runId;
@@ -62660,11 +63825,11 @@ async function activatePublicPool(backend, options) {
     ...options.localWorkers,
     startupTimeoutMs: undefined,
     leaseMs: undefined,
-    definitions: options.localWorkers.definitions.map((source) => ({ ...source, path: resolve12(cwd, source.path) }))
+    definitions: options.localWorkers.definitions.map((source) => ({ ...source, path: resolve13(cwd, source.path) }))
   };
   const admission = options.admission && {
     ...options.admission,
-    ...options.admission.userDatabase ? { userDatabase: resolve12(cwd, options.admission.userDatabase) } : {}
+    ...options.admission.userDatabase ? { userDatabase: resolve13(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({
@@ -64010,7 +65175,7 @@ function hasUsableContentBlock(block) {
 
 // dist/builtin/workflows/src/shared/stage-session-store.ts
 import { randomUUID as randomUUID18 } from "node:crypto";
-import { dirname as dirname13, resolve as resolve13 } from "node:path";
+import { dirname as dirname13, resolve as resolve14 } from "node:path";
 import {
   JsonlSessionStore,
   resolveSessionStore,
@@ -64046,11 +65211,11 @@ async function forkStageSession(store, sessionId, cwd, options, destination = st
 async function migrateLegacyStageSession(store, sessionId, sessionFile) {
   if (sessionFile === undefined || await store.readHeader(sessionId) !== undefined)
     return;
-  const location = resolve13(sessionFile);
+  const location = resolve14(sessionFile);
   const legacy = await JsonlSessionStore.open(dirname13(location), { exactDirectory: true, scanExisting: false });
   try {
     for await (const file of legacy.scanFiles()) {
-      if (resolve13(file.location) !== location || file.header.id !== sessionId)
+      if (resolve14(file.location) !== location || file.header.id !== sessionId)
         continue;
       const snapshot = await file.read();
       if (await store.readHeader(sessionId) === undefined)
@@ -64212,22 +65377,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;
@@ -64649,9 +65829,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 [];
@@ -70309,9 +71487,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 dirname14, isAbsolute as isAbsolute11, join as join29, resolve as resolve14 } from "node:path";
+import { basename as basename5, dirname as dirname14, isAbsolute as isAbsolute11, join as join29, resolve as resolve15 } from "node:path";
 function normalizeMaxOutput2(maxOutput) {
   return {
     bytes: maxOutput?.bytes ?? DEFAULT_MAX_OUTPUT_BYTES,
@@ -70373,7 +71551,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 join29(workflowArtifactRunPath(runId), "transcripts", `${digest}-${basename5(outputPath)}.transcript.md`);
 }
 function appendContent(lines, content) {
@@ -70419,7 +71597,7 @@ function renderTranscript(messages, fallbackOutput) {
 `);
 }
 function savedOutputReference(outputPath, fullOutput, transcriptPathValue, transcriptText, transcriptAvailable, warning) {
-  const absolutePath = resolve14(outputPath);
+  const absolutePath = resolve15(outputPath);
   const bytes = Buffer.byteLength(fullOutput, "utf8");
   const lines = countLines(fullOutput);
   const transcriptBytes = Buffer.byteLength(transcriptText, "utf8");
@@ -70434,8 +71612,8 @@ function resolveOutputPath(output, runtimeCwd, requestedCwd) {
     return;
   if (isAbsolute11(output))
     return output;
-  const baseCwd = requestedCwd === undefined ? runtimeCwd : isAbsolute11(requestedCwd) ? requestedCwd : resolve14(runtimeCwd, requestedCwd);
-  return resolve14(baseCwd, output);
+  const baseCwd = requestedCwd === undefined ? runtimeCwd : isAbsolute11(requestedCwd) ? requestedCwd : resolve15(runtimeCwd, requestedCwd);
+  return resolve15(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;
@@ -71444,7 +72622,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(),
@@ -72533,7 +73711,7 @@ init_admission_binding();
 init_definitions();
 init_resource_admission();
 import { randomUUID as randomUUID20 } from "node:crypto";
-import { setTimeout as delay3 } from "node:timers/promises";
+import { setTimeout as delay4 } from "node:timers/promises";
 import { withResourceAdmission as withResourceAdmission2 } from "@bastani/atomic";
 import { StorageProvider as StorageProvider3 } from "@bastani/atomic/storage";
 
@@ -72542,8 +73720,8 @@ init_stage_topology();
 init_run_durable_topology();
 import { randomUUID as randomUUID19 } from "node:crypto";
 function workerSessionStore(input) {
-  const checkpoint = async (id, header) => {
-    const owner = (header ?? await input.reader.readHeader(id))?.workflow;
+  const checkpoint = (id, header) => {
+    const owner = header.workflow;
     const run = input.store.runs().find((run) => run.id === owner?.runId);
     const stage = run?.stages.find((stage) => stage.id === owner?.stageId);
     if (!run || !stage?.replayKey)
@@ -72571,11 +73749,11 @@ function workerSessionStore(input) {
   };
   return {
     descriptor: input.reader.descriptor,
-    create: async (header, entries) => write({ kind: "session-create", checkpoint: await checkpoint(header.id, header), header, entries }),
-    append: async (id, entries, options) => write({ kind: "session-append", checkpoint: await checkpoint(id), entries, expectSeq: options.expectSeq }),
+    create: async (header, entries) => write({ kind: "session-create", checkpoint: checkpoint(header.id, header), header, entries }),
+    append: async (id, entries, options) => write({ kind: "session-append", sessionId: id, entries, expectSeq: options.expectSeq }),
     replace: async (id, header, entries, options) => write({
       kind: "session-replace",
-      checkpoint: await checkpoint(id, header),
+      checkpoint: checkpoint(id, header),
       header,
       entries,
       expectSeq: options.expectSeq
@@ -72603,6 +73781,14 @@ function collectWorkerUsage(runs) {
 
 // dist/builtin/workflows/src/workers/local-worker.ts
 async function runLocalWorker(start) {
+  if ("role" in start && start.role === POOL_COORDINATOR_ROLE) {
+    await Promise.resolve().then(() => init_pool_coordinator());
+    runPoolCoordinator();
+    return;
+  }
+  await runWorker(start);
+}
+async function runWorker(start) {
   let sequence = 0;
   const pending = new Map;
   process.on("message", (reply) => {
@@ -72726,13 +73912,13 @@ async function runLocalWorker(start) {
     for (;; ) {
       await observeControl();
       if (controlState !== "running") {
-        await delay3(25);
+        await delay4(25);
         continue;
       }
       await reader.catchUpWorkflow(start.root);
       const work = await request({ kind: "claim" });
       if (!work) {
-        await delay3(25 + Math.random() * 25);
+        await delay4(25 + Math.random() * 25);
         continue;
       }
       const index = start.definitions.findIndex((source) => `${source.path}#${source.exportName}` === work.definition && source.digest === work.digest);
@@ -72809,7 +73995,7 @@ async function runLocalWorker(start) {
           const control = await request({ kind: "budget" });
           if (control.state === "running")
             return;
-          await delay3(25, undefined, { signal });
+          await delay4(25, undefined, { signal });
         }
       };
       const resourceAdmission = {
@@ -72848,7 +74034,7 @@ async function runLocalWorker(start) {
         await observeControl();
         while ((await request({ kind: "control" })).state !== "running") {
           controller.signal.throwIfAborted();
-          await delay3(25);
+          await delay4(25);
         }
         const result = await withResourceAdmission2(resourceAdmission, () => run(definitions[index], work.inputs, {
           ...work.execution,