@bastani/atomic 0.9.43-alpha.1 → 0.9.44-alpha.1

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

@@ -99,7 +99,13 @@ function isLiveWorkflowStageRouteRefusalCode(value) {
 function isTransientLiveWorkflowStageRouteRefusal(code) {
   return TRANSIENT_REFUSAL_CODES.has(code);
 }
-var LIVE_WORKFLOW_STAGE_ROUTE_REFUSAL_CODES, LIVE_WORKFLOW_STAGE_ROUTE_REFUSAL_REASONS, TRANSIENT_REFUSAL_CODES, IntercomLiveRouteRefusedError;
+function liveRouteOwnerRetryDelayMs(attempt) {
+  return Math.min(LIVE_ROUTE_OWNER_RETRY_FIRST_MS * 2 ** attempt, LIVE_ROUTE_OWNER_RETRY_MAX_MS);
+}
+function isOwnerMissingRefusal(error) {
+  return error instanceof IntercomLiveRouteRefusedError && error.code === "owner_missing";
+}
+var LIVE_WORKFLOW_STAGE_ROUTE_REFUSAL_CODES, LIVE_WORKFLOW_STAGE_ROUTE_REFUSAL_REASONS, TRANSIENT_REFUSAL_CODES, IntercomLiveRouteRefusedError, LIVE_ROUTE_OWNER_WAIT_MS = 120000, LIVE_ROUTE_OWNER_RETRY_FIRST_MS = 250, LIVE_ROUTE_OWNER_RETRY_MAX_MS = 2000;
 var init_live_route_refusal = __esm(() => {
   LIVE_WORKFLOW_STAGE_ROUTE_REFUSAL_CODES = [
     "owner_missing",
@@ -908,7 +914,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, BROKER_CONNECT_TIMEOUT_MS = 1e4, PENDING_STAGE_ROUTE_ACK_TIMEOUT_MS = 1e4, GROUP_REQUEST_TIMEOUT_MS = 5000, PRESENCE_ACK_TIMEOUT_MS = 5000, RESTORING_RECIPIENT_REQUEST_TIMEOUT_MS = 5000, HELD_SEND_GRACE_MS = 5000, IntercomClient;
+var BROKER_SOCKET, BROKER_CONNECT_TIMEOUT_MS = 1e4, PENDING_STAGE_ROUTE_ACK_TIMEOUT_MS = 1e4, GROUP_REQUEST_TIMEOUT_MS = 5000, PRESENCE_ACK_TIMEOUT_MS = 5000, RESTORING_RECIPIENT_REQUEST_TIMEOUT_MS = 5000, HELD_SEND_GRACE_MS = 5000, IntercomPendingStageRouteRefusedError, PENDING_STAGE_ROUTE_REFUSAL_CODES, IntercomClient;
 var init_client = __esm(() => {
   init_paths();
   init_pending_send_registry();
@@ -917,6 +923,21 @@ var init_client = __esm(() => {
   init_live_route_refusal();
   init_retry_policy();
   BROKER_SOCKET = getBrokerSocketPath();
+  IntercomPendingStageRouteRefusedError = class IntercomPendingStageRouteRefusedError extends Error {
+    connectionKept;
+    code;
+    constructor(reason, refusal = { connectionKept: false }) {
+      super(reason);
+      this.name = "IntercomPendingStageRouteRefusedError";
+      this.connectionKept = refusal.connectionKept;
+      this.code = refusal.code;
+    }
+  };
+  PENDING_STAGE_ROUTE_REFUSAL_CODES = new Set([
+    "not_authorized",
+    "invalid_stage_roster",
+    "invalid_possible_stage_roster"
+  ]);
   IntercomClient = class IntercomClient extends EventEmitter {
     returnAddress;
     preferredSessionId;
@@ -924,6 +945,8 @@ var init_client = __esm(() => {
     connectTimeoutMs;
     brokerAcknowledgesReceipt = false;
     brokerAcknowledgesPendingStageRoutes = false;
+    multiplexesPendingStageRoutes;
+    brokerRefusesPendingStageRoutesInPlace = false;
     brokerAnswersStatus = false;
     socket = null;
     _sessionId = null;
@@ -989,6 +1012,7 @@ var init_client = __esm(() => {
       this.preferredSessionId = options.preferredSessionId;
       this.acknowledgesReceipt = options.acknowledgesReceipt === true;
       this.connectTimeoutMs = options.connectTimeoutMs ?? BROKER_CONNECT_TIMEOUT_MS;
+      this.multiplexesPendingStageRoutes = options.multiplexesPendingStageRoutes === true;
     }
     failPending(error) {
       this.pendingSends.rejectAll(error);
@@ -1101,6 +1125,7 @@ var init_client = __esm(() => {
           this._supervisorSessionId = null;
           this.brokerAcknowledgesReceipt = false;
           this.brokerAcknowledgesPendingStageRoutes = false;
+          this.brokerRefusesPendingStageRoutesInPlace = false;
           this.brokerAnswersStatus = false;
           this._messageSource = undefined;
           this.disconnectError = null;
@@ -1179,7 +1204,7 @@ var init_client = __esm(() => {
       }
       switch (brokerMessage.type) {
         case "registered": {
-          if (typeof brokerMessage.sessionId !== "string" || brokerMessage.supervisorSessionId !== undefined && typeof brokerMessage.supervisorSessionId !== "string" || brokerMessage.acknowledgesReceipt !== undefined && brokerMessage.acknowledgesReceipt !== true || brokerMessage.acknowledgesPendingStageRoutes !== undefined && brokerMessage.acknowledgesPendingStageRoutes !== true || brokerMessage.brokerStatus !== undefined && brokerMessage.brokerStatus !== true) {
+          if (typeof brokerMessage.sessionId !== "string" || brokerMessage.supervisorSessionId !== undefined && typeof brokerMessage.supervisorSessionId !== "string" || brokerMessage.acknowledgesReceipt !== undefined && brokerMessage.acknowledgesReceipt !== true || brokerMessage.acknowledgesPendingStageRoutes !== undefined && brokerMessage.acknowledgesPendingStageRoutes !== true || brokerMessage.refusesPendingStageRoutesInPlace !== undefined && brokerMessage.refusesPendingStageRoutesInPlace !== true || brokerMessage.brokerStatus !== undefined && brokerMessage.brokerStatus !== true) {
             throw new Error("Invalid registered message");
           }
           if (this._sessionId !== null) {
@@ -1189,6 +1214,7 @@ var init_client = __esm(() => {
           this._supervisorSessionId = typeof brokerMessage.supervisorSessionId === "string" ? brokerMessage.supervisorSessionId : null;
           this.brokerAcknowledgesReceipt = this.acknowledgesReceipt && brokerMessage.acknowledgesReceipt === true;
           this.brokerAcknowledgesPendingStageRoutes = brokerMessage.acknowledgesPendingStageRoutes === true;
+          this.brokerRefusesPendingStageRoutesInPlace = brokerMessage.refusesPendingStageRoutesInPlace === true;
           this.brokerAnswersStatus = brokerMessage.brokerStatus === true;
           this.emit("_registered", { type: "registered", sessionId: brokerMessage.sessionId });
           break;
@@ -1201,6 +1227,12 @@ var init_client = __esm(() => {
             this.emit("_registration_failed", refusal);
             break;
           }
+          const refusedRouteId = typeof brokerMessage.requestId === "string" ? brokerMessage.requestId : "";
+          const refusedRoute = this.pendingStageRouteRegistrations.get(refusedRouteId);
+          if (refusedRoute !== undefined) {
+            this.pendingStageRouteRegistrations.delete(refusedRouteId);
+            refusedRoute.reject(new IntercomPendingStageRouteRefusedError(brokerMessage.reason));
+          }
           this.disconnectError ??= refusal;
           this.failPending(this.disconnectError);
           this.socket?.destroy();
@@ -1326,6 +1358,21 @@ var init_client = __esm(() => {
           this.emit("pending_stage_route_revoked", { runId });
           break;
         }
+        case "pending_stage_route_refused": {
+          const { requestId, runId, code, reason } = brokerMessage;
+          if (typeof requestId !== "string" || typeof runId !== "string" || typeof reason !== "string" || typeof code !== "string") {
+            throw new Error("Invalid pending-stage route refusal");
+          }
+          const pending = this.pendingStageRouteRegistrations.get(requestId);
+          if (!pending)
+            return;
+          this.pendingStageRouteRegistrations.delete(requestId);
+          pending.reject(new IntercomPendingStageRouteRefusedError(reason, {
+            connectionKept: true,
+            ...PENDING_STAGE_ROUTE_REFUSAL_CODES.has(code) ? { code } : {}
+          }));
+          break;
+        }
         case "pending_stage_route_registered": {
           const { requestId } = brokerMessage;
           if (typeof requestId !== "string")
@@ -1829,7 +1876,8 @@ var init_client = __esm(() => {
             stages,
             possibleStages,
             ...parent === undefined ? {} : { parent },
-            ...dormant === true ? { dormant: true } : {}
+            ...dormant === true ? { dormant: true } : {},
+            ...this.multiplexesPendingStageRoutes && this.brokerRefusesPendingStageRoutesInPlace ? { refusalKeepsConnection: true } : {}
           });
         } catch (error) {
           clearTimeout(timeout);
@@ -7472,6 +7520,7 @@ __export(exports_index_heavy, {
 });
 import { APP_NAME, sessionScopedExtensionState } from "@bastani/atomic";
 import { appendFileSync as appendFileSync2 } from "node:fs";
+import { setTimeout as delay3 } from "node:timers/promises";
 function isPendingStageUndeliverableEvent(value) {
   if (typeof value !== "object" || value === null)
     return false;
@@ -7543,6 +7592,7 @@ function piIntercomExtension(pi, testOverrides = {}) {
   const inboundDeliveries = new InboundMessageAdmission;
   const pendingStageRoutes = new Map;
   const pendingStageRouteClients = new Map;
+  const pendingStageRouteConnections = new Map;
   const routeClientConnectGate = createConcurrencyGate(ROUTE_CLIENT_CONNECT_CONCURRENCY);
   const supervisorAuthorizations = new SupervisorAuthorizationRegistry;
   const releasedStagePeers = new ReleasedStagePeers({
@@ -8123,42 +8173,105 @@ function piIntercomExtension(pi, testOverrides = {}) {
       });
     }, jitteredReconnectDelayMs(state.reconnectAttempt));
   }
-  function attachPendingStageRouteClientHandlers(runId, state, nextClient) {
+  function pendingStageRouteRunsOn(nextClient) {
+    return [...pendingStageRouteClients].filter(([, state]) => state.client === nextClient);
+  }
+  function attachPendingStageRouteConnectionHandlers(connection, nextClient) {
     nextClient.on("pending_stage_message", (request) => {
-      handlePendingStageMessage(nextClient, request, () => state.client === nextClient && pendingStageRouteClientIsCurrent(runId, state));
+      handlePendingStageMessage(nextClient, request, () => {
+        const state = pendingStageRouteClients.get(request.runId);
+        return state?.client === nextClient && pendingStageRouteClientIsCurrent(request.runId, state);
+      });
     });
     nextClient.on("disconnected", () => {
-      if (state.client !== nextClient)
-        return;
-      state.client = null;
-      schedulePendingStageRouteReconnect(runId, state);
+      if (connection.client === nextClient)
+        connection.client = null;
+      for (const [runId, state] of pendingStageRouteRunsOn(nextClient)) {
+        state.client = null;
+        schedulePendingStageRouteReconnect(runId, state);
+      }
     });
     nextClient.on("error", () => {});
     nextClient.on("sticky_live_delivered", (notice) => {
-      if (state.client === nextClient)
+      if (connection.client === nextClient)
         relayStickyLiveDelivered(notice);
     });
     nextClient.on("pending_stage_route_revoked", (notice) => {
-      if (notice.runId !== runId || state.client !== nextClient)
+      const state = pendingStageRouteClients.get(notice.runId);
+      if (state === undefined || state.client !== nextClient)
         return;
       state.client = null;
       endPendingStageRouteBackoff(state, new IntercomClientDisconnectedError);
-      if (pendingStageRouteClients.get(runId) === state)
-        pendingStageRouteClients.delete(runId);
-      if (samePendingStageRoute(pendingStageRoutes.get(runId), state.route))
-        pendingStageRoutes.delete(runId);
-      nextClient.disconnect().catch(() => {});
-      pi.events.emit(PENDING_STAGE_ROUTE_REVOKED_EVENT, { runId, capability: state.route.capability });
+      pendingStageRouteClients.delete(notice.runId);
+      if (samePendingStageRoute(pendingStageRoutes.get(notice.runId), state.route))
+        pendingStageRoutes.delete(notice.runId);
+      if (pendingStageRouteRunsOn(nextClient).length === 0)
+        closePendingStageRouteConnection(nextClient);
+      pi.events.emit(PENDING_STAGE_ROUTE_REVOKED_EVENT, { runId: notice.runId, capability: state.route.capability });
     });
   }
+  function closePendingStageRouteConnection(nextClient) {
+    for (const [key, connection] of pendingStageRouteConnections) {
+      if (connection.client !== nextClient)
+        continue;
+      connection.client = null;
+      if (connection.promise === null)
+        pendingStageRouteConnections.delete(key);
+    }
+    nextClient.disconnect().catch(() => {});
+  }
+  function connectPendingStageRouteConnection(key, group) {
+    let connection = pendingStageRouteConnections.get(key);
+    if (connection === undefined) {
+      connection = { client: null, promise: null };
+      pendingStageRouteConnections.set(key, connection);
+    }
+    if (connection.client?.isConnected())
+      return Promise.resolve(connection.client);
+    if (connection.promise !== null)
+      return connection.promise;
+    const owner = connection;
+    const promise = routeClientConnectGate.run(async () => {
+      await spawnBrokerIfNeeded(config.brokerCommand, config.brokerArgs);
+      if (pendingStageRouteConnections.get(key) !== owner)
+        throw new IntercomClientDisconnectedError;
+      const routeReturnAddress = `${currentSessionId}:pending-stage-route:${key}`;
+      const nextClient = new IntercomClient(routeReturnAddress, {
+        connectTimeoutMs: testOverrides.connectTimeoutMs?.(routeReturnAddress),
+        multiplexesPendingStageRoutes: true
+      });
+      owner.client = nextClient;
+      attachPendingStageRouteConnectionHandlers(owner, nextClient);
+      try {
+        await nextClient.connect({ ...buildRegistration(), recipientPurpose: "control", name: undefined, groups: [group], group }, undefined, undefined, readSubagentMessageSource(runtimeContext?.subagentPolicy));
+      } catch (error) {
+        if (owner.client === nextClient)
+          owner.client = null;
+        try {
+          await nextClient.disconnect();
+        } catch {}
+        throw error;
+      }
+      return nextClient;
+    }).finally(() => {
+      if (owner.promise === promise)
+        owner.promise = null;
+    });
+    owner.promise = promise;
+    return promise;
+  }
   async function retirePendingStageRouteClient(state) {
     try {
       await state.promise;
     } catch {}
-    if (state.client) {
-      try {
-        await state.client.disconnect();
-      } catch {}
+    const retiredClient = state.client;
+    state.client = null;
+    if (retiredClient === null)
+      return;
+    const group = normalizeGroup(state.route.group);
+    const groupInUse = [...pendingStageRoutes.values()].some((route) => !registersOnMainClient(route) && normalizeGroup(route.group) === group);
+    if ((state.isolated || !groupInUse) && pendingStageRouteRunsOn(retiredClient).length === 0) {
+      closePendingStageRouteConnection(retiredClient);
     }
   }
   function supersededPendingStageRouteError(context, generation) {
@@ -8171,6 +8284,7 @@ function piIntercomExtension(pi, testOverrides = {}) {
       throw new Error("Intercom runtime not initialized");
     let existing = pendingStageRouteClients.get(runId);
     let retired;
+    const isolated = existing?.isolated === true && normalizeGroup(existing.route.group) === normalizeGroup(route.group);
     if (existing && !samePendingStageRoute(existing.route, route)) {
       pendingStageRouteClients.delete(runId);
       endPendingStageRouteBackoff(existing, new IntercomClientDisconnectedError);
@@ -8183,13 +8297,24 @@ function piIntercomExtension(pi, testOverrides = {}) {
       promise: null,
       reconnectTimer: null,
       reconnectAttempt: 0,
-      retryWaiters: new RouteRetryWaiters
+      retryWaiters: new RouteRetryWaiters,
+      isolated
     };
     if (!existing)
       pendingStageRouteClients.set(runId, state);
     state.route = route;
     if (state.client?.isConnected()) {
-      await state.client.registerPendingStageRouteAcknowledged(runId, normalizeGroup(route.group), route.capability, route.stages, route.possibleStages, route.parent, route.dormant === true);
+      await state.client.registerPendingStageRouteAcknowledged(runId, normalizeGroup(route.group), route.capability, route.stages, route.possibleStages, route.parent, route.dormant === true).catch((error) => {
+        if (error instanceof IntercomPendingStageRouteRefusedError) {
+          if (!error.connectionKept)
+            state.isolated = true;
+          else if (state.client !== null) {
+            state.client = null;
+            schedulePendingStageRouteReconnect(runId, state);
+          }
+        }
+        throw error;
+      });
       return;
     }
     if (state.promise) {
@@ -8198,42 +8323,31 @@ function piIntercomExtension(pi, testOverrides = {}) {
     }
     if (state.reconnectTimer !== null && options.bypassBackoff !== true)
       return state.retryWaiters.join();
-    const connect = () => routeClientConnectGate.run(async () => {
+    const connect = async () => {
       if (!pendingStageRouteClientIsCurrent(runId, state, contextAtStart, generationAtStart)) {
         throw supersededPendingStageRouteError(contextAtStart, generationAtStart);
       }
-      await spawnBrokerIfNeeded(config.brokerCommand, config.brokerArgs);
-      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));
+      const group = normalizeGroup(route.group);
+      const nextClient = await connectPendingStageRouteConnection(state.isolated ? runId : group, group);
       if (!pendingStageRouteClientIsCurrent(runId, state, contextAtStart, generationAtStart)) {
-        await nextClient.disconnect();
         throw supersededPendingStageRouteError(contextAtStart, generationAtStart);
       }
+      state.client = nextClient;
       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 supersededPendingStageRouteError(contextAtStart, generationAtStart);
       }
       state.reconnectAttempt = 0;
       endPendingStageRouteBackoff(state);
-    });
+    };
     const promise = retired === undefined ? connect() : retired.then(connect);
     state.promise = promise;
     try {
       await promise;
     } catch (error) {
-      const failedClient = state.client;
+      if (error instanceof IntercomPendingStageRouteRefusedError && !error.connectionKept)
+        state.isolated = true;
       state.client = null;
-      if (failedClient) {
-        try {
-          await failedClient.disconnect();
-        } catch {}
-      }
       if (state.promise === promise)
         state.promise = null;
       schedulePendingStageRouteReconnect(runId, state);
@@ -8246,17 +8360,25 @@ function piIntercomExtension(pi, testOverrides = {}) {
   async function disconnectPendingStageRouteClients() {
     const states = [...pendingStageRouteClients.values()];
     pendingStageRouteClients.clear();
+    const connections = [...pendingStageRouteConnections.values()];
+    pendingStageRouteConnections.clear();
     for (const state of states) {
       endPendingStageRouteBackoff(state, new IntercomClientDisconnectedError);
       try {
         await state.promise;
       } catch {}
-      if (!state.client)
+      state.client = null;
+    }
+    for (const connection of connections) {
+      try {
+        await connection.promise;
+      } catch {}
+      if (!connection.client)
         continue;
       try {
-        await state.client.disconnect();
+        await connection.client.disconnect();
       } catch {}
-      state.client = null;
+      connection.client = null;
     }
   }
   async function registerPendingStageRoute(activeClient, runId, route) {
@@ -8306,59 +8428,68 @@ function piIntercomExtension(pi, testOverrides = {}) {
     const nextReconnectPromise = (async () => {
       let connectFailed = false;
       await ownershipRecorded.promise;
-      const nextClient = new IntercomClient(sessionIdAtStart, {
-        preferredSessionId,
-        acknowledgesReceipt: true,
-        connectTimeoutMs: testOverrides.connectTimeoutMs?.(sessionIdAtStart)
-      });
-      client = nextClient;
-      attachClientHandlers(nextClient);
+      const ownerWaitDeadline = Date.now() + LIVE_ROUTE_OWNER_WAIT_MS;
       try {
-        await testOverrides.beforeConnectAttempt?.(reason);
-        await spawnBrokerIfNeeded(config.brokerCommand, config.brokerArgs);
-        const childMetadata = currentChildOrchestratorMetadata();
-        await nextClient.connect(buildRegistration(), childMetadata?.supervisor, supervisorAuthorizations.ownerToken, readSubagentMessageSource(runtimeContext?.subagentPolicy), resolveSessionHomeGroup());
-        clientRegistrationGroup = resolveSessionHomeGroup();
-        if (replyCapability() === "terminal")
-          nextClient.updatePresence({ replyCapability: "terminal" });
-        await supervisorAuthorizations.restore(nextClient);
-        for (const [runId, route] of pendingStageRoutes) {
-          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) {
-          const liveStageKeys = [orchestration.workflowStageId, orchestration.workflowStageName].filter((stageKey) => !stageKey.includes("/") && !stageKey.includes("*"));
-          if (liveStageKeys.length > 0) {
-            await nextClient.registerLiveWorkflowStageRoute(orchestration.workflowRunId, liveStageKeys, orchestration.pendingStageDelivery.routeCapability);
+        for (let ownerWait = 0;; ownerWait += 1) {
+          const nextClient = new IntercomClient(sessionIdAtStart, {
+            preferredSessionId,
+            acknowledgesReceipt: true,
+            connectTimeoutMs: testOverrides.connectTimeoutMs?.(sessionIdAtStart)
+          });
+          client = nextClient;
+          attachClientHandlers(nextClient);
+          try {
+            await testOverrides.beforeConnectAttempt?.(reason);
+            await spawnBrokerIfNeeded(config.brokerCommand, config.brokerArgs);
+            const childMetadata = currentChildOrchestratorMetadata();
+            await nextClient.connect(buildRegistration(), childMetadata?.supervisor, supervisorAuthorizations.ownerToken, readSubagentMessageSource(runtimeContext?.subagentPolicy), resolveSessionHomeGroup());
+            clientRegistrationGroup = resolveSessionHomeGroup();
+            if (replyCapability() === "terminal")
+              nextClient.updatePresence({ replyCapability: "terminal" });
+            await supervisorAuthorizations.restore(nextClient);
+            for (const [runId, route] of pendingStageRoutes) {
+              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) {
+              const liveStageKeys = [orchestration.workflowStageId, orchestration.workflowStageName].filter((stageKey) => !stageKey.includes("/") && !stageKey.includes("*"));
+              if (liveStageKeys.length > 0) {
+                await nextClient.registerLiveWorkflowStageRoute(orchestration.workflowRunId, liveStageKeys, orchestration.pendingStageDelivery.routeCapability);
+              }
+            }
+            if (!getLiveContext(contextAtStart, generationAtStart)) {
+              await nextClient.disconnect();
+              throw new Error("Intercom runtime no longer active");
+            }
+            client = nextClient;
+            if (nextClient.sessionId) {
+              process.env[INTERCOM_SESSION_ID_ENV] = nextClient.sessionId;
+            }
+            reconnectAttempt = 0;
+            if (nextClient.sessionId && nextClient.sessionId !== preferredSessionId) {
+              await recordIntercomSessionIdentity(sessionIdAtStart, nextClient.sessionId);
+            }
+            return nextClient;
+          } catch (error) {
+            if (client === nextClient) {
+              client = null;
+              clientRegistrationGroup = null;
+            }
+            try {
+              await nextClient.disconnect();
+            } catch {}
+            if (isOwnerMissingRefusal(error) && Date.now() < ownerWaitDeadline && !disposed && !shuttingDown && getLiveContext(contextAtStart, generationAtStart)) {
+              await delay3(liveRouteOwnerRetryDelayMs(ownerWait));
+              continue;
+            }
+            connectFailed = true;
+            throw toError3(error);
           }
         }
-        if (!getLiveContext(contextAtStart, generationAtStart)) {
-          await nextClient.disconnect();
-          throw new Error("Intercom runtime no longer active");
-        }
-        client = nextClient;
-        if (nextClient.sessionId) {
-          process.env[INTERCOM_SESSION_ID_ENV] = nextClient.sessionId;
-        }
-        reconnectAttempt = 0;
-        if (nextClient.sessionId && nextClient.sessionId !== preferredSessionId) {
-          await recordIntercomSessionIdentity(sessionIdAtStart, nextClient.sessionId);
-        }
-        return nextClient;
-      } catch (error) {
-        if (client === nextClient) {
-          client = null;
-          clientRegistrationGroup = null;
-        }
-        connectFailed = true;
-        try {
-          await nextClient.disconnect();
-        } catch {}
-        throw toError3(error);
       } finally {
         if (reconnectPromiseGeneration === generationAtStart) {
           reconnectPromise = null;
@@ -8652,6 +8783,7 @@ var init_index_heavy = __esm(() => {
   init_runtime_group();
   init_reconnect_backoff();
   init_recoverable_disconnect();
+  init_live_route_refusal();
   init_route_retry_waiters();
   init_released_stage_peers();
   init_supervisor_authorization_registry();

package/dist/builtin/intercom/live-route-refusal.ts

@@ -67,3 +67,23 @@ export class IntercomLiveRouteRefusedError extends Error {
 		this.transient = isTransientLiveWorkflowStageRouteRefusal(code);
 	}
 }
+
+/**
+ * How long a starting stage keeps waiting out an `owner_missing` refusal. The run's owner
+ * registers its route over its own broker connection, which may still be connecting, backing
+ * off (up to 30 s) or waiting out 10 s connect and acknowledgement timeouts when the stage
+ * starts, so a few quick retries would turn ordinary registration latency into a failed stage
+ * (#3904). Past this bound the refusal surfaces as before.
+ */
+export const LIVE_ROUTE_OWNER_WAIT_MS = 120_000;
+const LIVE_ROUTE_OWNER_RETRY_FIRST_MS = 250;
+const LIVE_ROUTE_OWNER_RETRY_MAX_MS = 2_000;
+
+/** Delay before the next registration attempt while the owner is missing: doubling, capped at 2 s. */
+export function liveRouteOwnerRetryDelayMs(attempt: number): number {
+	return Math.min(LIVE_ROUTE_OWNER_RETRY_FIRST_MS * 2 ** attempt, LIVE_ROUTE_OWNER_RETRY_MAX_MS);
+}
+
+export function isOwnerMissingRefusal(error: unknown): boolean {
+	return error instanceof IntercomLiveRouteRefusedError && error.code === "owner_missing";
+}

package/dist/builtin/intercom/package.json

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

package/dist/builtin/intercom/skills/intercom/SKILL.md

@@ -247,12 +247,15 @@ In Atomic workflows, each invocation has its own Intercom group, and parallel st
 
 ### Pattern 8: Peer Coordination Between Subagents and Workflow Stages
 
-Communication inside a delegation is not only vertical. Children launched in one parallel set (or one explicit `group`) share an Intercom group, and workflow stages share their invocation group `workflow:<rootRunId>`; delegated subagents inside a stage inherit it. Any of them can list live siblings and message them directly. `contact_supervisor` is reserved for the supervisor; peer traffic uses ordinary `intercom`.
+Peer-to-peer (swarm) is the default topology inside a delegation. There are no limits on communication between agents; it is encouraged whenever you need to. The supervisor is not a message relay: relaying adds latency, loses detail, and fills the supervisor's context, so siblings exchange evidence directly and self-organize. Children launched in one parallel set (or one explicit `group`) share an Intercom group, and workflow stages share their invocation group `workflow:<rootRunId>`; delegated subagents inside a stage inherit it. Any of them can list live siblings and message them directly. `contact_supervisor` is reserved for the supervisor; peer traffic uses ordinary `intercom`.
 
 ```typescript
 // Any child or stage: discover who is live in your group
 intercom({ action: "list" })
 
+// Broadcast: share a finding with every live sibling in the workflow
+intercom({ action: "send", to: "workflow:<rootRunId>/**", message: "Root cause confirmed: cache key omits tenant id (src/cache.ts:52). Adjust your angle." })
+
 // Connect: pass what you found to the sibling who needs it
 intercom({ action: "send", to: "codebase-analyzer-2", message: "Null handling lives in src/auth/session.ts:40-118 and src/auth/refresh.ts:12-60. Start there." })
 
@@ -266,14 +269,15 @@ intercom({ action: "ask", to: "debugger-1", message: "What exact command and env
 intercom({ action: "ask", to: "reviewer-2", message: "You called the retry loop unbounded. client.ts:88 caps attempts at 5 — which path bypasses it?" })
 ```
 
-Rules that keep peer exchange useful:
+How a swarm works:
 
-- Peers do not coordinate spontaneously. The launcher's prompt should name the peers (or how to discover them with `list`) and what they are expected to exchange.
-- Bound the exchange: one evidence round for reviewers, one ownership claim per shared step, one ask per fact you need. Then return your own complete result.
-- Decide on evidence, not deference. A peer's approval, rejection, or claim is input to inspect, not a verdict to copy.
-- Scope, product, architecture, and acceptance decisions stay with the supervisor (`contact_supervisor`) or a workflow gate.
+- Coordinate proactively. Discover peers with `list` as soon as you start and again whenever new siblings may have joined, without waiting for the launcher to name them.
+- Broadcast findings, claim files or expensive steps, hand work along a chain, ask and answer each other, and debate disagreements for as long as it is useful.
+- Decide on evidence, not deference. A peer's approval, rejection, or claim is input to inspect, not a verdict to copy, and each agent still returns its own result.
+- `contact_supervisor` is for supervisor decisions; explicit user approval gates and authorization for destructive or external actions still apply.
 - Inside a workflow, `send` to a known pending sibling queues until it starts, and `ask` to a completed sibling that retains a valid conversation reopens it for a post-mortem turn. Named stage subgroups isolate their members from sibling subgroups.
 - Peer asks and one blocking supervisor request may wait concurrently in the same child; mutual asks work when both sides process inbound work.
+- Scale with the task. For very complex work or requested heavy parallelism, hundreds or thousands of agents self-organize into teams (named groups, per-stage subagent sets, child workflows) and coordinate peer-to-peer like an organization. Groups have no member limit; team members reach their lead with `contact_supervisor`, and leads talk to each other in their shared group.
 
 ## Key Differences
 

package/dist/builtin/intercom/types.ts

@@ -221,6 +221,12 @@ export type ClientMessage =
 		parent?: WorkflowRunParentAnnouncement;
 		/** Interrupted run queued by its restarted owner before resume; yields to the process that resumes it (#3760). */
 		dormant?: true;
+		/**
+		 * #3906: the connection carries the routes of many runs, so a refusal of this one is answered with
+		 * `pending_stage_route_refused` and leaves the connection open. Honoured only with a `requestId`, and sent only to
+		 * a broker that advertised `refusesPendingStageRoutesInPlace`; an older broker ignores it and ends the connection.
+		 */
+		refusalKeepsConnection?: true;
 	}
   | {
       type: "register_live_workflow_stage_route";
@@ -254,6 +260,9 @@ export type ClientMessage =
 	/** Allowed before `register`: shut the broker down; its sessions reconnect to a new broker. */
 	| { type: "shutdown"; requestId: string };
 
+/** Why the broker refused a pending-stage route registration (#3906). Authorization decides these, not the client. */
+export type PendingStageRouteRefusalCode = "not_authorized" | "invalid_stage_roster" | "invalid_possible_stage_roster";
+
 export type BrokerMessage =
 	| { type: "health"; requestId: string; instanceId: string }
 	| {
@@ -264,10 +273,12 @@ export type BrokerMessage =
 			acknowledgesReceipt?: true;
 			/** This broker acknowledges a `register_pending_stage_route` that carries a `requestId`; absent on older brokers. */
 			acknowledgesPendingStageRoutes?: true;
+			/** #3906: this broker honours `refusalKeepsConnection`; absent on older brokers, which end the connection. */
+			refusesPendingStageRoutesInPlace?: true;
 			/** This broker answers `broker_status`; absent on older brokers, which drop a client that sends it. */
 			brokerStatus?: true;
 	  }
-  | { type: "registration_failed"; reason: string; code?: LiveWorkflowStageRouteRefusalCode }
+  | { type: "registration_failed"; reason: string; code?: LiveWorkflowStageRouteRefusalCode; requestId?: string }
   | { type: "question_target"; messageId: string; attemptId: string; sessionId: string }
  | { type: "sessions"; requestId: string; sessions: SessionInfo[]; workflowStages?: WorkflowStageRosterEntry[]; workflowFutureStages?: WorkflowFutureStageRosterEntry[]; restricted?: true }
 	| { type: "groups"; requestId: string; groups: GroupSummary[] }
@@ -288,6 +299,14 @@ export type BrokerMessage =
 	  }
   | { type: "live_workflow_stage_route_registered"; requestId: string }
 	| { type: "pending_stage_route_registered"; requestId: string }
+	/** #3906: the registration `requestId` of run `runId` was refused; the connection and its other routes are kept. */
+	| {
+			type: "pending_stage_route_refused";
+			requestId: string;
+			runId: string;
+			code: PendingStageRouteRefusalCode;
+			reason: string;
+	  }
 	/** A dormant route's run was resumed by another process, which now owns the run's routes (#3760). */
 	| { type: "pending_stage_route_revoked"; runId: string }
   | { type: "presence_update"; session: SessionInfo }

package/dist/builtin/mcp/CHANGELOG.md

@@ -7,6 +7,13 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.9.44-alpha.1] - 2026-10-24
+
+### Fixed
+
+- MCP sign-in now accepts only `http:` and `https:` authorization endpoints and other OAuth metadata URLs. Before, a malicious MCP server could supply a `file:` or custom protocol authorization endpoint (for example `search-ms:`), which the platform URL handler would launch on sign-in ([pi 9ffd27cf](https://github.com/earendil-works/pi/commit/9ffd27cfaaeed5c1ecf9369f393c3222975729b4))
+- The excerpt of an HTTP error body in Streamable HTTP errors no longer keeps the whole response body alive ([pi #9265](https://github.com/earendil-works/pi/issues/9265))
+
 ## [0.9.35] - 2026-10-13
 
 ### Fixed