@bastani/atomic 0.9.43 → 0.9.44-alpha.2

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",
@@ -358,6 +364,8 @@ function isMessage(value) {
     return false;
   if (message.expectsReply !== undefined && typeof message.expectsReply !== "boolean")
     return false;
+  if (message.delivery !== undefined && message.delivery !== "steer" && message.delivery !== "followUp" && message.delivery !== "interrupt")
+    return false;
   if (message.replyError !== undefined && typeof message.replyError !== "string")
     return false;
   if (message.source !== undefined && !isMessageSource(message.source))
@@ -683,7 +691,8 @@ function buildSendSignature(to, options) {
     attachments: canonicalizeAttachmentsForSendSignature(options.attachments) ?? [],
     replyTo: options.replyTo ?? null,
     expectsReply: options.expectsReply ?? false,
-    replyError: options.replyError ?? null
+    replyError: options.replyError ?? null,
+    ...options.delivery === undefined || options.delivery === "steer" ? {} : { delivery: options.delivery }
   });
 }
 
@@ -908,7 +917,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 +926,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 +948,8 @@ var init_client = __esm(() => {
     connectTimeoutMs;
     brokerAcknowledgesReceipt = false;
     brokerAcknowledgesPendingStageRoutes = false;
+    multiplexesPendingStageRoutes;
+    brokerRefusesPendingStageRoutesInPlace = false;
     brokerAnswersStatus = false;
     socket = null;
     _sessionId = null;
@@ -989,6 +1015,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 +1128,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 +1207,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 +1217,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 +1230,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 +1361,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 +1879,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);
@@ -1942,6 +1993,7 @@ var init_client = __esm(() => {
         timestamp: Date.now(),
         replyTo: options.replyTo,
         expectsReply: options.expectsReply,
+        ...options.delivery === undefined || options.delivery === "steer" ? {} : { delivery: options.delivery },
         replyError: options.replyError,
         source: this._messageSource,
         content: { text: options.text, attachments: options.attachments }
@@ -2742,6 +2794,7 @@ class ReplyTracker {
   pendingAsks = new Map;
   pendingTurnContexts = [];
   currentTurnContext = null;
+  turnContextAdmitted = false;
   constructor(askTimeoutMs = ASK_REPLY_TIMEOUT_MS) {
     this.askTimeoutMs = askTimeoutMs;
   }
@@ -2767,15 +2820,27 @@ class ReplyTracker {
   }
   beginTurn(now = Date.now()) {
     this.pruneExpired(now);
-    this.currentTurnContext = this.pendingTurnContexts.shift() ?? null;
+    this.turnContextAdmitted = false;
+  }
+  admitTurnMessage(messageId) {
+    if (this.currentTurnContext?.message.id === messageId) {
+      this.turnContextAdmitted = true;
+      return;
+    }
+    const index = this.pendingTurnContexts.findIndex((context) => context.message.id === messageId);
+    if (index < 0)
+      return;
+    const [admitted] = this.pendingTurnContexts.splice(index, 1);
+    if (this.turnContextAdmitted)
+      return;
+    this.currentTurnContext = admitted;
+    this.turnContextAdmitted = true;
   }
   endTurn() {
     this.currentTurnContext = null;
   }
   restoreTurnContext() {
-    if (this.currentTurnContext)
-      this.pendingTurnContexts.unshift(this.currentTurnContext);
-    this.currentTurnContext = null;
+    this.turnContextAdmitted = false;
   }
   reset() {
     this.pendingAsks.clear();
@@ -2824,10 +2889,11 @@ class ReplyTracker {
       }
       throw new Error(`No pending ask from "${options.to}"`);
     }
-    if (pending.length === 1) {
-      return pending[0];
+    const visible = pending.filter((context) => !this.pendingTurnContexts.some((queued) => queued.message.id === context.message.id));
+    if (visible.length === 1) {
+      return visible[0];
     }
-    if (pending.length === 0) {
+    if (visible.length === 0) {
       throw new Error("No active intercom context to reply to");
     }
     throw new Error("Multiple pending asks — specify `to`");
@@ -4030,6 +4096,10 @@ A valid target outside the known set queues speculatively with a \`notInKnownSet
 undeliverable at terminal only if never delivered. Use \`ask\` only for a live, reply-capable target.
 Stage paths win over same-named owned subgroups for send/ask; \`list\` with \`group\` continues to
 select the group.
+Choose \`delivery\` per send/ask by urgency. The default "steer" arrives after the recipient's current
+tool calls finish and never cancels its work. Use "interrupt" when it must stop now (an urgent correction
+or a stop order); it cancels the current model call or tool call. Use "followUp" when the message can wait
+until the recipient finishes (low priority, "after you're done"). An idle recipient starts a turn.
 For send/ask/reply, Intercom retries recoverable disconnects internally up to three times with the same operation identity. Each new tool call is a new operation. If recovery ends with an unknown delivery outcome, do not repeat it automatically.
 
 Usage:
@@ -4041,6 +4111,7 @@ Usage:
   intercom({ action: "leave" })                   → Return to your resolved home group
   intercom({ action: "send", to: "session-name", message: "..." })  → Send message (shared group only)
   intercom({ action: "ask", to: "session-name", message: "..." })   → Ask and wait for reply
+  intercom({ action: "send", to: "session-name", message: "...", delivery: "interrupt" }) → Cancel the recipient's current work
   intercom({ action: "reply", message: "..." })                      → Reply to the active or exact pending ask
   intercom({ action: "pending" })                                      → List unresolved inbound asks
   intercom({ action: "status" })                  → Show connection status and all your groups
@@ -4065,6 +4136,9 @@ one shared membership; contact_supervisor remains the only cross-group path.`,
         content: Type2.String(),
         language: Type2.Optional(Type2.String())
       }))),
+      delivery: Type2.Optional(Type2.Union([Type2.Literal("steer"), Type2.Literal("followUp"), Type2.Literal("interrupt")], {
+        description: "For 'send'/'ask'; choose per message by urgency. 'steer' (default): arrives after the recipient's current tool calls, never cancelling work. 'interrupt': the recipient must stop now (urgent correction, stop order); cancels its current model call or tool call. 'followUp': can wait until the recipient finishes (low priority, after you're done)."
+      })),
       replyTo: Type2.Optional(Type2.String({
         description: "Exact pending-ask message ID or unique 8-hex UUID prefix; disambiguates concurrent asks, including asks from one sender"
       })),
@@ -4082,6 +4156,7 @@ one shared membership; contact_supervisor remains the only cross-group path.`,
       }
       const toolSessionId = ctx.sessionManager.getSessionId();
       const { action, to, message, replyTo, group } = params;
+      const deliveryOption = params.delivery === undefined || params.delivery === "steer" ? {} : { delivery: params.delivery };
       const attachments = params.attachments?.map((attachment) => ({ ...attachment }));
       const executeAttempt = async (retryToken, _signal) => {
         if (retryToken !== undefined) {
@@ -4392,7 +4467,8 @@ ${message}${attachmentText}`);
                 logicalTarget: to,
                 text: message,
                 attachments,
-                replyTo
+                replyTo,
+                ...deliveryOption
               });
               if (result.queued === true) {
                 retryIdentities.release(retryIdentity);
@@ -4624,6 +4700,7 @@ ${message}${attachmentText}`);
                 attachments,
                 replyTo,
                 expectsReply: true,
+                ...deliveryOption,
                 onReplyTarget: wait.bindSender
               });
               if (sendResult.queued === true) {
@@ -5513,6 +5590,13 @@ function registerIntercomLifecycle(pi, deps) {
     deps.syncPresenceIdentity(ctx.sessionManager.getSessionId());
     activeReplyTracker().beginTurn();
   });
+  pi.on("message_start", (event, ctx) => {
+    if (!deps.getLiveContext(ctx))
+      return;
+    const id = admittedIntercomMessageId(event.message, ctx);
+    if (id !== undefined)
+      activeReplyTracker().admitTurnMessage(id);
+  });
   pi.on("model_select", (event, ctx) => {
     if (!deps.getLiveContext(ctx))
       return;
@@ -5527,6 +5611,25 @@ function registerIntercomLifecycle(pi, deps) {
     }
   });
 }
+function intercomMessageId(customType, details) {
+  if (customType !== "intercom_message" || details === null || typeof details !== "object")
+    return;
+  const id = details.message?.id;
+  return typeof id === "string" ? id : undefined;
+}
+function admittedIntercomMessageId(message, ctx) {
+  const custom = message;
+  if (custom?.role !== "custom")
+    return;
+  if (custom.customType !== PROTECTED_RECONCILIATION_CUSTOM_TYPE)
+    return intercomMessageId(custom.customType, custom.details);
+  const intentEntryId = custom.details?.protectedReconciliationOf;
+  if (typeof intentEntryId !== "string")
+    return;
+  const intent = ctx.sessionManager.getEntries().find((entry) => entry.id === intentEntryId);
+  return intent?.type === "custom_message" ? intercomMessageId(intent.customType, intent.details) : undefined;
+}
+var PROTECTED_RECONCILIATION_CUSTOM_TYPE = "atomic:protected-streaming-reconciliation";
 var init_lifecycle = __esm(() => {
   init_diagnostics();
   init_intercom_utils();
@@ -6606,8 +6709,9 @@ function createIncomingMessageSender(input) {
     if (!input.canDeliver(generation)) {
       return Promise.reject(new Error("Intercom session retired before inbound delivery"));
     }
-    const delivery = (requested === "trigger" || requested === "interrupt") && !mayStartTurn(entry) ? "prelude" : requested;
-    if ((delivery === "trigger" || delivery === "interrupt") && trackReplyContext && maySupplyReplyContext(entry)) {
+    const startsTurn = requested === "trigger" || requested === "triggerFollowUp" || requested === "interrupt";
+    const delivery = startsTurn && !mayStartTurn(entry) ? "prelude" : requested;
+    if ((delivery === "trigger" || delivery === "triggerFollowUp" || delivery === "interrupt") && trackReplyContext && maySupplyReplyContext(entry)) {
       input.queueTurnContext(turnContext ?? { from: entry.from, message: entry.message, receivedAt: Date.now() });
     }
     const baseOptions = {
@@ -6615,7 +6719,7 @@ function createIncomingMessageSender(input) {
       persistWhenStreaming: true,
       ...stageAdmissionBarrier ? { stageAdmissionBarrier } : {}
     };
-    const options = delivery === "interrupt" ? { ...baseOptions, triggerTurn: true, deliverAs: "interrupt" } : delivery === "trigger" ? { ...baseOptions, triggerTurn: true } : delivery === "followUp" ? { ...baseOptions, deliverAs: "followUp" } : baseOptions;
+    const options = delivery === "interrupt" ? { ...baseOptions, triggerTurn: true, deliverAs: "interrupt" } : delivery === "trigger" ? { ...baseOptions, triggerTurn: true } : delivery === "triggerFollowUp" ? { ...baseOptions, triggerTurn: true, deliverAs: "followUp" } : delivery === "followUp" ? { ...baseOptions, deliverAs: "followUp" } : baseOptions;
     return Promise.resolve(input.pi.sendMessage(buildIncomingCustomMessage(entry), options));
   };
 }
@@ -7472,6 +7576,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 +7648,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({
@@ -7852,8 +7958,9 @@ function piIntercomExtension(pi, testOverrides = {}) {
     });
     const activeDelivery = admitActiveSessionInbound(liveContext, (admissionBarrier) => {
       replyTracker.queueTurnContext(replyContext);
+      const delivery = message.delivery === "interrupt" ? "interrupt" : message.delivery === "followUp" ? "triggerFollowUp" : "trigger";
       return retryStableDelivery({
-        deliver: () => sendIncomingMessage(entry, "interrupt", messageGeneration, false, undefined, admissionBarrier),
+        deliver: () => sendIncomingMessage(entry, delivery, messageGeneration, false, undefined, admissionBarrier),
         isCurrent: () => Boolean(getLiveContext(liveContext, messageGeneration)) && liveContext.subagentPolicy?.executionEnded?.aborted !== true && liveContext.subagentPolicy?.messageAdmission?.isOpen() !== false
       });
     }, () => foregroundDetachHandoff.claim(from, message, messageGeneration, () => Boolean(getLiveContext(liveContext, messageGeneration))), release);
@@ -8123,42 +8230,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 +8341,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 +8354,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 +8380,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 +8417,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 +8485,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 +8840,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();
@@ -8827,7 +9016,8 @@ function createForwardedHandlerMap() {
     agent_end: [],
     tool_execution_start: [],
     tool_execution_end: [],
-    model_select: []
+    model_select: [],
+    message_start: []
   };
 }
 function addHandler(captured, event, handler) {
@@ -8861,6 +9051,9 @@ function captureForwardedHandler(captured, event, handler) {
       return;
     case "model_select":
       addHandler(captured, event, handler);
+      return;
+    case "message_start":
+      addHandler(captured, event, handler);
   }
 }
 function addEventHandler(captured, event, handler) {
@@ -9369,6 +9562,13 @@ function intercom(pi, options = {}) {
     if (heavy)
       await lifecycleForward.enqueue(() => dispatchHandlers(heavy, "agent_end", event, ctx));
   });
+  pi.on("message_start", async (event, ctx) => {
+    if (activeLease.retired)
+      return;
+    const heavy = loadedHeavy?.heavy;
+    if (heavy)
+      await lifecycleForward.enqueue(() => dispatchHandlers(heavy, "message_start", event, ctx));
+  });
   pi.on("tool_execution_start", async (event, ctx) => {
     if (activeLease.retired)
       return;