@bastani/atomic 0.9.41 → 0.9.42-alpha.1

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

@@ -585,6 +585,32 @@ function createMessageReader(onMessage, onError) {
   };
 }
 
+// dist/builtin/intercom/broker/broker-status.ts
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isOptionalString(value) {
+  return value === undefined || typeof value === "string";
+}
+function isBrokerStatusReport(value) {
+  if (!isObject(value) || typeof value.pid !== "number" || typeof value.sessions !== "number")
+    return false;
+  const { storage, multiNode } = value;
+  if (storage !== undefined && (!isObject(storage) || typeof storage.digest !== "string" || storage.source !== "env" && storage.source !== "settings"))
+    return false;
+  return isObject(multiNode) && (multiNode.status === "off" || multiNode.status === "starting" || multiNode.status === "on" || multiNode.status === "unavailable") && isOptionalString(multiNode.reason) && isOptionalString(multiNode.adapter) && isOptionalString(multiNode.prefix) && (multiNode.peers === undefined || Array.isArray(multiNode.peers) && multiNode.peers.every((peer) => typeof peer === "string"));
+}
+function describeMultiNodeStatus(multiNode) {
+  const storage = multiNode.adapter === undefined ? "" : ` (adapter ${multiNode.adapter}, prefix ${multiNode.prefix ?? "none"})`;
+  if (multiNode.status === "off" || multiNode.status === "unavailable") {
+    return `${multiNode.status}${storage}${multiNode.reason === undefined ? "" : `: ${multiNode.reason}`}`;
+  }
+  if (multiNode.status === "starting" || multiNode.peers === undefined)
+    return `${multiNode.status}${storage}`;
+  const count = `${multiNode.peers.length} peer broker${multiNode.peers.length === 1 ? "" : "s"} live`;
+  return `on${storage}, ${count}${multiNode.peers.length === 0 ? "" : ` (${[...new Set(multiNode.peers)].join(", ")})`}`;
+}
+
 // dist/builtin/intercom/broker/paths.ts
 import { homedir } from "os";
 import { join } from "path";
@@ -730,14 +756,14 @@ class PendingSendRegistry {
       generation
     };
     attempt.timer = setTimeout(() => {
-      this.reject(attempt, new Error("Send timeout"));
+      this.expire(attempt);
     }, timeoutMs);
     this.attempts.set(messageId, attempt);
     return { attempt, owner: true };
   }
   resolve(messageId, attemptId, result) {
     const attempt = this.attempts.get(messageId);
-    if (!attempt || attempt.attemptId !== attemptId)
+    if (!attempt || attempt.timedOut || attempt.attemptId !== attemptId)
       return false;
     this.attempts.delete(messageId);
     if (attempt.timer)
@@ -748,21 +774,36 @@ class PendingSendRegistry {
   }
   extend(messageId, attemptId, timeoutMs) {
     const attempt = this.attempts.get(messageId);
-    if (!attempt || (attemptId === undefined ? !attempt.legacyEligible : attempt.attemptId !== attemptId))
+    if (!attempt || attempt.timedOut || (attemptId === undefined ? !attempt.legacyEligible : attempt.attemptId !== attemptId))
       return false;
     if (attempt.timer)
       clearTimeout(attempt.timer);
     attempt.timer = setTimeout(() => {
-      this.reject(attempt, new Error("Send timeout"));
+      this.expire(attempt);
     }, timeoutMs);
     return true;
   }
   resolveLegacy(messageId, result) {
     const attempt = this.attempts.get(messageId);
-    if (!attempt?.legacyEligible)
+    if (!attempt?.legacyEligible || attempt.timedOut)
       return false;
     return this.resolve(messageId, attempt.attemptId, result);
   }
+  expire(attempt) {
+    if (this.attempts.get(attempt.messageId) !== attempt)
+      return;
+    attempt.timedOut = true;
+    attempt.timer = undefined;
+    attempt.reject(new PendingSendTimeoutError);
+  }
+  release(attempt) {
+    const current = this.attempts.get(attempt.messageId);
+    if (current !== attempt || !current.timedOut)
+      return false;
+    this.attempts.delete(attempt.messageId);
+    this.touchGeneration(current);
+    return true;
+  }
   reject(attempt, error) {
     const current = this.attempts.get(attempt.messageId);
     if (current !== attempt)
@@ -779,9 +820,14 @@ class PendingSendRegistry {
       this.reject(attempt, error);
   }
 }
-var DEFAULT_GENERATION_TTL_MS, DEFAULT_MAX_GENERATIONS = 1e4;
+var DEFAULT_GENERATION_TTL_MS, DEFAULT_MAX_GENERATIONS = 1e4, PendingSendTimeoutError;
 var init_pending_send_registry = __esm(() => {
   DEFAULT_GENERATION_TTL_MS = 10 * 60 * 1000;
+  PendingSendTimeoutError = class PendingSendTimeoutError extends Error {
+    constructor() {
+      super("Send timeout");
+    }
+  };
 });
 
 // dist/builtin/intercom/source-ownership.ts
@@ -878,16 +924,19 @@ var init_client = __esm(() => {
     connectTimeoutMs;
     brokerAcknowledgesReceipt = false;
     brokerAcknowledgesPendingStageRoutes = false;
+    brokerAnswersStatus = false;
     socket = null;
     _sessionId = null;
     _supervisorSessionId = null;
     _messageSource;
     pendingSends = new PendingSendRegistry;
+    sendResults = new WeakMap;
     pendingReplyTargets = new Map;
     pendingGroupLists = new Map;
     pendingLists = new Map;
     pendingPresence = new Map;
     pendingMemberships = new Map;
+    pendingBrokerStatus = new Map;
     _groups = normalizeGroups();
     pendingLiveWorkflowStageRoutes = new Map;
     pendingStageRouteRegistrations = new Map;
@@ -895,6 +944,43 @@ var init_client = __esm(() => {
     pendingRestoringRecipientRequests = new Map;
     disconnecting = false;
     disconnectError = null;
+    healthCheck;
+    async requestTimeout(socket, error) {
+      if (this.socket !== socket || socket.destroyed)
+        return this.disconnectError ?? new IntercomClientDisconnectedError;
+      if (this.healthCheck?.socket !== socket) {
+        const requestId = randomUUID2();
+        const result = new Promise((resolve) => {
+          const finish = (failure) => {
+            clearTimeout(timer);
+            this.pendingGroupLists.delete(requestId);
+            resolve(failure);
+          };
+          const timer = setTimeout(() => finish(new IntercomBrokerTimeoutError("Broker health check timed out")), GROUP_REQUEST_TIMEOUT_MS);
+          this.pendingGroupLists.set(requestId, { resolve: () => finish(), reject: finish });
+          try {
+            writeMessage(socket, { type: "list_groups", requestId });
+          } catch (cause) {
+            finish(new IntercomClientDisconnectedError({ cause }));
+          }
+        });
+        this.healthCheck = { socket, result };
+      }
+      const check = this.healthCheck;
+      const failure = await check.result;
+      if (this.healthCheck === check)
+        this.healthCheck = undefined;
+      if (failure === undefined)
+        return error;
+      const reported = failure instanceof IntercomBrokerTimeoutError ? new IntercomBrokerTimeoutError(error.message, { cause: failure }) : failure;
+      if (this.socket === socket && !this.disconnecting) {
+        this.disconnectError ??= reported;
+        this.failPending(this.disconnectError);
+        socket.destroy();
+        return this.disconnectError;
+      }
+      return reported;
+    }
     constructor(returnAddress = randomUUID2(), options = {}) {
       super();
       if (returnAddress.length === 0)
@@ -922,6 +1008,8 @@ var init_client = __esm(() => {
         pending.reject(error);
       for (const pending of this.pendingStageRouteRegistrations.values())
         pending.reject(error);
+      for (const pending of this.pendingBrokerStatus.values())
+        pending.reject(error);
       this.pendingLists.clear();
       this.pendingGroupLists.clear();
       this.pendingSupervisorAuthorizations.clear();
@@ -930,6 +1018,7 @@ var init_client = __esm(() => {
       this.pendingMemberships.clear();
       this.pendingLiveWorkflowStageRoutes.clear();
       this.pendingStageRouteRegistrations.clear();
+      this.pendingBrokerStatus.clear();
     }
     get sessionId() {
       return this._sessionId;
@@ -1012,6 +1101,7 @@ var init_client = __esm(() => {
           this._supervisorSessionId = null;
           this.brokerAcknowledgesReceipt = false;
           this.brokerAcknowledgesPendingStageRoutes = false;
+          this.brokerAnswersStatus = false;
           this._messageSource = undefined;
           this.disconnectError = null;
           if (connectionEstablished && !wasDisconnecting) {
@@ -1089,7 +1179,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) {
+          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) {
             throw new Error("Invalid registered message");
           }
           if (this._sessionId !== null) {
@@ -1099,6 +1189,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.brokerAnswersStatus = brokerMessage.brokerStatus === true;
           this.emit("_registered", { type: "registered", sessionId: brokerMessage.sessionId });
           break;
         }
@@ -1154,6 +1245,18 @@ var init_client = __esm(() => {
           pending.resolve(groups);
           break;
         }
+        case "broker_status": {
+          const { requestId } = brokerMessage;
+          const report = brokerMessage.report;
+          if (typeof requestId !== "string" || !isBrokerStatusReport(report))
+            throw new Error("Invalid broker_status message");
+          const pending = this.pendingBrokerStatus.get(requestId);
+          if (!pending)
+            return;
+          this.pendingBrokerStatus.delete(requestId);
+          pending.resolve(report);
+          break;
+        }
         case "supervisor_authorized": {
           const { requestId, capability, supervisorSessionId, childName } = brokerMessage;
           if (typeof requestId !== "string" || typeof capability !== "string" || typeof supervisorSessionId !== "string" || typeof childName !== "string") {
@@ -1455,7 +1558,7 @@ var init_client = __esm(() => {
         const timeout = setTimeout(() => {
           if (!this.pendingLists.delete(requestId))
             return;
-          reject(new Error("List sessions timeout"));
+          this.requestTimeout(socket, new Error("List sessions timeout")).then(reject);
         }, 5000);
         this.pendingLists.set(requestId, {
           resolve: (directory) => {
@@ -1488,7 +1591,7 @@ var init_client = __esm(() => {
         const timeout = setTimeout(() => {
           if (!this.pendingGroupLists.delete(requestId))
             return;
-          reject(new Error("List groups timeout"));
+          this.requestTimeout(socket, new Error("List groups timeout")).then(reject);
         }, GROUP_REQUEST_TIMEOUT_MS);
         this.pendingGroupLists.set(requestId, {
           resolve: (groups) => {
@@ -1509,6 +1612,41 @@ var init_client = __esm(() => {
         }
       });
     }
+    brokerStatus() {
+      let socket;
+      try {
+        socket = this.requireActiveSocket();
+      } catch (error) {
+        return Promise.reject(toError(error));
+      }
+      if (!this.brokerAnswersStatus)
+        return Promise.resolve(undefined);
+      const requestId = randomUUID2();
+      return new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+          if (!this.pendingBrokerStatus.delete(requestId))
+            return;
+          reject(new Error("Broker status timeout"));
+        }, GROUP_REQUEST_TIMEOUT_MS);
+        this.pendingBrokerStatus.set(requestId, {
+          resolve: (report) => {
+            clearTimeout(timeout);
+            resolve(report);
+          },
+          reject: (error) => {
+            clearTimeout(timeout);
+            reject(error);
+          }
+        });
+        try {
+          writeMessage(socket, { type: "broker_status", requestId });
+        } catch (error) {
+          clearTimeout(timeout);
+          this.pendingBrokerStatus.delete(requestId);
+          reject(toError(error));
+        }
+      });
+    }
     joinGroup(group) {
       return this.updateMembership("join_group", group);
     }
@@ -1527,7 +1665,7 @@ var init_client = __esm(() => {
         const timeout = setTimeout(() => {
           if (!this.pendingMemberships.delete(requestId))
             return;
-          reject(new Error("Membership update timeout"));
+          this.requestTimeout(socket, new Error("Membership update timeout")).then(reject);
         }, GROUP_REQUEST_TIMEOUT_MS);
         this.pendingMemberships.set(requestId, {
           resolve: (groups) => {
@@ -1563,7 +1701,7 @@ var init_client = __esm(() => {
         const timeout = setTimeout(() => {
           if (!this.pendingSupervisorAuthorizations.delete(requestId))
             return;
-          reject(new Error("Supervisor authorization timeout"));
+          this.requestTimeout(socket, new Error("Supervisor authorization timeout")).then(reject);
         }, 5000);
         this.pendingSupervisorAuthorizations.set(requestId, {
           resolve: (authorization) => {
@@ -1614,7 +1752,7 @@ var init_client = __esm(() => {
         const timeout = setTimeout(() => {
           if (!this.pendingRestoringRecipientRequests.delete(requestId))
             return;
-          reject(new Error("Restoring-recipient request timeout"));
+          this.requestTimeout(socket, new Error("Restoring-recipient request timeout")).then(reject);
         }, RESTORING_RECIPIENT_REQUEST_TIMEOUT_MS);
         this.pendingRestoringRecipientRequests.set(requestId, {
           resolve: () => {
@@ -1669,7 +1807,7 @@ var init_client = __esm(() => {
         const timeout = setTimeout(() => {
           if (!this.pendingStageRouteRegistrations.delete(requestId))
             return;
-          reject(new IntercomBrokerTimeoutError("Pending-stage route registration timeout"));
+          this.requestTimeout(socket, new IntercomBrokerTimeoutError("Pending-stage route registration timeout")).then(reject);
         }, PENDING_STAGE_ROUTE_ACK_TIMEOUT_MS);
         this.pendingStageRouteRegistrations.set(requestId, {
           resolve: () => {
@@ -1783,8 +1921,22 @@ var init_client = __esm(() => {
       } catch (error) {
         return Promise.reject(toError(error));
       }
+      let result = this.sendResults.get(acquired.attempt.promise);
+      if (result === undefined) {
+        result = acquired.attempt.promise.catch(async (error) => {
+          if (error instanceof PendingSendTimeoutError) {
+            try {
+              throw await this.requestTimeout(socket, error);
+            } finally {
+              this.pendingSends.release(acquired.attempt);
+            }
+          }
+          throw error;
+        });
+        this.sendResults.set(acquired.attempt.promise, result);
+      }
       if (!acquired.owner)
-        return acquired.attempt.promise;
+        return result;
       const message = {
         id: messageId,
         timestamp: Date.now(),
@@ -1817,7 +1969,7 @@ var init_client = __esm(() => {
         this.pendingReplyTargets.delete(acquired.attempt.attemptId);
       };
       acquired.attempt.promise.then(clearReplyTarget, clearReplyTarget);
-      return acquired.attempt.promise;
+      return result;
     }
     updatePresence(updates) {
       if (this.disconnecting) {
@@ -1854,7 +2006,7 @@ var init_client = __esm(() => {
         const timeout = setTimeout(() => {
           if (!this.pendingPresence.delete(requestId))
             return;
-          reject(new Error("Presence update timeout"));
+          this.requestTimeout(socket, new Error("Presence update timeout")).then(reject);
         }, PRESENCE_ACK_TIMEOUT_MS);
         this.pendingPresence.set(requestId, {
           resolve: wrappedResolve,
@@ -2039,7 +2191,16 @@ function getBrokerSpawnOptions(extensionDir = EXTENSION_DIR, stderr = "ignore")
 function resetBrokerLog(logPath = BROKER_LOG) {
   ensurePrivateDirectory(dirname(logPath));
   try {
+    const previous = readBrokerLogTail(logPath);
     closeSync(openSync(logPath, "w"));
+    if (previous.length > 0) {
+      try {
+        const previousPath = `${logPath}.previous`;
+        writeFileSync(previousPath, Buffer.from(previous).subarray(-BROKER_LOG_TAIL_BYTES), { mode: 384 });
+        if (process.platform !== "win32")
+          chmodSync(previousPath, 384);
+      } catch {}
+    }
     return true;
   } catch (error) {
     const code = error.code;
@@ -2080,7 +2241,7 @@ ${tail}`;
 function toError2(error) {
   return error instanceof Error ? error : new Error(String(error));
 }
-async function spawnBrokerIfNeeded(brokerCommand, brokerArgs, readyTimeoutMs = BROKER_READY_TIMEOUT_MS) {
+async function spawnBrokerIfNeeded(brokerCommand, brokerArgs, readyTimeoutMs = BROKER_READY_TIMEOUT_MS, extensionDir = EXTENSION_DIR) {
   ensurePrivateDirectory(INTERCOM_DIR);
   if (await isBrokerRunning()) {
     return;
@@ -2095,8 +2256,8 @@ async function spawnBrokerIfNeeded(brokerCommand, brokerArgs, readyTimeoutMs = B
     if (await isBrokerRunning()) {
       return;
     }
-    const brokerPath = resolveBrokerEntrypoint(EXTENSION_DIR);
-    const launch = getBrokerLaunchSpec(brokerPath, brokerCommand, brokerArgs);
+    const brokerPath = resolveBrokerEntrypoint(extensionDir);
+    const launch = getBrokerLaunchSpec(brokerPath, brokerCommand, brokerArgs, extensionDir);
     if (launch.kind === "windows-launcher") {
       writeWindowsHiddenLauncher(launch.launcherCommandLine, launch.launcherPath);
     }
@@ -2107,7 +2268,7 @@ async function spawnBrokerIfNeeded(brokerCommand, brokerArgs, readyTimeoutMs = B
     const logFd = launch.kind === "direct" ? openSync(BROKER_LOG, "a") : undefined;
     let child;
     try {
-      child = spawn(launch.command, launch.args, getBrokerSpawnOptions(EXTENSION_DIR, logFd ?? "ignore"));
+      child = spawn(launch.command, launch.args, getBrokerSpawnOptions(extensionDir, logFd ?? "ignore"));
     } finally {
       if (logFd !== undefined)
         closeSync(logFd);
@@ -3753,6 +3914,19 @@ function retainInconclusiveRetry(reservations, attempt) {
     remainingRetries: reservations.remainingRetries(attempt)
   };
 }
+async function multiNodeStatus(client) {
+  if (typeof client.brokerStatus !== "function")
+    return;
+  try {
+    const report = await client.brokerStatus();
+    if (report === undefined) {
+      return { line: "unknown (the running broker predates status reporting; `atomic intercom restart` replaces it)" };
+    }
+    return { line: describeMultiNodeStatus(report.multiNode), multiNode: report.multiNode };
+  } catch (error) {
+    return { line: `unknown (${getErrorMessage(error)})` };
+  }
+}
 async function listDirectory(client, group) {
   if (typeof client.listDirectory === "function")
     return client.listDirectory(group);
@@ -4750,6 +4924,9 @@ ${lines.join(`
               const selectedGroupSessions = selectedGroup === undefined ? undefined : await connectedClient.listSessions(selectedGroup);
               const selectedSection = selectedGroupSessions === undefined ? "" : `
 Selected group [${selectedGroup}]: ${selectedGroupSessions.length} session(s)`;
+              const multiNode = await multiNodeStatus(connectedClient);
+              const multiNodeSection = multiNode === undefined ? "" : `
+Multi-node routing: ${multiNode.line}`;
               return {
                 content: [{
                   type: "text",
@@ -4757,13 +4934,14 @@ Selected group [${selectedGroup}]: ${selectedGroupSessions.length} session(s)`;
 Connected: Yes
 Session ID: ${mySessionId}
 Groups: ${ownGroups.join(", ")}
-Active visible sessions: ${sessions.length}${selectedSection}`
+Active visible sessions: ${sessions.length}${selectedSection}${multiNodeSection}`
                 }],
                 isError: false,
                 details: {
                   group: ownGroups.at(-1),
                   groups: ownGroups,
-                  ...selectedGroup === undefined ? {} : { selectedGroup, selectedGroupSessionCount: selectedGroupSessions?.length ?? 0 }
+                  ...selectedGroup === undefined ? {} : { selectedGroup, selectedGroupSessionCount: selectedGroupSessions?.length ?? 0 },
+                  ...multiNode?.multiNode === undefined ? {} : { multiNode: multiNode.multiNode }
                 }
               };
             } catch (error) {

package/dist/builtin/intercom/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/intercom",
-  "version": "0.9.41",
+  "version": "0.9.42-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/types.ts

@@ -93,6 +93,28 @@ export interface GroupSummary {
 	member: boolean;
 }
 
+/** A broker's multi-node routing state, as `broker_status` reports it. */
+export interface BrokerMultiNodeStatus {
+	status: "off" | "starting" | "on" | "unavailable";
+	/** Why routing is off or unavailable. */
+	reason?: string;
+	/** The shared selection's adapter module, or `sqlite` for a `path` selection. */
+	adapter?: string;
+	prefix?: string;
+	/** Host names of the other brokers whose membership lease is live, while routing is on. */
+	peers?: string[];
+}
+
+/** What a broker reports about itself; read before registering by `atomic intercom restart` and `atomic storage status`. */
+export interface BrokerStatusReport {
+	pid: number;
+	/** Sessions connected to this broker. */
+	sessions: number;
+	/** The shared storage selection the broker read, as a digest of its JSON, and where it read it; absent without one. */
+	storage?: { digest: string; source: "env" | "settings" };
+	multiNode: BrokerMultiNodeStatus;
+}
+
 export interface Message {
   id: string;
   timestamp: number;
@@ -125,6 +147,7 @@ export interface SupervisorRegistration {
 
 
 export type ClientMessage =
+	| { type: "health"; requestId: string }
 	| {
 			type: "register";
 			session: Omit<SessionInfo, "id">;
@@ -225,9 +248,14 @@ export type ClientMessage =
       /** Legacy single-group membership; accepted alongside `groups` for compatibility. */
       group?: string;
       requestId?: string;
-    };
+    }
+	/** Allowed before `register`: the broker's own status. */
+	| { type: "broker_status"; requestId: string }
+	/** Allowed before `register`: shut the broker down; its sessions reconnect to a new broker. */
+	| { type: "shutdown"; requestId: string };
 
 export type BrokerMessage =
+	| { type: "health"; requestId: string; instanceId: string }
 	| {
 			type: "registered";
 			sessionId: string;
@@ -236,6 +264,8 @@ export type BrokerMessage =
 			acknowledgesReceipt?: true;
 			/** This broker acknowledges a `register_pending_stage_route` that carries a `requestId`; absent on older brokers. */
 			acknowledgesPendingStageRoutes?: 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: "question_target"; messageId: string; attemptId: string; sessionId: string }
@@ -272,4 +302,6 @@ export type BrokerMessage =
 	/** #3760: the send is held for a subagent that is being restored; wait up to `timeoutMs` for its outcome. */
 	| { type: "send_held"; messageId: string; attemptId?: string; timeoutMs: number }
 	| { type: "restoring_recipient_ack"; requestId: string; error?: string }
-	| { type: "delivery_failed"; messageId: string; reason: string; reasonCode?: "message_id_conflict" | "session_not_found"; attemptId?: string };
+	| { type: "delivery_failed"; messageId: string; reason: string; reasonCode?: "message_id_conflict" | "session_not_found"; attemptId?: string }
+	| { type: "broker_status"; requestId: string; report: BrokerStatusReport }
+	| { type: "shutdown_ack"; requestId: string };

package/dist/builtin/mcp/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/mcp",
-  "version": "0.9.41",
+  "version": "0.9.42-alpha.1",
   "private": true,
   "description": "Atomic's pi-compatible MCP integration for server connections, OAuth, tools, resources, and terminal management.",
   "contributors": [

package/dist/builtin/subagents/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/subagents",
-  "version": "0.9.41",
+  "version": "0.9.42-alpha.1",
   "private": true,
   "description": "Atomic extension for delegating tasks to subagents with parallel execution. Fork of: https://github.com/nicobailon/pi-subagents",
   "contributors": [

package/dist/builtin/subagents/src/extension/index.bundle.mjs

@@ -13205,6 +13205,7 @@ class SubagentControlRuntime {
             ...inherited,
             customTools: admitted.policy.customTools ?? inherited.customTools,
             resourceLoader,
+            resourceAdmissionSignal: AbortSignal.any([signals.abort, signals.interrupt]),
             subagentPolicy: {
               ...admitted.policy,
               executionEnded: executionEnded.signal,

package/dist/builtin/web-access/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/web-access",
-  "version": "0.9.41",
+  "version": "0.9.42-alpha.1",
   "private": true,
   "description": "Atomic extension for web search, URL fetching, GitHub repo cloning, PDF/video extraction. Fork of: https://github.com/nicobailon/pi-web-access",
   "contributors": [

package/dist/builtin/workflows/CHANGELOG.md

@@ -6,6 +6,18 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 
 ## [Unreleased]
 
+## [0.9.42-alpha.1] - 2026-10-23
+
+### Added
+
+- Local workflow pools can be enabled per run through SDK options or workflow settings, with root and optional user-wide admission limits. A root stays local while registered child workflow subtrees run in local worker processes; unsupported process containment and incompatible worker definitions fail closed ([#3869](https://github.com/bastani-inc/atomic/issues/3869)).
+
+### Fixed
+
+- Workflow model chains now share provider-account cooldowns after rate limits, honor `Retry-After`, and wait for the earliest eligible account instead of exhausting a cooling chain. Retries remain bounded, including retries within each session; waits can be paused or cancelled, and workflow status and task results report provider counts and cooldown deadlines. Retrying a follow-up on the same model preserves its conversation history. Follow-ups keep each model's retry allowance across account switches and can return to an earlier account when its cooldown expires ([#3864](https://github.com/bastani-inc/atomic/issues/3864)).
+- Workflow stages now reload resources up to four at a time per Atomic process instead of one at a time, so a slow reload no longer blocks every other stage at startup. Cancelling a stage waiting for a reload slot removes it from the queue immediately; an active reload retains its slot until it finishes ([#3861](https://github.com/bastani-inc/atomic/issues/3861)).
+- Standalone `run()` now owns Intercom routes for eligible workflow stages until the run settles, so stages can use Intercom without an interactive workflow host. An installed SDK reuses an Intercom owner the extension bundle already registered for the store instead of starting a second one. When a route-update acknowledgement times out, the update retries without disconnecting a healthy owner ([#3863](https://github.com/bastani-inc/atomic/issues/3863))
+
 ## [0.9.41] - 2026-10-22
 
 ### Added

package/dist/builtin/workflows/README.md

@@ -504,6 +504,16 @@ For authored workflows, choose thinking effort by stage role and failure cost ra
 
 When pi exposes its model registry, workflow runs validate user-specified `model` / `fallbackModels` before starting model-backed work and report all unavailable or ambiguous IDs together. Bare model IDs are accepted only when they resolve uniquely or match the current provider; otherwise use `provider/model`. Fallback attempts may send the same prompt/context to a different provider, so choose fallbacks that fit your cost, privacy, and data-handling requirements.
 
+### Rate-limit-aware fallback
+
+A 429 puts its configured provider account on a cooldown shared by every stage in the process. The chain prefers a ready candidate; when all eligible candidates are cooling down, it waits for the earliest deadline and rechecks. `Retry-After` seconds and HTTP dates take precedence over local exponential backoff with jitter. Local backoff is capped at 60 seconds, but a longer server deadline is respected.
+
+Retries remain bounded by the session's `retry.enabled` and `retry.maxRetries`. Custom adapters without retry settings allow two rate-limit retries per candidate. Pausing, quitting, or cancelling interrupts a cooldown wait. Workflow and structured-output time limits still include time spent waiting.
+
+Stage metadata and task results expose `rateLimits`: configured provider IDs, process-wide `rateLimitCount`, `cooldownUntil`, and `waitingUntil` while the fallback scheduler waits. The model-facing `workflow status` listing names waiting stages and their provider counts. Timestamps use Unix milliseconds; historical records do not restore active cooldowns after restart.
+
+For optional per-provider rolling request budgets, call `configureProviderRequestBudget(provider, { maxRequests, intervalMs })` from `@bastani/atomic` before model work. Pass `undefined` to remove a budget. Budgets apply across model runtimes in the same process. HTTP-based OpenAI, Anthropic, Azure, Mistral, pi-messages, and explicit Codex SSE transports count each HTTP attempt; other transports count stream starts rather than their internal retries. Separate configured provider IDs have independent budgets even when they point to the same account. See [provider rate limits](../coding-agent/docs/workflows.md#provider-rate-limits) for an example and limitations.
+
 ### `createRegistry` — grouping workflows
 
 ```typescript

package/dist/builtin/workflows/builtin/{chunk-txbc93t6.js → chunk-3s95f7ry.js}

@@ -37,7 +37,7 @@ import {
   parseFailureDiagnostics,
   summarizeReviewConvergence,
   reverify_consolidated_batch
-} from "./chunk-8x61e0s7.js";
+} from "./chunk-frqxd4d1.js";
 import {
   VERIFICATION_SCALE
 } from "./chunk-n1910xc4.js";

package/dist/builtin/workflows/builtin/{chunk-n2gkzkty.js → chunk-edhf30ef.js}

@@ -39,7 +39,7 @@ import {
   reviewerFailureText,
   summarizeReviewConvergence,
   reverify_consolidated_batch
-} from "./chunk-8x61e0s7.js";
+} from "./chunk-frqxd4d1.js";
 import {
   fold_usage
 } from "./chunk-tgt0s5e5.js";