@bastani/atomic 0.9.40-alpha.2 → 0.9.41-alpha.1

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

@@ -145,13 +145,26 @@ function isRecoverableIntercomDisconnect(error) {
       return false;
     if (current instanceof IntercomClientDisconnectedError)
       return true;
+    if (current instanceof IntercomBrokerTimeoutError)
+      return true;
     if (current instanceof IntercomLiveRouteRefusedError)
       return current.transient;
     current = current.cause;
   }
   return false;
 }
-var RECOVERABLE_DISCONNECT_MESSAGE = "Client disconnected", MAX_CAUSE_DEPTH = 8, IntercomClientDisconnectedError;
+function isIntercomBrokerTimeout(error) {
+  let current = error;
+  for (let depth = 0;depth <= MAX_CAUSE_DEPTH; depth += 1) {
+    if (!(current instanceof Error))
+      return false;
+    if (current instanceof IntercomBrokerTimeoutError)
+      return true;
+    current = current.cause;
+  }
+  return false;
+}
+var RECOVERABLE_DISCONNECT_MESSAGE = "Client disconnected", MAX_CAUSE_DEPTH = 8, IntercomClientDisconnectedError, IntercomBrokerTimeoutError;
 var init_recoverable_disconnect = __esm(() => {
   init_live_route_refusal();
   IntercomClientDisconnectedError = class IntercomClientDisconnectedError extends Error {
@@ -161,6 +174,13 @@ var init_recoverable_disconnect = __esm(() => {
       this.name = "IntercomClientDisconnectedError";
     }
   };
+  IntercomBrokerTimeoutError = class IntercomBrokerTimeoutError extends Error {
+    intercomRecoverableDisconnect = true;
+    constructor(message, options) {
+      super(message, options);
+      this.name = "IntercomBrokerTimeoutError";
+    }
+  };
 });
 
 // dist/builtin/intercom/retry-policy.ts
@@ -177,6 +197,10 @@ var init_retry_policy = __esm(() => {
 function reconnectDelayMs(attempt) {
   return BACKOFF_MS[Math.min(attempt, BACKOFF_MS.length - 1)];
 }
+function jitteredReconnectDelayMs(attempt, random = Math.random) {
+  const ceiling = reconnectDelayMs(attempt);
+  return Math.round(ceiling / 2 + ceiling / 2 * random());
+}
 var BACKOFF_MS;
 var init_reconnect_backoff = __esm(() => {
   BACKOFF_MS = [1000, 2000, 5000, 1e4, 30000];
@@ -838,7 +862,7 @@ 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, GROUP_REQUEST_TIMEOUT_MS = 5000, PRESENCE_ACK_TIMEOUT_MS = 5000, RESTORING_RECIPIENT_REQUEST_TIMEOUT_MS = 5000, HELD_SEND_GRACE_MS = 5000, IntercomClient;
+var BROKER_SOCKET, BROKER_CONNECT_TIMEOUT_MS = 1e4, PENDING_STAGE_ROUTE_ACK_TIMEOUT_MS = 1e4, GROUP_REQUEST_TIMEOUT_MS = 5000, PRESENCE_ACK_TIMEOUT_MS = 5000, RESTORING_RECIPIENT_REQUEST_TIMEOUT_MS = 5000, HELD_SEND_GRACE_MS = 5000, IntercomClient;
 var init_client = __esm(() => {
   init_paths();
   init_pending_send_registry();
@@ -851,7 +875,9 @@ var init_client = __esm(() => {
     returnAddress;
     preferredSessionId;
     acknowledgesReceipt;
+    connectTimeoutMs;
     brokerAcknowledgesReceipt = false;
+    brokerAcknowledgesPendingStageRoutes = false;
     socket = null;
     _sessionId = null;
     _supervisorSessionId = null;
@@ -864,6 +890,7 @@ var init_client = __esm(() => {
     pendingMemberships = new Map;
     _groups = normalizeGroups();
     pendingLiveWorkflowStageRoutes = new Map;
+    pendingStageRouteRegistrations = new Map;
     pendingSupervisorAuthorizations = new Map;
     pendingRestoringRecipientRequests = new Map;
     disconnecting = false;
@@ -875,6 +902,7 @@ var init_client = __esm(() => {
       this.returnAddress = returnAddress;
       this.preferredSessionId = options.preferredSessionId;
       this.acknowledgesReceipt = options.acknowledgesReceipt === true;
+      this.connectTimeoutMs = options.connectTimeoutMs ?? BROKER_CONNECT_TIMEOUT_MS;
     }
     failPending(error) {
       this.pendingSends.rejectAll(error);
@@ -892,6 +920,8 @@ var init_client = __esm(() => {
         pending.reject(error);
       for (const pending of this.pendingLiveWorkflowStageRoutes.values())
         pending.reject(error);
+      for (const pending of this.pendingStageRouteRegistrations.values())
+        pending.reject(error);
       this.pendingLists.clear();
       this.pendingGroupLists.clear();
       this.pendingSupervisorAuthorizations.clear();
@@ -899,6 +929,7 @@ var init_client = __esm(() => {
       this.pendingPresence.clear();
       this.pendingMemberships.clear();
       this.pendingLiveWorkflowStageRoutes.clear();
+      this.pendingStageRouteRegistrations.clear();
     }
     get sessionId() {
       return this._sessionId;
@@ -945,9 +976,9 @@ var init_client = __esm(() => {
               this.socket = null;
             }
             socket.destroy();
-            reject(new Error("Connection timeout"));
+            reject(new IntercomBrokerTimeoutError("Connection timeout"));
           }
-        }, 1e4);
+        }, this.connectTimeoutMs);
         let connectionEstablished = false;
         const onRegistered = () => {
           settled = true;
@@ -980,6 +1011,7 @@ var init_client = __esm(() => {
           this._sessionId = null;
           this._supervisorSessionId = null;
           this.brokerAcknowledgesReceipt = false;
+          this.brokerAcknowledgesPendingStageRoutes = false;
           this._messageSource = undefined;
           this.disconnectError = null;
           if (connectionEstablished && !wasDisconnecting) {
@@ -1057,7 +1089,7 @@ var init_client = __esm(() => {
       }
       switch (brokerMessage.type) {
         case "registered": {
-          if (typeof brokerMessage.sessionId !== "string" || brokerMessage.supervisorSessionId !== undefined && typeof brokerMessage.supervisorSessionId !== "string" || brokerMessage.acknowledgesReceipt !== undefined && brokerMessage.acknowledgesReceipt !== true) {
+          if (typeof brokerMessage.sessionId !== "string" || brokerMessage.supervisorSessionId !== undefined && typeof brokerMessage.supervisorSessionId !== "string" || brokerMessage.acknowledgesReceipt !== undefined && brokerMessage.acknowledgesReceipt !== true || brokerMessage.acknowledgesPendingStageRoutes !== undefined && brokerMessage.acknowledgesPendingStageRoutes !== true) {
             throw new Error("Invalid registered message");
           }
           if (this._sessionId !== null) {
@@ -1066,6 +1098,7 @@ var init_client = __esm(() => {
           this._sessionId = brokerMessage.sessionId;
           this._supervisorSessionId = typeof brokerMessage.supervisorSessionId === "string" ? brokerMessage.supervisorSessionId : null;
           this.brokerAcknowledgesReceipt = this.acknowledgesReceipt && brokerMessage.acknowledgesReceipt === true;
+          this.brokerAcknowledgesPendingStageRoutes = brokerMessage.acknowledgesPendingStageRoutes === true;
           this.emit("_registered", { type: "registered", sessionId: brokerMessage.sessionId });
           break;
         }
@@ -1093,8 +1126,8 @@ var init_client = __esm(() => {
           break;
         }
         case "sessions": {
-          const { requestId, sessions, workflowStages, workflowFutureStages } = brokerMessage;
-          if (typeof requestId !== "string" || !Array.isArray(sessions) || !sessions.every(isSessionInfo) || workflowStages !== undefined && !isWorkflowStageRosterEntries(workflowStages) || workflowFutureStages !== undefined && !isWorkflowFutureStageRosterEntries(workflowFutureStages)) {
+          const { requestId, sessions, workflowStages, workflowFutureStages, restricted } = brokerMessage;
+          if (typeof requestId !== "string" || !Array.isArray(sessions) || !sessions.every(isSessionInfo) || workflowStages !== undefined && !isWorkflowStageRosterEntries(workflowStages) || workflowFutureStages !== undefined && !isWorkflowFutureStageRosterEntries(workflowFutureStages) || restricted !== undefined && restricted !== true) {
             throw new Error("Invalid sessions message");
           }
           const pending = this.pendingLists.get(requestId);
@@ -1104,7 +1137,8 @@ var init_client = __esm(() => {
           pending.resolve({
             sessions,
             workflowStages: workflowStages ?? [],
-            workflowFutureStages: workflowFutureStages ?? []
+            workflowFutureStages: workflowFutureStages ?? [],
+            ...restricted === true ? { restricted: true } : {}
           });
           break;
         }
@@ -1189,6 +1223,17 @@ var init_client = __esm(() => {
           this.emit("pending_stage_route_revoked", { runId });
           break;
         }
+        case "pending_stage_route_registered": {
+          const { requestId } = brokerMessage;
+          if (typeof requestId !== "string")
+            throw new Error("Invalid pending-stage route registration acknowledgement");
+          const pending = this.pendingStageRouteRegistrations.get(requestId);
+          if (!pending)
+            return;
+          this.pendingStageRouteRegistrations.delete(requestId);
+          pending.resolve();
+          break;
+        }
         case "live_workflow_stage_route_registered": {
           const { requestId } = brokerMessage;
           if (typeof requestId !== "string")
@@ -1602,6 +1647,59 @@ var init_client = __esm(() => {
         ...dormant === true ? { dormant: true } : {}
       });
     }
+    registerPendingStageRouteAcknowledged(runId, group, capability, stages, possibleStages, parent, dormant) {
+      let socket;
+      try {
+        socket = this.requireActiveSocket();
+      } catch (error) {
+        return Promise.reject(toError(error));
+      }
+      if (!this.brokerAcknowledgesPendingStageRoutes) {
+        try {
+          this.registerPendingStageRoute(runId, group, capability, stages, possibleStages, parent, dormant);
+        } catch (error) {
+          return Promise.reject(toError(error));
+        }
+        return this.listSessions().then(() => {
+          return;
+        });
+      }
+      return new Promise((resolve, reject) => {
+        const requestId = randomUUID2();
+        const timeout = setTimeout(() => {
+          if (!this.pendingStageRouteRegistrations.delete(requestId))
+            return;
+          reject(new IntercomBrokerTimeoutError("Pending-stage route registration timeout"));
+        }, PENDING_STAGE_ROUTE_ACK_TIMEOUT_MS);
+        this.pendingStageRouteRegistrations.set(requestId, {
+          resolve: () => {
+            clearTimeout(timeout);
+            resolve();
+          },
+          reject: (error) => {
+            clearTimeout(timeout);
+            reject(error);
+          }
+        });
+        try {
+          writeMessage(socket, {
+            type: "register_pending_stage_route",
+            requestId,
+            runId,
+            group,
+            capability,
+            stages,
+            possibleStages,
+            ...parent === undefined ? {} : { parent },
+            ...dormant === true ? { dormant: true } : {}
+          });
+        } catch (error) {
+          clearTimeout(timeout);
+          this.pendingStageRouteRegistrations.delete(requestId);
+          reject(toError(error));
+        }
+      });
+    }
     registerLiveWorkflowStageRoute(runId, stageKeys, capability) {
       let socket;
       try {
@@ -3973,8 +4071,10 @@ ${lines.join(`
                   ...peeked.workflowStages.map(formatWorkflowStageRow),
                   ...(peeked.workflowFutureStages ?? []).map(formatWorkflowFutureStageRow)
                 ];
-                const section = rows.length === 0 ? `**Group [${requestedGroup}] (read-only peek):**
-No sessions or workflow stages in this group.` : `**Group [${requestedGroup}] (read-only peek):**
+                const heading = `**Group [${requestedGroup}] (read-only peek):**`;
+                const section = peeked.restricted === true ? `${heading}
+Workflow group ${requestedGroup} is visible only to its members. Join it with \`intercom join\` to list its stages.` : rows.length === 0 ? `${heading}
+No sessions or workflow stages in this group.` : `${heading}
 ${rows.join(`
 `)}`;
                 return {
@@ -3987,7 +4087,8 @@ ${section}` }],
                     groups: ownGroups,
                     peekGroup: requestedGroup,
                     workflowStages: peeked.workflowStages,
-                    ...(peeked.workflowFutureStages?.length ?? 0) === 0 ? {} : { workflowFutureStages: peeked.workflowFutureStages }
+                    ...(peeked.workflowFutureStages?.length ?? 0) === 0 ? {} : { workflowFutureStages: peeked.workflowFutureStages },
+                    ...peeked.restricted === true ? { restricted: true } : {}
                   }
                 };
               }
@@ -6917,6 +7018,63 @@ function clearRuntimeIntercomGroup(sessionId) {
 }
 var init_runtime_group = () => {};
 
+// dist/builtin/intercom/route-retry-waiters.ts
+class RouteRetryWaiters {
+  pending = null;
+  join() {
+    this.pending ??= Promise.withResolvers();
+    return this.pending.promise;
+  }
+  succeed() {
+    this.settle()?.resolve();
+  }
+  fail(error) {
+    this.settle()?.reject(error);
+  }
+  settle() {
+    const pending = this.pending;
+    this.pending = null;
+    return pending;
+  }
+}
+function scheduledRetryFailure(error) {
+  if (isIntercomBrokerTimeout(error) || !isRecoverableIntercomDisconnect(error))
+    return error;
+  return new IntercomBrokerTimeoutError("Connection timeout: the run's route registration retry did not complete", {
+    cause: error
+  });
+}
+var init_route_retry_waiters = __esm(() => {
+  init_recoverable_disconnect();
+});
+
+// dist/builtin/intercom/route-connect-gate.ts
+function createConcurrencyGate(limit) {
+  let active = 0;
+  const waiting = [];
+  const release = () => {
+    const next = waiting.shift();
+    if (next === undefined)
+      active -= 1;
+    else
+      next();
+  };
+  return {
+    async run(operation) {
+      if (active < limit)
+        active += 1;
+      else
+        await new Promise((resolve) => waiting.push(resolve));
+      try {
+        return await operation();
+      } finally {
+        release();
+      }
+    }
+  };
+}
+var ROUTE_CLIENT_CONNECT_CONCURRENCY = 4;
+
 // dist/builtin/intercom/released-stage-peers.ts
 function isReleasedStageAnnouncement(value) {
   const route = value;
@@ -7207,6 +7365,7 @@ function piIntercomExtension(pi, testOverrides = {}) {
   const inboundDeliveries = new InboundMessageAdmission;
   const pendingStageRoutes = new Map;
   const pendingStageRouteClients = new Map;
+  const routeClientConnectGate = createConcurrencyGate(ROUTE_CLIENT_CONNECT_CONCURRENCY);
   const supervisorAuthorizations = new SupervisorAuthorizationRegistry;
   const releasedStagePeers = new ReleasedStagePeers({
     prepare: () => spawnBrokerIfNeeded(config.brokerCommand, config.brokerArgs),
@@ -7756,17 +7915,35 @@ function piIntercomExtension(pi, testOverrides = {}) {
   function pendingStageRouteClientIsCurrent(runId, state, context = runtimeContext, generation = runtimeGeneration) {
     return pendingStageRouteClients.get(runId) === state && samePendingStageRoute(pendingStageRoutes.get(runId), state.route) && Boolean(getLiveContext(context, generation));
   }
+  function endPendingStageRouteBackoff(state, failure) {
+    if (state.reconnectTimer)
+      clearTimeout(state.reconnectTimer);
+    state.reconnectTimer = null;
+    if (failure === undefined)
+      state.retryWaiters.succeed();
+    else
+      state.retryWaiters.fail(failure);
+  }
   function schedulePendingStageRouteReconnect(runId, state) {
     if (state.reconnectTimer || state.promise || !pendingStageRouteClientIsCurrent(runId, state))
       return;
     const scheduledGeneration = runtimeGeneration;
     state.reconnectTimer = setTimeout(() => {
       state.reconnectTimer = null;
-      if (!pendingStageRouteClientIsCurrent(runId, state, runtimeContext, scheduledGeneration))
+      if (!pendingStageRouteClientIsCurrent(runId, state, runtimeContext, scheduledGeneration)) {
+        endPendingStageRouteBackoff(state, new IntercomClientDisconnectedError);
         return;
+      }
       state.reconnectAttempt += 1;
-      ensurePendingStageRouteClient(runId, state.route).catch(() => {});
-    }, reconnectDelayMs(state.reconnectAttempt));
+      ensurePendingStageRouteClient(runId, state.route).then(() => {
+        state.retryWaiters.succeed();
+        pi.events.emit(ROUTE_RETRY_OUTCOME_EVENT, { runId });
+      }, (error) => {
+        const failure = toError3(error);
+        state.retryWaiters.fail(scheduledRetryFailure(failure));
+        pi.events.emit(ROUTE_RETRY_OUTCOME_EVENT, { runId, error: failure });
+      });
+    }, jitteredReconnectDelayMs(state.reconnectAttempt));
   }
   function attachPendingStageRouteClientHandlers(runId, state, nextClient) {
     nextClient.on("pending_stage_message", (request) => {
@@ -7787,9 +7964,7 @@ function piIntercomExtension(pi, testOverrides = {}) {
       if (notice.runId !== runId || state.client !== nextClient)
         return;
       state.client = null;
-      if (state.reconnectTimer)
-        clearTimeout(state.reconnectTimer);
-      state.reconnectTimer = null;
+      endPendingStageRouteBackoff(state, new IntercomClientDisconnectedError);
       if (pendingStageRouteClients.get(runId) === state)
         pendingStageRouteClients.delete(runId);
       if (samePendingStageRoute(pendingStageRoutes.get(runId), state.route))
@@ -7798,7 +7973,7 @@ function piIntercomExtension(pi, testOverrides = {}) {
       pi.events.emit(PENDING_STAGE_ROUTE_REVOKED_EVENT, { runId, capability: state.route.capability });
     });
   }
-  async function ensurePendingStageRouteClient(runId, route) {
+  async function ensurePendingStageRouteClient(runId, route, options = {}) {
     const contextAtStart = getLiveContext();
     const generationAtStart = runtimeGeneration;
     if (!contextAtStart)
@@ -7806,8 +7981,7 @@ function piIntercomExtension(pi, testOverrides = {}) {
     let existing = pendingStageRouteClients.get(runId);
     if (existing && !samePendingStageRoute(existing.route, route)) {
       pendingStageRouteClients.delete(runId);
-      if (existing.reconnectTimer)
-        clearTimeout(existing.reconnectTimer);
+      endPendingStageRouteBackoff(existing, new IntercomClientDisconnectedError);
       try {
         await existing.promise;
       } catch {}
@@ -7823,23 +7997,31 @@ function piIntercomExtension(pi, testOverrides = {}) {
       client: null,
       promise: null,
       reconnectTimer: null,
-      reconnectAttempt: 0
+      reconnectAttempt: 0,
+      retryWaiters: new RouteRetryWaiters
     };
     if (!existing)
       pendingStageRouteClients.set(runId, state);
+    state.route = route;
     if (state.client?.isConnected()) {
-      state.route = route;
-      state.client.registerPendingStageRoute(runId, normalizeGroup(route.group), route.capability, route.stages, route.possibleStages, route.parent, route.dormant === true);
-      await state.client.listSessions();
+      await state.client.registerPendingStageRouteAcknowledged(runId, normalizeGroup(route.group), route.capability, route.stages, route.possibleStages, route.parent, route.dormant === true);
       return;
     }
     if (state.promise) {
       await state.promise;
-      return ensurePendingStageRouteClient(runId, route);
+      return ensurePendingStageRouteClient(runId, route, options);
     }
-    const promise = (async () => {
+    if (state.reconnectTimer !== null && options.bypassBackoff !== true)
+      return state.retryWaiters.join();
+    const promise = routeClientConnectGate.run(async () => {
+      if (!pendingStageRouteClientIsCurrent(runId, state, contextAtStart, generationAtStart)) {
+        throw new Error("Intercom runtime no longer active");
+      }
       await spawnBrokerIfNeeded(config.brokerCommand, config.brokerArgs);
-      const nextClient = new IntercomClient(`${currentSessionId}:pending-stage-route:${runId}`);
+      const routeReturnAddress = `${currentSessionId}:pending-stage-route:${runId}`;
+      const nextClient = new IntercomClient(routeReturnAddress, {
+        connectTimeoutMs: testOverrides.connectTimeoutMs?.(routeReturnAddress)
+      });
       state.client = nextClient;
       attachPendingStageRouteClientHandlers(runId, state, nextClient);
       await nextClient.connect({ ...buildRegistration(), recipientPurpose: "control", name: undefined, groups: [normalizeGroup(route.group)], group: normalizeGroup(route.group) }, undefined, undefined, readSubagentMessageSource(runtimeContext?.subagentPolicy));
@@ -7847,14 +8029,14 @@ function piIntercomExtension(pi, testOverrides = {}) {
         await nextClient.disconnect();
         throw new Error("Intercom runtime no longer active");
       }
-      nextClient.registerPendingStageRoute(runId, normalizeGroup(route.group), route.capability, route.stages, route.possibleStages, route.parent, route.dormant === true);
-      await nextClient.listSessions();
+      await nextClient.registerPendingStageRouteAcknowledged(runId, normalizeGroup(route.group), route.capability, route.stages, route.possibleStages, route.parent, route.dormant === true);
       if (!pendingStageRouteClientIsCurrent(runId, state, contextAtStart, generationAtStart)) {
         await nextClient.disconnect();
         throw new Error("Intercom runtime no longer active");
       }
       state.reconnectAttempt = 0;
-    })();
+      endPendingStageRouteBackoff(state);
+    });
     state.promise = promise;
     try {
       await promise;
@@ -7879,8 +8061,7 @@ function piIntercomExtension(pi, testOverrides = {}) {
     const states = [...pendingStageRouteClients.values()];
     pendingStageRouteClients.clear();
     for (const state of states) {
-      if (state.reconnectTimer)
-        clearTimeout(state.reconnectTimer);
+      endPendingStageRouteBackoff(state, new IntercomClientDisconnectedError);
       try {
         await state.promise;
       } catch {}
@@ -7893,13 +8074,14 @@ function piIntercomExtension(pi, testOverrides = {}) {
     }
   }
   async function registerPendingStageRoute(activeClient, runId, route) {
-    const routeGroup = normalizeGroup(route.group);
-    if (clientRegistrationGroup === routeGroup && route.dormant !== true) {
-      activeClient.registerPendingStageRoute(runId, routeGroup, route.capability, route.stages, route.possibleStages, route.parent);
-      await activeClient.listSessions();
+    if (registersOnMainClient(route)) {
+      await activeClient.registerPendingStageRouteAcknowledged(runId, normalizeGroup(route.group), route.capability, route.stages, route.possibleStages, route.parent);
       return;
     }
-    await ensurePendingStageRouteClient(runId, { ...route, group: routeGroup });
+    await ensurePendingStageRouteClient(runId, { ...route, group: normalizeGroup(route.group) });
+  }
+  function registersOnMainClient(route) {
+    return clientRegistrationGroup === normalizeGroup(route.group) && route.dormant !== true;
   }
   function persistedIntercomSessionId(ctx, sessionId) {
     try {
@@ -7938,7 +8120,11 @@ function piIntercomExtension(pi, testOverrides = {}) {
     const nextReconnectPromise = (async () => {
       let connectFailed = false;
       await ownershipRecorded.promise;
-      const nextClient = new IntercomClient(sessionIdAtStart, { preferredSessionId, acknowledgesReceipt: true });
+      const nextClient = new IntercomClient(sessionIdAtStart, {
+        preferredSessionId,
+        acknowledgesReceipt: true,
+        connectTimeoutMs: testOverrides.connectTimeoutMs?.(sessionIdAtStart)
+      });
       client = nextClient;
       attachClientHandlers(nextClient);
       try {
@@ -7951,7 +8137,11 @@ function piIntercomExtension(pi, testOverrides = {}) {
           nextClient.updatePresence({ replyCapability: "terminal" });
         await supervisorAuthorizations.restore(nextClient);
         for (const [runId, route] of pendingStageRoutes) {
-          await registerPendingStageRoute(nextClient, runId, route);
+          if (registersOnMainClient(route)) {
+            await registerPendingStageRoute(nextClient, runId, route);
+            continue;
+          }
+          ensurePendingStageRouteClient(runId, { ...route, group: normalizeGroup(route.group) }).catch(() => {});
         }
         const orchestration = contextAtStart.orchestrationContext;
         if (orchestration?.kind === "workflow-stage" && orchestration.pendingStageDelivery !== undefined) {
@@ -8026,7 +8216,7 @@ function piIntercomExtension(pi, testOverrides = {}) {
       throw new Error("Pending workflow route is unavailable");
     if (client?.isConnected() && clientRegistrationGroup === normalizeGroup(route.group))
       return client;
-    await ensurePendingStageRouteClient(runId, route);
+    await ensurePendingStageRouteClient(runId, route, { bypassBackoff: true });
     const routeClient = pendingStageRouteClients.get(runId)?.client;
     if (!routeClient?.isConnected())
       throw new Error("Pending workflow route is disconnected");
@@ -8246,7 +8436,7 @@ function piIntercomExtension(pi, testOverrides = {}) {
     syncPresenceIdentity
   });
 }
-var INTERCOM_SESSION_ID_ENV, PENDING_STAGE_ROUTE_EVENT = "atomic:workflow-pending-stage-route", PENDING_STAGE_MESSAGE_EVENT = "atomic:workflow-pending-stage-message", PENDING_STAGE_UNDELIVERABLE_EVENT = "atomic:workflow-pending-stage-undeliverable", STICKY_LIVE_DELIVERED_EVENT = "atomic:workflow-sticky-live-delivered", PENDING_STAGE_ROUTE_REVOKED_EVENT = "atomic:workflow-pending-stage-route-revoked";
+var INTERCOM_SESSION_ID_ENV, PENDING_STAGE_ROUTE_EVENT = "atomic:workflow-pending-stage-route", PENDING_STAGE_MESSAGE_EVENT = "atomic:workflow-pending-stage-message", PENDING_STAGE_UNDELIVERABLE_EVENT = "atomic:workflow-pending-stage-undeliverable", STICKY_LIVE_DELIVERED_EVENT = "atomic:workflow-sticky-live-delivered", ROUTE_RETRY_OUTCOME_EVENT = "atomic:intercom-route-retry-outcome", PENDING_STAGE_ROUTE_REVOKED_EVENT = "atomic:workflow-pending-stage-route-revoked";
 var init_index_heavy = __esm(() => {
   init_session_recovery();
   init_client();
@@ -8275,6 +8465,8 @@ var init_index_heavy = __esm(() => {
   init_group();
   init_runtime_group();
   init_reconnect_backoff();
+  init_recoverable_disconnect();
+  init_route_retry_waiters();
   init_released_stage_peers();
   init_supervisor_authorization_registry();
   if (process.env.ATOMIC_TEST_LAZY_IMPORT_SENTINEL === "1") {
@@ -8322,8 +8514,9 @@ async function executeHeavyTool(loadHeavy, name, args) {
       if (!recoverInitialization || !isRecoverableIntercomDisconnect(error))
         throw error;
       const delayMs = RECONNECT_DELAYS_MS[retries];
-      if (delayMs === undefined)
-        return initializationFailure("Client disconnected", retries);
+      if (delayMs === undefined) {
+        return initializationFailure(isIntercomBrokerTimeout(error) ? "Connection timeout" : "Client disconnected", retries);
+      }
       try {
         await delay(delayMs, undefined, { signal: args[2] });
       } catch {
@@ -8539,6 +8732,7 @@ var SUBAGENT_SUPERVISOR_AUTHORIZATION_EVENT2 = "subagent:supervisor-authorizatio
 var WORKFLOW_STAGE_LATE_MESSAGE_EVENT = "atomic:workflow-stage-late-message";
 var PENDING_STAGE_ROUTE_EVENT2 = "atomic:workflow-pending-stage-route";
 var PENDING_STAGE_UNDELIVERABLE_EVENT2 = "atomic:workflow-pending-stage-undeliverable";
+var ROUTE_RETRY_OUTCOME_EVENT2 = "atomic:intercom-route-retry-outcome";
 var RELEASED_STAGE_EVENT2 = "atomic:workflow-released-stage";
 function isPendingStageUndeliverableRelay(value) {
   if (typeof value !== "object" || value === null)
@@ -8600,6 +8794,23 @@ function reportRelayFailure(route, eventName, error) {
   const detail = diagnosticDetail(error);
   reportDiagnostic(route, `${prefix} ${detail}`, error, "error", prefix);
 }
+var BROKER_OUTAGE_REPORT_AFTER_MS = 60000;
+
+class BrokerOutage {
+  startedAt = null;
+  reported = false;
+  timedOut(now) {
+    this.startedAt ??= now;
+    if (this.reported || now - this.startedAt < BROKER_OUTAGE_REPORT_AFTER_MS)
+      return false;
+    this.reported = true;
+    return true;
+  }
+  recovered() {
+    this.startedAt = null;
+    this.reported = false;
+  }
+}
 var WARM_UP_RETRY_ATTEMPTS = 5;
 function intercom(pi, options = {}) {
   const inheritedDelegatedSessionName = readSubagentEnv("INTERCOM_SESSION_NAME");
@@ -8612,6 +8823,15 @@ function intercom(pi, options = {}) {
   let activeLease = createLifecycleLease(nextLeaseId++);
   let replayedGeneration = 0;
   let replayAttempt = null;
+  const brokerOutage = new BrokerOutage;
+  function reportBackgroundRelayFailure(route, eventName, error) {
+    if (isIntercomBrokerTimeout(error) && brokerOutage.timedOut(Date.now())) {
+      const prefix = `Intercom broker has not answered for over ${BROKER_OUTAGE_REPORT_AFTER_MS / 1000}s; background relays keep retrying (${eventName}):`;
+      reportDiagnostic(route, `${prefix} ${diagnosticDetail(error)}`, error, "error", prefix);
+      return;
+    }
+    reportRelayFailure(route, eventName, error);
+  }
   const lifecycleForward = new SerializedLifecycleForwarder;
   const invalidatedMessage = "Intercom initialization was invalidated by session shutdown";
   const activeLifecycle = {
@@ -9106,6 +9326,18 @@ function intercom(pi, options = {}) {
     const restored = await awaitRestoredIntercomPeers(pi.events, ctx.sessionManager.getSessionId());
     return planIntercomRecoveryReplay(event.pending, peers, restored);
   });
+  pi.events.on(ROUTE_RETRY_OUTCOME_EVENT2, (payload) => {
+    const outcome = payload;
+    if (outcome?.error === undefined) {
+      brokerOutage.recovered();
+      return;
+    }
+    if (!isIntercomBrokerTimeout(outcome.error))
+      return;
+    const ctx = latestLifecycleContext();
+    const diagnosticRoute = ctx ? captureDiagnosticRoute(ctx) : shutdownDiagnosticRoute ?? "console";
+    reportBackgroundRelayFailure(diagnosticRoute, PENDING_STAGE_ROUTE_EVENT2, outcome.error);
+  });
   pi.events.on(PENDING_STAGE_UNDELIVERABLE_EVENT2, (payload) => {
     if (!isPendingStageUndeliverableRelay(payload) || payload.handled === true)
       return;
@@ -9119,7 +9351,7 @@ function intercom(pi, options = {}) {
       handle.assertCurrent();
       return forwarded.handled === true && forwarded.completion !== undefined ? await forwarded.completion : false;
     }).catch((error) => {
-      reportRelayFailure(diagnosticRoute, PENDING_STAGE_UNDELIVERABLE_EVENT2, error);
+      reportBackgroundRelayFailure(diagnosticRoute, PENDING_STAGE_UNDELIVERABLE_EVENT2, error);
       return false;
     });
   });
@@ -9145,9 +9377,9 @@ function intercom(pi, options = {}) {
       if (eventName === PENDING_STAGE_ROUTE_EVENT2 && payload && typeof payload === "object") {
         payload.completion = completion;
       }
-      completion.catch((error) => {
+      completion.then(() => brokerOutage.recovered(), (error) => {
         rejectLazyResultRelay(pi, eventName, payload, error);
-        reportRelayFailure(diagnosticRoute, eventName, error);
+        reportBackgroundRelayFailure(diagnosticRoute, eventName, error);
       });
     });
   }

package/dist/builtin/intercom/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/intercom",
-  "version": "0.9.40-alpha.2",
+  "version": "0.9.41-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": [