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

package/dist/builtin/intercom/reply-tracker.ts

@@ -1,4 +1,5 @@
 import type { Message, SessionInfo } from "./types.ts";
+import { resolveSessionTarget, sessionTargetFailureReason } from "./session-target.js";
 
 export interface IntercomContext {
   from: SessionInfo;
@@ -6,14 +7,6 @@ export interface IntercomContext {
   receivedAt: number;
 }
 
-function matchesPendingSender(context: IntercomContext, to: string): boolean {
-  if (context.from.id === to) {
-    return true;
-  }
-
-  return context.from.name?.toLowerCase() === to.toLowerCase();
-}
-
 export class ReplyTracker {
   private readonly pendingAsks = new Map<string, IntercomContext>();
   private readonly pendingTurnContexts: IntercomContext[] = [];
@@ -56,21 +49,28 @@ export class ReplyTracker {
     }
 
     const pending = Array.from(this.pendingAsks.values());
-    if (pending.length === 1) {
-      return pending[0]!;
-    }
-
     if (options.to) {
-      const matches = pending.filter((context) => matchesPendingSender(context, options.to!));
-      if (matches.length === 1) {
-        return matches[0]!;
+      const senders = [...new Map(
+        pending.map((context) => [context.from.id, context.from] as const),
+      ).values()];
+      const resolution = resolveSessionTarget(senders, options.to);
+      if (resolution.kind !== "resolved") {
+        if (resolution.kind === "not_found") {
+          throw new Error(`No pending ask from "${options.to}"`);
+        }
+        throw new Error(sessionTargetFailureReason(options.to, resolution));
       }
+      const matches = pending.filter(
+        (context) => context.from.id === resolution.session.id,
+      );
+      if (matches.length === 1) return matches[0]!;
       if (matches.length > 1) {
-        throw new Error(`Multiple pending asks from \"${options.to}\" — use the sender session ID instead.`);
-      }
-      if (pending.length > 1) {
-        throw new Error(`No pending ask from \"${options.to}\"`);
+        throw new Error(`Multiple pending asks from "${options.to}"`);
       }
+      throw new Error(`No pending ask from "${options.to}"`);
+    }
+    if (pending.length === 1) {
+      return pending[0]!;
     }
 
     if (pending.length === 0) {

package/dist/builtin/intercom/session-target.ts

@@ -0,0 +1,68 @@
+import type { SessionInfo } from "./types.js";
+
+export type SessionTargetResolution =
+  | { kind: "resolved"; session: SessionInfo }
+  | { kind: "ambiguous_name"; matches: readonly SessionInfo[] }
+  | { kind: "ambiguous_prefix"; matches: readonly SessionInfo[] }
+  | { kind: "not_found" };
+
+/** Resolve an Intercom session by exact ID, exact case-insensitive name, or unique ID prefix. */
+export function resolveSessionTarget(
+  sessions: readonly SessionInfo[],
+  nameOrId: string,
+): SessionTargetResolution {
+  const target = nameOrId.trim();
+  const exactId = sessions.find((session) => session.id === target);
+  if (exactId !== undefined) return { kind: "resolved", session: exactId };
+
+  const lowerTarget = target.toLowerCase();
+  const exactNames = sessions.filter(
+    (session) => session.name?.toLowerCase() === lowerTarget,
+  );
+  if (exactNames.length === 1) {
+    return { kind: "resolved", session: exactNames[0]! };
+  }
+  if (exactNames.length > 1) {
+    return { kind: "ambiguous_name", matches: exactNames };
+  }
+
+  const prefixedIds = sessions.filter((session) => session.id.startsWith(target));
+  if (prefixedIds.length === 1) {
+    return { kind: "resolved", session: prefixedIds[0]! };
+  }
+  if (prefixedIds.length > 1) {
+    return { kind: "ambiguous_prefix", matches: prefixedIds };
+  }
+  return { kind: "not_found" };
+}
+
+export function sessionTargetFailureReason(
+  target: string,
+  resolution: Exclude<SessionTargetResolution, { kind: "resolved" }>,
+): string {
+  if (resolution.kind === "ambiguous_name") {
+    return `Multiple sessions named "${target}" are connected. Use the session ID instead.`;
+  }
+  if (resolution.kind === "ambiguous_prefix") {
+    const labels = resolution.matches
+      .map((session) => `${session.name ?? "Unnamed session"} (${session.id})`)
+      .join(", ");
+    return `Ambiguous session ID prefix "${target}" matches: ${labels}. Use a longer ID or an exact session name.`;
+  }
+  return "Session not found";
+}
+
+export interface SessionListingClient {
+  listSessions(): Promise<SessionInfo[]>;
+}
+
+/** Resolve a target through the broker's current session list. */
+export async function resolveSessionTargetId(
+  client: SessionListingClient,
+  nameOrId: string,
+): Promise<string | null> {
+  const resolution = resolveSessionTarget(await client.listSessions(), nameOrId);
+  if (resolution.kind === "resolved") return resolution.session.id;
+  if (resolution.kind === "not_found") return null;
+  throw new Error(sessionTargetFailureReason(nameOrId, resolution));
+}

package/dist/builtin/intercom/skills/intercom/SKILL.md

@@ -67,13 +67,16 @@ intercom({
 
 ### Pattern 2: Quick Status Check
 
-Before sending, verify who's connected:
+Before sending, verify who's connected. The short ID printed by `list` is directly usable by `send`, `ask`, and targeted `reply`:
 
 ```typescript
 intercom({ action: "list" })
-// → Shows all connected sessions with names, cwd, models, and live status (`idle`, `thinking`, `tool:<name>`)
+// → • planner (6332faab) — /workspace (model) [idle]
+intercom({ action: "ask", to: "6332faab", message: "Which option should I use?" })
 ```
 
+Intercom resolves exact full IDs first, exact case-insensitive names second, and unique ID prefixes last. A colliding prefix returns an ambiguity error; use a longer displayed ID or an exact name rather than guessing.
+
 ### Pattern 3: Reply Naturally
 
 When responding to an inbound ask, prefer `reply` instead of reconstructing raw IDs:
@@ -199,9 +202,9 @@ message, treat it as a `contact_supervisor` escalation.
 |--------|----------|----------|
 | `send` | Fire-and-forget | You don't need a response |
 | `ask` | Blocks until reply (10 min timeout) | You need an answer to continue |
-| `reply` | Responds to the active or pending inbound ask | You were asked something and need to answer naturally |
+| `reply` | Responds to the active or pending inbound ask; `to` accepts a displayed short ID | You were asked something and need to answer naturally |
 | `pending` | Lists unresolved inbound asks | You need to see who is waiting before replying |
-| `list` | Returns all sessions with live status | You need to discover targets or choose an idle peer |
+| `list` | Returns all sessions with actionable short IDs and live status | You need to discover targets or choose an idle peer |
 | `status` | Returns your connection state | Troubleshooting |
 
 ## Optional: Visible Peer Sessions via cmux, tmux, or psmux (Windows rewrite of tmux that has fully parity with tmux)

package/dist/builtin/intercom/source-ownership.ts

@@ -0,0 +1,34 @@
+import { APP_NAME, getEnvValue } from "@bastani/atomic";
+import type { Message } from "./types.js";
+
+const ENV_PREFIX = APP_NAME.toUpperCase();
+const SUBAGENT_RUN_ID_ENV = `${ENV_PREFIX}_SUBAGENT_RUN_ID`;
+const SUBAGENT_CHILD_AGENT_ENV = `${ENV_PREFIX}_SUBAGENT_CHILD_AGENT`;
+const SUBAGENT_CHILD_INDEX_ENV = `${ENV_PREFIX}_SUBAGENT_CHILD_INDEX`;
+
+export function buildSubagentMessageSource(
+  runIdValue: string | undefined,
+  agentValue: string | undefined,
+  indexValue: string | undefined,
+): Message["source"] | undefined {
+  const subagentRunId = runIdValue?.trim();
+  if (!subagentRunId) return undefined;
+  const subagentAgent = agentValue?.trim();
+  const rawIndex = indexValue?.trim();
+  const parsedIndex = rawIndex === undefined ? undefined : Number(rawIndex);
+  const subagentIndex = parsedIndex !== undefined && Number.isInteger(parsedIndex) && parsedIndex >= 0
+    ? parsedIndex : undefined;
+  return {
+    subagentRunId,
+    ...(subagentAgent ? { subagentAgent } : {}),
+    ...(subagentIndex !== undefined ? { subagentIndex } : {}),
+  };
+}
+
+export function readSubagentMessageSource(): Message["source"] | undefined {
+  return buildSubagentMessageSource(
+    getEnvValue(SUBAGENT_RUN_ID_ENV),
+    getEnvValue(SUBAGENT_CHILD_AGENT_ENV),
+    getEnvValue(SUBAGENT_CHILD_INDEX_ENV),
+  );
+}

package/dist/builtin/intercom/subagent-relay.ts

@@ -6,11 +6,14 @@ import {
   SUBAGENT_CONTROL_INTERCOM_EVENT,
   SUBAGENT_RESULT_INTERCOM_DELIVERY_EVENT,
   SUBAGENT_RESULT_INTERCOM_EVENT,
+  SUBAGENT_TERMINAL_ORDERING_BARRIER_EVENT,
   getErrorMessage,
   parseSubagentIntercomPayload,
+  parseSubagentResultBarrier,
 } from "./intercom-utils.js";
 import { DeliveredMessageCache } from "./broker/delivered-message-cache.js";
 import { buildSendSignature } from "./broker/send-signature.js";
+import { emitGlobalTerminalOrderingBarrier } from "./terminal-ordering-barrier.js";
 
 interface SubagentRelayDeps {
   runtimeGeneration(): number;
@@ -26,26 +29,47 @@ interface SubagentRelayDeps {
 export function registerSubagentRelay(pi: ExtensionAPI, deps: SubagentRelayDeps): void {
   const { getLiveContext, currentSessionTargetMatches, sendIncomingMessage, ensureConnected, resolveSessionTarget } = deps;
   const localDeliveries = new DeliveredMessageCache();
-  function deliverLocalSubagentRelayMessage(sender: "subagent-control" | "subagent-result", status: string, messageText: string): void {
+  function deliverLocalSubagentRelayMessage(
+    sender: "subagent-control" | "subagent-result",
+    status: string,
+    messageText: string,
+    terminalBarrier?: { runId: string; terminalId?: string; sourceSessionTargets: string[] },
+  ): void {
     const now = Date.now();
-    sendIncomingMessage({
+    const entry = {
       from: {
-        id: sender,
-        name: sender,
-        cwd: deps.runtimeContext()?.cwd ?? process.cwd(),
-        model: sender,
-        pid: process.pid,
-        startedAt: now,
-        lastActivity: now,
-        status,
-      },
-      message: {
-        id: randomUUID(),
-        timestamp: now,
-        content: { text: messageText },
+        id: sender, name: sender, cwd: deps.runtimeContext()?.cwd ?? process.cwd(),
+        model: sender, pid: process.pid, startedAt: now, lastActivity: now, status,
       },
+      message: { id: randomUUID(), timestamp: now, content: { text: messageText } },
       bodyText: messageText,
-    }, "trigger");
+    };
+    let dispatched = false;
+    if (terminalBarrier) {
+      const payload = {
+        ...terminalBarrier,
+        terminalAt: now,
+        source: "result-relay" as const,
+        dispatch: (prefix: Array<{ customType: string; content: string; display: boolean; details?: unknown }>) => {
+          const terminalMessage = {
+            customType: "intercom_message",
+            content: `**📨 From ${sender}** (${entry.from.cwd})\n\n${messageText}`,
+            display: true,
+            details: entry,
+          };
+          if (typeof pi.sendMessages === "function") {
+            pi.sendMessages([...prefix, terminalMessage], { triggerTurn: true });
+          } else {
+            for (const message of prefix) pi.sendMessage(message, { deliverAs: "steer" });
+            pi.sendMessage(terminalMessage, { triggerTurn: true });
+          }
+          dispatched = true;
+        },
+      };
+      pi.events.emit(SUBAGENT_TERMINAL_ORDERING_BARRIER_EVENT, payload);
+      emitGlobalTerminalOrderingBarrier(payload);
+    }
+    if (!dispatched) sendIncomingMessage(entry, "trigger");
   }
   function recordSubagentDeliveryError(entryType: string, to: string, message: string, error: unknown): void {
     pi.appendEntry(entryType, {
@@ -68,7 +92,7 @@ export function registerSubagentRelay(pi: ExtensionAPI, deps: SubagentRelayDeps)
   }
   function deliverLocal(
     parsed: ReturnType<typeof parseSubagentIntercomPayload> & {},
-    options: { sender: "subagent-control" | "subagent-result"; status: string; errorEntryType: string; acknowledge?: boolean },
+    options: { sender: "subagent-control" | "subagent-result"; status: string; errorEntryType: string; acknowledge?: boolean; terminalBarrier?: { runId: string; terminalId?: string; sourceSessionTargets: string[] } },
   ): void {
     try {
       const signature = buildSendSignature(parsed.to, { text: parsed.message });
@@ -77,7 +101,7 @@ export function registerSubagentRelay(pi: ExtensionAPI, deps: SubagentRelayDeps)
         throw new Error(`Intercom message ID '${parsed.requestId}' was already delivered with a different target or payload`);
       }
       if (match === "miss") {
-        deliverLocalSubagentRelayMessage(options.sender, options.status, parsed.message);
+        deliverLocalSubagentRelayMessage(options.sender, options.status, parsed.message, options.terminalBarrier);
         if (parsed.requestId) localDeliveries.record(parsed.requestId, signature);
       }
       acknowledgeResult(options, parsed.requestId, true);
@@ -102,6 +126,7 @@ export function registerSubagentRelay(pi: ExtensionAPI, deps: SubagentRelayDeps)
   }): void {
     const parsed = parseSubagentIntercomPayload(payload);
     if (!parsed) return;
+    const terminalBarrier = options.sender === "subagent-result" ? parseSubagentResultBarrier(payload) ?? undefined : undefined;
 
     const relayGeneration = deps.runtimeGeneration();
     void (async () => {
@@ -112,7 +137,7 @@ export function registerSubagentRelay(pi: ExtensionAPI, deps: SubagentRelayDeps)
         return;
       }
       if (currentSessionTargetMatches(parsed.to)) {
-        deliverLocal(parsed, options);
+        deliverLocal(parsed, { ...options, terminalBarrier });
         return;
       }
       if (!deps.runtimeStarted()) {
@@ -145,7 +170,7 @@ export function registerSubagentRelay(pi: ExtensionAPI, deps: SubagentRelayDeps)
         return;
       }
       if (currentSessionTargetMatches(parsed.to, target, activeClient)) {
-        deliverLocal(parsed, options);
+        deliverLocal(parsed, { ...options, terminalBarrier });
         return;
       }
 

package/dist/builtin/intercom/terminal-ordering-barrier.ts

@@ -0,0 +1,111 @@
+import type { ExtensionAPI } from "@bastani/atomic";
+import { SUBAGENT_TERMINAL_ORDERING_BARRIER_EVENT, type InboundMessageEntry } from "./intercom-utils.js";
+import type { InboundIdleQueue } from "./inbound-idle-queue.js";
+
+export { SUBAGENT_TERMINAL_ORDERING_BARRIER_EVENT } from "./intercom-utils.js";
+
+const GLOBAL_BARRIER_HANDLER = "__atomicTerminalOrderingBarrierHandler";
+
+export interface OrderedTerminalPreludeMessage {
+  customType: "intercom_message";
+  content: string;
+  display: true;
+  details: InboundMessageEntry;
+}
+
+export interface TerminalOrderingBarrier {
+  runId: string;
+  terminalId: string;
+  terminalAt: number;
+  source: "background-notify" | "result-relay";
+  sourceSessionTargets: string[];
+  dispatch?(prefix: OrderedTerminalPreludeMessage[]): void;
+}
+
+interface TerminalOrderingBarrierOptions {
+  queue: InboundIdleQueue;
+  toMessage?(entry: InboundMessageEntry): OrderedTerminalPreludeMessage;
+  deliver(entry: InboundMessageEntry, mode: "prelude"): void;
+  onDrain?(): void;
+}
+
+function parseBarrier(value: unknown): TerminalOrderingBarrier | null {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  const record = value as Record<string, unknown>;
+  if (typeof record.runId !== "string" || !record.runId) return null;
+  if (typeof record.terminalAt !== "number" || !Number.isFinite(record.terminalAt)) return null;
+  if (record.source !== "background-notify" && record.source !== "result-relay") return null;
+  if (!Array.isArray(record.sourceSessionTargets)) return null;
+  const sourceSessionTargets = record.sourceSessionTargets
+    .filter((target): target is string => typeof target === "string")
+    .map((target) => target.trim())
+    .filter(Boolean);
+  if (sourceSessionTargets.length === 0) return null;
+  const terminalId = typeof record.terminalId === "string" && record.terminalId
+    ? record.terminalId : `${record.source}:${record.terminalAt}`;
+  return {
+    runId: record.runId,
+    terminalId,
+    terminalAt: record.terminalAt,
+    source: record.source,
+    sourceSessionTargets,
+    ...(typeof record.dispatch === "function"
+      ? { dispatch: record.dispatch as (prefix: OrderedTerminalPreludeMessage[]) => void }
+      : {}),
+  };
+}
+
+export function emitGlobalTerminalOrderingBarrier(value: unknown): void {
+  const handler = (globalThis as Record<string, unknown>)[GLOBAL_BARRIER_HANDLER];
+  if (typeof handler === "function") (handler as (payload: unknown) => void)(value);
+}
+
+/** Claims accepted same-child messages before terminal delivery. */
+export function registerTerminalOrderingBarrier(
+  pi: Pick<ExtensionAPI, "events">,
+  options: TerminalOrderingBarrierOptions,
+): () => void {
+  const drainedTargetsByTerminal = new Map<string, Set<string>>();
+  const handle = (value: unknown): void => {
+    const barrier = parseBarrier(value);
+    if (!barrier) return;
+    const terminalKey = `${barrier.runId}\0${barrier.terminalId}`;
+    const drainedTargets = drainedTargetsByTerminal.get(terminalKey) ?? new Set<string>();
+    const pendingTargets = barrier.sourceSessionTargets.filter((target) => !drainedTargets.has(target));
+    if (pendingTargets.length === 0) return;
+    const claim = options.queue.claimOrdinarySourceTargets(barrier.runId, pendingTargets, barrier.terminalAt);
+    if (barrier.dispatch && options.toMessage) {
+      try {
+        barrier.dispatch(claim.entries.map(options.toMessage));
+      } catch (error) {
+        claim.rollbackFrom(0);
+        throw error;
+      }
+    } else {
+      for (let index = 0; index < claim.entries.length; index++) {
+        try {
+          options.deliver(claim.entries[index]!, "prelude");
+        } catch (error) {
+          claim.rollbackFrom(index);
+          throw error;
+        }
+      }
+    }
+    if ((barrier.dispatch && options.toMessage) || claim.entries.length > 0) {
+      for (const target of pendingTargets) drainedTargets.add(target);
+      drainedTargetsByTerminal.set(terminalKey, drainedTargets);
+    }
+    if (drainedTargetsByTerminal.size > 1_000) {
+      const oldestKey = drainedTargetsByTerminal.keys().next().value;
+      if (oldestKey !== undefined) drainedTargetsByTerminal.delete(oldestKey);
+    }
+    if (claim.entries.length > 0) options.onDrain?.();
+  };
+  (globalThis as Record<string, unknown>)[GLOBAL_BARRIER_HANDLER] = handle;
+  const unsubscribe = pi.events.on(SUBAGENT_TERMINAL_ORDERING_BARRIER_EVENT, handle);
+  return () => {
+    unsubscribe();
+    const globals = globalThis as Record<string, unknown>;
+    if (globals[GLOBAL_BARRIER_HANDLER] === handle) delete globals[GLOBAL_BARRIER_HANDLER];
+  };
+}

package/dist/builtin/intercom/types.ts

@@ -14,6 +14,11 @@ export interface Message {
   timestamp: number;
   replyTo?: string;
   expectsReply?: boolean;
+  source?: {
+    subagentRunId: string;
+    subagentAgent?: string;
+    subagentIndex?: number;
+  };
   content: {
     text: string;
     attachments?: Attachment[];

package/dist/builtin/mcp/CHANGELOG.md

@@ -7,6 +7,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.9.9-alpha.3] - 2026-07-14
+
+### Changed
+
+- Published a synchronized Atomic 0.9.9-alpha.3 prerelease for the MCP extension; no functional MCP changes were made after 0.9.9-alpha.2.
+
 ## [0.9.9-alpha.2] - 2026-07-14
 
 ### Changed

package/dist/builtin/mcp/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/mcp",
-  "version": "0.9.9-alpha.2",
+  "version": "0.9.9-alpha.3",
   "private": true,
   "description": "Atomic extension that adapts MCP (Model Context Protocol) servers into the coding agent. Fork of: https://github.com/nicobailon/pi-mcp-adapter",
   "contributors": [

package/dist/builtin/subagents/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 ## [Unreleased]
 
+## [0.9.9-alpha.3] - 2026-07-14
+
+### Fixed
+
+- Preserved background async-child completion chronology with Intercom by emitting a terminal-ordering barrier and atomically batching claimed same-child messages before the completion notice, with a compatibility fallback for hosts without batched message admission.
+
 ## [0.9.9-alpha.2] - 2026-07-14
 
 ### Changed

package/dist/builtin/subagents/package.json

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

package/dist/builtin/subagents/src/runs/background/notify.ts

@@ -3,14 +3,17 @@
  */
 
 import type { ExtensionAPI } from "@bastani/atomic";
+import { resolveSubagentIntercomTarget } from "../../intercom/intercom-bridge.ts";
 import { buildCompletionKey, hasSeenWithTtl, recordSeen } from "./completion-dedupe.ts";
 import type { CompletionNotificationEnvelope } from "./completion-notification.ts";
-import { SUBAGENT_ASYNC_COMPLETE_EVENT } from "../../shared/types.ts";
+import { SUBAGENT_ASYNC_COMPLETE_EVENT, SUBAGENT_TERMINAL_ORDERING_BARRIER_EVENT } from "../../shared/types.ts";
 
 interface ChainStepResult {
 	agent: string;
 	output: string;
 	success: boolean;
+	intercomTarget?: string;
+	index?: number;
 }
 
 export interface SubagentNotifyDetails {
@@ -25,6 +28,8 @@ export interface SubagentNotifyDetails {
 
 interface SubagentResult {
 	id: string | null;
+	runId?: string;
+	notificationId?: string;
 	agent: string | null;
 	success: boolean;
 	summary: string;
@@ -41,6 +46,13 @@ interface SubagentResult {
 	totalTasks?: number;
 }
 
+interface TerminalPreludeMessage {
+	customType: string;
+	content: string;
+	display: boolean;
+	details?: unknown;
+}
+
 interface NotifyRegistration {
 	unsubscribe: () => void;
 }
@@ -87,6 +99,30 @@ export default function registerSubagentNotify(pi: ExtensionAPI): () => void {
 	const seen = getNotifySeen(pi);
 	const ttlMs = 10 * 60 * 1000;
 
+	const emitTerminalOrderingBarrier = (result: SubagentResult, dispatch?: (prefix: TerminalPreludeMessage[]) => void): void => {
+		const runId = result.runId ?? result.id;
+		if (!runId) return;
+		const resultTargets = result.results?.map((child, arrayIndex) =>
+			child.intercomTarget?.trim() || resolveSubagentIntercomTarget(runId, child.agent, child.index ?? arrayIndex)) ?? [];
+		const sourceSessionTargets = resultTargets.length > 0
+			? resultTargets
+			: result.agent ? [resolveSubagentIntercomTarget(runId, result.agent, 0)] : [];
+		if (sourceSessionTargets.length === 0) return;
+		const terminalId = result.notificationId?.startsWith("completion-notify-")
+			? result.notificationId.slice("completion-notify-".length)
+			: result.notificationId;
+		const payload = {
+			runId,
+			...(terminalId ? { terminalId } : {}),
+			terminalAt: Number.isFinite(result.timestamp) ? result.timestamp : Date.now(),
+			source: "background-notify" as const,
+			sourceSessionTargets,
+			...(dispatch ? { dispatch } : {}),
+		};
+		pi.events.emit(SUBAGENT_TERMINAL_ORDERING_BARRIER_EVENT, payload);
+		const globalHandler = (globalThis as Record<string, unknown>).__atomicTerminalOrderingBarrierHandler;
+		if (typeof globalHandler === "function") (globalHandler as (value: unknown) => void)(payload);
+	};
 	let registration: NotifyRegistration;
 	const handleComplete = (data: unknown) => {
 		if (registry.get(pi) !== registration) return;
@@ -130,15 +166,23 @@ export default function registerSubagentNotify(pi: ExtensionAPI): () => void {
 			.filter((line) => line !== undefined)
 			.join("\n");
 
+		const terminalMessage = {
+			customType: "subagent-notify",
+			content,
+			display: true,
+		};
 		try {
-			pi.sendMessage(
-				{
-					customType: "subagent-notify",
-					content,
-					display: true,
-				},
-				{ triggerTurn: true },
-			);
+			let dispatched = false;
+			emitTerminalOrderingBarrier(result, (prefix) => {
+				if (typeof pi.sendMessages === "function") {
+					pi.sendMessages([...prefix, terminalMessage], { triggerTurn: true });
+				} else {
+					for (const message of prefix) pi.sendMessage(message, { deliverAs: "steer" });
+					pi.sendMessage(terminalMessage, { triggerTurn: true });
+				}
+				dispatched = true;
+			});
+			if (!dispatched) pi.sendMessage(terminalMessage, { triggerTurn: true });
 			recordSeen(seen, key, Date.now());
 			result.acknowledge?.(true);
 		} catch (error) {

package/dist/builtin/subagents/src/shared/types-config.ts

@@ -48,6 +48,7 @@ export const SUBAGENT_ASYNC_COMPLETE_EVENT = "subagent:async-complete";
 export const SUBAGENT_CONTROL_EVENT = "subagent:control-event";
 export const SUBAGENT_CONTROL_INTERCOM_EVENT = "subagent:control-intercom";
 export const SUBAGENT_RESULT_INTERCOM_EVENT = "subagent:result-intercom";
+export const SUBAGENT_TERMINAL_ORDERING_BARRIER_EVENT = "subagent:terminal-ordering-barrier";
 export const SUBAGENT_RESULT_INTERCOM_DELIVERY_EVENT = "subagent:result-intercom-delivery";
 
 // ============================================================================

package/dist/builtin/web-access/CHANGELOG.md

@@ -4,6 +4,12 @@ All notable changes to this project will be documented in this file.
 
 ## [Unreleased]
 
+## [0.9.9-alpha.3] - 2026-07-14
+
+### Changed
+
+- Published a synchronized Atomic 0.9.9-alpha.3 prerelease for the web-access extension; no functional web-access changes were made after 0.9.9-alpha.2.
+
 ## [0.9.9-alpha.2] - 2026-07-14
 
 ### Changed

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

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/web-access",
-  "version": "0.9.9-alpha.2",
+  "version": "0.9.9-alpha.3",
   "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.9-alpha.3] - 2026-07-14
+
+### Fixed
+
+- Made `workflow({ action: "status", runId })` apply the same exact-or-unique-prefix contract as the other run actions. A prefix shared by multiple retained runs now returns the standard ambiguity diagnostic instead of silently inspecting the first match, so abbreviated run IDs printed by status surfaces remain safe and actionable.
+
 ## [0.9.9-alpha.2] - 2026-07-14
 
 ### Changed

package/dist/builtin/workflows/package.json

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