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

package/dist/builtin/intercom/index.bundle.mjs

@@ -153,6 +153,8 @@ function isRecoverableIntercomDisconnect(error) {
       return true;
     if (current instanceof IntercomBrokerTimeoutError)
       return true;
+    if (current instanceof IntercomBrokerRetiringError)
+      return true;
     if (current instanceof IntercomLiveRouteRefusedError)
       return current.transient;
     current = current.cause;
@@ -170,7 +172,18 @@ function isIntercomBrokerTimeout(error) {
   }
   return false;
 }
-var RECOVERABLE_DISCONNECT_MESSAGE = "Client disconnected", MAX_CAUSE_DEPTH = 8, IntercomClientDisconnectedError, IntercomBrokerTimeoutError;
+function isIntercomBrokerRetiring(error) {
+  let current = error;
+  for (let depth = 0;depth <= MAX_CAUSE_DEPTH; depth += 1) {
+    if (!(current instanceof Error))
+      return false;
+    if (current instanceof IntercomBrokerRetiringError)
+      return true;
+    current = current.cause;
+  }
+  return false;
+}
+var RECOVERABLE_DISCONNECT_MESSAGE = "Client disconnected", MAX_CAUSE_DEPTH = 8, 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 {
@@ -187,6 +200,13 @@ 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/retry-policy.ts
@@ -208,7 +228,10 @@ function jitteredReconnectDelayMs(attempt, random = Math.random) {
   const ceiling = reconnectDelayMs(attempt);
   return Math.round(ceiling / 2 + ceiling / 2 * random());
 }
-var BACKOFF_MS;
+function brokerRetiringRetryDelayMs(attempt) {
+  return Math.min(100 * 2 ** attempt, 1000);
+}
+var BACKOFF_MS, BROKER_RETIRING_RETRY_WINDOW_MS = 1e4;
 var init_reconnect_backoff = __esm(() => {
   BACKOFF_MS = [1000, 2000, 5000, 1e4, 30000];
 });
@@ -702,6 +725,9 @@ function getBrokerSpawnLockPath(agentDir = getAgentDir()) {
 function getBrokerLogPath(agentDir = getAgentDir()) {
   return join(getIntercomDirPath(agentDir), "broker.log");
 }
+function getBrokerStartAnnouncementPath(agentDir = getAgentDir()) {
+  return join(getIntercomDirPath(agentDir), "broker.starting");
+}
 function getBrokerSocketPath(platform = process.platform, agentDir = getAgentDir()) {
   if (platform === "win32") {
     return `\\\\.\\pipe\\pi-intercom-${sanitizePipeSegment(agentDir)}`;
@@ -940,9 +966,40 @@ var init_group = __esm(() => {
   RESERVED_RUNTIME_GROUPS = new Set(["true", "auto"]);
 });
 
+// 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/broker/client.ts
 import { EventEmitter } from "events";
-import net from "net";
+import net2 from "net";
 import { randomUUID as randomUUID2 } from "crypto";
 function connectAborted() {
   return new IntercomClientDisconnectedError({ cause: new Error("Disconnected before the broker connection registered") });
@@ -967,6 +1024,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));
 }
@@ -976,15 +1046,22 @@ function isWorkflowFutureStageRosterEntries(value) {
 function isWorkflowStageRosterEntries(value) {
   return Array.isArray(value) && value.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;
@@ -1152,8 +1229,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);
           }
@@ -1170,7 +1253,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;
@@ -1228,7 +1311,7 @@ var init_client = __esm(() => {
             this.emit("disconnected", disconnectError);
           }
           if (wasConnecting) {
-            reject(new Error("Connection closed before registration"));
+            reject(new ConnectionClosedBeforeRegistrationError);
           }
         };
         const onSocketError = (err) => {
@@ -1330,7 +1413,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;
@@ -2225,40 +2308,34 @@ var init_client = __esm(() => {
   };
 });
 
-// dist/builtin/intercom/broker/socket-liveness.ts
-import net2 from "net";
-function isSocketAnswering(socketPath, timeoutMs = SOCKET_PROBE_TIMEOUT_MS) {
-  return new Promise((resolve) => {
-    const socket = net2.connect(socketPath);
-    const finish = (isConnected) => {
-      clearTimeout(timeout);
-      socket.off("connect", onConnect);
-      socket.off("error", onError);
-      resolve(isConnected);
-    };
-    const onConnect = () => {
-      socket.on("error", () => {});
-      socket.end();
-      finish(true);
-    };
-    const onError = () => {
-      socket.destroy();
-      finish(false);
-    };
-    socket.on("connect", onConnect);
-    socket.on("error", onError);
-    const timeout = setTimeout(() => {
-      socket.destroy();
-      finish(false);
-    }, timeoutMs);
-  });
+// dist/builtin/intercom/broker/startup-timeout.ts
+var BROKER_READY_TIMEOUT_MS = 30000, MIN_BROKER_STARTUP_TIMEOUT_MS = 1000;
+
+// dist/builtin/intercom/broker/start-announcement.ts
+import { readFileSync, unlinkSync, writeFileSync } from "node:fs";
+function readBrokerStartAnnouncement(announcement) {
+  let text;
+  try {
+    text = readFileSync(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, existsSync, mkdirSync, openSync, readFileSync, readSync, statSync, unlinkSync, writeFileSync } from "fs";
+import { randomUUID as randomUUID3 } from "crypto";
+import { appendFileSync, chmodSync, closeSync, existsSync, mkdirSync, openSync, readFileSync as readFileSync2, readSync, statSync, unlinkSync as unlinkSync2, writeFileSync as writeFileSync2 } from "fs";
 import { join as join2, dirname } from "path";
 import { fileURLToPath } from "url";
 import { createRequire } from "module";
@@ -2347,7 +2424,7 @@ function getWindowsHiddenLauncherScript(commandLine) {
 }
 function writeWindowsHiddenLauncher(commandLine, launcherPath = getWindowsHiddenLauncherPath()) {
   ensurePrivateDirectory(dirname(launcherPath));
-  writeFileSync(launcherPath, getWindowsHiddenLauncherScript(commandLine), "utf-8");
+  writeFileSync2(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) {
@@ -2375,7 +2452,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,
@@ -2383,7 +2460,8 @@ function getBrokerSpawnOptions(extensionDir = EXTENSION_DIR, stderr = "ignore")
     cwd: extensionDir,
     env: createChildProcessEnvironment({
       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
   };
@@ -2396,7 +2474,7 @@ function resetBrokerLog(logPath = BROKER_LOG) {
     if (previous.length > 0) {
       try {
         const previousPath = `${logPath}.previous`;
-        writeFileSync(previousPath, Buffer.from(previous).subarray(-BROKER_LOG_TAIL_BYTES), { mode: 384 });
+        writeFileSync2(previousPath, Buffer.from(previous).subarray(-BROKER_LOG_TAIL_BYTES), { mode: 384 });
         if (process.platform !== "win32")
           chmodSync(previousPath, 384);
       } catch {}
@@ -2458,6 +2536,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: randomUUID3() } : undefined;
+    if (announcement !== undefined) {
+      try {
+        unlinkSync2(announcement.path);
+      } catch {}
+    }
     if (launch.kind === "windows-launcher") {
       writeWindowsHiddenLauncher(launch.launcherCommandLine, launch.launcherPath);
     }
@@ -2468,7 +2552,7 @@ async function spawnBrokerIfNeeded(brokerCommand, brokerArgs, readyTimeoutMs = B
     const logFd = launch.kind === "direct" ? openSync(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)
         closeSync(logFd);
@@ -2504,7 +2588,7 @@ ${describeBrokerLog()}`);
       };
       child.once("error", onError);
       child.once("exit", onExit);
-      waitForBroker(readyTimeoutMs).then(() => {
+      waitForBroker(readyTimeoutMs, announcement === undefined ? undefined : () => readBrokerStartAnnouncement(announcement)).then(() => {
         cleanup();
         resolve();
       }, (error) => {
@@ -2525,7 +2609,7 @@ async function isBrokerRunning() {
   if (!existsSync(BROKER_PID))
     return false;
   try {
-    const pid = parseInt(readFileSync(BROKER_PID, "utf-8").trim(), 10);
+    const pid = parseInt(readFileSync2(BROKER_PID, "utf-8").trim(), 10);
     if (!Number.isFinite(pid))
       return false;
     process.kill(pid, 0);
@@ -2550,7 +2634,7 @@ function handSpawnLockToBroker(pid, owner) {
 }
 function ownsSpawnLock(owner, lockPath = BROKER_SPAWN_LOCK) {
   try {
-    return readFileSync(lockPath, "utf-8").startsWith(owner);
+    return readFileSync2(lockPath, "utf-8").startsWith(owner);
   } catch {
     return false;
   }
@@ -2562,7 +2646,7 @@ function acquireSpawnLock() {
 ${Date.now()}
 `;
     try {
-      writeFileSync(BROKER_SPAWN_LOCK, owner, { flag: "wx" });
+      writeFileSync2(BROKER_SPAWN_LOCK, owner, { flag: "wx" });
       return owner;
     } catch (error) {
       if (!(error instanceof Error) || error.code !== "EEXIST") {
@@ -2570,7 +2654,7 @@ ${Date.now()}
       }
       if (isSpawnLockStale()) {
         try {
-          unlinkSync(BROKER_SPAWN_LOCK);
+          unlinkSync2(BROKER_SPAWN_LOCK);
         } catch {}
         continue;
       }
@@ -2592,7 +2676,7 @@ function isSpawnLockStale(lockPath = BROKER_SPAWN_LOCK, nowMs = Date.now()) {
     return false;
   }
   try {
-    const [spawnerLine = "", createdAtLine = "", brokerLine = ""] = readFileSync(lockPath, "utf-8").trim().split(`
+    const [spawnerLine = "", createdAtLine = "", brokerLine = ""] = readFileSync2(lockPath, "utf-8").trim().split(`
 `);
     const spawnerPid = Number.parseInt(spawnerLine, 10);
     const createdAt = Number.parseInt(createdAtLine, 10);
@@ -2610,25 +2694,34 @@ function releaseSpawnLock(owner, lockPath = BROKER_SPAWN_LOCK) {
   if (!ownsSpawnLock(owner, lockPath))
     return;
   try {
-    unlinkSync(lockPath);
+    unlinkSync2(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);
@@ -2636,6 +2729,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;
 });
 
@@ -2792,14 +2886,14 @@ var init_reply_waiter = __esm(() => {
 });
 
 // dist/builtin/intercom/config.ts
-import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { existsSync as existsSync2, readFileSync as readFileSync3 } from "fs";
 import { getAgentConfigPaths } from "@bastani/atomic";
 function loadConfig() {
   if (!existsSync2(CONFIG_PATH)) {
     return { ...defaults };
   }
   try {
-    const raw = readFileSync2(CONFIG_PATH, "utf-8");
+    const raw = readFileSync3(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");
@@ -2829,6 +2923,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`);
@@ -2876,6 +2976,7 @@ var init_config = __esm(() => {
   defaults = {
     brokerCommand: DEFAULT_BROKER_COMMAND,
     brokerArgs: [...DEFAULT_BROKER_ARGS],
+    brokerStartupTimeoutMs: BROKER_READY_TIMEOUT_MS,
     confirmSend: false,
     maxPendingAsks: DEFAULT_MAX_PENDING_REPLY_WAITS,
     replyHint: true
@@ -3475,7 +3576,7 @@ var init_intercom_utils = __esm(() => {
 });
 
 // dist/builtin/intercom/contact-supervisor-tool.ts
-import { randomUUID as randomUUID3 } from "crypto";
+import { randomUUID as randomUUID4 } from "crypto";
 import { Type } from "typebox";
 import { Text as Text2 } from "@earendil-works/pi-tui";
 function registerContactSupervisorTool(pi, deps) {
@@ -3675,7 +3776,7 @@ function registerContactSupervisorTool(pi, deps) {
           }
           let wait = null;
           try {
-            const questionId = randomUUID3();
+            const questionId = randomUUID4();
             const admission = beginReplyWait(sendTo, questionId, signal);
             if (!admission.ok) {
               return {
@@ -3797,7 +3898,7 @@ var init_workflow_stage_target = __esm(() => {
 });
 
 // dist/builtin/intercom/retry-identity.ts
-import { randomUUID as randomUUID4 } from "node:crypto";
+import { randomUUID as randomUUID5 } from "node:crypto";
 function operationKey(input) {
   return JSON.stringify([
     input.sessionId,
@@ -3825,8 +3926,8 @@ class RetryIdentityReservations {
     this.maxEntries = options.maxEntries ?? RETRY_IDENTITY_MAX_ENTRIES;
     this.maxReuses = options.maxReuses ?? RETRY_IDENTITY_MAX_REUSES;
     this.now = options.now ?? Date.now;
-    this.createId = options.createId ?? randomUUID4;
-    this.createToken = options.createToken ?? randomUUID4;
+    this.createId = options.createId ?? randomUUID5;
+    this.createToken = options.createToken ?? randomUUID5;
   }
   begin(input, retryToken) {
     const now = this.now();
@@ -5799,8 +5900,8 @@ import {
   existsSync as existsSync3,
   mkdirSync as mkdirSync2,
   openSync as openSync2,
-  readFileSync as readFileSync3,
-  writeFileSync as writeFileSync2
+  readFileSync as readFileSync4,
+  writeFileSync as writeFileSync3
 } from "node:fs";
 import { dirname as dirname2 } from "node:path";
 import { DatabaseSync } from "node:sqlite";
@@ -5865,13 +5966,13 @@ function prepareDurableAuthority(storagePath) {
     return;
   if (!databaseExists) {
     const key = randomBytes(AUTHORITY_KEY_BYTES);
-    writeFileSync2(keyPath, key, { flag: "wx", mode: 384 });
+    writeFileSync3(keyPath, key, { flag: "wx", mode: 384 });
     const databaseDescriptor = openSync2(storagePath, "wx", 384);
     closeSync2(databaseDescriptor);
     restrictExistingAuthorityArtifacts(storagePath, keyPath);
     return key;
   }
-  const key = readFileSync3(keyPath);
+  const key = readFileSync4(keyPath);
   if (key.length !== AUTHORITY_KEY_BYTES)
     return;
   return key;
@@ -6433,7 +6534,7 @@ var init_terminal_ordering_barrier = __esm(() => {
 
 // dist/builtin/intercom/subagent-relay.ts
 import { isStaleExtensionContextError as isStaleExtensionContextError4 } from "@bastani/atomic";
-import { randomUUID as randomUUID5 } from "crypto";
+import { randomUUID as randomUUID6 } from "crypto";
 async function dispatchRelayFallback(pi, prefix, terminalMessage, stageAdmissionKey) {
   let delivered = 0;
   try {
@@ -6465,7 +6566,7 @@ function registerSubagentRelay(pi, deps) {
         status,
         group: deps.homeGroup?.()
       },
-      message: { id: randomUUID5(), timestamp: now, content: { text: messageText } },
+      message: { id: randomUUID6(), timestamp: now, content: { text: messageText } },
       bodyText: messageText
     };
     let dispatched = false;
@@ -7705,11 +7806,11 @@ var init_released_stage_peers = __esm(() => {
 });
 
 // dist/builtin/intercom/supervisor-authorization-registry.ts
-import { randomUUID as randomUUID6 } from "node:crypto";
+import { randomUUID as randomUUID7 } from "node:crypto";
 
 class SupervisorAuthorizationRegistry {
   byCapability = new Map;
-  ownerToken = randomUUID6();
+  ownerToken = randomUUID7();
   async authorize(childName, connect) {
     const client = await connect();
     const authorization = await client.authorizeSupervisorChild(childName.trim());
@@ -7731,7 +7832,7 @@ __export(exports_index_heavy, {
   default: () => piIntercomExtension
 });
 import { APP_NAME, sessionScopedExtensionState } from "@bastani/atomic";
-import { randomUUID as randomUUID7 } from "node:crypto";
+import { randomUUID as randomUUID8 } from "node:crypto";
 import { appendFileSync as appendFileSync2 } from "node:fs";
 import { setTimeout as delay3 } from "node:timers/promises";
 function isPendingStageUndeliverableEvent(value) {
@@ -7808,7 +7909,7 @@ function piIntercomExtension(pi, testOverrides = {}) {
   const launcherCapabilityFor = (runId) => {
     let capability = launcherCapabilities.get(runId);
     if (capability === undefined) {
-      capability = randomUUID7();
+      capability = randomUUID8();
       launcherCapabilities.set(runId, capability);
     }
     return capability;
@@ -7819,7 +7920,7 @@ function piIntercomExtension(pi, testOverrides = {}) {
   const routeClientConnectGate = createConcurrencyGate(ROUTE_CLIENT_CONNECT_CONCURRENCY);
   const supervisorAuthorizations = new SupervisorAuthorizationRegistry;
   const releasedStagePeers = new ReleasedStagePeers({
-    prepare: () => spawnBrokerIfNeeded(config.brokerCommand, config.brokerArgs),
+    prepare: () => spawnBrokerIfNeeded(config.brokerCommand, config.brokerArgs, config.brokerStartupTimeoutMs),
     createClient: (returnAddress) => new IntercomClient(returnAddress),
     cwd: () => getLiveContext()?.cwd ?? process.cwd(),
     relay: (from, message, channel) => {
@@ -8490,7 +8591,7 @@ function piIntercomExtension(pi, testOverrides = {}) {
       return connection.promise;
     const owner = connection;
     const promise = routeClientConnectGate.run(async () => {
-      await spawnBrokerIfNeeded(config.brokerCommand, config.brokerArgs);
+      await spawnBrokerIfNeeded(config.brokerCommand, config.brokerArgs, config.brokerStartupTimeoutMs);
       if (pendingStageRouteConnections.get(key) !== owner)
         throw new IntercomClientDisconnectedError;
       const routeReturnAddress = `${currentSessionId}:pending-stage-route:${key}`;
@@ -8697,6 +8798,8 @@ function piIntercomExtension(pi, testOverrides = {}) {
       let connectFailed = false;
       await ownershipRecorded.promise;
       const ownerWaitDeadline = Date.now() + LIVE_ROUTE_OWNER_WAIT_MS;
+      let retiringRetries = 0;
+      let retiringDeadline;
       try {
         for (let ownerWait = 0;; ownerWait += 1) {
           const nextClient = new IntercomClient(sessionIdAtStart, {
@@ -8708,7 +8811,7 @@ function piIntercomExtension(pi, testOverrides = {}) {
           attachClientHandlers(nextClient);
           try {
             await testOverrides.beforeConnectAttempt?.(reason);
-            await spawnBrokerIfNeeded(config.brokerCommand, config.brokerArgs);
+            await spawnBrokerIfNeeded(config.brokerCommand, config.brokerArgs, config.brokerStartupTimeoutMs);
             const childMetadata = currentChildOrchestratorMetadata();
             await nextClient.connect(buildRegistration(), childMetadata?.supervisor, supervisorAuthorizations.ownerToken, readSubagentMessageSource(runtimeContext?.subagentPolicy), resolveSessionHomeGroup());
             clientRegistrationGroup = resolveSessionHomeGroup();
@@ -8756,6 +8859,14 @@ function piIntercomExtension(pi, testOverrides = {}) {
               await delay3(liveRouteOwnerRetryDelayMs(ownerWait));
               continue;
             }
+            if (isIntercomBrokerRetiring(error)) {
+              retiringDeadline ??= Date.now() + BROKER_RETIRING_RETRY_WINDOW_MS;
+              if (Date.now() < retiringDeadline && !disposed && !shuttingDown && getLiveContext(contextAtStart, generationAtStart)) {
+                await delay3(brokerRetiringRetryDelayMs(retiringRetries++));
+                if (getLiveContext(contextAtStart, generationAtStart))
+                  continue;
+              }
+            }
             connectFailed = true;
             throw toError3(error);
           }

package/dist/builtin/intercom/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/intercom",
-  "version": "0.9.54-alpha.1",
+  "version": "0.9.55-alpha.1",
   "private": true,
   "description": "Atomic extension providing a private coordination channel between parent and child agent sessions. Fork of: https://github.com/nicobailon/pi-intercom",
   "contributors": [