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

package/CHANGELOG.md

@@ -2,6 +2,37 @@
 
 ## [Unreleased]
 
+## [0.9.44-alpha.3] - 2026-10-25
+
+Chatty workflow swarms stay fast and their journals stay small, and Atomic picks up a round of dependency security fixes.
+
+- **Pattern sends at fan-out scale:** stages that message each other through `workflow:<rootRunId>/...` patterns no longer saturate the workflow host or time out their sends, so every send in a 150-child fan-out is delivered ([#3931](https://github.com/bastani-inc/atomic/issues/3931), [#3932](https://github.com/bastani-inc/atomic/pull/3932))
+- **Journals that grow with the work, not the message count:** journal events record only what changed in a run's pending messages instead of the whole list ([#3929](https://github.com/bastani-inc/atomic/issues/3929), [#3930](https://github.com/bastani-inc/atomic/pull/3930))
+- **Security updates:** `undici` 8.12.3, `zod` 4.6.7, `fast-uri` 3.1.9, `body-parser` 2.4.0 and `tokio` 1.54.1 close the published advisories against them ([#3935](https://github.com/bastani-inc/atomic/pull/3935))
+
+### Fixed
+
+- Updated `undici`, which Atomic uses for HTTP requests, to 8.12.3. A server can no longer crash Atomic by sending more than five `Content-Encoding` values ([GHSA-xjj6-f33q-929c](https://github.com/advisories/GHSA-xjj6-f33q-929c)), Server-Sent Events streams can no longer grow parser memory without bound ([GHSA-4qv8-2p9j-2685](https://github.com/advisories/GHSA-4qv8-2p9j-2685)), and Subresource Integrity checks no longer skip uppercase algorithm names ([GHSA-f72v-6w45-q472](https://github.com/advisories/GHSA-f72v-6w45-q472)).
+- Updated the MCP SDK dependencies in the published lockfile to `zod` 4.6.7 ([GHSA-mrhx-c7xc-m3w5](https://github.com/advisories/GHSA-mrhx-c7xc-m3w5)), `fast-uri` 3.1.9 ([GHSA-w74x-v6f9-j3xg](https://github.com/advisories/GHSA-w74x-v6f9-j3xg), [GHSA-wjr9-j795-jxcr](https://github.com/advisories/GHSA-wjr9-j795-jxcr), [GHSA-xhq7-xmqj-769h](https://github.com/advisories/GHSA-xhq7-xmqj-769h), [GHSA-333x-w4r6-6crp](https://github.com/advisories/GHSA-333x-w4r6-6crp)), and `body-parser` 2.4.0 ([GHSA-27r3-jxmh-p828](https://github.com/advisories/GHSA-27r3-jxmh-p828)).
+- Updated the native module's `tokio` crate to 1.54.1, replacing the yanked 1.54.0 release and its `Interval` race ([GHSA-5wjr-9356-4wc8](https://github.com/advisories/GHSA-5wjr-9356-4wc8)).
+- Updated the gondolin example extension's lockfile to `undici` 6.29.1, resolving [GHSA-xjj6-f33q-929c](https://github.com/advisories/GHSA-xjj6-f33q-929c) and [GHSA-4qv8-2p9j-2685](https://github.com/advisories/GHSA-4qv8-2p9j-2685) in its `@earendil-works/gondolin` dependency.
+
+## [0.9.44-alpha.2] - 2026-10-24
+
+Workflow swarms now message each other without cancelling each other's work, and stages, replies and session exits behave reliably under fan-out.
+
+- **Messages no longer cancel a peer's work:** Intercom `send` and `ask` now default to `"steer"`, so a message reaches a busy subagent or workflow stage after its current tool calls finish; pass `delivery: "followUp"` to wait until it stops, or `"interrupt"` for the old cancelling behavior ([#3921](https://github.com/bastani-inc/atomic/issues/3921), [#3924](https://github.com/bastani-inc/atomic/pull/3924))
+- **Replies reach the right sender:** an implicit Intercom `reply` answers only messages the agent has actually seen, and every ask delivered in the same turn can still be answered ([#3921](https://github.com/bastani-inc/atomic/issues/3921), [#3927](https://github.com/bastani-inc/atomic/pull/3927))
+- **Workflow stages start reliably:** a message that reaches a stage before its own prompt becomes context for the first turn instead of failing the stage with `Agent is already processing` ([#3919](https://github.com/bastani-inc/atomic/issues/3919), [#3923](https://github.com/bastani-inc/atomic/pull/3923))
+- **Smaller journals under broadcast:** sticky broadcasts to many stages record only what changed, so the workflow journal grows linearly instead of quadratically ([#3920](https://github.com/bastani-inc/atomic/issues/3920), [#3922](https://github.com/bastani-inc/atomic/pull/3922))
+- **Clean exits and binary startup:** closing a session while background subagents finish no longer fails with `Cannot dispose a session with a queued protected reconciliation`, and the standalone binary starts the Intercom broker for pooled stages even when a build tree exists on the host ([#3925](https://github.com/bastani-inc/atomic/issues/3925), [#3926](https://github.com/bastani-inc/atomic/pull/3926), [#3917](https://github.com/bastani-inc/atomic/issues/3917), [#3918](https://github.com/bastani-inc/atomic/pull/3918))
+
+### Fixed
+
+- The standalone binary resolves its builtin packages only from the `builtin/` directory beside the executable, so the Intercom broker starts for pooled workflow stages even when the build tree still exists on the host ([#3917](https://github.com/bastani-inc/atomic/issues/3917))
+- Fixed workflow stages failing with `Agent is already processing. Specify streamingBehavior ('steer' or 'followUp') to queue the message.` when an Intercom message, such as a sibling's send or a sticky `workflow:<rootRunId>/**` broadcast, reached the stage after it went live but before the workflow sent the stage's own prompt. The message started a turn of its own and the stage prompt was rejected. Messages that arrive before the stage prompt now become context for the stage's first turn, and the stage prompt always starts that turn ([#3919](https://github.com/bastani-inc/atomic/issues/3919))
+- Background subagent completions that arrive while the parent session is finishing a turn now always get their reply turn, so exiting or disposing a session saved to a file no longer fails with `Cannot dispose a session with a queued protected reconciliation` ([#3925](https://github.com/bastani-inc/atomic/issues/3925))
+
 ## [0.9.44-alpha.1] - 2026-10-24
 
 Large agent swarms and local workflow fan-outs now run without freezing the TUI or losing their Intercom routes, and background completion notices survive a restart.

package/dist/builtin/intercom/CHANGELOG.md

@@ -4,6 +4,23 @@ All notable changes to the `pi-intercom` extension will be documented in this fi
 
 ## [Unreleased]
 
+## [0.9.44-alpha.3] - 2026-10-25
+
+### Fixed
+
+- Intercom `send` and `ask` to a workflow-stage target (`workflow:<rootRunId>/...`, including patterns) no longer fetch the whole session list before sending. The broker resolves those targets itself, so the extra request only added load, and when many stages sent at once some sends failed with `List sessions timeout` ([#3931](https://github.com/bastani-inc/atomic/issues/3931))
+- Receiving a large Intercom message (for example a big workflow roster) no longer copies its data again for every chunk that arrives, which made large frames cost quadratic time ([#3931](https://github.com/bastani-inc/atomic/issues/3931))
+
+## [0.9.44-alpha.2] - 2026-10-24
+
+### Changed
+
+- Intercom `send` and `ask` take a `delivery` option, and the default is now `"steer"`: a message to a working subagent or live workflow stage arrives after the recipient's current tool calls finish instead of cancelling its work, so peers in a swarm no longer abort each other's long-running tool calls. `"followUp"` waits until the recipient finishes and stops. `"interrupt"` keeps the previous behavior of cancelling the recipient's current model call or tool call, and is now opt-in ([#3921](https://github.com/bastani-inc/atomic/issues/3921))
+
+### Fixed
+
+- An implicit Intercom `reply` no longer answers a message the agent has not seen yet. Before, a queued message (for example a `"followUp"` ask that arrived while a tool ran) could become the reply target as soon as any new turn started, including the continuation after that tool call, so the reply reached the wrong sender or thread. A message now becomes the reply target only when it enters the agent's context, including when Intercom is loaded through its lazy entry point, and every ask that enters the context in the same turn (for example several `"followUp"` asks delivered together) can still be answered with an implicit `reply` after the first one is answered ([#3921](https://github.com/bastani-inc/atomic/issues/3921), follow-up to [#3924](https://github.com/bastani-inc/atomic/pull/3924))
+
 ## [0.9.44-alpha.1] - 2026-10-24
 
 ### Changed

package/dist/builtin/intercom/broker/client-message-validation.ts

@@ -22,6 +22,12 @@ export function isMessage(value: unknown): value is Message {
   if (typeof message.id !== "string" || typeof message.timestamp !== "number") return false;
   if (message.replyTo !== undefined && typeof message.replyTo !== "string") 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)) return false;
   if (typeof message.content !== "object" || message.content === null) return false;

package/dist/builtin/intercom/broker/client.ts

@@ -18,6 +18,7 @@ import type {
 	WorkflowPossibleStageAnnouncement,
 	WorkflowRunParentAnnouncement,
 	PendingStageRouteRefusalCode,
+	IntercomDeliveryMode,
 } from "../types.js";
 import { buildSendSignature, PendingSendRegistry, PendingSendTimeoutError } from "./pending-send-registry.js";
 import { readSubagentMessageSource } from "../source-ownership.js";
@@ -43,6 +44,8 @@ export interface SendOptions {
   attachments?: Attachment[];
   replyTo?: string;
   expectsReply?: boolean;
+  /** How a busy recipient receives the message; absent means `steer`. */
+  delivery?: IntercomDeliveryMode;
   replyError?: string;
   messageId?: string;
   /** Internal caller-issued target identity; transport still uses the `to` argument. */
@@ -1410,6 +1413,7 @@ export class IntercomClient extends EventEmitter {
       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 },

package/dist/builtin/intercom/broker/framing.ts

@@ -27,14 +27,31 @@ export function createMessageReader(
   onError: (error: Error) => void,
 ) {
   let buffer = Buffer.alloc(0);
+  // Chunks of a frame still arriving: joined once the frame is complete, not on every
+  // chunk, so a large frame costs linear rather than quadratic copying.
+  let pending: Buffer[] = [];
+  let pendingLength = 0;
+  let awaitedLength = 0;
 
   return (data: Buffer) => {
-    buffer = Buffer.concat([buffer, data]);
+    if (pendingLength + data.length < awaitedLength) {
+      pending.push(data);
+      pendingLength += data.length;
+      return;
+    }
+    buffer = pending.length === 0 ? Buffer.concat([buffer, data]) : Buffer.concat([...pending, data]);
+    pending = [];
+    pendingLength = 0;
+    awaitedLength = 0;
 
     while (buffer.length >= 4) {
       const length = buffer.readUInt32BE(0);
       
       if (buffer.length < 4 + length) {
+        pending = [buffer];
+        pendingLength = buffer.length;
+        awaitedLength = 4 + length;
+        buffer = Buffer.alloc(0);
         break;
       }
 

package/dist/builtin/intercom/broker/send-signature.ts

@@ -1,10 +1,11 @@
-import type { Attachment, Message } from "../types.js";
+import type { Attachment, IntercomDeliveryMode, Message } from "../types.js";
 
 export interface LogicalSendOptions {
   text: string;
   attachments?: Attachment[];
   replyTo?: string;
   expectsReply?: boolean;
+  delivery?: IntercomDeliveryMode;
   replyError?: string;
 }
 
@@ -28,6 +29,7 @@ export function buildSendSignature(to: string, options: LogicalSendOptions): str
     replyTo: options.replyTo ?? null,
     expectsReply: options.expectsReply ?? false,
     replyError: options.replyError ?? null,
+    ...(options.delivery === undefined || options.delivery === "steer" ? {} : { delivery: options.delivery }),
   });
 }
 
@@ -37,6 +39,7 @@ export function buildMessageSendSignature(to: string, message: Message, senderId
 		attachments: message.content.attachments,
 		replyTo: message.replyTo,
 		expectsReply: message.expectsReply,
+		delivery: message.delivery,
 		replyError: message.replyError,
 	});
 	if (senderId === undefined && message.source === undefined) return logicalSignature;

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

@@ -364,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))
@@ -563,11 +565,26 @@ function writeMessage(socket, msg, callback) {
 }
 function createMessageReader(onMessage, onError) {
   let buffer = Buffer.alloc(0);
+  let pending = [];
+  let pendingLength = 0;
+  let awaitedLength = 0;
   return (data) => {
-    buffer = Buffer.concat([buffer, data]);
+    if (pendingLength + data.length < awaitedLength) {
+      pending.push(data);
+      pendingLength += data.length;
+      return;
+    }
+    buffer = pending.length === 0 ? Buffer.concat([buffer, data]) : Buffer.concat([...pending, data]);
+    pending = [];
+    pendingLength = 0;
+    awaitedLength = 0;
     while (buffer.length >= 4) {
       const length = buffer.readUInt32BE(0);
       if (buffer.length < 4 + length) {
+        pending = [buffer];
+        pendingLength = buffer.length;
+        awaitedLength = 4 + length;
+        buffer = Buffer.alloc(0);
         break;
       }
       const payload = buffer.subarray(4, 4 + length);
@@ -689,7 +706,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 }
   });
 }
 
@@ -1990,6 +2008,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 }
@@ -2790,6 +2809,7 @@ class ReplyTracker {
   pendingAsks = new Map;
   pendingTurnContexts = [];
   currentTurnContext = null;
+  turnContextAdmitted = false;
   constructor(askTimeoutMs = ASK_REPLY_TIMEOUT_MS) {
     this.askTimeoutMs = askTimeoutMs;
   }
@@ -2815,15 +2835,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();
@@ -2872,10 +2904,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`");
@@ -4055,6 +4088,7 @@ function registerIntercomTool(pi, deps) {
   const retryIdentities = new RetryIdentityReservations({ maxEntries: deps.retryIdentityMaxEntries });
   const { childOrchestratorMetadata, ensureConnected, syncPresenceIdentity, beginReplyWait } = deps;
   const resolveTarget = deps.resolveSessionTarget ?? resolveSessionTargetId;
+  const resolveRecipient = async (client, target) => parseWorkflowStageTarget(target) === undefined ? await resolveTarget(client, target) ?? target : target;
   const getMetadata = typeof childOrchestratorMetadata === "function" ? childOrchestratorMetadata : () => childOrchestratorMetadata ?? null;
   const activeReplyTracker = () => typeof deps.replyTracker === "function" ? deps.replyTracker() : deps.replyTracker;
   pi.registerTool({
@@ -4078,6 +4112,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:
@@ -4089,6 +4127,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
@@ -4113,6 +4152,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"
       })),
@@ -4130,6 +4172,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) {
@@ -4413,7 +4456,7 @@ ${message}${attachmentText}`);
                   details: { error: true, delivered: false, reason: goneChild }
                 };
               }
-              const sendTo = await resolveTarget(connectedClient, to) ?? to;
+              const sendTo = await resolveRecipient(connectedClient, to);
               if (_signal?.aborted) {
                 const retained = retainInconclusiveRetry(retryIdentities, retryIdentity);
                 retryIdentity = undefined;
@@ -4440,7 +4483,8 @@ ${message}${attachmentText}`);
                 logicalTarget: to,
                 text: message,
                 attachments,
-                replyTo
+                replyTo,
+                ...deliveryOption
               });
               if (result.queued === true) {
                 retryIdentities.release(retryIdentity);
@@ -4586,8 +4630,7 @@ ${message}${attachmentText}`);
                   details: { error: true, delivered: false, reason: goneChild }
                 };
               }
-              const listedTarget = await resolveTarget(connectedClient, to);
-              const sendTo = listedTarget ?? to;
+              const sendTo = await resolveRecipient(connectedClient, to);
               if (_signal?.aborted) {
                 const retained = retryIdentity === undefined ? undefined : retainInconclusiveRetry(retryIdentities, retryIdentity);
                 retryIdentity = undefined;
@@ -4672,6 +4715,7 @@ ${message}${attachmentText}`);
                 attachments,
                 replyTo,
                 expectsReply: true,
+                ...deliveryOption,
                 onReplyTarget: wait.bindSender
               });
               if (sendResult.queued === true) {
@@ -5561,6 +5605,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;
@@ -5575,6 +5626,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();
@@ -6654,8 +6724,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 = {
@@ -6663,7 +6734,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));
   };
 }
@@ -7902,8 +7973,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);
@@ -8959,7 +9031,8 @@ function createForwardedHandlerMap() {
     agent_end: [],
     tool_execution_start: [],
     tool_execution_end: [],
-    model_select: []
+    model_select: [],
+    message_start: []
   };
 }
 function addHandler(captured, event, handler) {
@@ -8993,6 +9066,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) {
@@ -9501,6 +9577,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;

package/dist/builtin/intercom/package.json

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

@@ -276,6 +276,7 @@ How a swarm works:
 - 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.
+- 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), and `"followUp"` when the message can wait until it finishes (low priority, "after you're done").
 - 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.
 

package/dist/builtin/intercom/types.ts

@@ -115,11 +115,19 @@ export interface BrokerStatusReport {
 	multiNode: BrokerMultiNodeStatus;
 }
 
+export type IntercomDeliveryMode = "steer" | "followUp" | "interrupt";
+
 export interface Message {
   id: string;
   timestamp: number;
   replyTo?: string;
   expectsReply?: boolean;
+  /**
+   * How a busy recipient receives this message. `steer` (default when absent) queues it until the current turn's tool
+   * calls finish, never cancelling in-flight work. `followUp` waits until the recipient's agent finishes and stops.
+   * `interrupt` cancels the current model call or cancellable tool call and handles the message next.
+   */
+  delivery?: IntercomDeliveryMode;
   /** Correlated delivery refusal: settles a waiting ask, otherwise surfaces as send feedback. */
   replyError?: string;
   source?: {

package/dist/builtin/mcp/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/mcp",
-  "version": "0.9.44-alpha.1",
+  "version": "0.9.44-alpha.3",
   "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.44-alpha.1",
+  "version": "0.9.44-alpha.3",
   "private": true,
   "description": "Atomic extension for delegating tasks to subagents with parallel execution. Fork of: https://github.com/nicobailon/pi-subagents",
   "contributors": [