@bastani/atomic 0.9.54-alpha.1 → 0.9.55-alpha.1

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

@@ -3824,10 +3824,16 @@ function selectRunJournal(options = {}) {
 async function resolveRunJournal(options = {}) {
   return openSelectedRunJournal(selectRunJournal(options), options.agentDir);
 }
+function runJournalOrigin(journal) {
+  return journalOrigins.get(journal);
+}
 async function openSelectedRunJournal(selection, agentDir = getAgentDir()) {
   if ("createRun" in selection)
     return selection;
-  return withRunJournalConfigSource(selection, () => provider.openRunJournal(selection, { agentDir, domain: "journal" }));
+  const journal = await withRunJournalConfigSource(selection, () => provider.openRunJournal(selection, { agentDir, domain: "journal" }));
+  if (!journalOrigins.has(journal))
+    journalOrigins.set(journal, { selection, agentDir });
+  return journal;
 }
 async function withRunJournalConfigSource(selection, open) {
   if ("createRun" in selection)
@@ -3845,7 +3851,7 @@ async function withRunJournalConfigSource(selection, open) {
     throw error;
   }
 }
-var hostModules, provider, origins;
+var hostModules, provider, origins, journalOrigins;
 var init_resolution = __esm(() => {
   init_memory_run_journal();
   init_sql_run_journal();
@@ -3858,6 +3864,7 @@ var init_resolution = __esm(() => {
     }
   });
   origins = new WeakMap;
+  journalOrigins = new WeakMap;
 });
 
 // dist/builtin/workflows/src/authoring/keep-context.ts
@@ -17283,7 +17290,7 @@ async function admitWorkflowSessions(backend, opts, callback) {
     return callback(opts);
   if (!(rootBackend instanceof JournalDurableBackend))
     throw new Error("Resource admission requires a journal backend");
-  const admission = await SqlResourceAdmission.open(rootBackend.journal, {
+  const admission = await SqlResourceAdmission.open(poolJournalFor(rootBackend.journal), {
     ...config,
     root: opts.parentRun?.rootRunId ?? opts.runId,
     holder: randomUUID7()
@@ -17301,6 +17308,7 @@ var init_admission_binding = __esm(() => {
   init_journal_backend();
   init_wiring();
   init_stage_runner_session_options();
+  init_pool_journal();
   init_resource_admission();
   workflowResourceAdmission = new WeakMap;
 });
@@ -59185,6 +59193,84 @@ var init_host_options = __esm(() => {
   hostWorkerBindings = Symbol("host-worker-bindings");
 });
 
+// dist/builtin/workflows/src/durable/journal/pool-remote-journal.ts
+class PoolRemoteJournal {
+  journal;
+  storage;
+  mirrored;
+  mirroring;
+  constructor(journal, storage) {
+    this.journal = journal;
+    this.storage = storage;
+  }
+  async mirror(lease) {
+    const root = lease.runId;
+    const sampledAt = performance.now();
+    const [run, state] = await Promise.all([this.journal.getRun(root), this.journal.leaseState(root)]);
+    if (run === undefined)
+      throw new RunNotFoundError(root);
+    const { runs, leases } = this.storage.tables;
+    await this.storage.transaction(async (tx) => {
+      await tx.run(`INSERT INTO ${runs}(run_id, name, cwd, created_at, status, header_json) VALUES (?, ?, ?, ?, ?, ?)
+				ON CONFLICT(run_id) DO UPDATE SET status = excluded.status`, root, run.name, run.cwd, run.createdAt, run.status, serializeJson({ runId: root, name: run.name, cwd: run.cwd, createdAt: run.createdAt, status: run.status }));
+      if (state === undefined)
+        await tx.run(`DELETE FROM ${leases} WHERE run_id = ?`, root);
+      else
+        await tx.run(`INSERT INTO ${leases}(run_id, holder_id, epoch, renewed_at) VALUES (?, ?, ?, CAST(unixepoch('subsec') * 1000 AS INTEGER) - ?)
+					ON CONFLICT(run_id) DO UPDATE SET holder_id = excluded.holder_id, epoch = excluded.epoch, renewed_at = excluded.renewed_at`, root, state.holderId, state.epoch, Math.ceil(Math.max(0, state.ageMs) + (performance.now() - sampledAt)));
+    });
+    if (state === undefined || state.holderId !== lease.holderId || state.epoch !== lease.epoch)
+      throw new StaleLeaseError(root, lease.epoch, state?.epoch ?? 0);
+    this.mirrored = { lease, at: sampledAt };
+  }
+  async fresh(lease, maxAgeMs = MIRROR_FRESH_MS) {
+    const known = this.mirrored;
+    if (known !== undefined && known.lease.holderId === lease.holderId && known.lease.epoch === lease.epoch && performance.now() - known.at < maxAgeMs)
+      return;
+    this.mirroring ??= this.mirror(lease).finally(() => {
+      this.mirroring = undefined;
+    });
+    try {
+      await this.mirroring;
+    } catch (error) {
+      if (error instanceof StaleLeaseError || error instanceof RunNotFoundError)
+        throw error;
+    }
+  }
+  entry(root, key) {
+    return this.journal.readKey(root, key);
+  }
+  append(lease, key, checkpoint) {
+    const event = { type: RUN_EVENT_TYPES.checkpointRecorded, payload: checkpoint };
+    return this.journal.append(lease, event, { key });
+  }
+  events(root) {
+    return (fromSeq) => this.journal.read(root, fromSeq);
+  }
+}
+function isSameCheckpointValue(stored, next) {
+  const hash = (value2) => durableHash(value2);
+  return hash(stored) === hash(next);
+}
+function isRecordedCheckpointValue(stored, next) {
+  const recorded = stored;
+  if (isSameCheckpointValue(recorded, next))
+    return true;
+  const { completedAt, startedAt } = recorded;
+  if (typeof completedAt !== "number")
+    return false;
+  const later = next;
+  if (startedAt === undefined !== (later.startedAt === undefined))
+    return false;
+  return isSameCheckpointValue({ ...later, completedAt, ...startedAt === undefined ? {} : { startedAt } }, recorded);
+}
+var MIRROR_FRESH_MS = 2000;
+var init_pool_remote_journal = __esm(() => {
+  init_durable_hash();
+  init_types();
+  init_values();
+});
+
 // dist/builtin/workflows/src/durable/journal/pool-checkpoint-index.ts
 function push(map, key, value2) {
   if (key === undefined)
@@ -59252,6 +59338,11 @@ class PoolCheckpointRead {
       this.pending = apply;
     });
   }
+  readEntries(stream) {
+    return this.index.readEntries(this.root, stream, (apply) => {
+      this.pending = apply;
+    });
+  }
   commit() {
     this.pending?.();
     this.pending = undefined;
@@ -59274,7 +59365,6 @@ class PoolCheckpointIndex {
     }
     const from = base?.seq ?? 0;
     const to = head ? Number(head.seq) : 0;
-    const delta = new Partitions;
     const added = [];
     if (to > from) {
       const rows = await tx.all(`SELECT seq, key, payload FROM ${events} WHERE run_id = ? AND seq > ? AND seq <= ? AND type = ? ORDER BY seq`, root, from, to, RUN_EVENT_TYPES.checkpointRecorded);
@@ -59282,15 +59372,57 @@ class PoolCheckpointIndex {
         const checkpoint = JSON.parse(String(row.payload));
         if (checkpoint.kind === "ui")
           continue;
-        const entry = {
+        added.push({
           seq: Number(row.seq),
           order: row.key === null ? Buffer.alloc(0) : Buffer.from(row.key, "utf8"),
           checkpoint
-        };
-        delta.add(entry);
-        added.push(entry);
+        });
       }
     }
+    return this.view(root, current, base, from, to, head, added, onCommit);
+  }
+  async readEntries(root, stream, onCommit) {
+    const current = this.roots.get(root);
+    let base = current;
+    for (;; ) {
+      const mark = base !== undefined && base.seq > 0 ? { seq: base.seq, key: base.key, at: base.at } : undefined;
+      let verified = mark === undefined;
+      let mismatch = false;
+      let head;
+      const added = [];
+      for await (const entry of stream(mark === undefined ? 1 : mark.seq)) {
+        if (mark !== undefined && entry.seq === mark.seq) {
+          if ((entry.key ?? null) !== mark.key || entry.at !== mark.at) {
+            mismatch = true;
+            break;
+          }
+          verified = true;
+          head = { seq: entry.seq, key: entry.key ?? null, at: entry.at };
+          continue;
+        }
+        head = { seq: entry.seq, key: entry.key ?? null, at: entry.at };
+        if (entry.event.type !== RUN_EVENT_TYPES.checkpointRecorded)
+          continue;
+        const checkpoint = entry.event.payload;
+        if (checkpoint.kind === "ui")
+          continue;
+        added.push({
+          seq: entry.seq,
+          order: entry.key === undefined ? Buffer.alloc(0) : Buffer.from(entry.key, "utf8"),
+          checkpoint
+        });
+      }
+      if (mark !== undefined && (mismatch || !verified)) {
+        base = undefined;
+        continue;
+      }
+      return this.view(root, current, base, mark?.seq ?? 0, head?.seq ?? 0, head, added, onCommit);
+    }
+  }
+  view(root, current, base, from, to, head, added, onCommit) {
+    const delta = new Partitions;
+    for (const entry of added)
+      delta.add(entry);
     onCommit(() => {
       const latest = this.roots.get(root);
       if (!base) {
@@ -59553,15 +59685,21 @@ function expiry(now, duration) {
 
 class SqlPoolQueue {
   storage;
+  remote;
   meta;
   roots;
   work;
   operations;
+  outbox;
   transaction;
   journal;
   checkpoints = new PoolCheckpointIndex;
-  constructor(storage) {
+  committing = new Map;
+  draining;
+  outboxPending = false;
+  constructor(storage, remote) {
     this.storage = storage;
+    this.remote = remote;
     const { transaction, tables: journal } = storage;
     this.transaction = transaction;
     this.journal = journal;
@@ -59569,10 +59707,11 @@ class SqlPoolQueue {
     this.roots = `${journal.runs}_pool`;
     this.work = `${journal.runs}_work`;
     this.operations = `${journal.runs}_pool_operations`;
+    this.outbox = `${journal.runs}_pool_outbox`;
   }
-  static async open(storage) {
+  static async open(storage, remote) {
     const journal = storage.tables;
-    const pool = new SqlPoolQueue(storage);
+    const pool = new SqlPoolQueue(storage, remote);
     await storage.transaction(async (tx) => {
       if ((await tx.get("PRAGMA foreign_keys"))?.foreign_keys !== 1)
         throw new Error("Pool requires SQLite foreign keys");
@@ -59615,6 +59754,15 @@ class SqlPoolQueue {
 				state TEXT NOT NULL DEFAULT 'running', revision INTEGER NOT NULL DEFAULT 0
 			)`);
       await tx.exec(poolUsageSchema(journal.runs));
+      if (remote)
+        await tx.exec(`CREATE TABLE IF NOT EXISTS ${pool.outbox}(
+					work TEXT NOT NULL REFERENCES ${pool.work}(id) ON DELETE CASCADE,
+					generation INTEGER NOT NULL, operation TEXT NOT NULL, request TEXT NOT NULL,
+					event_key TEXT NOT NULL, payload TEXT NOT NULL, last_seq INTEGER,
+					PRIMARY KEY(work, generation, operation)
+				)`);
+      if (remote)
+        pool.outboxPending = await tx.get(`SELECT 1 AS held FROM ${pool.outbox} LIMIT 1`) !== undefined;
       if (version === 1)
         await pool.migrateFromVersion1(tx);
     });
@@ -59659,6 +59807,7 @@ class SqlPoolQueue {
     });
   }
   async setControl(lease, state) {
+    await this.remote?.fresh(lease);
     return this.transaction(async (tx) => {
       await this.authority(tx, lease);
       await tx.run(`INSERT INTO ${this.roots}_control(root, state, revision) VALUES (?, ?, 1)
@@ -59670,7 +59819,7 @@ class SqlPoolQueue {
   withCurrentAppend(lease, token, assertSession, action) {
     lease = snapshotLease(lease);
     token = { ...token };
-    return this.storage.withAppendGuard(async (tx, runId) => {
+    const guard = async (tx, runId) => {
       try {
         if (runId !== lease.runId)
           throw new Error("Pool delivery cannot write another root");
@@ -59688,7 +59837,10 @@ class SqlPoolQueue {
           throw error;
         throw new PoolAppendRefusedError(error.message, { cause: error });
       }
-    }, action);
+    };
+    if (this.remote)
+      return this.transaction((tx) => guard(tx, lease.runId)).then(action);
+    return this.storage.withAppendGuard(guard, action);
   }
   async assertCurrent(lease, token) {
     await this.transaction(async (tx) => {
@@ -59721,6 +59873,8 @@ class SqlPoolQueue {
     const payload = serializeJson(boundary);
     const fingerprint = durableHash({ descriptor: JSON.parse(json), boundary: JSON.parse(payload) });
     const key = JSON.stringify([RUN_EVENT_TYPES.checkpointRecorded, boundary.kind, boundary.checkpointId]);
+    if (this.remote)
+      await this.recordBoundaryStart(lease, key, boundary);
     return this.transaction(async (tx) => {
       const { now } = await this.authority(tx, lease);
       const previous = await tx.get(`SELECT * FROM ${this.work} WHERE root = ? AND (boundary = ? OR json_extract(descriptor, '$.scope') = ? OR json_extract(descriptor, '$.childRunId') = ?)`, lease.runId, boundaryId, scope, childRunId);
@@ -59737,21 +59891,47 @@ class SqlPoolQueue {
         throw new Error("Pool work scopes overlap");
       const id = randomUUID10();
       await tx.run(`INSERT INTO ${this.work}(id, root, boundary, descriptor, fingerprint, epoch, ready_at) VALUES (?, ?, ?, ?, ?, ?, ?)`, id, lease.runId, boundaryId, json, fingerprint, lease.epoch, now);
-      const seq = await tx.get(`SELECT COALESCE(MAX(seq), 0) AS seq FROM ${this.journal.events} WHERE run_id = ?`, lease.runId);
-      const existing = await tx.get(`SELECT payload FROM ${this.journal.events} WHERE run_id = ? AND key = ?`, lease.runId, key);
-      if (existing && existing.payload !== payload)
-        throw new Error("Pool boundary identity conflict");
-      if (!existing)
-        await tx.run(`INSERT INTO ${this.journal.events} VALUES (?, ?, ?, ?, ?, ?, ?)`, lease.runId, journalCounter(lease.runId, "seq", Number(seq.seq) + 1, "overflow"), lease.epoch, key, RUN_EVENT_TYPES.checkpointRecorded, payload, now);
+      if (!this.remote) {
+        const seq = await tx.get(`SELECT COALESCE(MAX(seq), 0) AS seq FROM ${this.journal.events} WHERE run_id = ?`, lease.runId);
+        const existing = await tx.get(`SELECT payload FROM ${this.journal.events} WHERE run_id = ? AND key = ?`, lease.runId, key);
+        if (existing && existing.payload !== payload)
+          throw new Error("Pool boundary identity conflict");
+        if (!existing)
+          await tx.run(`INSERT INTO ${this.journal.events} VALUES (?, ?, ?, ?, ?, ?, ?)`, lease.runId, journalCounter(lease.runId, "seq", Number(seq.seq) + 1, "overflow"), lease.epoch, key, RUN_EVENT_TYPES.checkpointRecorded, payload, now);
+      }
       return fromRow(await tx.get(`SELECT * FROM ${this.work} WHERE id = ?`, id));
     });
   }
+  async recordBoundaryStart(lease, key, boundary) {
+    const remote = this.remote;
+    await remote.fresh(lease);
+    const existing = await remote.entry(lease.runId, key);
+    if (existing) {
+      if (!isSameCheckpointValue(existing.event.payload, boundary))
+        throw new Error("Pool boundary identity conflict");
+      return;
+    }
+    const outcome = await remote.append(lease, key, boundary);
+    if (outcome.status === "exists" && !isSameCheckpointValue(outcome.entry.event.payload, boundary))
+      throw new Error("Pool boundary identity conflict");
+  }
   async claim(lease, worker, definitions, durationMs) {
     positive(durationMs);
     lease = snapshotLease(lease);
     const compatibleDefinitions = definitions.flatMap((d) => [d.definition, d.digest]);
     validateText("holderId", worker);
     const compatible = definitions.map(() => "(json_extract(descriptor, '$.definition') = ? AND json_extract(descriptor, '$.digest') = ?)").join(" OR ");
+    if (this.remote) {
+      await this.remote.fresh(lease);
+      try {
+        while (this.outboxPending || this.draining !== undefined)
+          await this.drainOutbox(lease);
+      } catch (error) {
+        if (error instanceof StaleLeaseError)
+          throw error;
+        return;
+      }
+    }
     return this.transaction(async (tx) => {
       const { now, status } = await this.authority(tx, lease);
       const control = await tx.get(`SELECT state FROM ${this.roots}_control WHERE root = ?`, lease.runId);
@@ -59785,6 +59965,7 @@ class SqlPoolQueue {
     positive(durationMs);
     lease = snapshotLease(lease);
     token = { ...token };
+    await this.remote?.fresh(lease);
     return this.transaction(async (tx) => {
       const { now } = await this.authority(tx, lease);
       const row = await this.current(tx, lease, token);
@@ -59803,6 +59984,8 @@ class SqlPoolQueue {
     const request = serializeJson({ epoch: token.epoch, worker: token.worker, mutation });
     const identity = requestIdentity(request);
     mutation = JSON.parse(request).mutation;
+    if (this.remote && mutation.kind !== "session-append")
+      return this.commitRemote(lease, token, operationId, mutation, identity);
     const checkpoints = this.checkpoints.begin(lease.runId);
     const receipt = await this.transaction(async (tx) => {
       const { now, status } = await this.authority(tx, lease);
@@ -59826,6 +60009,127 @@ class SqlPoolQueue {
     checkpoints.commit();
     return receipt;
   }
+  commitRemote(lease, token, operationId, mutation, identity) {
+    const flight = JSON.stringify([token.id, token.generation, operationId]);
+    const running = this.committing.get(flight);
+    if (running)
+      return running;
+    const commit = this.stageAndDeliver(lease, token, operationId, mutation, identity).finally(() => {
+      this.committing.delete(flight);
+    });
+    this.committing.set(flight, commit);
+    return commit;
+  }
+  async stageAndDeliver(lease, token, operationId, mutation, identity) {
+    const remote = this.remote;
+    await remote.fresh(lease);
+    const checkpoint = mutation.checkpoint;
+    const key = JSON.stringify([RUN_EVENT_TYPES.checkpointRecorded, checkpoint.kind, checkpoint.checkpointId]);
+    const reads = this.checkpoints.begin(lease.runId);
+    const [existing, view] = await Promise.all([
+      remote.entry(lease.runId, key),
+      checkpoint.kind === "ui" ? undefined : reads.readEntries(remote.events(lease.runId))
+    ]);
+    reads.commit();
+    const source = {
+      read: async () => view ?? Promise.reject(new Error("Pool checkpoint view is unavailable"))
+    };
+    const staged = await this.transaction(async (tx) => {
+      const { now, status } = await this.authority(tx, lease);
+      const row = await this.current(tx, lease, token);
+      if (row.epoch !== lease.epoch)
+        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 !== identity)
+          throw new Error("Pool operation identity conflict");
+        return { receipt: JSON.parse(previous.receipt) };
+      }
+      const held = await tx.get(`SELECT * FROM ${this.outbox} WHERE work = ? AND generation = ? AND operation = ?`, token.id, token.generation, operationId);
+      if (held) {
+        if (held.request !== identity)
+          throw new Error("Pool operation identity conflict");
+        return { held };
+      }
+      if (row.expires_at < now)
+        throw new Error(STALE_WORK_LEASE);
+      if (!await this.admitsAttemptWrites(tx, lease, status))
+        throw new Error("Pool root is not running");
+      await validatePoolMutation(tx, this.journal, lease.runId, fromRow(row), mutation, source);
+      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");
+      if (existing && !isRecordedCheckpointValue(existing.event.payload, checkpoint))
+        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 billed = poolCheckpointUsage(checkpoint);
+      if (billed && !existing)
+        await upsertPoolUsage(tx, this.journal.runs, row.id, token.generation, billed.key, billed.usage);
+      if (existing) {
+        const receipt = { seq: existing.seq, at: existing.at };
+        await tx.run(`INSERT INTO ${this.operations} VALUES (?, ?, ?, ?, ?)`, token.id, token.generation, operationId, identity, JSON.stringify(receipt));
+        return { receipt };
+      }
+      const entry = {
+        work: token.id,
+        generation: token.generation,
+        operation: operationId,
+        request: identity,
+        event_key: key,
+        payload: serializeJson(checkpoint),
+        last_seq: lastSeq ?? null
+      };
+      await tx.run(`INSERT INTO ${this.outbox} VALUES (?, ?, ?, ?, ?, ?, ?)`, entry.work, entry.generation, entry.operation, entry.request, entry.event_key, entry.payload, entry.last_seq);
+      return { held: entry };
+    });
+    if (staged.receipt !== undefined)
+      return staged.receipt;
+    this.outboxPending = true;
+    return this.deliver(lease, staged.held);
+  }
+  async deliver(lease, held) {
+    const remote = this.remote;
+    const checkpoint = JSON.parse(held.payload);
+    const outcome = await remote.append(lease, held.event_key, checkpoint);
+    const forget = (tx) => tx.run(`DELETE FROM ${this.outbox} WHERE work = ? AND generation = ? AND operation = ?`, held.work, held.generation, held.operation);
+    if (outcome.status === "exists" && !isRecordedCheckpointValue(outcome.entry.event.payload, checkpoint)) {
+      await this.transaction(forget);
+      throw new Error("Pool checkpoint identity conflict");
+    }
+    const receipt = {
+      seq: outcome.entry.seq,
+      at: outcome.entry.at,
+      ...held.last_seq === null ? {} : { lastSeq: Number(held.last_seq) }
+    };
+    await this.transaction(async (tx) => {
+      await tx.run(`INSERT OR IGNORE INTO ${this.operations} VALUES (?, ?, ?, ?, ?)`, held.work, held.generation, held.operation, held.request, JSON.stringify(receipt));
+      await forget(tx);
+    });
+    return receipt;
+  }
+  drainOutbox(lease) {
+    if (!this.remote)
+      return Promise.resolve(0);
+    lease = snapshotLease(lease);
+    this.draining ??= this.deliverAll(lease).finally(() => {
+      this.draining = undefined;
+    });
+    return this.draining;
+  }
+  async deliverAll(lease) {
+    this.outboxPending = false;
+    const rows = await this.transaction((tx) => tx.all(`SELECT o.* FROM ${this.outbox} o JOIN ${this.work} w ON w.id = o.work WHERE w.root = ? ORDER BY o.rowid`, lease.runId));
+    try {
+      for (const row of rows)
+        await this.deliver(lease, row);
+    } catch (error) {
+      this.outboxPending = true;
+      throw error;
+    }
+    return rows.length;
+  }
   async appendSession(tx, row, mutation, now) {
     return { at: now, lastSeq: await applyPoolSession(tx, `${this.journal.runs}_pool_`, row.id, mutation) };
   }
@@ -59861,6 +60165,7 @@ class SqlPoolQueue {
     token = { ...token };
     assertWorkflowSerializableObject(result, "Pool result");
     const payload = serializeJson(result);
+    await this.remote?.fresh(lease);
     await this.transaction(async (tx) => {
       const { now, status } = await this.authority(tx, lease);
       const row = await this.current(tx, lease, token, true);
@@ -59876,6 +60181,8 @@ class SqlPoolQueue {
         throw new Error(STALE_WORK_LEASE);
       if (JSON.parse(payload).runId !== fromRow(row).childRunId)
         throw new Error("Pool result identity mismatch");
+      if (this.remote && await tx.get(`SELECT 1 AS held FROM ${this.outbox} WHERE work = ? LIMIT 1`, token.id))
+        throw new Error("Pool work has journal events not yet recorded");
       await tx.run(`INSERT INTO ${this.work}_results VALUES (?, ?)`, token.id, payload);
       await tx.run(`UPDATE ${this.work} SET state = 'completed' WHERE id = ?`, token.id);
     });
@@ -59902,6 +60209,7 @@ class SqlPoolQueue {
     positive(durationMs);
     lease = snapshotLease(lease);
     token = { ...token };
+    await this.remote?.fresh(lease);
     return this.transaction(async (tx) => {
       const { now } = await this.authority(tx, lease);
       const row = await this.current(tx, lease, token);
@@ -59973,11 +60281,11 @@ function isRecordedCheckpoint(stored, payload) {
     return false;
   return serializeJson({ ...next, completedAt, ...startedAt === undefined ? {} : { startedAt } }) === stored;
 }
-function openSqlPoolQueue(journal) {
+function openSqlPoolQueue(journal, remote) {
   const storage = sqlPoolStorage(journal);
   if (!storage)
     return Promise.reject(new Error("Worker pool requires a SQL run journal"));
-  return SqlPoolQueue.open(storage);
+  return SqlPoolQueue.open(storage, remote);
 }
 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", PoolAppendRefusedError;
 var init_sql_pool_queue = __esm(() => {
@@ -59987,6 +60295,7 @@ var init_sql_pool_queue = __esm(() => {
   init_internal();
   init_pool_checkpoint_index();
   init_pool_mutations();
+  init_pool_remote_journal();
   init_pool_stage_usage();
   init_types();
   init_values();
@@ -61791,6 +62100,9 @@ function getBrokerSpawnLockPath(agentDir = getAgentDir5()) {
 function getBrokerLogPath(agentDir = getAgentDir5()) {
   return join26(getIntercomDirPath(agentDir), "broker.log");
 }
+function getBrokerStartAnnouncementPath(agentDir = getAgentDir5()) {
+  return join26(getIntercomDirPath(agentDir), "broker.starting");
+}
 function getBrokerSocketPath(platform = process.platform, agentDir = getAgentDir5()) {
   if (platform === "win32") {
     return `\\\\.\\pipe\\pi-intercom-${sanitizePipeSegment(agentDir)}`;
@@ -62097,7 +62409,7 @@ var init_live_route_refusal = __esm(() => {
 });
 
 // dist/builtin/intercom/recoverable-disconnect.ts
-var RECOVERABLE_DISCONNECT_MESSAGE = "Client disconnected", IntercomClientDisconnectedError, IntercomBrokerTimeoutError;
+var RECOVERABLE_DISCONNECT_MESSAGE = "Client disconnected", IntercomClientDisconnectedError, IntercomBrokerTimeoutError, BROKER_RETIRING_CODE = "broker_retiring", BROKER_RETIRING_REASON = "Intercom broker is retiring; connect to its replacement", IntercomBrokerRetiringError;
 var init_recoverable_disconnect = __esm(() => {
   init_live_route_refusal();
   IntercomClientDisconnectedError = class IntercomClientDisconnectedError extends Error {
@@ -62114,8 +62426,46 @@ var init_recoverable_disconnect = __esm(() => {
       this.name = "IntercomBrokerTimeoutError";
     }
   };
+  IntercomBrokerRetiringError = class IntercomBrokerRetiringError extends Error {
+    intercomRecoverableDisconnect = true;
+    constructor(message = BROKER_RETIRING_REASON, options) {
+      super(message, options);
+      this.name = "IntercomBrokerRetiringError";
+    }
+  };
 });
 
+// dist/builtin/intercom/broker/socket-liveness.ts
+import net from "net";
+function isSocketAnswering(socketPath, timeoutMs = SOCKET_PROBE_TIMEOUT_MS) {
+  return new Promise((resolve) => {
+    const socket = net.connect(socketPath);
+    const finish = (isConnected) => {
+      clearTimeout(timeout);
+      socket.off("connect", onConnect);
+      socket.off("error", onError);
+      resolve(isConnected);
+    };
+    const onConnect = () => {
+      socket.on("error", () => {});
+      socket.end();
+      finish(true);
+    };
+    const onError = () => {
+      socket.destroy();
+      finish(false);
+    };
+    socket.on("connect", onConnect);
+    socket.on("error", onError);
+    const timeout = setTimeout(() => {
+      socket.destroy();
+      finish(false);
+    }, timeoutMs);
+  });
+}
+var SOCKET_PROBE_TIMEOUT_MS = 1000;
+var init_socket_liveness = () => {};
+
 // dist/builtin/intercom/retry-policy.ts
 var ASK_REPLY_TIMEOUT_MS, RETRY_IDENTITY_RETRY_OPPORTUNITY_MS, RETRY_IDENTITY_TTL_MS, DELIVERED_MESSAGE_TTL_MS, SEND_RESPONSE_TIMEOUT_MS = 1e4, RECIPIENT_RECEIPT_TIMEOUT_MS = 8000, RECIPIENT_SAVING_REPORT_INTERVAL_MS;
 var init_retry_policy = __esm(() => {
@@ -62128,7 +62478,7 @@ var init_retry_policy = __esm(() => {
 
 // dist/builtin/intercom/broker/client.ts
 import { EventEmitter } from "events";
-import net from "net";
+import net2 from "net";
 import { randomUUID as randomUUID13 } from "crypto";
 function connectAborted() {
   return new IntercomClientDisconnectedError({ cause: new Error("Disconnected before the broker connection registered") });
@@ -62153,6 +62503,19 @@ function isBacklogRefusal(error) {
   const code = error.code;
   return code === "ECONNREFUSED" || code === "EAGAIN";
 }
+function isLostBrokerSignature(error) {
+  if (error instanceof ConnectionClosedBeforeRegistrationError)
+    return true;
+  const code = error.code;
+  return code === "ENOENT" || code === "ECONNRESET" || code === "EPIPE";
+}
+async function classifyRegistrationFailure(error) {
+  if (!isLostBrokerSignature(error) || await isSocketAnswering(BROKER_SOCKET))
+    return error;
+  return new IntercomBrokerRetiringError(`Intercom broker went away before it registered this session: ${error.message}`, {
+    cause: error
+  });
+}
 function toError(error) {
   return error instanceof Error ? error : new Error(String(error));
 }
@@ -62162,15 +62525,22 @@ 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, BROKER_BACKLOG_RETRIES = 6, BROKER_BACKLOG_RETRY_BASE_MS = 25, HELD_SEND_GRACE_MS = 5000, IntercomPendingStageRouteRefusedError, PENDING_STAGE_ROUTE_REFUSAL_CODES, 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, BROKER_BACKLOG_RETRIES = 6, BROKER_BACKLOG_RETRY_BASE_MS = 25, ConnectionClosedBeforeRegistrationError, HELD_SEND_GRACE_MS = 5000, IntercomPendingStageRouteRefusedError, PENDING_STAGE_ROUTE_REFUSAL_CODES, IntercomClient;
 var init_client = __esm(() => {
   init_paths();
   init_pending_send_registry();
   init_group();
   init_recoverable_disconnect();
+  init_socket_liveness();
   init_live_route_refusal();
   init_retry_policy();
   BROKER_SOCKET = getBrokerSocketPath();
+  ConnectionClosedBeforeRegistrationError = class ConnectionClosedBeforeRegistrationError extends Error {
+    constructor() {
+      super("Connection closed before registration");
+      this.name = "ConnectionClosedBeforeRegistrationError";
+    }
+  };
   IntercomPendingStageRouteRefusedError = class IntercomPendingStageRouteRefusedError extends Error {
     connectionKept;
     code;
@@ -62338,8 +62708,14 @@ var init_client = __esm(() => {
           } catch (error) {
             if (attempt.signal.aborted)
               throw connectAborted();
-            if (!(error instanceof Error) || !isBacklogRefusal(error) || retry >= BROKER_BACKLOG_RETRIES)
+            if (!(error instanceof Error))
               throw error;
+            if (!isBacklogRefusal(error) || retry >= BROKER_BACKLOG_RETRIES) {
+              const classified = await classifyRegistrationFailure(error);
+              if (attempt.signal.aborted)
+                throw connectAborted();
+              throw classified;
+            }
             const backoff = BROKER_BACKLOG_RETRY_BASE_MS * 2 ** retry;
             await abortableDelay(backoff * (0.5 + Math.random() / 2), attempt.signal);
           }
@@ -62356,7 +62732,7 @@ var init_client = __esm(() => {
       this._messageSource = messageSource ?? readSubagentMessageSource();
       this._groups = normalizeGroups(session.groups, session.group);
       return new Promise((resolve, reject) => {
-        const socket = net.connect(BROKER_SOCKET);
+        const socket = net2.connect(BROKER_SOCKET);
         this.socket = socket;
         this.disconnectError = null;
         let settled = false;
@@ -62414,7 +62790,7 @@ var init_client = __esm(() => {
             this.emit("disconnected", disconnectError);
           }
           if (wasConnecting) {
-            reject(new Error("Connection closed before registration"));
+            reject(new ConnectionClosedBeforeRegistrationError);
           }
         };
         const onSocketError = (err) => {
@@ -62516,7 +62892,7 @@ var init_client = __esm(() => {
         case "registration_failed": {
           if (typeof brokerMessage.reason !== "string")
             throw new Error("Invalid registration_failed message");
-          const refusal = isLiveWorkflowStageRouteRefusalCode(brokerMessage.code) ? new IntercomLiveRouteRefusedError(brokerMessage.code, brokerMessage.reason) : new Error(brokerMessage.reason);
+          const refusal = isLiveWorkflowStageRouteRefusalCode(brokerMessage.code) ? new IntercomLiveRouteRefusedError(brokerMessage.code, brokerMessage.reason) : brokerMessage.code === BROKER_RETIRING_CODE ? new IntercomBrokerRetiringError(brokerMessage.reason) : new Error(brokerMessage.reason);
           if (this._sessionId === null) {
             this.emit("_registration_failed", refusal);
             break;
@@ -63411,40 +63787,34 @@ var init_client = __esm(() => {
   };
 });
 
-// dist/builtin/intercom/broker/socket-liveness.ts
-import net2 from "net";
-function isSocketAnswering(socketPath, timeoutMs = SOCKET_PROBE_TIMEOUT_MS) {
-  return new Promise((resolve) => {
-    const socket = net2.connect(socketPath);
-    const finish = (isConnected) => {
-      clearTimeout(timeout);
-      socket.off("connect", onConnect);
-      socket.off("error", onError);
-      resolve(isConnected);
-    };
-    const onConnect = () => {
-      socket.on("error", () => {});
-      socket.end();
-      finish(true);
-    };
-    const onError = () => {
-      socket.destroy();
-      finish(false);
-    };
-    socket.on("connect", onConnect);
-    socket.on("error", onError);
-    const timeout = setTimeout(() => {
-      socket.destroy();
-      finish(false);
-    }, timeoutMs);
-  });
+// dist/builtin/intercom/broker/startup-timeout.ts
+var BROKER_READY_TIMEOUT_MS = 30000, MIN_BROKER_STARTUP_TIMEOUT_MS = 1000;
+
+// dist/builtin/intercom/broker/start-announcement.ts
+import { readFileSync as readFileSync3, unlinkSync as unlinkSync3, writeFileSync as writeFileSync4 } from "node:fs";
+function readBrokerStartAnnouncement(announcement) {
+  let text;
+  try {
+    text = readFileSync3(announcement.path, "utf-8");
+  } catch {
+    return;
+  }
+  if (!text.endsWith(`
+`))
+    return;
+  const [token, pid, ...rest] = text.trim().split(/\s+/u);
+  if (token !== announcement.token || rest.length > 0)
+    return;
+  const parsed = Number(pid);
+  return Number.isInteger(parsed) && parsed > 0 ? parsed : undefined;
 }
-var SOCKET_PROBE_TIMEOUT_MS = 1000;
-var init_socket_liveness = () => {};
+var BROKER_ANNOUNCE_PATH_ENV = "ATOMIC_INTERCOM_BROKER_ANNOUNCE_PATH", BROKER_ANNOUNCE_TOKEN_ENV = "ATOMIC_INTERCOM_BROKER_ANNOUNCE_TOKEN";
+var init_start_announcement = () => {};
 
 // dist/builtin/intercom/broker/spawn.ts
 import { spawn } from "child_process";
-import { appendFileSync, chmodSync, closeSync as closeSync3, existsSync as existsSync5, mkdirSync as mkdirSync7, openSync as openSync3, readFileSync as readFileSync3, readSync as readSync2, statSync as statSync5, unlinkSync as unlinkSync3, writeFileSync as writeFileSync4 } from "fs";
+import { randomUUID as randomUUID14 } from "crypto";
+import { appendFileSync, chmodSync, closeSync as closeSync3, existsSync as existsSync5, mkdirSync as mkdirSync7, openSync as openSync3, readFileSync as readFileSync4, readSync as readSync2, statSync as statSync5, unlinkSync as unlinkSync4, writeFileSync as writeFileSync5 } from "fs";
 import { join as join27, dirname as dirname11 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 import { createRequire as createRequire3 } from "module";
@@ -63533,7 +63903,7 @@ function getWindowsHiddenLauncherScript(commandLine) {
 }
 function writeWindowsHiddenLauncher(commandLine, launcherPath = getWindowsHiddenLauncherPath()) {
   ensurePrivateDirectory(dirname11(launcherPath));
-  writeFileSync4(launcherPath, getWindowsHiddenLauncherScript(commandLine), "utf-8");
+  writeFileSync5(launcherPath, getWindowsHiddenLauncherScript(commandLine), "utf-8");
   return launcherPath;
 }
 function getBrokerLaunchSpec(brokerPath, brokerCommand, brokerArgs, extensionDir = EXTENSION_DIR, platform = process.platform, intercomDir = INTERCOM_DIR, nodePath = process.execPath, runtime = getCurrentBrokerRuntime(), logPath = BROKER_LOG) {
@@ -63561,7 +63931,7 @@ function getBrokerLaunchSpec(brokerPath, brokerCommand, brokerArgs, extensionDir
     args: [...brokerArgs, brokerPath]
   };
 }
-function getBrokerSpawnOptions(extensionDir = EXTENSION_DIR, stderr = "ignore") {
+function getBrokerSpawnOptions(extensionDir = EXTENSION_DIR, stderr = "ignore", announcement) {
   const storage = processSharedStorageSelection();
   return {
     detached: true,
@@ -63569,7 +63939,8 @@ function getBrokerSpawnOptions(extensionDir = EXTENSION_DIR, stderr = "ignore")
     cwd: extensionDir,
     env: createChildProcessEnvironment4({
       NODE_NO_WARNINGS: "1",
-      ...storage === undefined ? {} : { [BROKER_STORAGE_ENV]: storage }
+      ...storage === undefined ? {} : { [BROKER_STORAGE_ENV]: storage },
+      ...announcement === undefined ? {} : { [BROKER_ANNOUNCE_PATH_ENV]: announcement.path, [BROKER_ANNOUNCE_TOKEN_ENV]: announcement.token }
     }),
     windowsHide: true
   };
@@ -63582,7 +63953,7 @@ function resetBrokerLog(logPath = BROKER_LOG) {
     if (previous.length > 0) {
       try {
         const previousPath = `${logPath}.previous`;
-        writeFileSync4(previousPath, Buffer.from(previous).subarray(-BROKER_LOG_TAIL_BYTES), { mode: 384 });
+        writeFileSync5(previousPath, Buffer.from(previous).subarray(-BROKER_LOG_TAIL_BYTES), { mode: 384 });
         if (process.platform !== "win32")
           chmodSync(previousPath, 384);
       } catch {}
@@ -63644,6 +64015,12 @@ async function spawnBrokerIfNeeded(brokerCommand, brokerArgs, readyTimeoutMs = B
     }
     const brokerPath = resolveBrokerEntrypoint(extensionDir);
     const launch = getBrokerLaunchSpec(brokerPath, brokerCommand, brokerArgs, extensionDir);
+    const announcement = launch.kind === "windows-launcher" ? { path: BROKER_START_ANNOUNCEMENT, token: randomUUID14() } : undefined;
+    if (announcement !== undefined) {
+      try {
+        unlinkSync4(announcement.path);
+      } catch {}
+    }
     if (launch.kind === "windows-launcher") {
       writeWindowsHiddenLauncher(launch.launcherCommandLine, launch.launcherPath);
     }
@@ -63654,7 +64031,7 @@ async function spawnBrokerIfNeeded(brokerCommand, brokerArgs, readyTimeoutMs = B
     const logFd = launch.kind === "direct" ? openSync3(BROKER_LOG, "a") : undefined;
     let child;
     try {
-      child = spawn(launch.command, launch.args, getBrokerSpawnOptions(extensionDir, logFd ?? "ignore"));
+      child = spawn(launch.command, launch.args, getBrokerSpawnOptions(extensionDir, logFd ?? "ignore", announcement));
     } finally {
       if (logFd !== undefined)
         closeSync3(logFd);
@@ -63690,7 +64067,7 @@ ${describeBrokerLog()}`);
       };
       child.once("error", onError);
       child.once("exit", onExit);
-      waitForBroker(readyTimeoutMs).then(() => {
+      waitForBroker(readyTimeoutMs, announcement === undefined ? undefined : () => readBrokerStartAnnouncement(announcement)).then(() => {
         cleanup();
         resolve();
       }, (error) => {
@@ -63711,7 +64088,7 @@ async function isBrokerRunning() {
   if (!existsSync5(BROKER_PID))
     return false;
   try {
-    const pid = parseInt(readFileSync3(BROKER_PID, "utf-8").trim(), 10);
+    const pid = parseInt(readFileSync4(BROKER_PID, "utf-8").trim(), 10);
     if (!Number.isFinite(pid))
       return false;
     process.kill(pid, 0);
@@ -63736,7 +64113,7 @@ function handSpawnLockToBroker(pid, owner) {
 }
 function ownsSpawnLock(owner, lockPath = BROKER_SPAWN_LOCK) {
   try {
-    return readFileSync3(lockPath, "utf-8").startsWith(owner);
+    return readFileSync4(lockPath, "utf-8").startsWith(owner);
   } catch {
     return false;
   }
@@ -63748,7 +64125,7 @@ function acquireSpawnLock() {
 ${Date.now()}
 `;
     try {
-      writeFileSync4(BROKER_SPAWN_LOCK, owner, { flag: "wx" });
+      writeFileSync5(BROKER_SPAWN_LOCK, owner, { flag: "wx" });
       return owner;
     } catch (error) {
       if (!(error instanceof Error) || error.code !== "EEXIST") {
@@ -63756,7 +64133,7 @@ ${Date.now()}
       }
       if (isSpawnLockStale()) {
         try {
-          unlinkSync3(BROKER_SPAWN_LOCK);
+          unlinkSync4(BROKER_SPAWN_LOCK);
         } catch {}
         continue;
       }
@@ -63778,7 +64155,7 @@ function isSpawnLockStale(lockPath = BROKER_SPAWN_LOCK, nowMs = Date.now()) {
     return false;
   }
   try {
-    const [spawnerLine = "", createdAtLine = "", brokerLine = ""] = readFileSync3(lockPath, "utf-8").trim().split(`
+    const [spawnerLine = "", createdAtLine = "", brokerLine = ""] = readFileSync4(lockPath, "utf-8").trim().split(`
 `);
     const spawnerPid = Number.parseInt(spawnerLine, 10);
     const createdAt = Number.parseInt(createdAtLine, 10);
@@ -63796,25 +64173,34 @@ function releaseSpawnLock(owner, lockPath = BROKER_SPAWN_LOCK) {
   if (!ownsSpawnLock(owner, lockPath))
     return;
   try {
-    unlinkSync3(lockPath);
+    unlinkSync4(lockPath);
   } catch {}
 }
-async function waitForBroker(timeoutMs = BROKER_READY_TIMEOUT_MS) {
+async function waitForBroker(timeoutMs = BROKER_READY_TIMEOUT_MS, announcedPid) {
   const start = Date.now();
   let interval = BROKER_POLL_INITIAL_INTERVAL_MS;
   while (Date.now() - start < timeoutMs) {
     if (await checkSocketConnectable()) {
       return;
     }
+    const pid = announcedPid?.();
+    if (pid !== undefined && !isProcessAlive(pid)) {
+      if (await checkSocketConnectable())
+        return;
+      throw new Error(`Intercom broker exited before startup (pid ${pid})
+${describeBrokerLog()}`);
+    }
     await sleep(interval);
     interval = Math.min(interval * 2, BROKER_POLL_MAX_INTERVAL_MS);
   }
-  throw new Error(`Broker failed to start within timeout
+  throw new Error(`Broker failed to start within timeout (${timeoutMs} ms)
+` + "The broker did not answer on its socket in time; it may still be starting, which a busy machine or an empty jiti " + "cache slows. Try again, or raise `brokerStartupTimeoutMs` in the Intercom config.json (default " + `${BROKER_READY_TIMEOUT_MS} ms).
 ${describeBrokerLog()}`);
 }
-var INTERCOM_DIR, EXTENSION_DIR, BROKER_SOCKET2, BROKER_PID, BROKER_SPAWN_LOCK, BROKER_LOG, BROKER_LOG_TAIL_BYTES, BROKER_POLL_INITIAL_INTERVAL_MS = 10, BROKER_POLL_MAX_INTERVAL_MS = 100, BROKER_READY_TIMEOUT_MS = 5000, BROKER_SPAWN_LOCK_MAX_AGE_MS = 60000, INTERNAL_INTERCOM_BROKER_ARG = "--atomic-internal-intercom-broker";
+var INTERCOM_DIR, EXTENSION_DIR, BROKER_SOCKET2, BROKER_PID, BROKER_SPAWN_LOCK, BROKER_LOG, BROKER_START_ANNOUNCEMENT, BROKER_LOG_TAIL_BYTES, BROKER_POLL_INITIAL_INTERVAL_MS = 10, BROKER_POLL_MAX_INTERVAL_MS = 100, BROKER_SPAWN_LOCK_MAX_AGE_MS = 60000, INTERNAL_INTERCOM_BROKER_ARG = "--atomic-internal-intercom-broker";
 var init_spawn = __esm(() => {
   init_socket_liveness();
+  init_start_announcement();
   init_paths();
   INTERCOM_DIR = getIntercomDirPath();
   EXTENSION_DIR = resolveIntercomPackageRoot(import.meta.url);
@@ -63822,6 +64208,7 @@ var init_spawn = __esm(() => {
   BROKER_PID = getBrokerPidPath();
   BROKER_SPAWN_LOCK = getBrokerSpawnLockPath();
   BROKER_LOG = getBrokerLogPath();
+  BROKER_START_ANNOUNCEMENT = getBrokerStartAnnouncementPath();
   BROKER_LOG_TAIL_BYTES = 8 * 1024;
 });
 
@@ -63846,14 +64233,14 @@ var init_reply_waiter = __esm(() => {
 });
 
 // dist/builtin/intercom/config.ts
-import { existsSync as existsSync6, readFileSync as readFileSync4 } from "fs";
+import { existsSync as existsSync6, readFileSync as readFileSync5 } from "fs";
 import { getAgentConfigPaths } from "@bastani/atomic";
 function loadConfig() {
   if (!existsSync6(CONFIG_PATH)) {
     return { ...defaults };
   }
   try {
-    const raw = readFileSync4(CONFIG_PATH, "utf-8");
+    const raw = readFileSync5(CONFIG_PATH, "utf-8");
     const parsed = JSON.parse(raw);
     if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
       throw new Error("Config must be a JSON object");
@@ -63883,6 +64270,12 @@ function loadConfig() {
       }
       config.brokerArgs = brokerArgs;
     }
+    if (Object.hasOwn(parsedConfig, "brokerStartupTimeoutMs")) {
+      if (!Number.isInteger(parsedConfig.brokerStartupTimeoutMs) || Number(parsedConfig.brokerStartupTimeoutMs) < MIN_BROKER_STARTUP_TIMEOUT_MS) {
+        throw new Error(`"brokerStartupTimeoutMs" must be an integer of at least ${MIN_BROKER_STARTUP_TIMEOUT_MS}`);
+      }
+      config.brokerStartupTimeoutMs = Number(parsedConfig.brokerStartupTimeoutMs);
+    }
     if (Object.hasOwn(parsedConfig, "confirmSend")) {
       if (typeof parsedConfig.confirmSend !== "boolean") {
         throw new Error(`"confirmSend" must be a boolean`);
@@ -63930,6 +64323,7 @@ var init_config = __esm(() => {
   defaults = {
     brokerCommand: DEFAULT_BROKER_COMMAND,
     brokerArgs: [...DEFAULT_BROKER_ARGS],
+    brokerStartupTimeoutMs: BROKER_READY_TIMEOUT_MS,
     confirmSend: false,
     maxPendingAsks: DEFAULT_MAX_PENDING_REPLY_WAITS,
     replyHint: true
@@ -63950,7 +64344,7 @@ var init_reconnect_backoff = __esm(() => {
 });
 
 // dist/builtin/intercom/workflow-route-owner.ts
-import { randomUUID as randomUUID14 } from "node:crypto";
+import { randomUUID as randomUUID15 } from "node:crypto";
 import { createEventBus, getBuiltinPackagePaths } from "@bastani/atomic";
 function closedError() {
   return new Error("Workflow Intercom route owner closed");
@@ -63958,7 +64352,7 @@ function closedError() {
 function createWorkflowRouteOwner(cwd) {
   const events = createEventBus();
   const config = loadConfig();
-  const id = randomUUID14();
+  const id = randomUUID15();
   const routes = new Map;
   const connections = new Map;
   const isCurrent = (state) => routes.get(state.route.runId) === state;
@@ -64022,7 +64416,7 @@ function createWorkflowRouteOwner(cwd) {
       });
       if (extensionDir === undefined)
         throw new Error("Intercom builtin package is unavailable");
-      await spawnBrokerIfNeeded(config.brokerCommand, config.brokerArgs, undefined, extensionDir);
+      await spawnBrokerIfNeeded(config.brokerCommand, config.brokerArgs, config.brokerStartupTimeoutMs, extensionDir);
       if (connections.get(connection.key) !== connection)
         throw closedError();
       const client = new IntercomClient(`${id}:pending-stage-route:${connection.key}`, {
@@ -64666,7 +65060,7 @@ var init_startup_timeout = () => {};
 
 // dist/builtin/workflows/src/workers/pool-coordinator.ts
 import { fork } from "node:child_process";
-import { randomUUID as randomUUID15 } from "node:crypto";
+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 dirname13, join as join29, resolve as resolve12 } from "node:path";
@@ -64891,6 +65285,9 @@ class PoolCoordinator {
   lease;
   options;
   journal;
+  durable;
+  remote;
+  mirrorTimer;
   queue;
   usageLedger;
   usageTotal;
@@ -64923,6 +65320,7 @@ class PoolCoordinator {
     while (this.inflight.size > 0)
       await Promise.allSettled([...this.inflight]);
     await this.journal?.close().catch(() => {});
+    await this.durable?.close().catch(() => {});
   }
   receive(message) {
     if (message.kind === "request-reply") {
@@ -65012,11 +65410,21 @@ class PoolCoordinator {
     this.desiredControl ??= control;
     configurePooledWatchTrace(options.journalPath, "coordinator");
     this.journal ??= await resolveRunJournal({ journal: { path: options.journalPath } });
+    if (options.durable !== undefined && this.remote === undefined) {
+      this.durable = await openDurableJournal(options.durable);
+      this.remote = new PoolRemoteJournal(this.durable, sqlPoolStorage(this.journal));
+    }
+    await this.remote?.mirror(lease);
     this.usageLedger ??= await openSqlPoolUsage(this.journal);
     this.usageTotal = await this.usageLedger.total(root);
     this.lease = lease;
-    const queue = await openSqlPoolQueue(this.journal);
+    const queue = await openSqlPoolQueue(this.journal, this.remote);
     await queue.initialize(lease, COORDINATOR_LEASE_MS);
+    await queue.drainOutbox(lease);
+    if (this.remote !== undefined) {
+      const remote = this.remote;
+      this.mirrorTimer = setInterval(() => void remote.fresh(lease, 0).catch(() => {}), MIRROR_INTERVAL_MS).unref();
+    }
     const retained = [];
     for (const work of await queue.inspect(root))
       if (work.state === "leased" && work.epoch < lease.epoch && (await unconfirmedProcessGroups(this.journal, root, { attempt: work })).length > 0)
@@ -65149,7 +65557,7 @@ class PoolCoordinator {
       throw new Error("Worker exited before delivery acknowledgement");
     const { slot, workerRequest } = target;
     await new Promise((resolve, reject) => {
-      const id = randomUUID15();
+      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) {
@@ -65490,12 +65898,16 @@ class PoolCoordinator {
         admission: options.admission,
         ...this.promptNodes ? { promptNodes: true } : {}
       })
-    ], { stdio: ["ignore", "ignore", "pipe", "ipc"], execArgv: [] });
+    ], {
+      stdio: ["ignore", "ignore", "pipe", "ipc"],
+      execArgv: [],
+      ...options.durable === undefined ? {} : { env: { ...process.env, [POOL_DURABLE_JOURNAL_ENV]: JSON.stringify(options.durable) } }
+    });
     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 = randomUUID15();
+    const worker = randomUUID16();
     this.incarnations.set(worker, child);
     const slot = { worker, child, deliveries: new Map, runs: new Set, stageCommands: new Map };
     this.slots.add(slot);
@@ -65896,6 +66308,7 @@ class PoolCoordinator {
     this.closed = true;
     clearInterval(this.ticker);
     clearInterval(this.recoveryTimer);
+    clearInterval(this.mirrorTimer);
     this.rateLimitOutbox.close();
     let failure;
     let stopping = [];
@@ -65974,8 +66387,10 @@ function runPoolCoordinator() {
   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, MAX_CHILD_ATTEMPTS = 3, ROUTE_REGISTRATION_WAIT_MS = 120000, STAGE_WATCH_BACKLOG_EVENTS = 2000, STAGE_WATCH_BACKLOG_BYTES, 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", ENDED_WATCHES_REMEMBERED = 1024;
+var CONTROL_ACKNOWLEDGEMENT_TIMEOUT_MS = 5000, RECOVERY_INTERVAL_MS = 500, TICK_INTERVAL_MS = 100, STALL_THRESHOLD_MS = 500, COORDINATOR_LEASE_MS, MIRROR_INTERVAL_MS = 1e4, STDERR_TAIL_CHARACTERS = 8192, STDERR_DRAIN_GRACE_MS = 1000, MAX_CHILD_ATTEMPTS = 3, ROUTE_REGISTRATION_WAIT_MS = 120000, STAGE_WATCH_BACKLOG_EVENTS = 2000, STAGE_WATCH_BACKLOG_BYTES, 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", ENDED_WATCHES_REMEMBERED = 1024;
 var init_pool_coordinator = __esm(() => {
+  init_internal();
+  init_pool_remote_journal();
   init_resolution();
   init_workflows_host_module();
   init_sql_pool_queue();
@@ -65986,6 +66401,7 @@ var init_pool_coordinator = __esm(() => {
   init_pending_stage_route_capability();
   init_pending_stage_route_readiness();
   init_store();
+  init_pool_journal();
   init_pooled_watch_trace();
   init_resource_admission();
   init_stage_watch_coalesce();
@@ -66800,7 +67216,7 @@ class StageToolExecutionBuffer {
 }
 
 // dist/builtin/workflows/src/workers/pooled-stage-handle.ts
-import { randomUUID as randomUUID16 } from "node:crypto";
+import { randomUUID as randomUUID17 } from "node:crypto";
 
 class PooledStageHandle {
   runId;
@@ -67118,7 +67534,7 @@ class PooledStageHandle {
       return Promise.reject(new PooledStageDeliveryError("StageNotLive", this.stageName));
     const outcome = Promise.withResolvers();
     const entry = {
-      op: randomUUID16(),
+      op: randomUUID17(),
       text,
       intent,
       ...options === undefined ? {} : { options },
@@ -67576,7 +67992,7 @@ var init_pooled_stage_registry = __esm(() => {
 
 // dist/builtin/workflows/src/workers/local-pool.ts
 import { fork as fork2 } from "node:child_process";
-import { randomUUID as randomUUID17 } from "node:crypto";
+import { randomUUID as randomUUID18 } from "node:crypto";
 import { resolve as resolve13 } from "node:path";
 import { setTimeout as delay3 } from "node:timers/promises";
 import { fileURLToPath as fileURLToPath5 } from "node:url";
@@ -67761,8 +68177,7 @@ class LocalWorkerPool {
   async prepare(root, store) {
     if (this.closed)
       throw new Error("Local worker pool is closed");
-    if (!(this.backend.journal instanceof SqlRunJournal) || resolve13(this.options.journalPath) !== resolve13(this.backend.journal.path) || sqlPoolStorage(this.backend.journal)?.tables.runs !== "wf_runs")
-      throw new Error("Local workers require the same default-prefix SQLite journal");
+    const poolJournal = await this.poolJournal();
     if (this.root !== undefined && this.root !== root)
       throw new Error("Local worker pool belongs to another root");
     this.root = root;
@@ -67779,6 +68194,7 @@ class LocalWorkerPool {
       lease: this.lease,
       options: {
         journalPath: this.options.journalPath,
+        ...this.options.durable === undefined ? {} : { durable: this.options.durable },
         workers: this.options.workers,
         leaseMs: this.leaseMs,
         startupTimeoutMs: this.options.startupTimeoutMs ?? defaultStartupTimeoutMs(this.options.workers),
@@ -67787,7 +68203,20 @@ class LocalWorkerPool {
       },
       ...this.desiredControl === undefined ? {} : { control: this.desiredControl }
     });
-    this.queue ??= await openSqlPoolQueue(this.backend.journal);
+    this.queue ??= await openSqlPoolQueue(poolJournal, this.options.durable === undefined ? undefined : new PoolRemoteJournal(this.backend.journal, sqlPoolStorage(poolJournal)));
+  }
+  async poolJournal() {
+    const journal = this.backend.journal;
+    if (this.options.durable === undefined) {
+      if (!(journal instanceof SqlRunJournal) || resolve13(this.options.journalPath) !== resolve13(journal.path) || sqlPoolStorage(journal)?.tables.runs !== "wf_runs")
+        throw new Error("Local workers require the same default-prefix SQLite journal");
+      return journal;
+    }
+    if (isLocalPoolJournal(journal))
+      throw new Error("Local workers share a local SQLite journal as it is; a durable journal selection does not apply");
+    const coordination = await openCoordinationJournal(this.options.journalPath);
+    registerPoolJournal(journal, coordination);
+    return coordination;
   }
   async control(state) {
     this.desiredControl = state;
@@ -67870,7 +68299,7 @@ class LocalWorkerPool {
       return { ok: false, refusal: "PoolClosed" };
     if (this.coordinator === undefined)
       return { ok: false, refusal: "StageNotOnWorker" };
-    const watch = randomUUID17();
+    const watch = randomUUID18();
     this.stageWatches.set(watch, listener);
     try {
       const result = await this.command({ kind: "stage-watch", watch, ...ref });
@@ -68754,6 +69183,7 @@ var RECONNECT_ATTEMPT_PUBLICATIONS = 40, INTERNAL_WORKFLOW_WORKER_ARG = "--inter
 var init_local_pool = __esm(() => {
   init_internal();
   init_journal_backend();
+  init_pool_remote_journal();
   init_sql_pool_queue();
   init_sql_run_journal();
   init_workflow_tool_abort();
@@ -68768,6 +69198,7 @@ var init_local_pool = __esm(() => {
   init_held_prompt_answers();
   init_host_options();
   init_pool_coordinator();
+  init_pool_journal();
   init_pooled_stage_sources();
   init_pooled_watch_trace();
   init_stage_handoff();
@@ -68809,8 +69240,18 @@ async function activatePublicPool(backend, options) {
     throw new Error("Local worker containment is unavailable on Windows; pooled tool processes cannot be enabled");
   if (process.platform !== "linux" && process.platform !== "darwin" || !await hasNativeProcessIdentity() || !await admissionBootIdentity())
     throw new Error("Local worker containment requires native process identity support");
-  if (!(backend instanceof JournalDurableBackend) || !(backend.journal instanceof SqlRunJournal) || backend.journal.path === ":memory:" || sqlPoolStorage(backend.journal)?.tables.runs !== "wf_runs")
-    throw new Error("Local workers require a default-prefix local SQLite journal");
+  if (!(backend instanceof JournalDurableBackend))
+    throw new Error("Local workers require a journal backend");
+  const local = isLocalPoolJournal(backend.journal);
+  let durable;
+  let poolJournal = backend.journal;
+  let poolPath = local ? backend.journal.path : "";
+  if (!local) {
+    durable = poolDurableJournal(backend.journal);
+    poolPath = coordinationPath(durable);
+    poolJournal = await openCoordinationJournal(poolPath);
+    registerPoolJournal(backend.journal, poolJournal);
+  }
   const cwd = options.cwd ?? process.cwd();
   const localWorkers = options.localWorkers && {
     ...options.localWorkers,
@@ -68822,16 +69263,27 @@ async function activatePublicPool(backend, options) {
     ...options.admission,
     ...options.admission.userDatabase ? { userDatabase: resolve14(cwd, options.admission.userDatabase) } : {}
   };
+  if (durable !== undefined && admission?.userLimits) {
+    if (admission.userDatabase !== undefined && admission.userDatabase !== resolve14(poolPath))
+      throw new Error(`admission.userDatabase must be omitted, or ${resolve14(poolPath)}, for a journal that is not a local SQLite file`);
+    admission.userDatabase = resolve14(poolPath);
+  }
   const sources = localWorkers && await Promise.all(localWorkers.definitions.map(async (source) => ({ ...source, digest: await definitionDigest(source.path) })));
   const resources = JSON.parse(JSON.stringify({
     ...localWorkers ? { localWorkers, definitions: sources } : {},
-    ...admission ? { admission } : {}
+    ...admission ? { admission } : {},
+    ...durable !== undefined && localWorkers ? { coordinator: { host: poolHostId(durable.agentDir), database: coordinationDatabase(durable) } } : {}
   }));
+  const saved = options.effectiveResources?.coordinator;
+  if (saved !== undefined && resources.coordinator !== undefined && saved.host !== resources.coordinator.host)
+    throw new Error(`This root's local workers ran on another machine (${saved.host}). Their work queue and leases are in that machine's pool database, which this machine cannot see, and its workers may still be running children. Resume the root on that machine.`);
+  if (saved !== undefined && resources.coordinator !== undefined && saved.host === resources.coordinator.host && saved.database !== resources.coordinator.database)
+    throw new Error(`This root's local workers keep their work queue and leases in the pool database ${saved.database} on this machine, but the journal is now selected in a way that uses ${resources.coordinator.database}: its adapter, options, prefix or the agent directory changed. Resume the root with the journal selected as it was when the root started.`);
   if (options.effectiveResources && !isDeepStrictEqual2(options.effectiveResources, resources))
     throw new Error("Worker definition compatibility or immutable resource configuration changed");
   options.effectiveResources = resources;
   if (resources.admission)
-    await SqlResourceAdmission.open(backend.journal, {
+    await SqlResourceAdmission.open(poolJournal, {
       ...resources.admission,
       root: options.runId,
       holder: "preflight"
@@ -68841,7 +69293,8 @@ async function activatePublicPool(backend, options) {
   const definitions = await Promise.all((sources ?? []).map(async (source) => ({ ...source, definition: await loadWorkerDefinition(source) })));
   const pool = new LocalWorkerPool(backend, {
     rootId: options.runId,
-    journalPath: backend.journal.path,
+    journalPath: poolPath,
+    ...durable === undefined ? {} : { durable },
     workers: localWorkers.count,
     definitions,
     admission: resources.admission ?? {},
@@ -68858,13 +69311,12 @@ async function activatePublicPool(backend, options) {
   }
 }
 var init_public_pool = __esm(() => {
-  init_internal();
   init_journal_backend();
-  init_sql_run_journal();
   init_admission_host();
   init_definitions();
   init_host_options();
   init_local_pool();
+  init_pool_journal();
   init_resource_admission();
 });
 
@@ -69324,7 +69776,7 @@ var init_run_budget = __esm(() => {
 });
 
 // dist/builtin/workflows/src/engine/primitives/parallel.ts
-import { randomUUID as randomUUID18 } from "node:crypto";
+import { randomUUID as randomUUID19 } from "node:crypto";
 function createParallelPrimitive(input) {
   return async (steps, options = {}) => {
     input.runtime.exit.throwIfWorkflowExitSelected();
@@ -69332,7 +69784,7 @@ function createParallelPrimitive(input) {
     const normalizedOptions = normalizeGroup(options);
     const normalizedSteps = steps.map(normalizeGroup);
     const needsAutoGroup = normalizedOptions.group === true || normalizedSteps.some((step) => step.group === true);
-    const autoGroup = needsAutoGroup ? randomUUID18() : undefined;
+    const autoGroup = needsAutoGroup ? randomUUID19() : undefined;
     const resolveAutoGroup = (value2) => value2.group === true && autoGroup ? { ...value2, group: autoGroup } : value2;
     const resolvedOptions = resolveAutoGroup(normalizedOptions);
     const resolvedSteps = normalizedSteps.map(resolveAutoGroup);
@@ -70216,7 +70668,7 @@ function hasUsableContentBlock(block) {
 }
 
 // dist/builtin/workflows/src/shared/stage-session-store.ts
-import { randomUUID as randomUUID19 } from "node:crypto";
+import { randomUUID as randomUUID20 } from "node:crypto";
 import { dirname as dirname14, resolve as resolve15 } from "node:path";
 import {
   JsonlSessionStore,
@@ -70238,7 +70690,7 @@ async function stageSessionStore(options, defaultSessionDir) {
 }
 async function forkStageSession(store, sessionId, cwd, options, destination = store) {
   const source = await store.load(sessionId);
-  const id = randomUUID19();
+  const id = randomUUID20();
   await destination.create({
     id,
     version: 4,
@@ -70273,6 +70725,7 @@ var init_stage_session_store = () => {};
 // dist/builtin/workflows/src/workers/pool-session-store.ts
 var init_pool_session_store = __esm(() => {
   init_internal();
+  init_pool_journal();
 });
 
 // dist/builtin/workflows/src/durable/completed-catalog-index.ts
@@ -78961,7 +79414,7 @@ var init_executor = __esm(() => {
 });
 
 // dist/builtin/workflows/src/runs/foreground/sdk-run.ts
-import { randomUUID as randomUUID20 } from "node:crypto";
+import { randomUUID as randomUUID21 } from "node:crypto";
 async function run2(def, inputs, callerOpts = {}) {
   let opts = callerOpts;
   const store2 = opts.store === undefined || opts.store === store ? currentWorkflowStore() : opts.store;
@@ -78972,7 +79425,7 @@ async function run2(def, inputs, callerOpts = {}) {
   if (opts.journal === undefined && opts.durableBackend === undefined && ownedBackend === undefined) {
     bindStoreDurableBackend(store2, backend);
   }
-  const runId = opts.runId ?? randomUUID20();
+  const runId = opts.runId ?? randomUUID21();
   if (sourceRunId !== undefined || opts.localWorkers || opts.admission) {
     opts = await restoreWorkerOptions(backend, { ...opts, runId });
   }
@@ -79142,10 +79595,128 @@ var init_workflows_host_module = __esm(() => {
   provideRunJournalHostModules({ "@bastani/atomic/workflows": exports_sdk_surface });
 });
 
+// dist/builtin/workflows/src/workers/pool-journal.ts
+import { createHash as createHash6, randomUUID as randomUUID22 } from "node:crypto";
+import { existsSync as existsSync7, mkdirSync as mkdirSync8, readFileSync as readFileSync6, writeFileSync as writeFileSync6 } from "node:fs";
+import { basename as basename6, dirname as dirname16, join as join31, resolve as resolve17 } from "node:path";
+import { storageSelectionKey as storageSelectionKey2 } from "@bastani/atomic/storage";
+function encodeOption(value2) {
+  if (typeof value2 === "bigint")
+    return { $bigint: value2.toString() };
+  if (value2 instanceof Uint8Array)
+    return { $bytes: Buffer.from(value2).toString("base64") };
+  return value2;
+}
+function decodeOption(value2) {
+  if (value2 !== null && typeof value2 === "object") {
+    if ("$bigint" in value2)
+      return BigInt(value2.$bigint);
+    return new Uint8Array(Buffer.from(value2.$bytes, "base64"));
+  }
+  return value2;
+}
+function isReopenableSelection(selection) {
+  return selection.kind === "sqlite" || selection.kind === "adapter";
+}
+function encodeSelection(selection) {
+  if (selection.kind === "sqlite")
+    return JSON.stringify({ ...selection, path: resolve17(selection.path) });
+  return JSON.stringify({
+    ...selection,
+    ...selection.options === undefined ? {} : {
+      options: Object.fromEntries(Object.entries(selection.options).map(([key, value2]) => [key, encodeOption(value2)]))
+    }
+  });
+}
+function decodeSelection(text) {
+  const value2 = JSON.parse(text);
+  if (value2.kind === "sqlite" || value2.options === undefined)
+    return value2;
+  return {
+    ...value2,
+    options: Object.fromEntries(Object.entries(value2.options).map(([key, option]) => [key, decodeOption(option)]))
+  };
+}
+function isLocalPoolJournal(journal) {
+  return journal instanceof SqlRunJournal && journal.descriptor.adapter === "node-sqlite" && journal.path !== ":memory:" && sqlPoolStorage(journal)?.tables.runs === "wf_runs";
+}
+function poolDurableJournal(journal) {
+  const origin = runJournalOrigin(journal);
+  if (origin === undefined)
+    throw new Error("Local workers cannot reopen a journal passed as an object; select the journal with workflows.journal, --storage or ATOMIC_WORKFLOWS_JOURNAL so every worker process can open it");
+  if (!isReopenableSelection(origin.selection))
+    throw new Error(`Local workers need a journal their processes can open by selection, a SQLite file or a storage adapter, not ${origin.selection.kind}`);
+  return { selection: encodeSelection(origin.selection), agentDir: origin.agentDir };
+}
+function openDurableJournal(durable) {
+  return openSelectedRunJournal(decodeSelection(durable.selection), durable.agentDir);
+}
+function poolStateDirectory(agentDir) {
+  return join31(dirname16(agentDir), "workflows", "pool");
+}
+function databaseIdentity(selection, agentDir) {
+  return storageSelectionKey2(selection.kind === "adapter" ? { ...selection, secrets: undefined } : selection, agentDir);
+}
+function coordinationPath(durable) {
+  const selection = decodeSelection(durable.selection);
+  const identity = createHash6("sha256").update(databaseIdentity(selection, durable.agentDir)).digest("hex");
+  return join31(poolStateDirectory(durable.agentDir), `${identity.slice(0, 24)}.sqlite`);
+}
+function coordinationDatabase(durable) {
+  return basename6(coordinationPath(durable), ".sqlite");
+}
+function openCoordinationJournal(path) {
+  const file = resolve17(path);
+  let opened = coordinationJournals.get(file);
+  if (opened === undefined) {
+    mkdirSync8(dirname16(file), { recursive: true });
+    opened = resolveRunJournal({ journal: { path: file } });
+    coordinationJournals.set(file, opened);
+    opened.catch(() => {
+      if (coordinationJournals.get(file) === opened)
+        coordinationJournals.delete(file);
+    });
+  }
+  return opened;
+}
+function registerPoolJournal(durable, coordination) {
+  coordinations.set(durable, coordination);
+}
+function poolJournalFor(journal) {
+  return coordinations.get(journal) ?? journal;
+}
+function poolHostId(agentDir) {
+  const file = join31(poolStateDirectory(agentDir), "host-id");
+  try {
+    const existing = readFileSync6(file, "utf8").trim();
+    if (existing !== "")
+      return existing;
+  } catch {}
+  mkdirSync8(dirname16(file), { recursive: true });
+  const id = randomUUID22();
+  try {
+    writeFileSync6(file, `${id}
+`, { flag: "wx" });
+    return id;
+  } catch {
+    return readFileSync6(file, "utf8").trim();
+  }
+}
+var POOL_DURABLE_JOURNAL_ENV = "ATOMIC_POOL_DURABLE_JOURNAL", coordinationJournals, coordinations;
+var init_pool_journal = __esm(() => {
+  init_internal();
+  init_workflows_host_module();
+  init_resolution();
+  init_sql_run_journal();
+  coordinationJournals = new Map;
+  coordinations = new WeakMap;
+});
+
 // dist/builtin/workflows/src/workers/local-worker.ts
 init_internal();
 init_journal_backend();
 init_resolution();
+init_pool_journal();
 init_workflows_host_module();
 init_run();
 init_run_tool_control_registry();
@@ -79157,7 +79728,7 @@ init_stage_ui_broker();
 init_store();
 init_admission_binding();
 init_definitions();
-import { randomUUID as randomUUID22 } from "node:crypto";
+import { randomUUID as randomUUID24 } from "node:crypto";
 import { setTimeout as delay4 } from "node:timers/promises";
 import {
   applyProviderRateLimitObservation as applyProviderRateLimitObservation2,
@@ -79183,7 +79754,7 @@ init_resource_admission();
 // dist/builtin/workflows/src/workers/session-store.ts
 init_stage_topology();
 init_run_durable_topology();
-import { randomUUID as randomUUID21 } from "node:crypto";
+import { randomUUID as randomUUID23 } from "node:crypto";
 function workerSessionStore(input) {
   const checkpoint = (id, header) => {
     const owner = header.workflow;
@@ -79199,7 +79770,7 @@ function workerSessionStore(input) {
       ...durableStageCheckpointMetadata(stage, durableRunTopology(run), run.stages.indexOf(stage)),
       kind: "stage",
       workflowId: input.root,
-      checkpointId: `${prefix}:session:${id}:${randomUUID21()}`,
+      checkpointId: `${prefix}:session:${id}:${randomUUID23()}`,
       replayKey: `${prefix}:${stage.replayKey}`,
       name: stage.name,
       sessionId: id,
@@ -79863,7 +80434,10 @@ async function runWorker(start) {
     });
   });
   const definitions = await Promise.all(start.definitions.map(loadWorkerDefinition));
-  const journal = await resolveRunJournal({ journal: { path: start.journalPath } });
+  const poolJournal = await resolveRunJournal({ journal: { path: start.journalPath } });
+  const durableSelection = process.env[POOL_DURABLE_JOURNAL_ENV];
+  delete process.env[POOL_DURABLE_JOURNAL_ENV];
+  const journal = durableSelection === undefined ? poolJournal : await openDurableJournal(JSON.parse(durableSelection));
   const journalReads = new Set(["descriptor", "getRun", "listRuns", "read", "readKey", "leaseState", "close"]);
   const readOnlyJournal = new Proxy(journal, {
     get(target, key) {
@@ -79877,9 +80451,9 @@ async function runWorker(start) {
   });
   const reader = await JournalDurableBackend.open(readOnlyJournal, { runs: [] });
   configurePooledWatchTrace(start.journalPath, `worker:${process.pid}`);
-  const sessions = await new StorageProvider3().openSessionStore({ kind: "sqlite", path: start.journalPath, prefix: `${sqlPoolStorage(journal).tables.runs}_pool_` }, { agentDir: "", domain: "sessions" });
+  const sessions = await new StorageProvider3().openSessionStore({ kind: "sqlite", path: start.journalPath, prefix: `${sqlPoolStorage(poolJournal).tables.runs}_pool_` }, { agentDir: "", domain: "sessions" });
   const commit = poolWorkerCommit({
-    send: async (mutation) => await request({ kind: "commit", operation: randomUUID22(), mutation }),
+    send: async (mutation) => await request({ kind: "commit", operation: randomUUID24(), mutation }),
     catchUp: () => reader.catchUpWorkflow(start.root)
   });
   const reads = new Set([
@@ -80024,7 +80598,7 @@ async function runWorker(start) {
         });
       };
       const unsubscribe = store.subscribeInvalidation(publish);
-      const admission = start.admission ? await SqlResourceAdmission.open(journal, {
+      const admission = start.admission ? await SqlResourceAdmission.open(poolJournal, {
         ...start.admission,
         root: start.root,
         holder: work.worker,
@@ -80173,6 +80747,8 @@ async function runWorker(start) {
   } finally {
     await reader.close();
     await sessions.close();
+    if (poolJournal !== journal)
+      await poolJournal.close().catch(() => {});
   }
   if (rootLeaseLost)
     process.disconnect?.();