@bastani/atomic 0.9.54 → 0.9.55

package/dist/builtin/workflows/src/index.js

@@ -1996,10 +1996,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)
@@ -2017,7 +2023,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();
@@ -2030,6 +2036,7 @@ var init_resolution = __esm(() => {
     }
   });
   origins = new WeakMap;
+  journalOrigins = new WeakMap;
 });
 
 // dist/builtin/workflows/src/durable/journal/sqlite-run-journal.ts
@@ -16762,9 +16769,126 @@ var init_possible_stages = __esm(() => {
   TRACKED_NODE_METHODS = new Set(["stage", "task", "chain", "parallel", "workflow", "tool"]);
 });
 
+// dist/builtin/workflows/src/workers/pool-journal.ts
+import { createHash as createHash3, randomUUID as randomUUID6 } from "node:crypto";
+import { existsSync as existsSync4, mkdirSync as mkdirSync5, readFileSync as readFileSync2, writeFileSync as writeFileSync3 } from "node:fs";
+import { basename as basename5, dirname as dirname9, join as join12, resolve as resolve9 } 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: resolve9(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 join12(dirname9(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 = createHash3("sha256").update(databaseIdentity(selection, durable.agentDir)).digest("hex");
+  return join12(poolStateDirectory(durable.agentDir), `${identity.slice(0, 24)}.sqlite`);
+}
+function coordinationDatabase(durable) {
+  return basename5(coordinationPath(durable), ".sqlite");
+}
+function openCoordinationJournal(path) {
+  const file = resolve9(path);
+  let opened = coordinationJournals.get(file);
+  if (opened === undefined) {
+    mkdirSync5(dirname9(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 = join12(poolStateDirectory(agentDir), "host-id");
+  try {
+    const existing = readFileSync2(file, "utf8").trim();
+    if (existing !== "")
+      return existing;
+  } catch {}
+  mkdirSync5(dirname9(file), { recursive: true });
+  const id = randomUUID6();
+  try {
+    writeFileSync3(file, `${id}
+`, { flag: "wx" });
+    return id;
+  } catch {
+    return readFileSync2(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/admission-host.ts
 import { execFile, execFileSync } from "node:child_process";
-import { readdirSync as readdirSync2, readFileSync as readFileSync2 } from "node:fs";
+import { readdirSync as readdirSync2, readFileSync as readFileSync3 } from "node:fs";
 import { readFile } from "node:fs/promises";
 import { hostname } from "node:os";
 function admissionBootIdentity() {
@@ -16805,7 +16929,7 @@ function scanProcessGroup(group) {
         continue;
       let stat;
       try {
-        stat = readFileSync2(`/proc/${entry}/stat`, "utf8");
+        stat = readFileSync3(`/proc/${entry}/stat`, "utf8");
       } catch {
         complete = false;
         continue;
@@ -16869,7 +16993,7 @@ var init_admission_host = __esm(() => {
 });
 
 // dist/builtin/workflows/src/workers/resource-admission.ts
-import { randomUUID as randomUUID6 } from "node:crypto";
+import { randomUUID as randomUUID7 } from "node:crypto";
 import { realpath } from "node:fs/promises";
 import { cpus, freemem, loadavg } from "node:os";
 import { setTimeout as delay } from "node:timers/promises";
@@ -16884,7 +17008,7 @@ class SqlResourceAdmission {
   permits;
   configuration;
   owners;
-  owner = randomUUID6();
+  owner = randomUUID7();
   nextReconciliation = 0;
   constructor(storage, options) {
     this.storage = storage;
@@ -16991,7 +17115,7 @@ class SqlResourceAdmission {
   }
   async acquire(kind, signal, request) {
     signal?.throwIfAborted();
-    const operation = randomUUID6();
+    const operation = randomUUID7();
     const release = (reason = "resource cleanup confirmed") => this.storage.transaction(async (tx) => {
       await tx.run(`UPDATE ${this.permits} SET state = 'released', reason = ? WHERE operation = ? AND state != 'released'`, reason, operation);
     });
@@ -17214,7 +17338,7 @@ var init_resource_admission = __esm(() => {
 });
 
 // dist/builtin/workflows/src/workers/admission-binding.ts
-import { randomUUID as randomUUID7 } from "node:crypto";
+import { randomUUID as randomUUID8 } from "node:crypto";
 import { withResourceAdmission } from "@bastani/atomic";
 
 class SessionCapacitySlot {
@@ -17289,10 +17413,10 @@ 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()
+    holder: randomUUID8()
   });
   return withResourceAdmission(admission, () => callback({
     ...opts,
@@ -17307,6 +17431,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;
 });
@@ -53509,12 +53634,12 @@ var init_verification_prompts = __esm(() => {
 });
 
 // dist/builtin/workflows/builtin/pattern-artifact-root.ts
-import { randomUUID as randomUUID8 } from "node:crypto";
+import { randomUUID as randomUUID9 } from "node:crypto";
 import { mkdir as mkdir2 } from "node:fs/promises";
-import { join as join12 } from "node:path";
+import { join as join13 } from "node:path";
 async function stableArtifactRoot(ctx, workflowName) {
   const cwd = ctx.cwd ?? process.cwd();
-  const artifactDir = await ctx.tool("artifact-root", { workflow: workflowName }, async () => join12(cwd, ".atomic", "workflows", "runs", `${workflowName}-${randomUUID8()}`));
+  const artifactDir = await ctx.tool("artifact-root", { workflow: workflowName }, async () => join13(cwd, ".atomic", "workflows", "runs", `${workflowName}-${randomUUID9()}`));
   await mkdir2(artifactDir, { recursive: true });
   return artifactDir;
 }
@@ -53554,7 +53679,7 @@ function fold_usage(results) {
 
 // dist/builtin/workflows/builtin/adversarial-verification-runner.ts
 import { readFile as readFile2, writeFile } from "node:fs/promises";
-import { join as join13 } from "node:path";
+import { join as join14 } from "node:path";
 import { Type as Type4 } from "typebox";
 function isRecord3(value2) {
   return typeof value2 === "object" && value2 !== null && !Array.isArray(value2);
@@ -53649,8 +53774,8 @@ async function writeInvalid(path, stage) {
 }
 async function runAdversarialVerification(ctx) {
   const root = await stableArtifactRoot(ctx, "adversarial-verification");
-  const criteriaPath = join13(root, "criteria.md");
-  const candidatePath = join13(root, "candidate.md");
+  const criteriaPath = join14(root, "criteria.md");
+  const candidatePath = join14(root, "candidate.md");
   const resolvedCriteria = resolveCriteria(ctx.inputs.criteria);
   await writeFile(criteriaPath, renderCriteriaMarkdown(resolvedCriteria));
   await ctx.task("worker", { prompt: renderWorkerPrompt(ctx.inputs.task), context: "fresh", output: candidatePath, outputMode: "file-only" });
@@ -53682,7 +53807,7 @@ async function runAdversarialVerification(ctx) {
           criterion,
           verifierIndex: index + 1,
           name,
-          artifactPath: join13(root, `verification-${round}-${criterion.id}-${index + 1}.json`)
+          artifactPath: join14(root, `verification-${round}-${criterion.id}-${index + 1}.json`)
         });
       }
     }
@@ -53735,8 +53860,8 @@ async function runAdversarialVerification(ctx) {
     const decision = decide_verification(roundResult, { acceptMean, quorumFraction: QUORUM_FRACTION });
     finalDecision = decision;
     finalMean = meanScore(scoreReports);
-    scoreTablePath = join13(root, `verification-summary-${round}.json`);
-    reviewReportPath = join13(root, `review-${round}.json`);
+    scoreTablePath = join14(root, `verification-summary-${round}.json`);
+    reviewReportPath = join14(root, `review-${round}.json`);
     const summary = {
       scores: scoreReports,
       mean: finalMean,
@@ -53917,7 +54042,7 @@ var GROUNDED_REPORTING2 = "Before reporting progress, audit each claim against a
 
 // dist/builtin/workflows/builtin/classify-and-act-runner.ts
 import { writeFile as writeFile2 } from "node:fs/promises";
-import { join as join14 } from "node:path";
+import { join as join15 } from "node:path";
 import { Type as Type6 } from "typebox";
 function safeName(value2) {
   const normalized = value2.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
@@ -53957,7 +54082,7 @@ async function runClassifyAndAct(ctx) {
   const needsFallback = exactCategory === undefined || confidence < ctx.inputs.confidence_threshold;
   const fallback = needsFallback ? await resolveFallbackCategory(ctx, exactCategory) : undefined;
   const category = fallback?.category ?? exactCategory;
-  const classificationPath = join14(artifactDir, "classification.json");
+  const classificationPath = join15(artifactDir, "classification.json");
   await writeFile2(classificationPath, JSON.stringify({
     proposed_category: proposedCategory,
     selected_category: category,
@@ -53967,7 +54092,7 @@ async function runClassifyAndAct(ctx) {
     fallback_used: needsFallback,
     fallback_mode: fallback?.fallbackMode ?? "none"
   }, null, 2));
-  const actionPath = join14(artifactDir, `action-${safeName(category)}.md`);
+  const actionPath = join15(artifactDir, `action-${safeName(category)}.md`);
   const action = await ctx.task(`action-${safeName(category)}`, {
     tools: actionTools(category),
     prompt: actionPrompt({ prompt: ctx.inputs.prompt, category, classificationPath }),
@@ -54107,7 +54232,7 @@ var GROUNDED_REPORTING3 = "Before reporting progress, audit each claim against a
 
 // dist/builtin/workflows/builtin/fan-out-and-synthesize-runner.ts
 import { writeFile as writeFile3 } from "node:fs/promises";
-import { join as join15 } from "node:path";
+import { join as join16 } from "node:path";
 import { Type as Type8 } from "typebox";
 function safeName2(value2, index) {
   const normalized = value2.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
@@ -54138,9 +54263,9 @@ async function runFanOutAndSynthesize(ctx) {
     context: "fresh"
   });
   const partitions = parsedPartitions(plan.structured, ctx.inputs.max_branches, ctx.inputs.prompt);
-  const partitionPath = join15(artifactDir, "partition-plan.json");
+  const partitionPath = join16(artifactDir, "partition-plan.json");
   await writeFile3(partitionPath, JSON.stringify({ task: ctx.inputs.prompt, partitions }, null, 2));
-  const branchPaths = partitions.map((partition, index) => join15(artifactDir, `branch-${safeName2(partition.label, index)}.md`));
+  const branchPaths = partitions.map((partition, index) => join16(artifactDir, `branch-${safeName2(partition.label, index)}.md`));
   const steps = partitions.map((partition, index) => ({
     name: `branch-${safeName2(partition.label, index)}`,
     prompt: branchPrompt({ prompt: ctx.inputs.prompt, ...partition }),
@@ -54150,13 +54275,13 @@ async function runFanOutAndSynthesize(ctx) {
     outputMode: "file-only"
   }));
   await ctx.parallel(steps, { concurrency: Math.min(ctx.inputs.max_concurrency, partitions.length), failFast: false });
-  const manifestPath = join15(artifactDir, "manifest.json");
+  const manifestPath = join16(artifactDir, "manifest.json");
   await writeFile3(manifestPath, JSON.stringify({
     task: ctx.inputs.prompt,
     partition_plan: partitionPath,
     branches: partitions.map((partition, index) => ({ ...partition, artifact_path: branchPaths[index] }))
   }, null, 2));
-  const synthesisPath = join15(artifactDir, "synthesis.md");
+  const synthesisPath = join16(artifactDir, "synthesis.md");
   const synthesis = await ctx.task("synthesize", {
     prompt: synthesisPrompt(ctx.inputs.prompt, manifestPath),
     context: "fresh",
@@ -54321,7 +54446,7 @@ var init_generate_and_filter_prompts = __esm(() => {
 
 // dist/builtin/workflows/builtin/generate-and-filter-runner.ts
 import { readFile as readFile3, writeFile as writeFile4 } from "node:fs/promises";
-import { join as join16 } from "node:path";
+import { join as join17 } from "node:path";
 import { Type as Type10 } from "typebox";
 function isRecord4(value2) {
   return typeof value2 === "object" && value2 !== null && !Array.isArray(value2);
@@ -54340,7 +54465,7 @@ function judgeDecision(value2) {
 }
 async function runGenerateAndFilter(ctx) {
   const root = await stableArtifactRoot(ctx, "generate-and-filter");
-  const candidatePaths = Array.from({ length: ctx.inputs.num_candidates }, (_, index) => join16(root, `candidate-${index + 1}.md`));
+  const candidatePaths = Array.from({ length: ctx.inputs.num_candidates }, (_, index) => join17(root, `candidate-${index + 1}.md`));
   const shortlistLimit = Math.min(ctx.inputs.shortlist_size, ctx.inputs.num_candidates);
   await ctx.parallel(candidatePaths.map((path, index) => ({
     name: `generate-${index + 1}`,
@@ -54349,9 +54474,9 @@ async function runGenerateAndFilter(ctx) {
     output: path,
     outputMode: "file-only"
   })), { concurrency: ctx.inputs.max_concurrency, failFast: false });
-  const manifestPath = join16(root, "manifest.json");
+  const manifestPath = join17(root, "manifest.json");
   await writeFile4(manifestPath, JSON.stringify({ task: ctx.inputs.prompt, candidate_artifact_paths: candidatePaths }, null, 2));
-  const filterPath = join16(root, "filter.json");
+  const filterPath = join17(root, "filter.json");
   const filtered = await ctx.task("dedupe-and-filter", {
     prompt: renderFilterPrompt(ctx.inputs.prompt, candidatePaths, shortlistLimit),
     context: "fresh",
@@ -54368,7 +54493,7 @@ async function runGenerateAndFilter(ctx) {
   let judgePath = null;
   let decisionPath = filterPath;
   if (ctx.inputs.use_judge) {
-    judgePath = join16(root, "judge.json");
+    judgePath = join17(root, "judge.json");
     const judgeCandidates = await Promise.all(shortlist.map(async (path) => ({ path, body: await readFile3(path, "utf8") })));
     const judgePrompt = renderJudgePrompt(ctx.inputs.prompt, filterPath, shortlistLimit, judgeCandidates);
     const judged = await ctx.task("judge", {
@@ -54384,7 +54509,7 @@ async function runGenerateAndFilter(ctx) {
     shortlist = judgedShortlist.length > 0 ? judgedShortlist : shortlist;
     decisionPath = judgePath;
   }
-  const finalPath = join16(root, "shortlist.md");
+  const finalPath = join17(root, "shortlist.md");
   const finalShortlist = await ctx.task("final-shortlist", {
     prompt: renderFinalShortlistPrompt(ctx.inputs.prompt, decisionPath),
     context: "fresh",
@@ -54913,7 +55038,7 @@ var init_review_convergence = __esm(() => {
 
 // dist/builtin/workflows/builtin/goal-artifacts.ts
 import { writeFile as writeFile5 } from "node:fs/promises";
-import { join as join17 } from "node:path";
+import { join as join18 } from "node:path";
 function artifactSafeName(value2) {
   const safe = value2.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
   return safe.length > 0 ? safe : "artifact";
@@ -54924,7 +55049,7 @@ function withoutTurn(value2) {
   return copy;
 }
 async function writeReviewArtifact(artifactDir, reviewer, decision, rawText, convergenceDecision) {
-  const artifactPath = join17(artifactDir, `review-${artifactSafeName(reviewer)}.json`);
+  const artifactPath = join18(artifactDir, `review-${artifactSafeName(reviewer)}.json`);
   await writeFile5(artifactPath, `${JSON.stringify({ reviewer, decision, convergence_decision: convergenceDecision, raw_text: rawText }, null, 2)}
 `, { encoding: "utf8" });
   return artifactPath;
@@ -54933,7 +55058,7 @@ async function writeReviewRoundArtifact(artifactDir, reviews, consolidatedFindin
   reviewer: review.reviewer,
   findings: review.findings
 }))), reverification = []) {
-  const artifactPath = join17(artifactDir, "review-round-latest.json");
+  const artifactPath = join18(artifactDir, "review-round-latest.json");
   const visibleReviews = reviews.map(withoutTurn);
   await writeFile5(artifactPath, `${JSON.stringify({ reviews: visibleReviews, consolidated_findings: consolidatedFindings, reverification }, null, 2)}
 `, { encoding: "utf8" });
@@ -55161,9 +55286,9 @@ var init_goal_review = __esm(() => {
 });
 
 // dist/builtin/workflows/builtin/goal-ledger.ts
-import { randomUUID as randomUUID9 } from "node:crypto";
+import { randomUUID as randomUUID10 } from "node:crypto";
 import { readFile as readFile4, rename, rm as rm2, writeFile as writeFile6 } from "node:fs/promises";
-import { dirname as dirname9, join as join18 } from "node:path";
+import { dirname as dirname10, join as join19 } from "node:path";
 import { isDeepStrictEqual } from "node:util";
 function withoutTurn2(value2) {
   const copy = { ...value2 };
@@ -55188,7 +55313,7 @@ function modelVisibleLedger(ledger) {
   };
 }
 function goalLedgerStatePath(ledgerPath) {
-  return join18(dirname9(ledgerPath), LEDGER_STATE_FILENAME);
+  return join19(dirname10(ledgerPath), LEDGER_STATE_FILENAME);
 }
 function appendLifecycleEvent(ledger, event, summary, turn = ledger.turns) {
   ledger.lifecycle.push({
@@ -55264,14 +55389,14 @@ function recoverLegacyExecutionInterruption(ledger) {
   return true;
 }
 async function createGoalLedger(objective, acceptanceCriteria, artifactDir) {
-  const ledgerPath = join18(artifactDir, LEDGER_FILENAME);
+  const ledgerPath = join19(artifactDir, LEDGER_FILENAME);
   const existing = await readExistingGoalLedger(ledgerPath);
   if (existing !== undefined) {
     if (recoverLegacyExecutionInterruption(existing))
       await writeGoalLedger(ledgerPath, existing);
     return { ledger: existing, ledgerPath, artifactDir };
   }
-  const goalId = randomUUID9();
+  const goalId = randomUUID10();
   const now = new Date().toISOString();
   const ledger = {
     goal_id: goalId,
@@ -55300,7 +55425,7 @@ async function writeGoalLedger(ledgerPath, ledger) {
   const stateContents = `${JSON.stringify(ledger, null, 2)}
 `;
   const statePath = goalLedgerStatePath(ledgerPath);
-  const pendingStatePath = `${statePath}.${randomUUID9()}.tmp`;
+  const pendingStatePath = `${statePath}.${randomUUID10()}.tmp`;
   await writeFile6(pendingStatePath, stateContents, { encoding: "utf8" });
   try {
     await rename(pendingStatePath, statePath);
@@ -55771,7 +55896,7 @@ var init_goal_orchestrator_prompts = __esm(() => {
 });
 
 // dist/builtin/workflows/builtin/goal-runner.ts
-import { join as join19 } from "node:path";
+import { join as join20 } from "node:path";
 function positiveInteger(value2, fallback) {
   if (typeof value2 !== "number" || !Number.isFinite(value2) || value2 <= 0) {
     return fallback;
@@ -55822,7 +55947,7 @@ async function runGoalWorkflow(ctx, options) {
       appendLifecycleEvent(ledger, "work_turn_started", "Orchestrator started.", turn);
       await writeGoalLedger(ledgerPath, ledger);
     }
-    const orchestratorReceiptPath = join19(artifactDir, "orchestrator-receipt.md");
+    const orchestratorReceiptPath = join20(artifactDir, "orchestrator-receipt.md");
     const orchestratorForkOptions = forkContinuationOptions(previousOrchestratorSessionId);
     const orchestratorPrompt = orchestratorForkOptions.forkFromSessionId === undefined ? renderGoalOrchestratorPrompt({
       ledger,
@@ -55893,7 +56018,7 @@ async function runGoalWorkflow(ctx, options) {
       const reviewerName = result.name ?? result.stageName;
       const normalizedReviewerName = reviewerName.replace(/-\d+$/u, "");
       const parsed = reviewerContractError === undefined ? parsedReviewDecisionFromResult(result, reviewerName) : { decision: reviewerErrorDecision(reviewerContractError.message), parsed: false, diagnostics: [reviewerContractError.message] };
-      const reviewArtifactPath = join19(artifactDir, `review-${artifactSafeName(normalizedReviewerName)}.json`);
+      const reviewArtifactPath = join20(artifactDir, `review-${artifactSafeName(normalizedReviewerName)}.json`);
       const record = reviewDecisionToRecord({
         turn,
         reviewer: normalizedReviewerName,
@@ -56214,7 +56339,7 @@ var GROUNDED_REPORTING5 = "Before reporting progress, audit each claim against a
 
 // dist/builtin/workflows/builtin/loop-until-done-runner.ts
 import { mkdir as mkdir3, writeFile as writeFile7 } from "node:fs/promises";
-import { join as join20 } from "node:path";
+import { join as join21 } from "node:path";
 import { Type as Type16 } from "typebox";
 function progressCurve(entries) {
   return entries.flatMap((entry) => entry.progress === undefined ? [] : [entry.progress.score]);
@@ -56297,18 +56422,18 @@ async function writeLedger(path, task, maxIterations, status, entries) {
 }
 async function runLoopUntilDone(ctx) {
   const artifactDir = await stableArtifactRoot(ctx, "loop-until-done");
-  const iterationsDir = join20(artifactDir, "iterations");
-  const evaluationsDir = join20(artifactDir, "evaluations");
+  const iterationsDir = join21(artifactDir, "iterations");
+  const evaluationsDir = join21(artifactDir, "evaluations");
   await mkdir3(iterationsDir, { recursive: true });
   await mkdir3(evaluationsDir, { recursive: true });
-  const ledgerPath = join20(artifactDir, "progress-ledger.json");
+  const ledgerPath = join21(artifactDir, "progress-ledger.json");
   const entries = [];
   const iterationArtifactPaths = [];
   const evaluationArtifactPaths = [];
   await writeLedger(ledgerPath, ctx.inputs.prompt, ctx.inputs.max_iterations, "active", entries);
   for (let iteration = 1;iteration <= ctx.inputs.max_iterations; iteration += 1) {
-    const iterationPath = join20(iterationsDir, `iteration-${iteration}.md`);
-    const evaluationPath = join20(evaluationsDir, `evaluation-${iteration}.json`);
+    const iterationPath = join21(iterationsDir, `iteration-${iteration}.md`);
+    const evaluationPath = join21(evaluationsDir, `evaluation-${iteration}.json`);
     iterationArtifactPaths.push(iterationPath);
     evaluationArtifactPaths.push(evaluationPath);
     await ctx.task(`iteration-${iteration}`, {
@@ -56357,7 +56482,7 @@ async function runLoopUntilDone(ctx) {
     await writeLedger(ledgerPath, ctx.inputs.prompt, ctx.inputs.max_iterations, decision.done ? "complete" : "active", entries);
     if (decision.done) {
       const report = progressReport(entries);
-      const resultPath = join20(artifactDir, "result.md");
+      const resultPath = join21(artifactDir, "result.md");
       const final = await ctx.task("completion-summary", {
         prompt: renderCompletionPrompt({ task: ctx.inputs.prompt, ledgerPath, iterationPath }),
         context: "fresh",
@@ -56474,9 +56599,9 @@ var init_loop_until_done = __esm(() => {
 
 // dist/builtin/workflows/builtin/open-claude-design-utils.ts
 import { spawnSync as spawnSync3 } from "node:child_process";
-import { mkdirSync as mkdirSync5 } from "node:fs";
+import { mkdirSync as mkdirSync6 } from "node:fs";
 import { tmpdir, userInfo } from "node:os";
-import { join as join21 } from "node:path";
+import { join as join22 } from "node:path";
 import { Type as Type18 } from "typebox";
 import { createChildProcessEnvironment as createChildProcessEnvironment3 } from "@bastani/atomic";
 function taggedPrompt3(sections) {
@@ -56519,32 +56644,32 @@ function tmpArtifactBase() {
   try {
     user = userInfo().username.replace(/[^A-Za-z0-9._-]/g, "_") || "default";
   } catch {}
-  return join21(tmpdir(), `open-claude-design-${user}`);
+  return join22(tmpdir(), `open-claude-design-${user}`);
 }
 function prepareArtifactDir(cwd = process.cwd()) {
   const runId = `${new Date().toISOString().replace(/[:.]/g, "-")}-${Math.random().toString(36).slice(2, 8)}`;
   const tmpCandidates = [
-    join21(tmpArtifactBase(), runId),
-    join21(tmpdir(), "open-claude-design", runId)
+    join22(tmpArtifactBase(), runId),
+    join22(tmpdir(), "open-claude-design", runId)
   ];
-  const candidates = process.env.NODE_ENV === "test" ? tmpCandidates : [join21(cwd, "specs", "design", runId), ...tmpCandidates];
+  const candidates = process.env.NODE_ENV === "test" ? tmpCandidates : [join22(cwd, "specs", "design", runId), ...tmpCandidates];
   for (const candidate of candidates) {
     try {
-      mkdirSync5(candidate, { recursive: true });
+      mkdirSync6(candidate, { recursive: true });
       return {
         runId,
         artifactDir: candidate,
-        previewPath: join21(candidate, "preview.html"),
-        specPath: join21(candidate, "spec.html")
+        previewPath: join22(candidate, "preview.html"),
+        specPath: join22(candidate, "spec.html")
       };
     } catch {}
   }
-  const fallback = join21(tmpArtifactBase(), runId);
+  const fallback = join22(tmpArtifactBase(), runId);
   return {
     runId,
     artifactDir: fallback,
-    previewPath: join21(fallback, "preview.html"),
-    specPath: join21(fallback, "spec.html")
+    previewPath: join22(fallback, "preview.html"),
+    specPath: join22(fallback, "spec.html")
   };
 }
 function ensureAgentBrowser() {
@@ -56878,8 +57003,8 @@ var init_open_claude_design_live_protocol = __esm(() => {
 });
 
 // dist/builtin/workflows/builtin/open-claude-design-setup.ts
-import { mkdirSync as mkdirSync6, writeFileSync as writeFileSync3 } from "node:fs";
-import { join as join22 } from "node:path";
+import { mkdirSync as mkdirSync7, writeFileSync as writeFileSync4 } from "node:fs";
+import { join as join23 } from "node:path";
 function renderDiscoveryContext(discovery) {
   return [
     `Confirmed design brief: ${discovery.brief}`,
@@ -56944,10 +57069,10 @@ async function runDiscoveryAndInit(args) {
   };
 }
 function designContextPath(artifactDir) {
-  return join22(artifactDir, DESIGN_CONTEXT_FILENAME);
+  return join23(artifactDir, DESIGN_CONTEXT_FILENAME);
 }
 function referencesBriefPath(artifactDir) {
-  return join22(artifactDir, REFERENCES_BRIEF_FILENAME);
+  return join23(artifactDir, REFERENCES_BRIEF_FILENAME);
 }
 function buildReferenceDiscoveryPrompt(args) {
   const siteList = REFERENCE_DESIGN_SITES.map((site, index) => `${index + 1}. ${site.name} — ${site.url}`).join(`
@@ -56973,8 +57098,8 @@ function buildReferenceDiscoveryPrompt(args) {
       [
         "Use the agent-browser skill to open each gallery; if `agent-browser` reports a missing browser executable, follow the bootstrap rules and retry once.",
         "From each gallery, choose 1-3 fitting designs and CLICK INTO each actual live or project-detail page; do not capture only the grid or thumbnail.",
-        `Capture motion across the entire page: start \`agent-browser record start ${join22(args.artifactDir, "ref-<site>-<n>.webm")}\`, scroll smoothly in small increments with waits (using repeated \`agent-browser scroll down 600\` or \`agent-browser mouse wheel 600\`) so animations fire and lazy content loads, then run \`agent-browser record stop\`.`,
-        `Also run \`agent-browser screenshot ${join22(args.artifactDir, "ref-<site>-<n>.png")} --full\`; this still is the minimum when video is unavailable.`,
+        `Capture motion across the entire page: start \`agent-browser record start ${join23(args.artifactDir, "ref-<site>-<n>.webm")}\`, scroll smoothly in small increments with waits (using repeated \`agent-browser scroll down 600\` or \`agent-browser mouse wheel 600\`) so animations fire and lazy content loads, then run \`agent-browser record stop\`.`,
+        `Also run \`agent-browser screenshot ${join23(args.artifactDir, "ref-<site>-<n>.png")} --full\`; this still is the minimum when video is unavailable.`,
         "Record the actual destination URL, title, and author. For each reference, cite observed layout, typography, color, spacing, and motion traits rather than inferred traits.",
         "Assess fit against DESIGN.md, PRODUCT.md, and the ds-* discovery evidence in the design-context file; prefer on-brand references and flag departures.",
         "Use ask_user_question to ask which reference direction they prefer, offering 2-4 strongest options plus `None of these fit`. If none fit, ask them to provide a reference image, screenshot, URL, or local file path and record the answer.",
@@ -56999,8 +57124,8 @@ function buildReferenceDiscoveryPrompt(args) {
 }
 function writeRequiredContextArtifact(artifactDir, filePath, content, label) {
   try {
-    mkdirSync6(artifactDir, { recursive: true });
-    writeFileSync3(filePath, `${content}
+    mkdirSync7(artifactDir, { recursive: true });
+    writeFileSync4(filePath, `${content}
 `);
   } catch (error) {
     const detail = error instanceof Error ? error.message : String(error);
@@ -57551,7 +57676,7 @@ var init_ralph_review_gate = __esm(() => {
 
 // dist/builtin/workflows/builtin/ralph-core.ts
 import { mkdir as mkdir4, writeFile as writeFile8 } from "node:fs/promises";
-import { dirname as dirname10, join as join23 } from "node:path";
+import { dirname as dirname11, join as join24 } from "node:path";
 import { Type as Type20 } from "typebox";
 function taggedPrompt4(sections) {
   return sections.map(([tag, content]) => {
@@ -57591,11 +57716,11 @@ function slugifyResearchTopic(prompt) {
 }
 function defaultResearchPath(prompt, now = new Date) {
   const date = now.toISOString().slice(0, 10);
-  return join23(DEFAULT_RESEARCH_DIR, `${date}-${slugifyResearchTopic(prompt)}.md`);
+  return join24(DEFAULT_RESEARCH_DIR, `${date}-${slugifyResearchTopic(prompt)}.md`);
 }
 async function createImplementationNotesFile(prompt, runId) {
   const notesDir = await createWorkflowArtifactDirectory(runId);
-  const notesPath = join23(notesDir, IMPLEMENTATION_NOTES_FILENAME);
+  const notesPath = join24(notesDir, IMPLEMENTATION_NOTES_FILENAME);
   const initialNotes = [
     "# Implementation Notes",
     "",
@@ -57616,7 +57741,7 @@ async function createImplementationNotesFile(prompt, runId) {
 }
 async function createQaEvidenceVideoPath(runId) {
   const qaDir = await createWorkflowArtifactDirectory(runId);
-  return join23(qaDir, QA_E2E_VIDEO_FILENAME);
+  return join24(qaDir, QA_E2E_VIDEO_FILENAME);
 }
 function renderQaE2eVideoGuidance(qaVideoPath) {
   return [
@@ -57682,7 +57807,7 @@ function artifactSafeName2(value2) {
   return safe.length > 0 ? safe : "artifact";
 }
 async function writeJsonArtifact(path, content) {
-  await mkdir4(dirname10(path), { recursive: true });
+  await mkdir4(dirname11(path), { recursive: true });
   await writeFile8(path, `${JSON.stringify(content, null, 2)}
 `, {
     encoding: "utf8"
@@ -58019,8 +58144,8 @@ var init_ralph_models = __esm(() => {
 });
 
 // dist/builtin/workflows/builtin/ralph-runner.ts
-import { existsSync as existsSync4 } from "node:fs";
-import { join as join24, resolve as resolve9 } from "node:path";
+import { existsSync as existsSync5 } from "node:fs";
+import { join as join25, resolve as resolve10 } from "node:path";
 async function runRalphWorkflow(ctx, options) {
   const { prompt, acceptanceCriteria, maxLoops, comparisonBaseBranch, workflowStartCwd, createPr, runId } = options;
   let latestReviewReportPath;
@@ -58032,7 +58157,7 @@ async function runRalphWorkflow(ctx, options) {
   let finalPrReport;
   const workflowCwdContext = workflowCwdContextSection(workflowStartCwd);
   const workflowPrompt = prompt;
-  const workflowResearchPath = resolve9(workflowStartCwd, defaultResearchPath(workflowPrompt));
+  const workflowResearchPath = resolve10(workflowStartCwd, defaultResearchPath(workflowPrompt));
   const implementationNotesPath = await createImplementationNotesFile(workflowPrompt, runId);
   const qaVideoPath = await createQaEvidenceVideoPath(runId);
   const artifactDir = await createWorkflowArtifactDirectory(runId);
@@ -58081,7 +58206,7 @@ async function runRalphWorkflow(ctx, options) {
     const researchPath = workflowResearchPath;
     finalResearchPath = researchPath;
     finalPlanPath = researchPath;
-    const orchestratorReportPath = join24(artifactDir, "orchestrator-report.md");
+    const orchestratorReportPath = join25(artifactDir, "orchestrator-report.md");
     const orchestratorForkOptions = forkContinuationOptions3(previousOrchestratorSessionId);
     const orchestratorPrompt = orchestratorForkOptions.forkFromSessionId === undefined ? taggedPrompt4([
       ["acceptance_criteria", keepContext(acceptanceCriteria)],
@@ -58217,7 +58342,7 @@ Read it before implementation or delegation because it is the primary current im
         diagnostics: parsed.diagnostics,
         allowFinalActionRemaining: createPr
       });
-      const artifactPath = join24(artifactDir, `review-${artifactSafeName2(reviewer)}.json`);
+      const artifactPath = join25(artifactDir, `review-${artifactSafeName2(reviewer)}.json`);
       await writeJsonArtifact(artifactPath, {
         reviewer,
         decision: parsed.decision,
@@ -58273,7 +58398,7 @@ Read it before implementation or delegation because it is the primary current im
         usage: fold_usage([orchestrator, ...reviews, ...reverifyResults])
       }));
     }
-    latestReviewReportPath = await writeJsonArtifact(join24(artifactDir, "review-round-latest.json"), {
+    latestReviewReportPath = await writeJsonArtifact(join25(artifactDir, "review-round-latest.json"), {
       convergence_decision: roundConvergenceDecision,
       convergence: convergenceEntries,
       consolidated_findings: reverified.batch,
@@ -58283,7 +58408,7 @@ Read it before implementation or delegation because it is the primary current im
     if (approved)
       break;
   }
-  const qaVideoAvailable = existsSync4(qaVideoPath);
+  const qaVideoAvailable = existsSync5(qaVideoPath);
   const unapprovedHandoff = createPr === true && !approved;
   const escalationEvidence = unapprovedHandoff ? convergence_escalation_evidence(convergenceEntries) : [];
   if (createPr === true) {
@@ -58642,7 +58767,7 @@ var init_tournament_prompts = __esm(() => {
 
 // dist/builtin/workflows/builtin/tournament-runner.ts
 import { mkdir as mkdir5, readFile as readFile5, writeFile as writeFile9 } from "node:fs/promises";
-import { join as join25, isAbsolute as isAbsolute9, relative as relative5, resolve as resolve10 } from "node:path";
+import { join as join26, isAbsolute as isAbsolute9, relative as relative5, resolve as resolve11 } from "node:path";
 import { Type as Type22 } from "typebox";
 function serializableObject2(value2) {
   if (value2 === null || Array.isArray(value2) || typeof value2 !== "object")
@@ -58679,8 +58804,8 @@ function criterionSlug(id) {
 }
 function judgeArtifactPath(judgesDir, job, criterionIndex) {
   const filename = `judge-${job.a}-${job.b}-c${criterionIndex}-${criterionSlug(job.criterionId)}-r${job.rep}.json`;
-  const root = resolve10(judgesDir);
-  const path = resolve10(judgesDir, filename);
+  const root = resolve11(judgesDir);
+  const path = resolve11(judgesDir, filename);
   const fromRoot = relative5(root, path);
   if (fromRoot.startsWith("..") || isAbsolute9(fromRoot)) {
     throw new Error(`tournament: judge artifact escaped its directory: ${path}`);
@@ -58731,16 +58856,16 @@ function combineUsage(totals) {
 }
 async function runTournament(ctx) {
   const artifactDir = await stableArtifactRoot(ctx, "tournament");
-  const attemptsDir = join25(artifactDir, "attempts");
+  const attemptsDir = join26(artifactDir, "attempts");
   const numAttempts = ctx.inputs.num_attempts ?? 4;
   const maxConcurrency = ctx.inputs.max_concurrency ?? 4;
   const nEvaluations = ctx.inputs.n_evaluations ?? 2;
   const pivotCount = ctx.inputs.pivots ?? 1;
   const seed = ctx.inputs.seed ?? 0;
-  const judgesDir = join25(artifactDir, "judges");
+  const judgesDir = join26(artifactDir, "judges");
   await mkdir5(attemptsDir, { recursive: true });
   await mkdir5(judgesDir, { recursive: true });
-  const attemptArtifactPaths = Array.from({ length: numAttempts }, (_, index) => join25(attemptsDir, `attempt-${index + 1}.md`));
+  const attemptArtifactPaths = Array.from({ length: numAttempts }, (_, index) => join26(attemptsDir, `attempt-${index + 1}.md`));
   const models = ctx.inputs.models;
   const attemptResults = await ctx.parallel(attemptArtifactPaths.map((path, index) => ({
     name: `attempt-${index + 1}`,
@@ -58905,7 +59030,7 @@ The previous report was invalid. Return the required JSON schema exactly once.`,
   const outputRanking = ranking.map(({ label, meanPreference }) => ({ label, meanPreference }));
   const budgetPivots = Math.min(pivotCount, entrants.length);
   const comparisonBudget = (entrants.length + budgetPivots * (entrants.length - budgetPivots) + budgetPivots * (budgetPivots - 1) / 2) * criteria.length * nEvaluations;
-  const comparisonPath = join25(artifactDir, "comparisons.json");
+  const comparisonPath = join26(artifactDir, "comparisons.json");
   const assignment = modelAssignment(entrants, models);
   const phaseUsage = {
     attempts: fold_usage(attemptResults),
@@ -58941,7 +59066,7 @@ The previous report was invalid. Return the required JSON schema exactly once.`,
   await writeLedger(fold_usage([]));
   const winner = ranking[0];
   const winnerEntrant = entrants[winner.index];
-  const resultPath = join25(artifactDir, "winner.md");
+  const resultPath = join26(artifactDir, "winner.md");
   const reducer = await ctx.task("comparisons-reducer", {
     prompt: renderComparisonsReducerPrompt({
       task: ctx.inputs.prompt,
@@ -59159,7 +59284,7 @@ var init_workflow_module_loader = __esm(() => {
 });
 
 // dist/builtin/workflows/src/workers/definitions.ts
-import { createHash as createHash3 } from "node:crypto";
+import { createHash as createHash4 } from "node:crypto";
 import { readFile as readFile6 } from "node:fs/promises";
 import { isAbsolute as isAbsolute10 } from "node:path";
 async function loadWorkerDefinition(source) {
@@ -59177,7 +59302,7 @@ async function loadWorkerWorkflow(path, exportName = "default") {
   return loadWorkerDefinition({ path, exportName, digest: await definitionDigest(path) });
 }
 async function definitionDigest(path) {
-  return createHash3("sha256").update(await readFile6(path)).digest("hex");
+  return createHash4("sha256").update(await readFile6(path)).digest("hex");
 }
 var workerDefinitionSources;
 var init_definitions = __esm(() => {
@@ -59191,6 +59316,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)
@@ -59258,6 +59461,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;
@@ -59280,7 +59488,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);
@@ -59288,15 +59495,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) {
@@ -59525,10 +59774,10 @@ var init_pool_stage_usage = __esm(() => {
 });
 
 // dist/builtin/workflows/src/durable/journal/sql-pool-queue.ts
-import { createHash as createHash4, randomUUID as randomUUID10 } from "node:crypto";
+import { createHash as createHash5, randomUUID as randomUUID11 } from "node:crypto";
 import { assertStorageSchemaVersion as assertStorageSchemaVersion2, StorageError as StorageError2 } from "@bastani/atomic/storage";
 function requestIdentity(request) {
-  return createHash4("sha256").update(request).digest("hex");
+  return createHash5("sha256").update(request).digest("hex");
 }
 function fromRow(row) {
   return {
@@ -59559,15 +59808,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;
@@ -59575,10 +59830,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");
@@ -59621,6 +59877,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);
     });
@@ -59665,6 +59930,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)
@@ -59676,7 +59942,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");
@@ -59694,7 +59960,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) => {
@@ -59727,6 +59996,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);
@@ -59741,23 +60012,49 @@ class SqlPoolQueue {
       const siblings = await tx.all(`SELECT json_extract(descriptor, '$.scope') AS scope FROM ${this.work} WHERE root = ?`, lease.runId);
       if (siblings.some((item) => scope.startsWith(`${item.scope}:`) || item.scope.startsWith(`${scope}:`)))
         throw new Error("Pool work scopes overlap");
-      const id = randomUUID10();
+      const id = randomUUID11();
       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);
@@ -59791,6 +60088,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);
@@ -59809,6 +60107,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);
@@ -59832,6 +60132,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) };
   }
@@ -59867,6 +60288,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);
@@ -59882,6 +60304,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);
     });
@@ -59908,6 +60332,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);
@@ -59979,11 +60404,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(() => {
@@ -59993,6 +60418,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();
@@ -60064,7 +60490,7 @@ var init_external_run_routes = __esm(() => {
 });
 
 // dist/builtin/workflows/src/shared/pending-stage-route-capability.ts
-import { randomUUID as randomUUID11 } from "node:crypto";
+import { randomUUID as randomUUID12 } from "node:crypto";
 function capabilitiesFor(store) {
   let capabilities = routeCapabilities.get(store);
   if (capabilities === undefined) {
@@ -60077,13 +60503,13 @@ function workflowPendingStageRouteCapability(store, runId) {
   const capabilities = capabilitiesFor(store);
   let capability = capabilities.get(runId);
   if (capability === undefined) {
-    capability = randomUUID11();
+    capability = randomUUID12();
     capabilities.set(runId, capability);
   }
   return capability;
 }
 function rotateWorkflowPendingStageRouteCapability(store, runId) {
-  const capability = randomUUID11();
+  const capability = randomUUID12();
   capabilitiesFor(store).set(runId, capability);
   return capability;
 }
@@ -61752,7 +62178,7 @@ function isBrokerStatusReport(value2) {
 
 // dist/builtin/intercom/broker/paths.ts
 import { homedir as homedir2 } from "os";
-import { join as join26 } from "path";
+import { join as join27 } from "path";
 function getHomeDir() {
   if (process.platform === "win32") {
     if (process.env.USERPROFILE)
@@ -61769,7 +62195,7 @@ function expandTildePath(path) {
   if (path === "~")
     return getHomeDir();
   if (path.startsWith("~/") || process.platform === "win32" && path.startsWith("~\\")) {
-    return join26(getHomeDir(), path.slice(2));
+    return join27(getHomeDir(), path.slice(2));
   }
   return path;
 }
@@ -61780,28 +62206,31 @@ function getAgentDir5() {
   const piAgentDir = process.env.PI_CODING_AGENT_DIR;
   if (piAgentDir)
     return expandTildePath(piAgentDir);
-  return join26(getHomeDir(), ".atomic", "agent");
+  return join27(getHomeDir(), ".atomic", "agent");
 }
 function sanitizePipeSegment(value2) {
   return value2.replace(/[^a-zA-Z0-9]+/g, "-").replace(/^-+|-+$/g, "").toLowerCase() || "default";
 }
 function getIntercomDirPath(agentDir = getAgentDir5()) {
-  return join26(agentDir, "intercom");
+  return join27(agentDir, "intercom");
 }
 function getBrokerPidPath(agentDir = getAgentDir5()) {
-  return join26(getIntercomDirPath(agentDir), "broker.pid");
+  return join27(getIntercomDirPath(agentDir), "broker.pid");
 }
 function getBrokerSpawnLockPath(agentDir = getAgentDir5()) {
-  return join26(getIntercomDirPath(agentDir), "broker.spawn.lock");
+  return join27(getIntercomDirPath(agentDir), "broker.spawn.lock");
 }
 function getBrokerLogPath(agentDir = getAgentDir5()) {
-  return join26(getIntercomDirPath(agentDir), "broker.log");
+  return join27(getIntercomDirPath(agentDir), "broker.log");
+}
+function getBrokerStartAnnouncementPath(agentDir = getAgentDir5()) {
+  return join27(getIntercomDirPath(agentDir), "broker.starting");
 }
 function getBrokerSocketPath(platform = process.platform, agentDir = getAgentDir5()) {
   if (platform === "win32") {
     return `\\\\.\\pipe\\pi-intercom-${sanitizePipeSegment(agentDir)}`;
   }
-  return join26(getIntercomDirPath(agentDir), "broker.sock");
+  return join27(getIntercomDirPath(agentDir), "broker.sock");
 }
 var BROKER_STORAGE_ENV = "ATOMIC_STORAGE";
 var init_paths = () => {};
@@ -61828,7 +62257,7 @@ function buildSendSignature(to, options) {
 }
 
 // dist/builtin/intercom/broker/pending-send-registry.ts
-import { randomUUID as randomUUID12 } from "crypto";
+import { randomUUID as randomUUID13 } from "crypto";
 
 class PendingSendRegistry {
   generationTtlMs;
@@ -61887,7 +62316,7 @@ class PendingSendRegistry {
     const generation = this.nextGeneration(messageId);
     const attempt = {
       messageId,
-      attemptId: randomUUID12(),
+      attemptId: randomUUID13(),
       signature,
       promise,
       resolve: resolvePromise,
@@ -62103,7 +62532,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 {
@@ -62120,8 +62549,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(() => {
@@ -62134,8 +62601,8 @@ var init_retry_policy = __esm(() => {
 
 // dist/builtin/intercom/broker/client.ts
 import { EventEmitter } from "events";
-import net from "net";
-import { randomUUID as randomUUID13 } from "crypto";
+import net2 from "net";
+import { randomUUID as randomUUID14 } from "crypto";
 function connectAborted() {
   return new IntercomClientDisconnectedError({ cause: new Error("Disconnected before the broker connection registered") });
 }
@@ -62159,6 +62626,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));
 }
@@ -62168,15 +62648,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;
@@ -62230,7 +62717,7 @@ var init_client = __esm(() => {
       if (this.socket !== socket || socket.destroyed)
         return this.disconnectError ?? new IntercomClientDisconnectedError;
       if (this.healthCheck?.socket !== socket) {
-        const requestId = randomUUID13();
+        const requestId = randomUUID14();
         const result = new Promise((resolve) => {
           const finish = (failure) => {
             clearTimeout(timer);
@@ -62262,7 +62749,7 @@ var init_client = __esm(() => {
       }
       return reported;
     }
-    constructor(returnAddress = randomUUID13(), options = {}) {
+    constructor(returnAddress = randomUUID14(), options = {}) {
       super();
       if (returnAddress.length === 0)
         throw new Error("Intercom return address must not be empty");
@@ -62344,8 +62831,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);
           }
@@ -62362,7 +62855,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;
@@ -62420,7 +62913,7 @@ var init_client = __esm(() => {
             this.emit("disconnected", disconnectError);
           }
           if (wasConnecting) {
-            reject(new Error("Connection closed before registration"));
+            reject(new ConnectionClosedBeforeRegistrationError);
           }
         };
         const onSocketError = (err) => {
@@ -62522,7 +63015,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;
@@ -62917,7 +63410,7 @@ var init_client = __esm(() => {
         return Promise.reject(toError(error));
       }
       return new Promise((resolve, reject) => {
-        const requestId = randomUUID13();
+        const requestId = randomUUID14();
         const timeout = setTimeout(() => {
           if (!this.pendingLists.delete(requestId))
             return;
@@ -62949,7 +63442,7 @@ var init_client = __esm(() => {
       } catch (error) {
         return Promise.reject(toError(error));
       }
-      const requestId = randomUUID13();
+      const requestId = randomUUID14();
       return new Promise((resolve, reject) => {
         const timeout = setTimeout(() => {
           if (!this.pendingGroupLists.delete(requestId))
@@ -62984,7 +63477,7 @@ var init_client = __esm(() => {
       }
       if (!this.brokerAnswersStatus)
         return Promise.resolve(undefined);
-      const requestId = randomUUID13();
+      const requestId = randomUUID14();
       return new Promise((resolve, reject) => {
         const timeout = setTimeout(() => {
           if (!this.pendingBrokerStatus.delete(requestId))
@@ -63023,7 +63516,7 @@ var init_client = __esm(() => {
       } catch (error) {
         return Promise.reject(toError(error));
       }
-      const requestId = randomUUID13();
+      const requestId = randomUUID14();
       return new Promise((resolve, reject) => {
         const timeout = setTimeout(() => {
           if (!this.pendingMemberships.delete(requestId))
@@ -63060,7 +63553,7 @@ var init_client = __esm(() => {
       if (!normalizedChildName)
         return Promise.reject(new Error("Child session name is required"));
       return new Promise((resolve, reject) => {
-        const requestId = randomUUID13();
+        const requestId = randomUUID14();
         const timeout = setTimeout(() => {
           if (!this.pendingSupervisorAuthorizations.delete(requestId))
             return;
@@ -63110,7 +63603,7 @@ var init_client = __esm(() => {
       } catch (error) {
         return Promise.reject(toError(error));
       }
-      const requestId = randomUUID13();
+      const requestId = randomUUID14();
       return new Promise((resolve, reject) => {
         const timeout = setTimeout(() => {
           if (!this.pendingRestoringRecipientRequests.delete(requestId))
@@ -63167,7 +63660,7 @@ var init_client = __esm(() => {
         });
       }
       return new Promise((resolve, reject) => {
-        const requestId = randomUUID13();
+        const requestId = randomUUID14();
         const timeout = setTimeout(() => {
           if (!this.pendingStageRouteRegistrations.delete(requestId))
             return;
@@ -63213,7 +63706,7 @@ var init_client = __esm(() => {
       }
       if (!this.brokerClaimsWorkflowInvocations)
         return Promise.resolve(false);
-      const requestId = randomUUID13();
+      const requestId = randomUUID14();
       return new Promise((resolve, reject) => {
         this.pendingWorkflowInvocationClaims.set(requestId, { resolve, reject });
         try {
@@ -63231,7 +63724,7 @@ var init_client = __esm(() => {
       } catch (error) {
         return Promise.reject(toError(error));
       }
-      const requestId = randomUUID13();
+      const requestId = randomUUID14();
       return new Promise((resolve, reject) => {
         this.pendingLiveWorkflowStageRoutes.set(requestId, { resolve, reject });
         try {
@@ -63299,7 +63792,7 @@ var init_client = __esm(() => {
       } catch (error) {
         return Promise.reject(toError(error));
       }
-      const messageId = options.messageId ?? randomUUID13();
+      const messageId = options.messageId ?? randomUUID14();
       let acquired;
       try {
         const pendingSignature = JSON.stringify({
@@ -63385,7 +63878,7 @@ var init_client = __esm(() => {
       } catch (error) {
         return Promise.reject(toError(error));
       }
-      const requestId = randomUUID13();
+      const requestId = randomUUID14();
       return new Promise((resolve, reject) => {
         const wrappedResolve = (group) => {
           clearTimeout(timeout);
@@ -63417,59 +63910,53 @@ 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 readFileSync4, unlinkSync as unlinkSync3, writeFileSync as writeFileSync5 } from "node:fs";
+function readBrokerStartAnnouncement(announcement) {
+  let text;
+  try {
+    text = readFileSync4(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 { join as join27, dirname as dirname11 } from "path";
+import { randomUUID as randomUUID15 } from "crypto";
+import { appendFileSync, chmodSync, closeSync as closeSync3, existsSync as existsSync6, mkdirSync as mkdirSync8, openSync as openSync3, readFileSync as readFileSync5, readSync as readSync2, statSync as statSync5, unlinkSync as unlinkSync4, writeFileSync as writeFileSync6 } from "fs";
+import { join as join28, dirname as dirname12 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 import { createRequire as createRequire3 } from "module";
 import { createChildProcessEnvironment as createChildProcessEnvironment4, isBunBinary, processSharedStorageSelection } from "@bastani/atomic";
 function isIntercomPackageRoot(dir) {
-  return existsSync5(join27(dir, "package.json")) && existsSync5(join27(dir, "broker"));
+  return existsSync6(join28(dir, "package.json")) && existsSync6(join28(dir, "broker"));
 }
 function resolveIntercomPackageRoot(moduleHref) {
-  const here = dirname11(fileURLToPath4(moduleHref));
+  const here = dirname12(fileURLToPath4(moduleHref));
   if (isIntercomPackageRoot(here))
     return here;
-  return join27(here, "..");
+  return join28(here, "..");
 }
 function resolveBrokerEntrypoint(packageRoot) {
-  const bundled = join27(packageRoot, "broker", "broker.bundle.mjs");
-  return existsSync5(bundled) ? bundled : join27(packageRoot, "broker", "broker.ts");
+  const bundled = join28(packageRoot, "broker", "broker.bundle.mjs");
+  return existsSync6(bundled) ? bundled : join28(packageRoot, "broker", "broker.ts");
 }
 function ensurePrivateDirectory(path) {
-  mkdirSync7(path, { recursive: true, mode: 448 });
+  mkdirSync8(path, { recursive: true, mode: 448 });
   if (process.platform !== "win32")
     chmodSync(path, 448);
 }
@@ -63482,14 +63969,14 @@ function getCurrentBrokerRuntime() {
   return isBunBinary ? "bun-binary" : "bun-source";
 }
 function requireFromExtensionDir(extensionDir) {
-  return createRequire3(join27(extensionDir, "package.json"));
+  return createRequire3(join28(extensionDir, "package.json"));
 }
 function getJitiCliPath(extensionDir = EXTENSION_DIR) {
   try {
     const jitiPackage = requireFromExtensionDir(extensionDir).resolve("jiti/package.json");
-    return join27(dirname11(jitiPackage), "lib", "jiti-cli.mjs");
+    return join28(dirname12(jitiPackage), "lib", "jiti-cli.mjs");
   } catch {
-    return join27(extensionDir, "node_modules", "jiti", "lib", "jiti-cli.mjs");
+    return join28(extensionDir, "node_modules", "jiti", "lib", "jiti-cli.mjs");
   }
 }
 function getDefaultBrokerRunnerPath(extensionDir) {
@@ -63511,7 +63998,7 @@ function quoteWindowsArg(value2) {
   return `"${value2.replace(/"/g, '""')}"`;
 }
 function getWindowsHiddenLauncherPath(intercomDir = INTERCOM_DIR) {
-  return join27(intercomDir, "broker-launch.vbs");
+  return join28(intercomDir, "broker-launch.vbs");
 }
 function usesDefaultBrokerCommand(brokerCommand, brokerArgs) {
   return brokerCommand === "npx" && brokerArgs.length === 2 && brokerArgs[0] === "--no-install" && brokerArgs[1] === "tsx";
@@ -63538,8 +64025,8 @@ function getWindowsHiddenLauncherScript(commandLine) {
 `);
 }
 function writeWindowsHiddenLauncher(commandLine, launcherPath = getWindowsHiddenLauncherPath()) {
-  ensurePrivateDirectory(dirname11(launcherPath));
-  writeFileSync4(launcherPath, getWindowsHiddenLauncherScript(commandLine), "utf-8");
+  ensurePrivateDirectory(dirname12(launcherPath));
+  writeFileSync6(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) {
@@ -63567,7 +64054,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,
@@ -63575,20 +64062,21 @@ 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
   };
 }
 function resetBrokerLog(logPath = BROKER_LOG) {
-  ensurePrivateDirectory(dirname11(logPath));
+  ensurePrivateDirectory(dirname12(logPath));
   try {
     const previous = readBrokerLogTail(logPath);
     closeSync3(openSync3(logPath, "w"));
     if (previous.length > 0) {
       try {
         const previousPath = `${logPath}.previous`;
-        writeFileSync4(previousPath, Buffer.from(previous).subarray(-BROKER_LOG_TAIL_BYTES), { mode: 384 });
+        writeFileSync6(previousPath, Buffer.from(previous).subarray(-BROKER_LOG_TAIL_BYTES), { mode: 384 });
         if (process.platform !== "win32")
           chmodSync(previousPath, 384);
       } catch {}
@@ -63650,6 +64138,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: randomUUID15() } : undefined;
+    if (announcement !== undefined) {
+      try {
+        unlinkSync4(announcement.path);
+      } catch {}
+    }
     if (launch.kind === "windows-launcher") {
       writeWindowsHiddenLauncher(launch.launcherCommandLine, launch.launcherPath);
     }
@@ -63660,7 +64154,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);
@@ -63696,7 +64190,7 @@ ${describeBrokerLog()}`);
       };
       child.once("error", onError);
       child.once("exit", onExit);
-      waitForBroker(readyTimeoutMs).then(() => {
+      waitForBroker(readyTimeoutMs, announcement === undefined ? undefined : () => readBrokerStartAnnouncement(announcement)).then(() => {
         cleanup();
         resolve();
       }, (error) => {
@@ -63714,10 +64208,10 @@ async function isBrokerRunning() {
   if (await checkSocketConnectable()) {
     return true;
   }
-  if (!existsSync5(BROKER_PID))
+  if (!existsSync6(BROKER_PID))
     return false;
   try {
-    const pid = parseInt(readFileSync3(BROKER_PID, "utf-8").trim(), 10);
+    const pid = parseInt(readFileSync5(BROKER_PID, "utf-8").trim(), 10);
     if (!Number.isFinite(pid))
       return false;
     process.kill(pid, 0);
@@ -63742,7 +64236,7 @@ function handSpawnLockToBroker(pid, owner) {
 }
 function ownsSpawnLock(owner, lockPath = BROKER_SPAWN_LOCK) {
   try {
-    return readFileSync3(lockPath, "utf-8").startsWith(owner);
+    return readFileSync5(lockPath, "utf-8").startsWith(owner);
   } catch {
     return false;
   }
@@ -63754,7 +64248,7 @@ function acquireSpawnLock() {
 ${Date.now()}
 `;
     try {
-      writeFileSync4(BROKER_SPAWN_LOCK, owner, { flag: "wx" });
+      writeFileSync6(BROKER_SPAWN_LOCK, owner, { flag: "wx" });
       return owner;
     } catch (error) {
       if (!(error instanceof Error) || error.code !== "EEXIST") {
@@ -63762,7 +64256,7 @@ ${Date.now()}
       }
       if (isSpawnLockStale()) {
         try {
-          unlinkSync3(BROKER_SPAWN_LOCK);
+          unlinkSync4(BROKER_SPAWN_LOCK);
         } catch {}
         continue;
       }
@@ -63780,11 +64274,11 @@ function isProcessAlive(pid) {
   }
 }
 function isSpawnLockStale(lockPath = BROKER_SPAWN_LOCK, nowMs = Date.now()) {
-  if (!existsSync5(lockPath)) {
+  if (!existsSync6(lockPath)) {
     return false;
   }
   try {
-    const [spawnerLine = "", createdAtLine = "", brokerLine = ""] = readFileSync3(lockPath, "utf-8").trim().split(`
+    const [spawnerLine = "", createdAtLine = "", brokerLine = ""] = readFileSync5(lockPath, "utf-8").trim().split(`
 `);
     const spawnerPid = Number.parseInt(spawnerLine, 10);
     const createdAt = Number.parseInt(createdAtLine, 10);
@@ -63802,25 +64296,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);
@@ -63828,6 +64331,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;
 });
 
@@ -63852,14 +64356,14 @@ var init_reply_waiter = __esm(() => {
 });
 
 // dist/builtin/intercom/config.ts
-import { existsSync as existsSync6, readFileSync as readFileSync4 } from "fs";
+import { existsSync as existsSync7, readFileSync as readFileSync6 } from "fs";
 import { getAgentConfigPaths } from "@bastani/atomic";
 function loadConfig() {
-  if (!existsSync6(CONFIG_PATH)) {
+  if (!existsSync7(CONFIG_PATH)) {
     return { ...defaults };
   }
   try {
-    const raw = readFileSync4(CONFIG_PATH, "utf-8");
+    const raw = readFileSync6(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");
@@ -63889,6 +64393,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`);
@@ -63931,11 +64441,12 @@ var init_config = __esm(() => {
   init_diagnostics();
   init_reply_waiter();
   CONFIG_PATHS = getAgentConfigPaths("intercom", "config.json");
-  CONFIG_PATH = CONFIG_PATHS.find((path) => existsSync6(path)) ?? CONFIG_PATHS[0];
+  CONFIG_PATH = CONFIG_PATHS.find((path) => existsSync7(path)) ?? CONFIG_PATHS[0];
   DEFAULT_BROKER_ARGS = ["--no-install", "tsx"];
   defaults = {
     brokerCommand: DEFAULT_BROKER_COMMAND,
     brokerArgs: [...DEFAULT_BROKER_ARGS],
+    brokerStartupTimeoutMs: BROKER_READY_TIMEOUT_MS,
     confirmSend: false,
     maxPendingAsks: DEFAULT_MAX_PENDING_REPLY_WAITS,
     replyHint: true
@@ -63956,7 +64467,7 @@ var init_reconnect_backoff = __esm(() => {
 });
 
 // dist/builtin/intercom/workflow-route-owner.ts
-import { randomUUID as randomUUID14 } from "node:crypto";
+import { randomUUID as randomUUID16 } from "node:crypto";
 import { createEventBus, getBuiltinPackagePaths } from "@bastani/atomic";
 function closedError() {
   return new Error("Workflow Intercom route owner closed");
@@ -63964,7 +64475,7 @@ function closedError() {
 function createWorkflowRouteOwner(cwd) {
   const events = createEventBus();
   const config = loadConfig();
-  const id = randomUUID14();
+  const id = randomUUID16();
   const routes = new Map;
   const connections = new Map;
   const isCurrent = (state) => routes.get(state.route.runId) === state;
@@ -64028,7 +64539,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}`, {
@@ -64486,12 +64997,12 @@ var init_sql_pool_usage = __esm(() => {
 
 // dist/builtin/workflows/src/workers/pooled-watch-trace.ts
 import { appendFileSync as appendFileSync2 } from "node:fs";
-import { dirname as dirname12, join as join28, resolve as resolve11 } from "node:path";
+import { dirname as dirname13, join as join29, resolve as resolve12 } from "node:path";
 function configurePooledWatchTrace(journalPath, processRole) {
   if (setting === undefined || setting === "" || setting === "0")
     return;
   role = processRole;
-  file = setting === "1" ? join28(dirname12(resolve11(journalPath)), "pooled-watch-trace.jsonl") : resolve11(setting);
+  file = setting === "1" ? join29(dirname13(resolve12(journalPath)), "pooled-watch-trace.jsonl") : resolve12(setting);
 }
 function tracePooledWatch(step, detail) {
   if (file === undefined)
@@ -64672,10 +65183,10 @@ 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 randomUUID17 } 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";
+import { dirname as dirname14, join as join30, resolve as resolve13 } from "node:path";
 import { setTimeout as delay2 } from "node:timers/promises";
 function isRootLeaseLost(error) {
   return error instanceof StaleLeaseError || error.message.startsWith("Stale lease for run ");
@@ -64684,7 +65195,7 @@ function unconfirmedCleanup(groups) {
   return new Error(`Local worker process cleanup unconfirmed; ${groups.length > 0 ? `process groups ${groups.join(", ")} still running after SIGKILL; ` : ""}permits quarantined`);
 }
 function workerLogDirectory(journalPath, root) {
-  return join29(dirname13(resolve12(journalPath)), "worker-logs", encodeURIComponent(root).replaceAll(".", "%2E"));
+  return join30(dirname14(resolve13(journalPath)), "worker-logs", encodeURIComponent(root).replaceAll(".", "%2E"));
 }
 function token(work) {
   return {
@@ -64897,6 +65408,9 @@ class PoolCoordinator {
   lease;
   options;
   journal;
+  durable;
+  remote;
+  mirrorTimer;
   queue;
   usageLedger;
   usageTotal;
@@ -64929,6 +65443,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") {
@@ -65018,11 +65533,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)
@@ -65155,7 +65680,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 = randomUUID17();
       slot.deliveries.set(id, { resolve, reject });
       slot.child.send({ id: workerRequest, delivery: { id, from: payload.from, message: payload.message } }, (error) => {
         if (error) {
@@ -65496,18 +66021,22 @@ 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 = randomUUID17();
     this.incarnations.set(worker, child);
     const slot = { worker, child, deliveries: new Map, runs: new Set, stageCommands: new Map };
     this.slots.add(slot);
     let ready = false;
     let serial = Promise.resolve();
-    const logPath = join29(this.logDirectory, `${worker}.log`);
+    const logPath = join30(this.logDirectory, `${worker}.log`);
     this.logs.set(child, logPath);
     let logFailure;
     const log = createWriteStream(logPath, { flags: "a" });
@@ -65902,6 +66431,7 @@ class PoolCoordinator {
     this.closed = true;
     clearInterval(this.ticker);
     clearInterval(this.recoveryTimer);
+    clearInterval(this.mirrorTimer);
     this.rateLimitOutbox.close();
     let failure;
     let stopping = [];
@@ -65954,8 +66484,10 @@ function childRetryLimit(work, reason) {
   const exportName = work.definition.slice(work.definition.lastIndexOf("#") + 1);
   return `Local worker retry limit: child ${work.childRunId} (${exportName}) ${reason} ${MAX_CHILD_ATTEMPTS} times`;
 }
-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();
@@ -65966,6 +66498,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();
@@ -66780,7 +67313,7 @@ class StageToolExecutionBuffer {
 }
 
 // dist/builtin/workflows/src/workers/pooled-stage-handle.ts
-import { randomUUID as randomUUID16 } from "node:crypto";
+import { randomUUID as randomUUID18 } from "node:crypto";
 
 class PooledStageHandle {
   runId;
@@ -67098,7 +67631,7 @@ class PooledStageHandle {
       return Promise.reject(new PooledStageDeliveryError("StageNotLive", this.stageName));
     const outcome = Promise.withResolvers();
     const entry = {
-      op: randomUUID16(),
+      op: randomUUID18(),
       text,
       intent,
       ...options === undefined ? {} : { options },
@@ -67556,8 +68089,8 @@ 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 { resolve as resolve13 } from "node:path";
+import { randomUUID as randomUUID19 } from "node:crypto";
+import { resolve as resolve14 } from "node:path";
 import { setTimeout as delay3 } from "node:timers/promises";
 import { fileURLToPath as fileURLToPath5 } from "node:url";
 import {
@@ -67741,8 +68274,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;
@@ -67759,6 +68291,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),
@@ -67767,7 +68300,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) || resolve14(this.options.journalPath) !== resolve14(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;
@@ -67850,7 +68396,7 @@ class LocalWorkerPool {
       return { ok: false, refusal: "PoolClosed" };
     if (this.coordinator === undefined)
       return { ok: false, refusal: "StageNotOnWorker" };
-    const watch = randomUUID17();
+    const watch = randomUUID19();
     this.stageWatches.set(watch, listener);
     try {
       const result = await this.command({ kind: "stage-watch", watch, ...ref });
@@ -68734,6 +69280,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();
@@ -68748,6 +69295,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();
@@ -68757,7 +69305,7 @@ var init_local_pool = __esm(() => {
 });
 
 // dist/builtin/workflows/src/workers/public-pool.ts
-import { resolve as resolve14 } from "node:path";
+import { resolve as resolve15 } from "node:path";
 import { isDeepStrictEqual as isDeepStrictEqual2 } from "node:util";
 async function restoreWorkerOptions(backend, options) {
   const source = options.continuation?.source.id ?? options.runId;
@@ -68789,29 +69337,50 @@ 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,
     startupTimeoutMs: undefined,
     leaseMs: undefined,
-    definitions: options.localWorkers.definitions.map((source) => ({ ...source, path: resolve14(cwd, source.path) }))
+    definitions: options.localWorkers.definitions.map((source) => ({ ...source, path: resolve15(cwd, source.path) }))
   };
   const admission = options.admission && {
     ...options.admission,
-    ...options.admission.userDatabase ? { userDatabase: resolve14(cwd, options.admission.userDatabase) } : {}
+    ...options.admission.userDatabase ? { userDatabase: resolve15(cwd, options.admission.userDatabase) } : {}
   };
+  if (durable !== undefined && admission?.userLimits) {
+    if (admission.userDatabase !== undefined && admission.userDatabase !== resolve15(poolPath))
+      throw new Error(`admission.userDatabase must be omitted, or ${resolve15(poolPath)}, for a journal that is not a local SQLite file`);
+    admission.userDatabase = resolve15(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"
@@ -68821,7 +69390,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 ?? {},
@@ -68838,13 +69408,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();
 });
 
@@ -69304,7 +69873,7 @@ var init_run_budget = __esm(() => {
 });
 
 // dist/builtin/workflows/src/engine/primitives/parallel.ts
-import { randomUUID as randomUUID18 } from "node:crypto";
+import { randomUUID as randomUUID20 } from "node:crypto";
 function createParallelPrimitive(input) {
   return async (steps, options = {}) => {
     input.runtime.exit.throwIfWorkflowExitSelected();
@@ -69312,7 +69881,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 ? randomUUID20() : undefined;
     const resolveAutoGroup = (value2) => value2.group === true && autoGroup ? { ...value2, group: autoGroup } : value2;
     const resolvedOptions = resolveAutoGroup(normalizedOptions);
     const resolvedSteps = normalizedSteps.map(resolveAutoGroup);
@@ -70196,8 +70765,8 @@ function hasUsableContentBlock(block) {
 }
 
 // dist/builtin/workflows/src/shared/stage-session-store.ts
-import { randomUUID as randomUUID19 } from "node:crypto";
-import { dirname as dirname14, resolve as resolve15 } from "node:path";
+import { randomUUID as randomUUID21 } from "node:crypto";
+import { dirname as dirname15, resolve as resolve16 } from "node:path";
 import {
   JsonlSessionStore,
   resolveSessionStore,
@@ -70218,7 +70787,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 = randomUUID21();
   await destination.create({
     id,
     version: 4,
@@ -70233,11 +70802,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 = resolve15(sessionFile);
-  const legacy = await JsonlSessionStore.open(dirname14(location), { exactDirectory: true, scanExisting: false });
+  const location = resolve16(sessionFile);
+  const legacy = await JsonlSessionStore.open(dirname15(location), { exactDirectory: true, scanExisting: false });
   try {
     for await (const file of legacy.scanFiles()) {
-      if (resolve15(file.location) !== location || file.header.id !== sessionId)
+      if (resolve16(file.location) !== location || file.header.id !== sessionId)
         continue;
       const snapshot = await file.read();
       if (await store.readHeader(sessionId) === undefined)
@@ -70253,6 +70822,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
@@ -76713,9 +77283,9 @@ var init_stage_runner_controller = __esm(() => {
 });
 
 // dist/builtin/workflows/src/runs/foreground/stage-runner-output.ts
-import { createHash as createHash5 } from "node:crypto";
+import { createHash as createHash6 } from "node:crypto";
 import { mkdir as mkdir7, writeFile as writeFile10 } from "node:fs/promises";
-import { basename as basename5, dirname as dirname15, isAbsolute as isAbsolute11, join as join30, resolve as resolve16 } from "node:path";
+import { basename as basename6, dirname as dirname16, isAbsolute as isAbsolute11, join as join31, resolve as resolve17 } from "node:path";
 function normalizeMaxOutput2(maxOutput) {
   return {
     bytes: maxOutput?.bytes ?? DEFAULT_MAX_OUTPUT_BYTES,
@@ -76777,8 +77347,8 @@ function formatByteSize(bytes) {
   return `${value2.toFixed(1)} ${units[unitIndex]}`;
 }
 function transcriptPath(runId, outputPath) {
-  const digest = createHash5("sha256").update(outputPath).digest("hex").slice(0, 16);
-  return join30(workflowArtifactRunPath(runId), "transcripts", `${digest}-${basename5(outputPath)}.transcript.md`);
+  const digest = createHash6("sha256").update(outputPath).digest("hex").slice(0, 16);
+  return join31(workflowArtifactRunPath(runId), "transcripts", `${digest}-${basename6(outputPath)}.transcript.md`);
 }
 function appendContent(lines, content) {
   if (typeof content === "string") {
@@ -76823,7 +77393,7 @@ function renderTranscript(messages, fallbackOutput) {
 `);
 }
 function savedOutputReference(outputPath, fullOutput, transcriptPathValue, transcriptText, transcriptAvailable, warning) {
-  const absolutePath = resolve16(outputPath);
+  const absolutePath = resolve17(outputPath);
   const bytes = Buffer.byteLength(fullOutput, "utf8");
   const lines = countLines(fullOutput);
   const transcriptBytes = Buffer.byteLength(transcriptText, "utf8");
@@ -76838,8 +77408,8 @@ function resolveOutputPath(output, runtimeCwd, requestedCwd) {
     return;
   if (isAbsolute11(output))
     return output;
-  const baseCwd = requestedCwd === undefined ? runtimeCwd : isAbsolute11(requestedCwd) ? requestedCwd : resolve16(runtimeCwd, requestedCwd);
-  return resolve16(baseCwd, output);
+  const baseCwd = requestedCwd === undefined ? runtimeCwd : isAbsolute11(requestedCwd) ? requestedCwd : resolve17(runtimeCwd, requestedCwd);
+  return resolve17(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;
@@ -76898,7 +77468,7 @@ async function finalizePromptOutput(fullOutput, outputOptions, runtimeCwd, runId
   const transcriptFile = transcriptPath(runId, outputPath);
   const transcript = renderTranscript(messages, fullOutput);
   try {
-    await mkdir7(dirname15(outputPath), { recursive: true });
+    await mkdir7(dirname16(outputPath), { recursive: true });
     await writeFile10(outputPath, fullOutput, "utf8");
   } catch (err) {
     return `${displayOutput}
@@ -76910,7 +77480,7 @@ ${err instanceof Error ? err.message : String(err)}`;
   let transcriptError;
   try {
     await ensureWorkflowArtifactRunDirectory(runId);
-    await mkdir7(dirname15(transcriptFile), { recursive: true });
+    await mkdir7(dirname16(transcriptFile), { recursive: true });
     await writeFile10(transcriptFile, transcript, "utf8");
     transcriptAvailable = true;
   } catch (err) {
@@ -78941,7 +79511,7 @@ var init_executor = __esm(() => {
 });
 
 // dist/builtin/workflows/src/runs/foreground/sdk-run.ts
-import { randomUUID as randomUUID20 } from "node:crypto";
+import { randomUUID as randomUUID22 } from "node:crypto";
 async function run2(def, inputs, callerOpts = {}) {
   let opts = callerOpts;
   const store2 = opts.store === undefined || opts.store === store ? currentWorkflowStore() : opts.store;
@@ -78952,7 +79522,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 ?? randomUUID22();
   if (sourceRunId !== undefined || opts.localWorkers || opts.admission) {
     opts = await restoreWorkerOptions(backend, { ...opts, runId });
   }