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

package/dist/builtin/intercom/CHANGELOG.md

@@ -4,6 +4,14 @@ All notable changes to the `pi-intercom` extension will be documented in this fi
 
 ## [Unreleased]
 
+## [0.9.18-alpha.3] - 2026-09-01
+
+### Fixed
+
+- Recoverable Intercom disconnects during lazy initialization no longer print a misleading error and stack trace in the interactive UI; later calls still retry initialization.
+- Fixed workflow invocation control across isolated workflow-owned subgroups: canonical pending/running roster discovery, queued pending sends, immediate live send/ask with correlated replies, immutable registration-based directory authorization after mutable joins, directional sibling and cross-run isolation, and invocation-unique group names ([#2784](https://github.com/bastani-inc/atomic/issues/2784)).
+- Durably queued pending-stage sends are now rendered as successful sends instead of failed sends ([#2784](https://github.com/bastani-inc/atomic/issues/2784)).
+
 ## [0.9.17] - 2026-08-29
 
 Cumulative release of the `0.9.17-alpha.1` prerelease. The summary below covers the user-visible outcome of that work; the per-change detail remains in the prerelease section below.

package/dist/builtin/intercom/README.md

@@ -367,11 +367,11 @@ Only registered in sessions where `pi-subagents` supplied the required child bri
 
 **`list`** — Keeps session-listing semantics: returns the current session and every active session sharing at least one membership. Pass `group` for a read-only view of one group.
 
-Live target lookup accepts only an exact full session ID or an exact case-insensitive session name. Ordinary `send` also accepts `<runId>:<stageKey>` for a known workflow stage whose session has not initialized. The run ID is a full UUID and the stage key is exact. Unknown runs and stages retain the ordinary unknown-target failure. All targeting remains **group-scoped** — see [Groups](#groups) below.
+Live target lookup accepts only an exact full Intercom session ID or an exact case-insensitive session name. `intercom list` also returns materialized workflow-stage rows labeled `PENDING` or `RUNNING`, with canonical `<runId>:<stageId>` targets and actual groups. From the main chat, join `workflow:<rootRunId>` before controlling those targets. An eligible invocation member has directional list/send/live-ask control over stages in owned `workflow:<rootRunId>/...` subgroups. A subgroup stage or another workflow root cannot turn a mutable join into parent control; sibling subgroups stay isolated, and explicit `group: "default"` remains non-owned.
 
-**`send`** — Sends through ordinary Intercom. Live workflow-stage sessions receive messages immediately and return `delivered`. For a known pending stage, Atomic persists the message and returns the distinct `queued` result with its FIFO position, then delivers it through the ordinary inbound path when the stage session initializes. Each exact run/stage key retains at most 50 queued messages; the next send is refused rather than evicting an older one. Only sessions in the run's Intercom group may queue messages. Delivery occurs before the first model turn under **Messages received before you started**, with sender identity and `Sent:` timestamp separate from the task prompt. Resume/replay, broker restart, and stage-attempt restart preserve exactly-once delivery by logical message ID. Skipped, cancelled, and terminal-before-initialization destinations make pending messages undeliverable and notify the sender. If the sender reconnects with a new broker UUID, notification fallback requires one unique same-group match for the immutable registration-time name; mutable presence names/groups, cross-group matches, and ambiguous duplicates are rejected. The broker trusts that initial name/group as host-orchestration metadata, while the original display/provenance remains unchanged in the durable record. Live sends remain immediate by default; `confirmSend: true` still enables confirmation for non-reply sends.
+**`send`** — Sends through ordinary Intercom. Live workflow-stage sessions receive messages immediately and return `delivered`. Known pending invocation-owned stages queue durably and return the distinct `queued` result with its FIFO position; a main-chat session that explicitly joined the owning invocation group may use that route. Pending `group: "default"` stages remain ineligible, and an ineligible attempt is refused with `Target workflow run is in a different intercom group`. Each exact run/stage key retains at most 50 queued messages; the next send is refused rather than evicting an older one. Delivery occurs before the first model turn under **Messages received before you started**, with sender identity and `Sent:` timestamp separate from the task prompt. Resume/replay, broker restart, and stage-attempt restart preserve exactly-once delivery by logical message ID. Skipped, cancelled, and terminal-before-initialization destinations make pending messages undeliverable and notify the sender. If the sender reconnects with a new broker UUID, notification fallback requires one unique same-group match for the immutable registration-time name; mutable presence names/groups, cross-group matches, and ambiguous duplicates are rejected. The broker trusts that initial name/group as host-orchestration metadata, while the original display/provenance remains unchanged in the durable record. Live sends remain immediate by default; `confirmSend: true` still enables confirmation for non-reply sends.
 
-**`ask`** — Sends a message and waits for a live recipient to reply (10-minute timeout). An ask to a known workflow stage whose session has not initialized is refused with `pending_stage_ask_unsupported` and recommends ordinary `send`, because holding a reply waiter until a stage eventually starts would be unbounded. A recipient disconnect after live delivery fails only that peer's exact wait promptly; the timeout remains the backstop while the recipient stays connected. Up to `maxPendingAsks` blocking asks (default: 6) may run concurrently, including same-target and mixed-target fan-out. Replies resolve by exact sender and message ID, so out-of-order replies cannot cross-settle another call. When capacity is full, new asks receive a structured refusal.
+**`ask`** — Sends a message and waits for a live recipient to reply (10-minute timeout). Invocation control supports a live ask into an owned isolated subgroup, and the exact broker-recorded reply resolves the waiting tool call at the asker without opening reverse or lateral group access. Ask to an uninitialized stage remains refused with `pending_stage_ask_unsupported`; use queued `send` instead, because holding a reply waiter until a stage eventually starts would be unbounded. A recipient disconnect after live delivery fails only that peer's exact wait promptly; the timeout remains the backstop while the recipient stays connected. Up to `maxPendingAsks` blocking asks (default: 6) may run concurrently, including same-target and mixed-target fan-out. Replies resolve by exact sender and message ID, so out-of-order replies cannot cross-settle another call. When capacity is full, new asks receive a structured refusal.
 
 **`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/full session ID in `to`, or the listed message ID in `replyTo`; use `pending` to inspect them first. `replyTo` also disambiguates multiple asks from the same sender. Under the hood this is still a normal `send` with the exact `replyTo` value.
 

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

@@ -6,7 +6,14 @@ import { writeFileSync, unlinkSync, mkdirSync, readFileSync } from "fs";
 import { randomUUID } from "crypto";
 import { writeMessage, createMessageReader } from "./framing.js";
 import { getBrokerPidPath, getBrokerSocketPath, getIntercomDirPath } from "./paths.js";
-import type { SessionInfo, Message, BrokerMessage, SupervisorRegistration } from "../types.js";
+import type {
+	SessionInfo,
+	Message,
+	BrokerMessage,
+	SupervisorRegistration,
+	WorkflowStageRosterAnnouncement,
+	WorkflowStageRosterEntry,
+} from "../types.js";
 import { DeliveredMessageCache } from "./delivered-message-cache.js";
 import { isMessage } from "./client-message-validation.js";
 import { buildMessageSendSignature } from "./send-signature.js";
@@ -40,6 +47,13 @@ interface PendingStageRouteRegistration {
   readonly capability: string;
 }
 
+interface WorkflowRosterRegistration {
+	readonly ownerSessionId: string;
+	readonly group: string;
+	readonly stages: WorkflowStageRosterAnnouncement[];
+}
+
+
 interface PendingStageAcknowledgment {
   readonly ownerSessionId: string;
   readonly senderSocket: net.Socket;
@@ -116,6 +130,31 @@ function isSupervisorRegistration(value: unknown): value is SupervisorRegistrati
     && typeof registration.supervisorSessionId === "string";
 }
 
+function invocationOwnsGroup(invocationGroup: string, candidateGroup: string): boolean {
+	const owner = normalizeGroup(invocationGroup);
+	const candidate = normalizeGroup(candidateGroup);
+	return candidate === owner || candidate.startsWith(`${owner}/`);
+}
+
+function isWorkflowStageRosterAnnouncements(value: unknown, runId: string): value is WorkflowStageRosterAnnouncement[] {
+	return (
+		Array.isArray(value) &&
+		value.every(
+			(stage) =>
+				typeof stage === "object" &&
+				stage !== null &&
+				typeof (stage as WorkflowStageRosterAnnouncement).stageId === "string" &&
+				typeof (stage as WorkflowStageRosterAnnouncement).stageName === "string" &&
+				(stage as WorkflowStageRosterAnnouncement).target ===
+					`${runId}:${(stage as WorkflowStageRosterAnnouncement).stageId}` &&
+				((stage as WorkflowStageRosterAnnouncement).lifecycle === "pending" ||
+					(stage as WorkflowStageRosterAnnouncement).lifecycle === "running") &&
+				typeof (stage as WorkflowStageRosterAnnouncement).routeEligible === "boolean" &&
+				typeof (stage as WorkflowStageRosterAnnouncement).group === "string"
+		)
+	);
+}
+
 
 class IntercomBroker {
   private sessions = new Map<string, ConnectedSession>();
@@ -128,6 +167,7 @@ class IntercomBroker {
   private pendingStageAcknowledgments = new Map<string, PendingStageAcknowledgment>();
 	private pendingStageNotificationAcknowledgments = new Map<string, PendingStageNotificationAcknowledgment>();
   private liveWorkflowStageRoutes = new Map<string, LiveWorkflowStageRouteRegistration>();
+  private workflowRosters = new Map<string, WorkflowRosterRegistration>();
   private liveWorkflowStageRouteActivations = new Map<string, LiveWorkflowStageRouteActivation>();
 
   constructor() {
@@ -203,6 +243,74 @@ class IntercomBroker {
     return undefined;
   };
 
+	private canInspectSelectedGroup(requester: ConnectedSession, selectedGroup: string): boolean {
+		const selected = normalizeGroup(selectedGroup);
+		const groups = sessionGroups(requester.info);
+		for (const roster of this.workflowRosters.values()) {
+			if (!roster.stages.some((stage) => stage.group === selected && invocationOwnsGroup(roster.group, selected))) continue;
+			return groups.has(selected) || this.canControlWorkflowInvocation(requester, roster.group);
+		}
+		return true;
+	}
+
+	/**
+	 * Invocation control may come from the invocation owner or from an ordinary
+	 * host session that explicitly joined the invocation group. A workflow stage
+	 * registered under any workflow group cannot turn mutable membership into a
+	 * parent-control capability for a sibling (or for another workflow run).
+	 */
+	private canControlWorkflowInvocation(sender: ConnectedSession, invocationGroup: string): boolean {
+		if (!hasGroup(sessionGroups(sender.info), invocationGroup)) return false;
+		const registrationGroup = normalizeGroup(sender.registrationGroup);
+		return registrationGroup === invocationGroup || !registrationGroup.startsWith("workflow:");
+	}
+
+	private canControlLiveWorkflowStage = (
+		sender: ConnectedSession,
+		target: ConnectedSession,
+		logicalTarget: string,
+	): boolean => {
+		const parsed = parsePendingStageTarget(logicalTarget);
+		const owner = parsed === undefined ? undefined : this.pendingStageRoutes.get(parsed.runId);
+		const live = this.liveWorkflowStageRoutes.get(logicalTarget);
+		if (owner === undefined || live?.sessionId !== target.info.id) return false;
+		const targetGroup = target.registrationGroup ?? target.info.group ?? "default";
+		return this.canControlWorkflowInvocation(sender, owner.group) && invocationOwnsGroup(owner.group, targetGroup);
+	};
+
+	private workflowStagesVisibleTo(requester: ConnectedSession, selectedGroup?: string): WorkflowStageRosterEntry[] {
+	const requesterGroups = sessionGroups(requester.info);
+	const selected = selectedGroup === undefined ? undefined : normalizeGroup(selectedGroup);
+	const entries: WorkflowStageRosterEntry[] = [];
+	for (const [runId, roster] of this.workflowRosters) {
+		for (const stage of roster.stages) {
+			if (!stage.routeEligible) continue;
+			const parentControl =
+				this.canControlWorkflowInvocation(requester, roster.group) && invocationOwnsGroup(roster.group, stage.group);
+			const directMembership = requesterGroups.has(stage.group);
+			if (!parentControl && !directMembership) continue;
+			if (selected !== undefined && selected !== stage.group) continue;
+			const live = this.liveWorkflowStageRoutes.get(stage.target);
+			const liveSession = live === undefined ? undefined : this.sessions.get(live.sessionId);
+			if (stage.lifecycle === "running" && liveSession === undefined) continue;
+			// #2784: never list the requester's own stage as an "other" participant.
+			// Ordinary session rows already exclude self; the roster must match.
+			if (liveSession !== undefined && liveSession.info.id === requester.info.id) continue;
+			entries.push({
+				kind: "workflow-stage",
+				runId,
+				stageId: stage.stageId,
+				stageName: stage.stageName,
+				target: stage.target,
+				lifecycle: liveSession === undefined ? "pending" : "running",
+				group: stage.group,
+				...(liveSession === undefined ? {} : { sessionId: liveSession.info.id }),
+			});
+		}
+	}
+	return entries;
+  }
+
   private acknowledgeLiveWorkflowStageRoute(requestId: string): void {
     const activation = this.liveWorkflowStageRouteActivations.get(requestId);
     if (activation === undefined || activation.pendingRequestIds.size > 0) return;
@@ -258,7 +366,7 @@ class IntercomBroker {
       this.pendingStageRoutes.delete(route.runId);
       return false;
     }
-		if (route.liveTargetId === undefined && !hasGroup(sessionGroups(route.from.info), ownerRegistration.group)) {
+    if (route.liveTargetId === undefined && !this.canControlWorkflowInvocation(route.from, ownerRegistration.group)) {
       writeMessage(route.socket, {
         type: "delivery_failed",
         messageId: route.message.id,
@@ -659,10 +767,18 @@ class IntercomBroker {
 
         const requester = currentId ? this.sessions.get(currentId) : undefined;
 		if (requester === undefined) throw new Error("Session not found");
-        const sessions = typeof clientMessage.group === "string"
-			? sessionsInGroup(this.sessions, clientMessage.group)
-			: sessionsVisibleTo(this.sessions, requester.info);
-        writeMessage(socket, { type: "sessions", requestId: clientMessage.requestId, sessions });
+		const sessions =
+			typeof clientMessage.group === "string"
+				? this.canInspectSelectedGroup(requester, clientMessage.group)
+					? sessionsInGroup(this.sessions, clientMessage.group)
+					: []
+				: sessionsVisibleTo(this.sessions, requester.info);
+        writeMessage(socket, {
+			type: "sessions",
+			requestId: clientMessage.requestId,
+			sessions,
+			workflowStages: this.workflowStagesVisibleTo(requester, clientMessage.group),
+		});
         break;
       }
 
@@ -726,10 +842,26 @@ class IntercomBroker {
           socket.end();
           return;
         }
+        if (
+          clientMessage.stages !== undefined &&
+          (!isWorkflowStageRosterAnnouncements(clientMessage.stages, clientMessage.runId) ||
+            !clientMessage.stages.every((stage) => invocationOwnsGroup(ownerGroup, stage.group)))
+        ) {
+          writeMessage(socket, { type: "registration_failed", reason: "Invalid workflow-stage roster" });
+          socket.end();
+          return;
+        }
         if (activeExisting !== undefined && activeExisting.sessionId !== currentId) {
-          // A stage replays the process-shared owner announcement before
-          // registering its live aliases. Authenticate it without replacing
-          // the workflow owner that handles pending delivery.
+          // A stage replays the process-shared owner announcement before registering its live aliases.
+          // It may publish the materialized roster, but the original workflow owner must continue to
+          // handle pending delivery and own roster cleanup.
+          if (clientMessage.stages !== undefined) {
+            this.workflowRosters.set(clientMessage.runId, {
+              ownerSessionId: activeExisting.sessionId,
+              group: ownerGroup,
+              stages: clientMessage.stages,
+            });
+          }
           break;
         }
         this.pendingStageRoutes.set(clientMessage.runId, {
@@ -737,6 +869,13 @@ class IntercomBroker {
           group: ownerGroup,
           capability: clientMessage.capability,
         });
+        if (clientMessage.stages !== undefined) {
+          this.workflowRosters.set(clientMessage.runId, {
+            ownerSessionId: currentId,
+            group: ownerGroup,
+            stages: clientMessage.stages,
+          });
+        }
         break;
       }
 
@@ -764,8 +903,10 @@ class IntercomBroker {
           ownerRegistration === undefined ||
           registeringSession === undefined ||
           ownerRegistration.capability !== clientMessage.capability ||
-          normalizeGroup(ownerRegistration.group) !==
-            normalizeGroup(registeringSession.registrationGroup ?? registeringSession.info.group) ||
+		  !invocationOwnsGroup(
+			ownerRegistration.group,
+			registeringSession.registrationGroup ?? registeringSession.info.group ?? "default",
+		  ) ||
           !this.registerLiveWorkflowStageRoute(
             currentId,
             clientMessage.requestId,
@@ -821,6 +962,7 @@ class IntercomBroker {
 				this.pendingQuestions,
 				this.routePendingStage,
 				this.resolveLiveWorkflowStage,
+				this.canControlLiveWorkflowStage,
 			);
 			break;
 		}
@@ -873,7 +1015,9 @@ class IntercomBroker {
     }
 
     for (const [runId, owner] of this.pendingStageRoutes) {
-      if (owner.sessionId === sessionId) this.pendingStageRoutes.delete(runId);
+      if (owner.sessionId !== sessionId) continue;
+      this.pendingStageRoutes.delete(runId);
+      this.workflowRosters.delete(runId);
     }
     for (const [requestId, pending] of this.pendingStageAcknowledgments) {
       if (pending.ownerSessionId !== sessionId) continue;

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

@@ -3,7 +3,16 @@ import net from "net";
 import { randomUUID } from "crypto";
 import { writeMessage, createMessageReader } from "./framing.js";
 import { getBrokerSocketPath } from "./paths.js";
-import type { SessionInfo, Message, Attachment, GroupSummary, SupervisorRegistration } from "../types.js";
+import type {
+	SessionInfo,
+	Message,
+	Attachment,
+	GroupSummary,
+	SupervisorRegistration,
+	SessionDirectory,
+	WorkflowStageRosterAnnouncement,
+	WorkflowStageRosterEntry,
+} from "../types.js";
 import { buildSendSignature, PendingSendRegistry } from "./pending-send-registry.js";
 import { readSubagentMessageSource } from "../source-ownership.js";
 import { isMessage, isSessionInfo } from "./client-message-validation.js";
@@ -74,6 +83,27 @@ function toError(error: unknown): Error {
 }
 
 
+function isWorkflowStageRosterEntries(value: unknown): value is WorkflowStageRosterEntry[] {
+	return (
+		Array.isArray(value) &&
+		value.every(
+			(entry) =>
+				typeof entry === "object" &&
+				entry !== null &&
+				(entry as WorkflowStageRosterEntry).kind === "workflow-stage" &&
+				typeof (entry as WorkflowStageRosterEntry).runId === "string" &&
+				typeof (entry as WorkflowStageRosterEntry).stageId === "string" &&
+				typeof (entry as WorkflowStageRosterEntry).stageName === "string" &&
+				typeof (entry as WorkflowStageRosterEntry).target === "string" &&
+				((entry as WorkflowStageRosterEntry).lifecycle === "pending" ||
+					(entry as WorkflowStageRosterEntry).lifecycle === "running") &&
+				typeof (entry as WorkflowStageRosterEntry).group === "string" &&
+				((entry as WorkflowStageRosterEntry).sessionId === undefined ||
+					typeof (entry as WorkflowStageRosterEntry).sessionId === "string"),
+		)
+	);
+}
+
 export class IntercomClient extends EventEmitter {
 	private readonly returnAddress: string;
   private socket: net.Socket | null = null;
@@ -83,7 +113,7 @@ export class IntercomClient extends EventEmitter {
   private _messageSource: Message["source"] | undefined;
   private pendingSends = new PendingSendRegistry();
   private pendingGroupLists = new Map<string, { resolve: (groups: GroupSummary[]) => void; reject: (error: Error) => void }>();
-  private pendingLists = new Map<string, { resolve: (sessions: SessionInfo[]) => void; reject: (e: Error) => void }>();
+  private pendingLists = new Map<string, { resolve: (directory: SessionDirectory) => void; reject: (e: Error) => void }>();
   private pendingPresence = new Map<string, {
     resolve: (group: string) => void;
     reject: (error: Error) => void;
@@ -329,19 +359,21 @@ export class IntercomClient extends EventEmitter {
         break;
       }
       case "sessions": {
-        const { requestId, sessions } = brokerMessage;
-        if (typeof requestId !== "string" || !Array.isArray(sessions) || !sessions.every(isSessionInfo)) {
-          throw new Error("Invalid sessions message");
-        }
-        const pending = this.pendingLists.get(requestId);
-        if (!pending) {
-          // Late list responses can still arrive after the caller has already timed out.
-          return;
-        }
-        this.pendingLists.delete(requestId);
-        pending.resolve(sessions);
-        break;
-      }
+		const { requestId, sessions, workflowStages } = brokerMessage;
+		if (
+			typeof requestId !== "string" ||
+			!Array.isArray(sessions) ||
+			!sessions.every(isSessionInfo) ||
+			(workflowStages !== undefined && !isWorkflowStageRosterEntries(workflowStages))
+		) {
+			throw new Error("Invalid sessions message");
+		}
+		const pending = this.pendingLists.get(requestId);
+		if (!pending) return;
+		this.pendingLists.delete(requestId);
+		pending.resolve({ sessions, workflowStages: workflowStages ?? [] });
+		break;
+	  }
       case "groups": {
         const { requestId, groups } = brokerMessage;
         if (
@@ -602,38 +634,41 @@ export class IntercomClient extends EventEmitter {
       }
     });
   }
-  listSessions(group?: string): Promise<SessionInfo[]> {
-    let socket: net.Socket;
-    try {
-      socket = this.requireActiveSocket();
-    } catch (error) {
-      return Promise.reject(toError(error));
-    }
-    return new Promise((resolve, reject) => {
-      const requestId = randomUUID();
-      const wrappedResolve = (sessions: SessionInfo[]) => {
-        clearTimeout(timeout);
-        resolve(sessions);
-      };
-      const wrappedReject = (error: Error) => {
-        clearTimeout(timeout);
-        reject(error);
-      };
-      const timeout = setTimeout(() => {
-        if (this.pendingLists.has(requestId)) {
-          this.pendingLists.delete(requestId);
-          wrappedReject(new Error("List sessions timeout"));
-        }
-      }, 5000);
-      this.pendingLists.set(requestId, { resolve: wrappedResolve, reject: wrappedReject });
-      try {
-        writeMessage(socket, group === undefined ? { type: "list", requestId } : { type: "list", requestId, group });
-      } catch (error) {
-        clearTimeout(timeout);
-        this.pendingLists.delete(requestId);
-        reject(toError(error));
-      }
-    });
+  async listSessions(group?: string): Promise<SessionInfo[]> {
+	return (await this.listDirectory(group)).sessions;
+  }
+
+  listDirectory(group?: string): Promise<SessionDirectory> {
+	let socket: net.Socket;
+	try {
+		socket = this.requireActiveSocket();
+	} catch (error) {
+		return Promise.reject(toError(error));
+	}
+	return new Promise((resolve, reject) => {
+		const requestId = randomUUID();
+		const timeout = setTimeout(() => {
+			if (!this.pendingLists.delete(requestId)) return;
+			reject(new Error("List sessions timeout"));
+		}, 5000);
+		this.pendingLists.set(requestId, {
+			resolve: (directory) => {
+				clearTimeout(timeout);
+				resolve(directory);
+			},
+			reject: (error) => {
+				clearTimeout(timeout);
+				reject(error);
+			},
+		});
+		try {
+			writeMessage(socket, group === undefined ? { type: "list", requestId } : { type: "list", requestId, group });
+		} catch (error) {
+			clearTimeout(timeout);
+			this.pendingLists.delete(requestId);
+			reject(toError(error));
+		}
+	});
   }
   listGroups(): Promise<GroupSummary[]> {
     let socket: net.Socket;
@@ -728,8 +763,13 @@ export class IntercomClient extends EventEmitter {
       }
     });
   }
-  registerPendingStageRoute(runId: string, group: string, capability: string): void {
-    writeMessage(this.requireActiveSocket(), { type: "register_pending_stage_route", runId, group, capability });
+  registerPendingStageRoute(
+	runId: string,
+	group: string,
+	capability: string,
+	stages?: WorkflowStageRosterAnnouncement[],
+  ): void {
+	writeMessage(this.requireActiveSocket(), { type: "register_pending_stage_route", runId, group, capability, stages });
   }
 
   registerLiveWorkflowStageRoute(runId: string, stageKeys: readonly string[], capability: string): Promise<void> {

package/dist/builtin/intercom/broker/pending-question-index.ts

@@ -15,6 +15,16 @@ export class PendingQuestionIndex {
     this.questions.set(messageId, routes);
   }
 
+	/** Authorize only the exact reverse route of a broker-recorded live ask. */
+	matchesReply(senderSessionId: string, targetSessionId: string, replyTo: string): boolean {
+		return (
+			this.questions
+				.get(replyTo)
+				?.some(
+					(route) => route.targetSessionId === senderSessionId && route.senderSessionId === targetSessionId,
+				) === true
+		);
+	}
   clearReply(senderSessionId: string, targetSessionId: string, replyTo: string): boolean {
     const routes = this.questions.get(replyTo);
     const index = routes?.findIndex(

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

@@ -42,6 +42,11 @@ export interface PendingStageRoute {
 export type PendingStageRouter = (route: PendingStageRoute) => boolean;
 
 export type LiveWorkflowStageResolver = (target: string) => BrokerConnectedSession | undefined;
+export type LiveWorkflowStageController = (
+	sender: BrokerConnectedSession,
+	target: BrokerConnectedSession,
+	logicalTarget: string,
+) => boolean;
 
 const WORKFLOW_RUN_ID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
 
@@ -56,6 +61,8 @@ export const PENDING_STAGE_ASK_REFUSAL =
   "Cannot ask a workflow stage whose session has not initialized. Use send; Atomic will queue the message until the stage session initializes.";
 
 
+
+
 interface SendClientMessage extends Record<string, unknown> {
   type: string;
 }
@@ -68,16 +75,17 @@ function wireMessageId(value: unknown): string {
 
 /** Validate and route one wire-level send request. */
 export function handleBrokerSend(
-  socket: net.Socket,
-  clientMessage: SendClientMessage,
-  currentId: string | null,
-  sessions: Map<string, BrokerConnectedSession>,
-  deliveredMessages: DeliveredMessageCache,
-  write: (target: net.Socket, message: BrokerMessage) => void,
-  supervisorCache: SupervisorChannelCache = new SupervisorChannelCache(),
-  pendingQuestions: PendingQuestionIndex = new PendingQuestionIndex(),
-  routePendingStage?: PendingStageRouter,
-  resolveLiveWorkflowStage?: LiveWorkflowStageResolver,
+	socket: net.Socket,
+	clientMessage: SendClientMessage,
+	currentId: string | null,
+	sessions: Map<string, BrokerConnectedSession>,
+	deliveredMessages: DeliveredMessageCache,
+	write: (target: net.Socket, message: BrokerMessage) => void,
+	supervisorCache: SupervisorChannelCache = new SupervisorChannelCache(),
+	pendingQuestions: PendingQuestionIndex = new PendingQuestionIndex(),
+	routePendingStage?: PendingStageRouter,
+	resolveLiveWorkflowStage?: LiveWorkflowStageResolver,
+	canControlLiveWorkflowStage?: LiveWorkflowStageController,
 ): void {
   const message = clientMessage.message;
   const messageId = wireMessageId(message);
@@ -158,13 +166,20 @@ export function handleBrokerSend(
       write(socket, { type: "delivery_failed", messageId: message.id, attemptId, reason: "Cannot message the current session" });
       return;
     }
-    const bypass = supervisorSend || isVerticalBypass({
-      replyTo: message.replyTo,
-      sender: fromSession.info,
-      target: target.info,
-      supervisorCache,
-    });
-    if (!bypass && !sameGroup(target.info, fromSession.info)) {
+	const correlatedReply =
+		message.replyTo !== undefined &&
+		pendingQuestions.matchesReply(fromSession.info.id, target.info.id, message.replyTo);
+	const bypass =
+		supervisorSend ||
+		isVerticalBypass({
+			replyTo: message.replyTo,
+			sender: fromSession.info,
+			target: target.info,
+			supervisorCache,
+		}) ||
+		correlatedReply ||
+		(liveWorkflowTarget !== undefined && canControlLiveWorkflowStage?.(fromSession, target, trimmedTo) === true);
+	if (!bypass && !sameGroup(target.info, fromSession.info)) {
       write(socket, {
         type: "delivery_failed",
         messageId: message.id,