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

package/CHANGELOG.md

@@ -2,6 +2,22 @@
 
 ## [Unreleased]
 
+## [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,16 @@ All notable changes to the `pi-intercom` extension will be documented in this fi
 
 ## [Unreleased]
 
+## [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/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))
@@ -689,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 }
   });
 }
 
@@ -1990,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 }
@@ -2790,6 +2794,7 @@ class ReplyTracker {
   pendingAsks = new Map;
   pendingTurnContexts = [];
   currentTurnContext = null;
+  turnContextAdmitted = false;
   constructor(askTimeoutMs = ASK_REPLY_TIMEOUT_MS) {
     this.askTimeoutMs = askTimeoutMs;
   }
@@ -2815,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();
@@ -2872,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`");
@@ -4078,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:
@@ -4089,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
@@ -4113,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"
       })),
@@ -4130,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) {
@@ -4440,7 +4467,8 @@ ${message}${attachmentText}`);
                 logicalTarget: to,
                 text: message,
                 attachments,
-                replyTo
+                replyTo,
+                ...deliveryOption
               });
               if (result.queued === true) {
                 retryIdentities.release(retryIdentity);
@@ -4672,6 +4700,7 @@ ${message}${attachmentText}`);
                 attachments,
                 replyTo,
                 expectsReply: true,
+                ...deliveryOption,
                 onReplyTarget: wait.bindSender
               });
               if (sendResult.queued === true) {
@@ -5561,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;
@@ -5575,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();
@@ -6654,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 = {
@@ -6663,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));
   };
 }
@@ -7902,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);
@@ -8959,7 +9016,8 @@ function createForwardedHandlerMap() {
     agent_end: [],
     tool_execution_start: [],
     tool_execution_end: [],
-    model_select: []
+    model_select: [],
+    message_start: []
   };
 }
 function addHandler(captured, event, handler) {
@@ -8993,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) {
@@ -9501,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;

package/dist/builtin/intercom/package.json

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

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/web-access",
-  "version": "0.9.44-alpha.1",
+  "version": "0.9.44-alpha.2",
   "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,12 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 
 ## [Unreleased]
 
+## [0.9.44-alpha.2] - 2026-10-24
+
+### Fixed
+
+- A sticky Intercom broadcast, such as `workflow:<rootRunId>/**`, that reaches many workflow stages no longer makes the workflow journal grow quadratically. Recording one more delivery used to rewrite every stage's deliveries in the run's queued-message event; each event now stores only the deliveries that changed since the run's previous event. In a 160-worker run this shrinks those events from about 160 MB to about 9 MB. Journals written by earlier versions read and resume unchanged ([#3920](https://github.com/bastani-inc/atomic/issues/3920))
+
 ## [0.9.44-alpha.1] - 2026-10-24
 
 ### Changed

package/dist/builtin/workflows/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/workflows",
-  "version": "0.9.44-alpha.1",
+  "version": "0.9.44-alpha.2",
   "private": true,
   "description": "Atomic extension for multi-stage workflow authoring and execution.",
   "contributors": [

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

@@ -6808,6 +6808,13 @@ function removeProcessExitCleanup(cleanup) {
   if (processExitCleanups.delete(cleanup) && processExitCleanups.size === 0)
     process.off("exit", runProcessExitCleanups);
 }
+function snapshotNeedsHistory(tail) {
+  const event = tail.snapshot.event;
+  if (event.type !== RUN_EVENT_TYPES.messageQueued)
+    return false;
+  const payload = event.payload;
+  return hasPendingStageDeliveryDelta(payload.pendingStageMessages);
+}
 function* invoke(action) {
   try {
     const result = action();
@@ -6923,8 +6930,11 @@ class JournalDurableBackend {
       this.projection.applyWorkflowSnapshot(event.payload.handle);
       this.prompts.set(entry.runId, new PromptReservationState(event.payload.handle.pendingPrompts, event.payload.prompts));
     } else {
-      const handle = event.payload;
       const previous = this.projection.getWorkflow(entry.runId);
+      const handle = event.type === RUN_EVENT_TYPES.messageQueued && hasPendingStageDeliveryDelta(event.payload.pendingStageMessages) ? {
+        ...event.payload,
+        pendingStageMessages: decodePendingStageDeliveries(previous?.pendingStageMessages ?? [], event.payload.pendingStageMessages ?? [])
+      } : event.payload;
       this.projection.applyWorkflowSnapshot(handle);
       if (event.type === RUN_EVENT_TYPES.runStarted || previous?.pendingPrompts !== handle.pendingPrompts)
         this.prompts.delete(entry.runId);
@@ -7220,11 +7230,23 @@ class JournalDurableBackend {
     for (const message of messages)
       if (message.runId !== logicalRunId)
         throw new JournalMessageScopeError(logicalRunId, message.runId);
-    yield* this.snapshot({
+    const next = {
       ...handle,
       pendingStageMessages: replacePendingStageMessagesForRun(handle.pendingStageMessages ?? [], logicalRunId, messages),
       updatedAt: Math.max(Date.now(), handle.updatedAt + 1)
-    }, RUN_EVENT_TYPES.messageQueued);
+    };
+    const encoded = encodePendingStageDeliveries(handle.pendingStageMessages ?? [], next.pendingStageMessages ?? []);
+    const base = this.sequences.get(runId);
+    if (encoded !== undefined && base !== undefined) {
+      try {
+        yield* this.append(runId, { type: RUN_EVENT_TYPES.messageQueued, payload: { ...next, pendingStageMessages: encoded } }, { expectSeq: base });
+        return true;
+      } catch (error) {
+        if (!(error instanceof JournalCasConflictError))
+          throw error;
+      }
+    }
+    yield* this.snapshot(next, RUN_EVENT_TYPES.messageQueued);
     return true;
   }
   async archivePendingStageMessage(runId, message) {
@@ -7318,7 +7340,7 @@ class JournalDurableBackend {
       if (summarized !== undefined && summarized.seq === version.seq && summarized.at === version.at)
         return;
       const tail = yield* invoke(() => journal.snapshotTail(runId));
-      if (tail !== undefined)
+      if (tail !== undefined && !snapshotNeedsHistory(tail))
         return this.summarize(runId, tail);
       if (summarized === undefined && version.seq === 0)
         return;
@@ -7544,6 +7566,69 @@ class JournalDurableBackend {
     }
   }
 }
+function identity(message) {
+  return JSON.stringify([message.runId, message.id]);
+}
+function uniqueByIdentity(messages) {
+  const result = new Map;
+  const repeated = new Set;
+  for (const message of messages) {
+    const key = identity(message);
+    if (result.has(key))
+      repeated.add(key);
+    result.set(key, message);
+  }
+  for (const key of repeated)
+    result.delete(key);
+  return result;
+}
+function isDeltaEncoded(message) {
+  return message.deliveryDelta !== undefined;
+}
+function encodePendingStageDeliveries(previous, next) {
+  const bases = uniqueByIdentity(previous);
+  const nextIdentities = uniqueByIdentity(next);
+  let encodedAny = false;
+  const encoded = next.map((message) => {
+    const base = bases.get(identity(message))?.deliveries;
+    const deliveries = message.deliveries;
+    if (base === undefined || deliveries === undefined || !nextIdentities.has(identity(message)))
+      return message;
+    const drop = [];
+    let kept = 0;
+    base.forEach((delivery, index) => {
+      if (kept < deliveries.length && JSON.stringify(delivery) === JSON.stringify(deliveries[kept]))
+        kept++;
+      else
+        drop.push(index);
+    });
+    const add = deliveries.slice(kept);
+    if (drop.length + add.length >= deliveries.length)
+      return message;
+    encodedAny = true;
+    const { deliveries: _full, ...rest } = message;
+    return { ...rest, deliveryDelta: drop.length === 0 ? { add } : { drop, add } };
+  });
+  return encodedAny ? encoded : undefined;
+}
+function decodePendingStageDeliveries(previous, messages) {
+  if (!messages.some(isDeltaEncoded))
+    return messages;
+  const bases = uniqueByIdentity(previous);
+  return messages.map((message) => {
+    if (!isDeltaEncoded(message))
+      return message;
+    const base = bases.get(identity(message))?.deliveries;
+    if (base === undefined)
+      throw new Error(`atomic-workflows: journal delivery change for ${identity(message)} has no base entry`);
+    const { deliveryDelta, ...rest } = message;
+    const dropped = new Set(deliveryDelta.drop ?? []);
+    return { ...rest, deliveries: [...base.filter((_, index) => !dropped.has(index)), ...deliveryDelta.add] };
+  });
+}
+function hasPendingStageDeliveryDelta(messages) {
+  return messages?.some(isDeltaEncoded) === true;
+}
 var PROCESS_HOLDER_ID, processExitCleanups, JournalOwnershipError, JournalBackendClosedError, JournalOperationAbortedError, JournalExecutionRetiredError, JournalMessageScopeError;
 var init_journal_backend = __esm(() => {
   init_workflow_instance_ownership_error();
@@ -61647,7 +61732,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 }
   });
 }
 
@@ -61833,6 +61919,8 @@ function isMessage(value2) {
     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))
@@ -63042,6 +63130,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 }