@bastani/atomic 0.9.9-alpha.2 → 0.9.9-alpha.3

package/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 ## [Unreleased]
 
+## [0.9.9-alpha.3] - 2026-07-14
+
+### Added
+
+- Added `pi.sendMessages()` for atomic, array-ordered custom-message admission without waiting for the resulting model turn, allowing companion extensions to keep related preludes and terminal notices contiguous without globally serializing unrelated work.
+
+### Fixed
+
+- Preserved accepted async-child Intercom chronology across lazily activated companion extensions by atomically admitting same-child ordinary messages before pause, completion, and failure notices; unrelated children remain independent and ask/reply behavior is unchanged ([#1802](https://github.com/bastani-inc/atomic/issues/1802)).
+
 ## [0.9.9-alpha.2] - 2026-07-14
 
 ### Changed

package/dist/builtin/cursor/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 ## [Unreleased]
 
+## [0.9.9-alpha.3] - 2026-07-14
+
+### Changed
+
+- Published a synchronized Atomic 0.9.9-alpha.3 prerelease for the Cursor provider package; no functional Cursor provider changes were made after 0.9.9-alpha.2.
+
 ## [0.9.9-alpha.2] - 2026-07-14
 
 ### Changed

package/dist/builtin/cursor/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/cursor",
-  "version": "0.9.9-alpha.2",
+  "version": "0.9.9-alpha.3",
   "private": true,
   "description": "Experimental first-party Atomic extension for Cursor OAuth, model discovery, and streaming provider registration.",
   "contributors": [
@@ -40,7 +40,7 @@
     }
   },
   "dependencies": {
-    "@bastani/atomic-natives": "0.9.9-alpha.2",
+    "@bastani/atomic-natives": "0.9.9-alpha.3",
     "@bufbuild/protobuf": "^2.12.1",
     "@earendil-works/pi-ai": "^0.80.7"
   }

package/dist/builtin/intercom/CHANGELOG.md

@@ -4,6 +4,13 @@ All notable changes to the `pi-intercom` extension will be documented in this fi
 
 ## [Unreleased]
 
+## [0.9.9-alpha.3] - 2026-07-14
+
+### Fixed
+
+- Preserved per-child chronology between busy-parent Intercom messages and terminal async subagent notifications: paused, completed, and failed paths now claim pre-terminal ordinary messages from the exact child session/run in FIFO order and atomically admit the prelude plus terminal notice through the custom-message batch API. A process-local bridge complements extension-bus delivery for lazily activated companions; terminal identity deduplicates both paths even when the successful terminal dispatch has an empty prelude, while failed dispatches remain retryable and distinct resumed-run lifecycle terminals remain independent. Idle flushes use the same ordered batch admission, unrelated children remain independent, and ask/reply correlation is unchanged ([#1802](https://github.com/bastani-inc/atomic/issues/1802)).
+- Made every short session ID printed by `intercom list` directly actionable in `send`, blocking `ask`, and targeted `reply`. Target resolution now preserves exact full IDs and exact case-insensitive names before accepting unique ID prefixes, reports colliding prefixes with the matching sessions instead of guessing, resolves blocking asks to the full sender ID so threaded replies correlate correctly, and rejects short-form self-targets at both tool and broker routing boundaries.
+
 ## [0.9.9-alpha.2] - 2026-07-14
 
 ### Changed

package/dist/builtin/intercom/README.md

@@ -86,6 +86,9 @@ intercom({ action: "list" })
 intercom({ action: "send", to: "research", message: "Check if UserService.validate() handles null" })
 // → Message sent to research
 
+// The short ID printed by list is also a valid target
+intercom({ action: "ask", to: "6332faab", message: "Which validation path should I use?" })
+
 // Check connection status
 intercom({ action: "status" })
 // → Connected: Yes, Session ID: abc123, Active sessions: 3
@@ -119,6 +122,8 @@ See auth.ts:142-156.
 
 The reply hint (enabled by default) points to `intercom({ action: "reply", ... })`, so recipients do not need raw sender or `replyTo` IDs. Idle recipients get a new turn immediately; busy interactive recipients receive the message once they go idle. Attachment content is included in the agent-visible body, and messages are rendered inline and stored in Pi session history.
 
+For delegated background children, queued messages and terminal lifecycle notices are ordered per child. Intercom claims the terminal child’s pre-terminal ordinary entries in FIFO order and atomically admits that prelude together with the paused, completed, or failed notice. A process-local companion bridge covers lazily loaded extensions whose event buses are distinct, while exact terminal-identity deduplication prevents double admission even when the successful terminal dispatch has no queued prelude. Failed dispatches remain retryable, and pause/resume/completion identities remain distinct. Other children’s entries remain independently queued, messages are not discarded, terminal admission does not wait for a separate model turn, and correlated ask replies still bypass unrelated queued sends.
+
 ## Workflow: Planner-Worker Coordination
 
 The most natural use of pi-intercom is splitting a task between two sessions — one holds the big picture, the other does the hands-on work. When the worker hits an ambiguity ("should I optimize for readability or performance here?"), they ask without losing context.
@@ -317,7 +322,7 @@ The supervisor can reply with plain JSON or a fenced `json` block. If the reply
 | Parameter | Type | Description |
 |-----------|------|-------------|
 | `action` | string | `"list"`, `"send"`, `"ask"`, `"reply"`, `"pending"`, or `"status"` |
-| `to` | string | Target session name or ID (for send/ask, or to disambiguate reply) |
+| `to` | string | Exact session name, exact full ID, or unique ID prefix (for send/ask, or to disambiguate reply) |
 | `message` | string | Message text (for send/ask/reply) |
 | `attachments` | array | Optional `file`, `snippet`, or `context` attachments |
 | `replyTo` | string | Optional message ID for threading or replying to an `ask` |
@@ -340,13 +345,15 @@ Only registered in sessions where `pi-subagents` supplied the required child bri
 
 ### intercom actions
 
-**`list`** — Returns the current session plus other active intercom-connected sessions with name, short ID, working directory, model, and live status. Status is derived automatically from Pi lifecycle events: `idle`, `thinking`, or `tool:<name>`.
+**`list`** — Returns the current session plus other active intercom-connected sessions with name, short ID, working directory, model, and live status. Every displayed short ID can be passed directly to `send`, `ask`, or targeted `reply`. Status is derived automatically from Pi lifecycle events: `idle`, `thinking`, or `tool:<name>`.
+
+Target lookup preserves exact full IDs and exact case-insensitive names, then accepts a unique session-ID prefix. If a prefix matches multiple sessions, Intercom reports every match and asks for a longer ID or exact name instead of guessing. Resolving a prefix to the current session still triggers the normal self-target rejection.
 
 **`send`** — Sends a message to the specified session. By default it sends immediately, including in interactive sessions. Set `confirmSend: true` in config if you want a confirmation dialog for non-reply sends. Replies that include `replyTo` skip confirmation. Returns delivery confirmation.
 
 **`ask`** — Sends a message and waits for the recipient to reply (10-minute timeout). The reply is returned as the tool result. No confirmation dialog. Only one pending `ask` is allowed per session at a time; if several blocking requests race (parallel `ask` calls, or `ask` alongside `contact_supervisor`), one wins the reservation and each other call returns a normal "Already waiting for a reply" tool error without disturbing the pending ask. Use this when the agent needs the answer to continue working.
 
-**`reply`** — Replies to the current intercom-triggered message if there is one. Otherwise it falls back to the single unresolved inbound ask. If multiple asks are pending, pass `to` or inspect them with `pending` first. Under the hood this is still a normal `send` with the exact `replyTo` value.
+**`reply`** — Replies to the current intercom-triggered message if there is one. Otherwise it falls back to the single unresolved inbound ask. If multiple asks are pending, pass an exact name, exact full ID, or unique ID prefix in `to`, or inspect them with `pending` first. Under the hood this is still a normal `send` with the exact `replyTo` value.
 
 **`pending`** — Lists unresolved inbound asks with sender, message ID, elapsed time, and a short preview. Useful when replying after the original triggered turn.
 

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

@@ -5,6 +5,7 @@ import { writeMessage, createMessageReader } from "./framing.js";
 import { getBrokerSocketPath } from "./paths.js";
 import type { SessionInfo, Message, Attachment } from "../types.js";
 import { buildSendSignature, PendingSendRegistry } from "./pending-send-registry.js";
+import { readSubagentMessageSource } from "../source-ownership.js";
 
 const BROKER_SOCKET = getBrokerSocketPath();
 
@@ -453,6 +454,7 @@ export class IntercomClient extends EventEmitter {
       timestamp: Date.now(),
       replyTo: options.replyTo,
       expectsReply: options.expectsReply,
+      source: readSubagentMessageSource(),
       content: { text: options.text, attachments: options.attachments },
     };
     try {

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

@@ -1,5 +1,6 @@
 import type net from "node:net";
 import type { Attachment, BrokerMessage, Message, SessionInfo } from "../types.js";
+import { resolveSessionTarget, sessionTargetFailureReason } from "../session-target.js";
 import { DeliveredMessageCache } from "./delivered-message-cache.js";
 import { buildMessageSendSignature } from "./send-signature.js";
 
@@ -32,13 +33,6 @@ function isMessage(value: unknown): value is Message {
   return content.attachments === undefined || (Array.isArray(content.attachments) && content.attachments.every(isAttachment));
 }
 
-function findSessions(sessions: Map<string, BrokerConnectedSession>, nameOrId: string): BrokerConnectedSession[] {
-  const byId = sessions.get(nameOrId);
-  if (byId) return [byId];
-  const lowerName = nameOrId.toLowerCase();
-  return Array.from(sessions.values()).filter((session) => session.info.name?.toLowerCase() === lowerName);
-}
-
 /** Validate and route one wire-level send request. */
 export function handleBrokerSend(
   socket: net.Socket,
@@ -81,26 +75,34 @@ export function handleBrokerSend(
     return;
   }
 
-  const targets = findSessions(sessions, clientMessage.to);
-  if (targets.length === 1) {
+  const resolution = resolveSessionTarget(
+    Array.from(sessions.values(), (session) => session.info),
+    clientMessage.to,
+  );
+  if (resolution.kind === "resolved") {
+    const target = sessions.get(resolution.session.id);
     const fromSession = currentId ? sessions.get(currentId) : undefined;
     if (!fromSession) {
       write(socket, { type: "delivery_failed", messageId: message.id, attemptId, reason: "Sender session not found" });
       return;
     }
-    write(targets[0].socket, { type: "message", from: fromSession.info, message });
+    if (!target) {
+      write(socket, { type: "delivery_failed", messageId: message.id, attemptId, reason: "Session not found" });
+      return;
+    }
+    if (target.info.id === fromSession.info.id) {
+      write(socket, { type: "delivery_failed", messageId: message.id, attemptId, reason: "Cannot message the current session" });
+      return;
+    }
+    write(target.socket, { type: "message", from: fromSession.info, message });
     deliveredMessages.record(message.id, signature);
     write(socket, { type: "delivered", messageId: message.id, attemptId });
     return;
   }
-  if (targets.length > 1) {
-    write(socket, {
-      type: "delivery_failed",
-      messageId: message.id,
-      attemptId,
-      reason: `Multiple sessions named \"${clientMessage.to}\" are connected. Use the session ID instead.`,
-    });
-    return;
-  }
-  write(socket, { type: "delivery_failed", messageId: message.id, attemptId, reason: "Session not found" });
+  write(socket, {
+    type: "delivery_failed",
+    messageId: message.id,
+    attemptId,
+    reason: sessionTargetFailureReason(clientMessage.to, resolution),
+  });
 }

package/dist/builtin/intercom/foreground-detach-handoff.ts

@@ -130,7 +130,9 @@ export async function handleForegroundInboundDelivery(input: {
   surface: () => void;
   isCurrent: () => boolean;
   onUnclaimed: () => void;
+  onDelivered?: () => void;
 }): Promise<void> {
   const disposition = await input.handoff.deliver(input);
-  if (disposition === "unclaimed" && input.isCurrent()) input.onUnclaimed();
+  if (disposition === "delivered") input.onDelivered?.();
+  else if (disposition === "unclaimed" && input.isCurrent()) input.onUnclaimed();
 }

package/dist/builtin/intercom/inbound-idle-queue.ts

@@ -0,0 +1,82 @@
+import type { InboundMessageEntry } from "./intercom-utils.js";
+
+export interface InboundIdleClaim {
+  entries: InboundMessageEntry[];
+  rollbackFrom(index: number): void;
+}
+
+/**
+ * FIFO ownership for ordinary inbound messages accepted while the parent is
+ * busy. A terminal barrier may claim only entries from its exact child session
+ * target; unrelated children retain their original queue positions.
+ */
+export class InboundIdleQueue {
+  private entries: InboundMessageEntry[] = [];
+
+  get size(): number {
+    return this.entries.length;
+  }
+
+  enqueue(entry: InboundMessageEntry): void {
+    this.entries.push(entry);
+  }
+
+  has(entry: InboundMessageEntry): boolean {
+    return this.entries.includes(entry);
+  }
+
+  remove(entry: InboundMessageEntry): boolean {
+    const index = this.entries.indexOf(entry);
+    if (index < 0) return false;
+    this.entries.splice(index, 1);
+    return true;
+  }
+
+  drain(): InboundMessageEntry[] {
+    const entries = this.entries;
+    this.entries = [];
+    return entries;
+  }
+
+  claimOrdinarySourceTargets(runId: string, sourceSessionTargets: readonly string[], terminalAt = Number.POSITIVE_INFINITY): InboundIdleClaim {
+    const targets = new Set(sourceSessionTargets);
+    const original = this.entries;
+    const legacyIdsByName = new Map<string, Set<string>>();
+    for (const entry of original) {
+      if (entry.message.source?.subagentRunId !== undefined || entry.from.name === undefined) continue;
+      const ids = legacyIdsByName.get(entry.from.name) ?? new Set<string>();
+      ids.add(entry.from.id);
+      legacyIdsByName.set(entry.from.name, ids);
+    }
+    const selected = original.filter((entry) => {
+      if (entry.message.expectsReply) return false;
+      if (entry.message.timestamp > terminalAt) return false;
+      const idMatches = targets.has(entry.from.id);
+      const nameMatches = entry.from.name !== undefined && targets.has(entry.from.name);
+      if (!idMatches && !nameMatches) return false;
+      const sourceRunId = entry.message.source?.subagentRunId;
+      if (sourceRunId !== undefined) return sourceRunId === runId;
+      return idMatches || (entry.from.name !== undefined && legacyIdsByName.get(entry.from.name)?.size === 1);
+    });
+    const selectedSet = new Set(selected);
+    const originalSet = new Set(original);
+    this.entries = original.filter((entry) => !selectedSet.has(entry));
+    let settled = false;
+    return {
+      entries: selected,
+      rollbackFrom: (index) => {
+        if (settled) return;
+        settled = true;
+        const undelivered = new Set(selected.slice(index));
+        const laterEntries = this.entries.filter((entry) => !originalSet.has(entry));
+        this.entries = original
+          .filter((entry) => !selectedSet.has(entry) || undelivered.has(entry))
+          .concat(laterEntries);
+      },
+    };
+  }
+
+  clear(): void {
+    this.entries = [];
+  }
+}

package/dist/builtin/intercom/index-heavy.ts

@@ -15,6 +15,9 @@ import { registerSubagentRelay } from "./subagent-relay.js";
 import { ForegroundDetachHandoff, handleForegroundInboundDelivery } from "./foreground-detach-handoff.js";
 import { routeIncomingReply } from "./reply-routing.js";
 import { INBOUND_FLUSH_DELAY_MS, INBOUND_IDLE_RETRY_MS, type InboundMessageEntry, buildPresenceIdentity, formatAttachments, readChildOrchestratorMetadata, toError } from "./intercom-utils.js";
+import { InboundIdleQueue } from "./inbound-idle-queue.js";
+import { registerTerminalOrderingBarrier } from "./terminal-ordering-barrier.js";
+import { resolveSessionTargetId } from "./session-target.js";
 if (process.env.ATOMIC_TEST_LAZY_IMPORT_SENTINEL === "1") {
   process.env.ATOMIC_INTERCOM_HEAVY_IMPORTED = "1";
 }
@@ -48,7 +51,7 @@ export default function piIntercomExtension(pi: ExtensionAPI) {
   const replyTracker = new ReplyTracker();
   const replyWaiters = new ReplyWaiterSlot();
   const foregroundDetachHandoff = new ForegroundDetachHandoff(pi);
-  const pendingIdleMessages: InboundMessageEntry[] = [];
+  const pendingIdleMessages = new InboundIdleQueue();
   let inboundFlushTimer: NodeJS.Timeout | null = null;
   function rejectReplyWaiter(error: Error): void {
     replyWaiters.rejectCurrent(error);
@@ -137,25 +140,39 @@ export default function piIntercomExtension(pi: ExtensionAPI) {
     return Boolean(resolvedTo && activeClient?.sessionId && resolvedTo === activeClient.sessionId)
       || targets.has(to.trim().toLowerCase());
   }
-  function sendIncomingMessage(entry: InboundMessageEntry, delivery: "trigger" | "followUp", generation = runtimeGeneration): void {
+  function buildIncomingCustomMessage(entry: InboundMessageEntry) {
+    const senderDisplay = entry.from.name || entry.from.id.slice(0, 8);
+    const replyInstruction = entry.replyCommand ? `\n\nTo reply, use the intercom tool: ${entry.replyCommand}` : "";
+    return {
+      customType: "intercom_message" as const,
+      content: `**📨 From ${senderDisplay}** (${entry.from.cwd})${replyInstruction}\n\n${entry.bodyText}`,
+      display: true as const,
+      details: entry,
+    };
+  }
+  function sendIncomingMessage(entry: InboundMessageEntry, delivery: "trigger" | "followUp" | "prelude", generation = runtimeGeneration): void {
     if (runtimeStarted && !getLiveContext(runtimeContext, generation)) {
       return;
     }
     if (delivery === "trigger") {
       replyTracker.queueTurnContext({ from: entry.from, message: entry.message, receivedAt: Date.now() });
     }
-    const senderDisplay = entry.from.name || entry.from.id.slice(0, 8);
-    const replyInstruction = entry.replyCommand ? `\n\nTo reply, use the intercom tool: ${entry.replyCommand}` : "";
-    pi.sendMessage(
-      {
-        customType: "intercom_message",
-        content: `**📨 From ${senderDisplay}** (${entry.from.cwd})${replyInstruction}\n\n${entry.bodyText}`,
-        display: true,
-        details: entry,
-      },
-      delivery === "trigger" ? { triggerTurn: true } : { deliverAs: "followUp" },
-    );
+    const options = delivery === "trigger"
+      ? { triggerTurn: true } as const
+      : delivery === "followUp" ? { deliverAs: "followUp" } as const : undefined;
+    pi.sendMessage(buildIncomingCustomMessage(entry), options);
   }
+  registerTerminalOrderingBarrier(pi, {
+    queue: pendingIdleMessages,
+    toMessage: buildIncomingCustomMessage,
+    // A prelude is admitted synchronously when idle, or FIFO-queued when busy.
+    // The following terminal trigger therefore sees it in context first without
+    // waiting for a separate ordinary-message model turn to complete.
+    deliver: (entry) => sendIncomingMessage(entry, "prelude"),
+    onDrain: () => {
+      if (pendingIdleMessages.size === 0) clearInboundFlushTimer();
+    },
+  });
   function scheduleInboundFlush(delayMs = INBOUND_FLUSH_DELAY_MS): void {
     if (!getLiveContext()) {
       return;
@@ -168,7 +185,7 @@ export default function piIntercomExtension(pi: ExtensionAPI) {
     }, delayMs);
   }
   function flushIdleMessages(generation = runtimeGeneration): void {
-    if (pendingIdleMessages.length === 0) {
+    if (pendingIdleMessages.size === 0) {
       return;
     }
     const ctx = getLiveContext(runtimeContext, generation);
@@ -187,10 +204,12 @@ export default function piIntercomExtension(pi: ExtensionAPI) {
       return;
     }
 
-    const entries = pendingIdleMessages.splice(0, pendingIdleMessages.length);
-    entries.forEach((entry, index) => {
-      sendIncomingMessage(entry, index === 0 ? "trigger" : "followUp");
-    });
+    const entries = pendingIdleMessages.drain();
+    const first = entries[0];
+    if (first) replyTracker.queueTurnContext({ from: first.from, message: first.message, receivedAt: Date.now() });
+    const messages = entries.map(buildIncomingCustomMessage);
+    if (typeof pi.sendMessages === "function") pi.sendMessages(messages, { triggerTurn: true });
+    else messages.forEach((message, index) => pi.sendMessage(message, index === 0 ? { triggerTurn: true } : { deliverAs: "followUp" }));
   }
   function handleIncomingMessage(ctx: ExtensionContext, from: SessionInfo, message: Message): void {
     const messageGeneration = runtimeGeneration;
@@ -231,19 +250,24 @@ export default function piIntercomExtension(pi: ExtensionAPI) {
           }
           return;
         }
+        // Establish queue ownership before probing asynchronously. If a terminal
+        // barrier wins the race, the later foreground callback cannot redeliver.
+        pendingIdleMessages.enqueue(entry);
         await handleForegroundInboundDelivery({
           handoff: foregroundDetachHandoff,
           from,
           message,
           generation: messageGeneration,
-          surface: () => sendIncomingMessage(entry, "trigger", messageGeneration),
+          surface: () => {
+            if (pendingIdleMessages.remove(entry)) sendIncomingMessage(entry, "trigger", messageGeneration);
+          },
           isCurrent: () => Boolean(getLiveContext(liveContext, messageGeneration)),
           onUnclaimed: () => {
             // No exact foreground owner acknowledged the target. Preserve the
             // established background/cross-session behavior by waiting for idle.
-            pendingIdleMessages.push(entry);
-            scheduleInboundFlush(INBOUND_IDLE_RETRY_MS);
+            if (pendingIdleMessages.has(entry)) scheduleInboundFlush(INBOUND_IDLE_RETRY_MS);
           },
+          onDelivered: () => { pendingIdleMessages.remove(entry); },
         });
         return;
       }
@@ -345,19 +369,6 @@ export default function piIntercomExtension(pi: ExtensionAPI) {
     reconnectPromiseGeneration = generationAtStart;
     return nextReconnectPromise;
   }
-  async function resolveSessionTarget(activeClient: IntercomClient, nameOrId: string): Promise<string | null> {
-    const sessions = await activeClient.listSessions();
-    const byId = sessions.find(s => s.id === nameOrId);
-    if (byId) {
-      return byId.id;
-    }
-    const lowerName = nameOrId.toLowerCase();
-    const byName = sessions.filter(s => s.name?.toLowerCase() === lowerName);
-    if (byName.length > 1) {
-      throw new Error(`Multiple sessions named "${nameOrId}" are connected. Use the session ID instead.`);
-    }
-    return byName[0]?.id ?? null;
-  }
   registerSubagentRelay(pi, {
     runtimeGeneration: () => runtimeGeneration,
     runtimeStarted: () => runtimeStarted,
@@ -366,7 +377,7 @@ export default function piIntercomExtension(pi: ExtensionAPI) {
     currentSessionTargetMatches,
     sendIncomingMessage,
     ensureConnected,
-    resolveSessionTarget,
+    resolveSessionTarget: resolveSessionTargetId,
   });
 
   registerIntercomLifecycle(pi, {
@@ -408,14 +419,13 @@ export default function piIntercomExtension(pi: ExtensionAPI) {
     childOrchestratorMetadata,
     ensureConnected,
     syncPresenceIdentity,
-    resolveSessionTarget,
+    resolveSessionTarget: resolveSessionTargetId,
     beginReplyWait: (from, replyTo, signal) => replyWaiters.begin(from, replyTo, signal),
     hasReplyWaiter: () => replyWaiters.has(),
   });
   registerIntercomTool(pi, {
     ensureConnected,
     syncPresenceIdentity,
-    resolveSessionTarget,
     beginReplyWait: (from, replyTo, signal) => replyWaiters.begin(from, replyTo, signal),
     confirmSend: config.confirmSend,
     replyTracker,

package/dist/builtin/intercom/intercom-tool.ts

@@ -13,11 +13,12 @@ import {
   toError,
 } from "./intercom-utils.js";
 import type { ReplyTracker } from "./reply-tracker.ts";
+import { resolveSessionTargetId } from "./session-target.js";
 
 interface IntercomToolDeps {
   ensureConnected(reason: "tool"): Promise<IntercomClient>;
   syncPresenceIdentity(sessionId: string): void;
-  resolveSessionTarget(activeClient: IntercomClient, nameOrId: string): Promise<string | null>;
+  resolveSessionTarget?(activeClient: IntercomClient, nameOrId: string): Promise<string | null>;
   confirmSend: boolean;
   /**
    * Atomically reserve the single reply-waiter slot. Returns a structured
@@ -31,7 +32,8 @@ interface IntercomToolDeps {
 }
 
 export function registerIntercomTool(pi: ExtensionAPI, deps: IntercomToolDeps): void {
-  const { ensureConnected, syncPresenceIdentity, resolveSessionTarget, beginReplyWait, replyTracker, hasReplyWaiter } = deps;
+  const { ensureConnected, syncPresenceIdentity, beginReplyWait, replyTracker, hasReplyWaiter } = deps;
+  const resolveTarget = deps.resolveSessionTarget ?? resolveSessionTargetId;
   pi.registerTool({
     name: "intercom",
     label: "Intercom",
@@ -129,7 +131,7 @@ Usage:
             };
           }
           try {
-            const sendTo = await resolveSessionTarget(connectedClient, to) ?? to;
+            const sendTo = await resolveTarget(connectedClient, to) ?? to;
             if (sendTo === connectedClient.sessionId) {
               return {
                 content: [{ type: "text", text: "Cannot message the current session" }],
@@ -214,7 +216,7 @@ Usage:
           let wait: ReplyWait | null = null;
 
           try {
-            const sendTo = await resolveSessionTarget(connectedClient, to) ?? to;
+            const sendTo = await resolveTarget(connectedClient, to) ?? to;
             if (_signal?.aborted) {
               return {
                 content: [{ type: "text", text: "Cancelled" }],

package/dist/builtin/intercom/intercom-utils.ts

@@ -6,6 +6,7 @@ import type { Attachment, Message, SessionInfo } from "./types.ts";
 export const SUBAGENT_CONTROL_INTERCOM_EVENT = "subagent:control-intercom";
 export const SUBAGENT_RESULT_INTERCOM_EVENT = "subagent:result-intercom";
 export const SUBAGENT_RESULT_INTERCOM_DELIVERY_EVENT = "subagent:result-intercom-delivery";
+export const SUBAGENT_TERMINAL_ORDERING_BARRIER_EVENT = "subagent:terminal-ordering-barrier";
 export const INBOUND_FLUSH_DELAY_MS = 200;
 export const INBOUND_IDLE_RETRY_MS = 500;
 export const DEFAULT_UNNAMED_SESSION_ALIAS_PREFIX = "subagent-chat";
@@ -361,6 +362,35 @@ export function parseSubagentIntercomPayload(payload: unknown): { to: string; me
   const requestId = typeof record.requestId === "string" ? record.requestId : undefined;
   return { to: record.to, message: record.message, ...(requestId ? { requestId } : {}) };
 }
+function subagentTargetPart(value: string): string {
+  return value.trim().toLowerCase().replace(/[^a-z0-9_-]+/g, "-").replace(/^-+|-+$/g, "") || "agent";
+}
+
+function resolveSubagentSourceTarget(runId: string, agent: string, index: number): string {
+  return `subagent-${subagentTargetPart(agent)}-${subagentTargetPart(runId)}-${index + 1}`;
+}
+
+export function parseSubagentResultBarrier(payload: unknown): { runId: string; terminalId?: string; sourceSessionTargets: string[] } | null {
+  if (!payload || typeof payload !== "object" || Array.isArray(payload)) return null;
+  const record = payload as Record<string, unknown>;
+  if (typeof record.runId !== "string" || !Array.isArray(record.children)) return null;
+  const runId = record.runId;
+  const requestId = typeof record.requestId === "string" ? record.requestId : undefined;
+  const terminalId = requestId?.startsWith("completion-") ? requestId.slice("completion-".length) : requestId;
+  const sourceSessionTargets = record.children.flatMap((child, arrayIndex) => {
+    if (!child || typeof child !== "object" || Array.isArray(child)) return [];
+    const childRecord = child as Record<string, unknown>;
+    const target = typeof childRecord.intercomTarget === "string" ? childRecord.intercomTarget.trim() : "";
+    if (target) return [target];
+    if (typeof childRecord.agent !== "string") return [];
+    const index = typeof childRecord.index === "number" && Number.isInteger(childRecord.index) && childRecord.index >= 0
+      ? childRecord.index : arrayIndex;
+    return [resolveSubagentSourceTarget(runId, childRecord.agent, index)];
+  });
+  return sourceSessionTargets.length > 0
+    ? { runId, ...(terminalId ? { terminalId } : {}), sourceSessionTargets }
+    : null;
+}
 export function resolveIntercomPresenceName(sessionName: string | undefined, sessionId: string): string {
   const trimmedName = sessionName?.trim();
   if (trimmedName) {

package/dist/builtin/intercom/lifecycle.ts

@@ -1,7 +1,8 @@
 import type { ExtensionAPI, ExtensionContext } from "@bastani/atomic";
 import type { IntercomClient } from "./broker/client.ts";
 import type { IntercomConfig } from "./config.ts";
-import { buildPresenceIdentity, type InboundMessageEntry } from "./intercom-utils.js";
+import { buildPresenceIdentity } from "./intercom-utils.js";
+import type { InboundIdleQueue } from "./inbound-idle-queue.js";
 import type { ReplyTracker } from "./reply-tracker.ts";
 
 interface LifecycleDeps {
@@ -23,7 +24,7 @@ interface LifecycleDeps {
   getLiveContext(ctx?: ExtensionContext | null, generation?: number): ExtensionContext | null;
   rejectReplyWaiter(error: Error): void;
   replyTracker: ReplyTracker;
-  pendingIdleMessages: InboundMessageEntry[];
+  pendingIdleMessages: InboundIdleQueue;
   clearInboundFlushTimer(): void;
   scheduleInboundFlush(delayMs?: number): void;
   syncPresenceStatus(): void;
@@ -43,7 +44,7 @@ export function registerIntercomLifecycle(pi: ExtensionAPI, deps: LifecycleDeps)
     deps.clearReconnectTimer();
     deps.rejectReplyWaiter(new Error(reason));
     deps.replyTracker.reset();
-    deps.pendingIdleMessages.length = 0;
+    deps.pendingIdleMessages.clear();
     deps.clearInboundFlushTimer();
     deps.setAgentRunning(false);
     deps.activeTools.clear();
@@ -89,7 +90,9 @@ export function registerIntercomLifecycle(pi: ExtensionAPI, deps: LifecycleDeps)
   pi.on("turn_end", () => {
     if (!deps.getLiveContext()) return;
     deps.replyTracker.endTurn();
-    deps.scheduleInboundFlush(0);
+    // Preserve the normal grace period so a same-tick terminal barrier can
+    // claim accepted child messages before idle delivery releases ownership.
+    deps.scheduleInboundFlush();
   });
   pi.on("agent_start", () => {
     if (!deps.getLiveContext()) return;
@@ -112,7 +115,7 @@ export function registerIntercomLifecycle(pi: ExtensionAPI, deps: LifecycleDeps)
     deps.setAgentRunning(false);
     deps.activeTools.clear();
     deps.syncPresenceStatus();
-    deps.scheduleInboundFlush(0);
+    deps.scheduleInboundFlush();
   });
   pi.on("turn_start", (_event, ctx) => {
     if (!deps.getLiveContext(ctx)) return;

package/dist/builtin/intercom/package.json

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