@bastani/atomic 0.9.9 → 0.9.10

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

@@ -14,6 +14,7 @@ import {
 } from "./intercom-utils.js";
 import type { ReplyTracker } from "./reply-tracker.ts";
 import { resolveSessionTargetId } from "./session-target.js";
+import { normalizeGroup } from "./group.js";
 
 interface IntercomToolDeps {
   ensureConnected(reason: "tool"): Promise<IntercomClient>;
@@ -26,29 +27,35 @@ interface IntercomToolDeps {
    * never observe a rejected promise.
    */
   beginReplyWait(from: string, replyTo: string, signal?: AbortSignal): ReplyWaitAdmission;
-  replyTracker: ReplyTracker;
+  replyTracker: ReplyTracker | (() => ReplyTracker);
   /** Advisory fast-path check; beginReplyWait is the authoritative reservation. */
   hasReplyWaiter(): boolean;
 }
 
 export function registerIntercomTool(pi: ExtensionAPI, deps: IntercomToolDeps): void {
-  const { ensureConnected, syncPresenceIdentity, beginReplyWait, replyTracker, hasReplyWaiter } = deps;
+  const { ensureConnected, syncPresenceIdentity, beginReplyWait, hasReplyWaiter } = deps;
   const resolveTarget = deps.resolveSessionTarget ?? resolveSessionTargetId;
+  const activeReplyTracker = (): ReplyTracker =>
+    typeof deps.replyTracker === "function" ? deps.replyTracker() : deps.replyTracker;
   pi.registerTool({
     name: "intercom",
     label: "Intercom",
     description: `Send a message to another local agent session running on this machine.
 Use this to communicate findings, request help, or coordinate work with other sessions.
 
+Sessions belong to an intercom group and can ONLY message sessions in the same group;
+cross-group sends are rejected by the broker. Ungrouped sessions share the "default" group.
+
 Usage:
-  intercom({ action: "list" })                    → List active sessions
-  intercom({ action: "send", to: "session-name", message: "..." })  → Send message
+  intercom({ action: "list" })                    → List sessions in your group
+  intercom({ action: "list", group: "name" })     → Read-only peek at another group's sessions
+  intercom({ action: "send", to: "session-name", message: "..." })  → Send message (own group only)
   intercom({ action: "ask", to: "session-name", message: "..." })   → Ask and wait for reply
   intercom({ action: "reply", message: "..." })                      → Reply to the active/single pending ask
   intercom({ action: "pending" })                                      → List unresolved inbound asks
-  intercom({ action: "status" })                  → Show connection status`,
+  intercom({ action: "status" })                  → Show connection status and your group`,
     promptSnippet:
-      "Use to coordinate with other local agent sessions: list peers, send updates, ask for help, or check intercom connectivity.",
+      "Use to coordinate with other local agent sessions in your intercom group: list peers, send updates, ask for help, or check intercom connectivity. Groups are isolated; you can only message sessions in your own group.",
 
     parameters: Type.Object({
       action: Type.String({
@@ -69,6 +76,9 @@ Usage:
       replyTo: Type.Optional(Type.String({
         description: "Message ID to reply to (for threading or responding to an 'ask')",
       })),
+      group: Type.Optional(Type.String({
+        description: "Read-only group filter for 'list'/'status' (peek who is in a named group). 'send'/'ask' are always locked to your own group; passing a different group errors.",
+      })),
     }),
 
     async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
@@ -85,15 +95,30 @@ Usage:
 
       syncPresenceIdentity(ctx.sessionManager.getSessionId());
 
-      const { action, to, message, attachments, replyTo } = params;
+      const { action, to, message, attachments, replyTo, group } = params;
+      const requestedGroup = typeof group === "string" && group.trim() ? normalizeGroup(group) : undefined;
+      const resolveOwnGroup = async (): Promise<string> => {
+        const sessions = await connectedClient.listSessions();
+        const self = sessions.find((s) => s.id === connectedClient.sessionId);
+        return normalizeGroup(self?.group);
+      };
+      if ((action === "send" || action === "ask") && requestedGroup) {
+        const ownGroup = await resolveOwnGroup();
+        if (requestedGroup !== ownGroup) {
+          return {
+            content: [{ type: "text", text: `The 'group' parameter is read-only for 'list'/'status'. '${action}' is always locked to your own group ("${ownGroup}"); it cannot target group "${requestedGroup}".` }],
+            isError: true,
+            details: { error: true },
+          };
+        }
+      }
 
       switch (action) {
         case "list": {
           try {
             const mySessionId = connectedClient.sessionId;
-            const sessions = await connectedClient.listSessions();
-            const currentSession = sessions.find(s => s.id === mySessionId);
-            const otherSessions = sessions.filter(s => s.id !== mySessionId);
+            const ownSessions = await connectedClient.listSessions();
+            const currentSession = ownSessions.find(s => s.id === mySessionId);
 
             if (!currentSession) {
               return {
@@ -102,16 +127,30 @@ Usage:
                 details: { error: true },
               };
             }
+            const ownGroup = normalizeGroup(currentSession.group);
+
+            if (requestedGroup && requestedGroup !== ownGroup) {
+              const peeked = await connectedClient.listSessions(requestedGroup);
+              const section = peeked.length === 0
+                ? `**Group [${requestedGroup}] (read-only peek):**\nNo sessions in this group.`
+                : `**Group [${requestedGroup}] (read-only peek):**\n${peeked.map(s => formatSessionListRow(s, currentSession.cwd, s.id === mySessionId)).join("\n")}`;
+              return {
+                content: [{ type: "text", text: `Your group: ${ownGroup}\n\n${section}` }],
+                isError: false,
+                details: { group: ownGroup, peekGroup: requestedGroup },
+              };
+            }
 
-            const currentSection = `**Current session:**\n${formatSessionListRow(currentSession, currentSession.cwd, true)}`;
+            const otherSessions = ownSessions.filter(s => s.id !== mySessionId);
+            const currentSection = `**Current session** (group: ${ownGroup}):\n${formatSessionListRow(currentSession, currentSession.cwd, true)}`;
             const otherSection = otherSessions.length === 0
-              ? "**Other sessions:**\nNo other sessions connected."
-              : `**Other sessions:**\n${otherSessions.map(s => formatSessionListRow(s, currentSession.cwd, false)).join("\n")}`;
+              ? `**Other sessions:**\nNo other sessions in your group (${ownGroup}).`
+              : `**Other sessions** (group: ${ownGroup}):\n${otherSessions.map(s => formatSessionListRow(s, currentSession.cwd, false)).join("\n")}`;
 
             return {
               content: [{ type: "text", text: `${currentSection}\n\n${otherSection}` }],
               isError: false,
-              details: {},
+              details: { group: ownGroup },
             };
           } catch (error) {
             return {
@@ -173,7 +212,7 @@ Usage:
               timestamp: Date.now(),
             });
             if (replyTo) {
-              replyTracker.markReplied(replyTo);
+              activeReplyTracker().markReplied(replyTo);
             }
             return {
               content: [{ type: "text", text: `Message sent to ${to}` }],
@@ -275,6 +314,13 @@ Usage:
               messageId: replyMessage.id,
               timestamp: replyMessage.timestamp,
             });
+            if (replyMessage.replyError !== undefined) {
+              return {
+                content: [{ type: "text", text: `Failed: ${replyMessage.replyError}` }],
+                isError: true,
+                details: { error: true, replyTo: replyMessage.replyTo },
+              };
+            }
             return {
               content: [{ type: "text", text: `**Reply from ${to}:**\n${replyText}${replyAttachments}` }],
               isError: false,
@@ -302,7 +348,7 @@ Usage:
           }
 
           try {
-            const target = replyTracker.resolveReplyTarget({ to });
+            const target = activeReplyTracker().resolveReplyTarget({ to });
             if (target.from.id === connectedClient.sessionId) {
               return {
                 content: [{ type: "text", text: "Cannot message the current session" }],
@@ -322,7 +368,7 @@ Usage:
                 details: { messageId: result.id, delivered: false, reason: result.reason },
               };
             }
-            replyTracker.markReplied(target.message.id);
+            activeReplyTracker().markReplied(target.message.id);
             pi.appendEntry("intercom_sent", {
               to: target.from.name || target.from.id,
               message: { text: message, replyTo: target.message.id },
@@ -344,7 +390,7 @@ Usage:
         }
 
         case "pending": {
-          const pendingAsks = replyTracker.listPending();
+          const pendingAsks = activeReplyTracker().listPending();
           if (pendingAsks.length === 0) {
             return {
               content: [{ type: "text", text: "No unresolved inbound asks." }],
@@ -370,13 +416,18 @@ Usage:
           try {
             const mySessionId = connectedClient.sessionId;
             const sessions = await connectedClient.listSessions();
+            const self = sessions.find((s) => s.id === mySessionId);
+            const ownGroup = normalizeGroup(self?.group);
+            const peekSection = requestedGroup && requestedGroup !== ownGroup
+              ? `\nPeeked group [${requestedGroup}]: ${(await connectedClient.listSessions(requestedGroup)).length} session(s)`
+              : "";
             return {
               content: [{
                 type: "text",
-                text: `**Intercom Status:**\nConnected: Yes\nSession ID: ${mySessionId}\nActive sessions: ${sessions.length}`,
+                text: `**Intercom Status:**\nConnected: Yes\nSession ID: ${mySessionId}\nGroup: ${ownGroup}\nActive sessions in group: ${sessions.length}${peekSection}`,
               }],
               isError: false,
-              details: {},
+              details: { group: ownGroup },
             };
           } catch (error) {
             return {

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

@@ -1,12 +1,14 @@
 import type { ExtensionAPI } from "@bastani/atomic";
 import { APP_NAME, getEnvValue } from "@bastani/atomic";
-import type { Attachment, Message, SessionInfo } from "./types.ts";
+import type { Attachment, Message, SessionInfo, SupervisorRegistration } from "./types.ts";
+import { DEFAULT_GROUP, normalizeGroup } from "./group.js";
 
 
 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 SUBAGENT_SUPERVISOR_AUTHORIZATION_EVENT = "subagent:supervisor-authorization";
 export const INBOUND_FLUSH_DELAY_MS = 200;
 export const INBOUND_IDLE_RETRY_MS = 500;
 export const DEFAULT_UNNAMED_SESSION_ALIAS_PREFIX = "subagent-chat";
@@ -16,6 +18,8 @@ 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`;
 const SUBAGENT_INTERCOM_SESSION_NAME_ENV = `${ENV_PREFIX}_SUBAGENT_INTERCOM_SESSION_NAME`;
+const SUBAGENT_SUPERVISOR_CAPABILITY_ENV = `${ENV_PREFIX}_SUBAGENT_SUPERVISOR_CAPABILITY`;
+const SUBAGENT_SUPERVISOR_SESSION_ID_ENV = `${ENV_PREFIX}_SUBAGENT_SUPERVISOR_SESSION_ID`;
 
 export interface ChildOrchestratorMetadata {
   orchestratorTarget: string;
@@ -23,11 +27,13 @@ export interface ChildOrchestratorMetadata {
   agent: string;
   index: string;
   sessionName?: string;
+  supervisor?: SupervisorRegistration;
 }
 
 export interface InboundMessageEntry {
   from: SessionInfo;
   message: Message;
+  channel?: "supervisor";
   replyCommand?: string;
   bodyText: string;
 }
@@ -79,12 +85,17 @@ export function readChildOrchestratorMetadata(): ChildOrchestratorMetadata | nul
     return null;
   }
   const sessionName = getEnvValue(SUBAGENT_INTERCOM_SESSION_NAME_ENV)?.trim();
+  const capability = getEnvValue(SUBAGENT_SUPERVISOR_CAPABILITY_ENV)?.trim();
+  const supervisorSessionId = getEnvValue(SUBAGENT_SUPERVISOR_SESSION_ID_ENV)?.trim();
   return {
     orchestratorTarget,
     runId,
     agent,
     index,
     ...(sessionName ? { sessionName } : {}),
+    ...(capability && supervisorSessionId
+      ? { supervisor: { capability, supervisorSessionId } }
+      : {}),
   };
 }
 export function formatChildOrchestratorMessage(kind: "ask" | "update" | "interview", metadata: ChildOrchestratorMetadata, message: string): string {
@@ -414,7 +425,9 @@ export function formatSessionLabel(session: SessionInfo, duplicates: Set<string>
 }
 export function formatSessionListRow(session: SessionInfo, currentCwd: string, isSelf: boolean): string {
   const name = session.name || "Unnamed session";
-  const tags = [isSelf ? "self" : session.cwd === currentCwd ? "same cwd" : undefined, session.status]
+  const normalizedGroup = normalizeGroup(session.group);
+  const groupTag = normalizedGroup !== DEFAULT_GROUP ? `group: ${normalizedGroup}` : undefined;
+  const tags = [isSelf ? "self" : session.cwd === currentCwd ? "same cwd" : undefined, session.status, groupTag]
     .filter((tag): tag is string => Boolean(tag));
   const suffix = tags.length ? ` [${tags.join(", ")}]` : "";
   return `• ${name} (${shortSessionId(session.id)}) — ${session.cwd} (${session.model})${suffix}`;

package/dist/builtin/intercom/late-stage-message-router.ts

@@ -0,0 +1,148 @@
+import type { ExtensionAPI } from "@bastani/atomic";
+import type { InboundMessageEntry } from "./intercom-utils.js";
+import type { InboundMessageAdmission, InboundMessageReservation } from "./inbound-message-admission.js";
+import type { IntercomContext, ReplyTracker } from "./reply-tracker.js";
+import { DEFAULT_GROUP, normalizeGroup } from "./group.js";
+
+const LATE_STAGE_MESSAGE_EVENT = "atomic:workflow-stage-late-message";
+type LateStageMessage = Parameters<ExtensionAPI["sendMessage"]>[0];
+type LateStageMessageEvent = {
+  handled: boolean;
+  completion?: Promise<void>;
+  batch: boolean;
+  messages: LateStageMessage[];
+  workflowRunId?: string;
+  workflowStageId?: string;
+  options?: Parameters<ExtensionAPI["sendMessage"]>[1];
+};
+
+interface LateStageReservation {
+  message: LateStageMessage;
+  reservation: InboundMessageReservation;
+  context: IntercomContext;
+}
+
+function isSubagentRelayHandoff(entry: InboundMessageEntry): boolean {
+  return entry.from.id === "subagent-control" || entry.from.id === "subagent-result";
+}
+
+export function registerLateStageMessageRouter(
+  pi: ExtensionAPI,
+  admission: InboundMessageAdmission,
+  getReplyTracker: () => ReplyTracker,
+  getOwnerGroup: () => string = () => DEFAULT_GROUP,
+): void {
+  pi.events.on(LATE_STAGE_MESSAGE_EVENT, (data) => {
+    if (!data || typeof data !== "object") return;
+    const event = data as Partial<LateStageMessageEvent>;
+    if (!Array.isArray(event.messages) || typeof event.batch !== "boolean") return;
+    // The workflow extension owns blocking asks to a completed stage so it can
+    // schedule a post-mortem turn in that exact retained conversation. Leaving
+    // the event unhandled here also makes listener registration order irrelevant.
+    if (isCompletedStageAskRoute(event)) return;
+    const tracker = getReplyTracker();
+    const accepted: LateStageMessage[] = [];
+    const reservations: LateStageReservation[] = [];
+    const joined: Promise<void>[] = [];
+    let queuedTurnContext = false;
+    for (const message of event.messages) {
+      if (message.customType !== "intercom_message") { accepted.push(message); continue; }
+      const entry = message.details as InboundMessageEntry | undefined;
+      if (!entry?.from || !entry.message) continue;
+      if (entry.channel !== "supervisor"
+        && !isSubagentRelayHandoff(entry)
+        && normalizeGroup(entry.from.group) !== normalizeGroup(getOwnerGroup())) continue;
+      const result = admission.admit(entry.from, entry.message);
+      if (result.kind === "pending") { joined.push(result.completion); continue; }
+      if (result.kind === "duplicate") continue;
+      const context = tracker.recordIncomingMessage(entry.from, entry.message);
+      if (!queuedTurnContext && event.options?.triggerTurn === true) {
+        tracker.queueTurnContext(context);
+        queuedTurnContext = true;
+      }
+      reservations.push({ message, reservation: result.reservation, context });
+      accepted.push(message);
+    }
+    event.handled = true;
+    const ownedCompletion = event.batch && typeof pi.sendMessages === "function"
+      ? deliverAtomicBatch(pi, accepted, event, reservations, admission, tracker)
+      : deliverSequentially(pi, accepted, event, reservations, admission, tracker);
+    event.completion = Promise.all([ownedCompletion, ...joined]).then(() => {});
+    return event.completion;
+  });
+}
+
+function isCompletedStageAskRoute(event: Partial<LateStageMessageEvent>): boolean {
+  return typeof event.workflowRunId === "string"
+    && typeof event.workflowStageId === "string"
+    && event.messages?.length !== 0
+    && event.messages?.every((message) => {
+      if (message.customType !== "intercom_message") return false;
+      const entry = message.details as InboundMessageEntry | undefined;
+      return entry?.message.expectsReply === true;
+    }) === true;
+}
+
+function deliverAtomicBatch(
+  pi: ExtensionAPI,
+  accepted: LateStageMessage[],
+  event: Partial<LateStageMessageEvent>,
+  reservations: LateStageReservation[],
+  admission: InboundMessageAdmission,
+  tracker: ReplyTracker,
+): Promise<void> {
+  if (accepted.length === 0) return Promise.resolve();
+  for (const { reservation } of reservations) admission.beginDelivery(reservation);
+  let delivery: Promise<void>;
+  try {
+    delivery = Promise.resolve(pi.sendMessages(accepted, event.options as Parameters<ExtensionAPI["sendMessages"]>[1]));
+  } catch (error) {
+    delivery = Promise.reject(error);
+  }
+  for (const { reservation } of reservations) admission.endDelivery(reservation);
+  return delivery.then(
+    () => { for (const { reservation } of reservations) admission.commit(reservation); },
+    (error: Error) => { releaseReservations(reservations, admission, tracker, error); throw error; },
+  );
+}
+
+async function deliverSequentially(
+  pi: ExtensionAPI,
+  accepted: LateStageMessage[],
+  event: Partial<LateStageMessageEvent>,
+  reservations: LateStageReservation[],
+  admission: InboundMessageAdmission,
+  tracker: ReplyTracker,
+): Promise<void> {
+  const pending = new Map(reservations.map((owned) => [owned.message, owned]));
+  for (let index = 0; index < accepted.length; index += 1) {
+    const message = accepted[index]!;
+    const owned = pending.get(message);
+    if (owned) admission.beginDelivery(owned.reservation);
+    try {
+      await pi.sendMessage(message, index === 0 ? event.options : { deliverAs: "followUp" });
+    } catch (error) {
+      if (owned) admission.endDelivery(owned.reservation);
+      const failure = error instanceof Error ? error : new Error(String(error));
+      releaseReservations([...pending.values()], admission, tracker, failure);
+      throw failure;
+    }
+    if (owned) {
+      admission.endDelivery(owned.reservation);
+      admission.commit(owned.reservation);
+      pending.delete(message);
+    }
+  }
+}
+
+function releaseReservations(
+  reservations: LateStageReservation[],
+  admission: InboundMessageAdmission,
+  tracker: ReplyTracker,
+  error: Error,
+): void {
+  for (const { reservation, context } of reservations) {
+    admission.release(reservation, error);
+    tracker.forgetIncomingMessage(context);
+  }
+}

package/dist/builtin/intercom/lifecycle.ts

@@ -23,7 +23,9 @@ interface LifecycleDeps {
   activeTools: Map<string, string>;
   getLiveContext(ctx?: ExtensionContext | null, generation?: number): ExtensionContext | null;
   rejectReplyWaiter(error: Error): void;
-  replyTracker: ReplyTracker;
+  replyTracker: ReplyTracker | (() => ReplyTracker);
+  bindReplyTracker?(ctx: ExtensionContext): void;
+  preserveReplyTrackerOnCleanup?(): boolean;
   pendingIdleMessages: InboundIdleQueue;
   clearInboundFlushTimer(): void;
   scheduleInboundFlush(delayMs?: number): void;
@@ -34,6 +36,8 @@ interface LifecycleDeps {
 }
 
 export function registerIntercomLifecycle(pi: ExtensionAPI, deps: LifecycleDeps): void {
+  const activeReplyTracker = (): ReplyTracker =>
+    typeof deps.replyTracker === "function" ? deps.replyTracker() : deps.replyTracker;
   let hasActiveSession = false;
 
   async function cleanupRuntime(reason: string): Promise<void> {
@@ -43,7 +47,7 @@ export function registerIntercomLifecycle(pi: ExtensionAPI, deps: LifecycleDeps)
     deps.incrementRuntimeGeneration();
     deps.clearReconnectTimer();
     deps.rejectReplyWaiter(new Error(reason));
-    deps.replyTracker.reset();
+    if (deps.preserveReplyTrackerOnCleanup?.() !== true) activeReplyTracker().reset();
     deps.pendingIdleMessages.clear();
     deps.clearInboundFlushTimer();
     deps.setAgentRunning(false);
@@ -74,6 +78,7 @@ export function registerIntercomLifecycle(pi: ExtensionAPI, deps: LifecycleDeps)
     deps.resetReconnectAttempt();
     deps.clearReconnectTimer();
     deps.setRuntimeContext(ctx);
+    deps.bindReplyTracker?.(ctx);
     deps.setCurrentSessionId(ctx.sessionManager.getSessionId());
     deps.setCurrentModel(ctx.model?.id ?? "unknown");
     deps.setSessionStartedAt(Date.now());
@@ -89,7 +94,7 @@ export function registerIntercomLifecycle(pi: ExtensionAPI, deps: LifecycleDeps)
 
   pi.on("turn_end", () => {
     if (!deps.getLiveContext()) return;
-    deps.replyTracker.endTurn();
+    activeReplyTracker().endTurn();
     // Preserve the normal grace period so a same-tick terminal barrier can
     // claim accepted child messages before idle delivery releases ownership.
     deps.scheduleInboundFlush();
@@ -119,9 +124,10 @@ export function registerIntercomLifecycle(pi: ExtensionAPI, deps: LifecycleDeps)
   });
   pi.on("turn_start", (_event, ctx) => {
     if (!deps.getLiveContext(ctx)) return;
+    deps.bindReplyTracker?.(ctx);
     deps.setCurrentSessionId(ctx.sessionManager.getSessionId());
     deps.syncPresenceIdentity(ctx.sessionManager.getSessionId());
-    deps.replyTracker.beginTurn();
+    activeReplyTracker().beginTurn();
   });
   pi.on("model_select", (event, ctx) => {
     if (!deps.getLiveContext(ctx)) return;

package/dist/builtin/intercom/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/intercom",
-  "version": "0.9.9",
+  "version": "0.9.10",
   "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": [
@@ -44,7 +44,7 @@
   },
   "peerDependencies": {
     "@bastani/atomic": "*",
-    "@earendil-works/pi-tui": "^0.80.7"
+    "@earendil-works/pi-tui": "^0.80.10"
   },
   "peerDependenciesMeta": {
     "@bastani/atomic": {

package/dist/builtin/intercom/reconnect-backoff.ts

@@ -0,0 +1,6 @@
+const BACKOFF_MS = [1000, 2000, 5000, 10000, 30000] as const;
+
+/** Reconnect backoff delay for the given zero-based attempt (clamped to the max step). */
+export function reconnectDelayMs(attempt: number): number {
+  return BACKOFF_MS[Math.min(attempt, BACKOFF_MS.length - 1)]!;
+}

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

@@ -26,6 +26,14 @@ export class ReplyTracker {
     this.pendingTurnContexts.push(context);
   }
 
+  forgetIncomingMessage(context: IntercomContext): void {
+    if (this.pendingAsks.get(context.message.id) === context) this.pendingAsks.delete(context.message.id);
+    for (let index = this.pendingTurnContexts.length - 1; index >= 0; index -= 1) {
+      if (this.pendingTurnContexts[index] === context) this.pendingTurnContexts.splice(index, 1);
+    }
+    if (this.currentTurnContext === context) this.currentTurnContext = null;
+  }
+
   beginTurn(now = Date.now()): void {
     this.pruneExpired(now);
     this.currentTurnContext = this.pendingTurnContexts.shift() ?? null;

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

@@ -207,6 +207,8 @@ message, treat it as a `contact_supervisor` escalation.
 | `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 |
 
+Inside workflows, `ask` may target a sibling stage that has already completed. If that stage retains a valid conversation, Atomic automatically schedules a post-mortem turn there and preserves the exact child-to-child reply thread; do not send a separate workflow follow-up. Missing, deleted, non-resumable, or failed-to-reopen completed targets return an actionable error. A parent or unrelated session cannot satisfy the pending ask.
+
 ## Optional: Visible Peer Sessions via cmux, tmux, or psmux (Windows rewrite of tmux that has fully parity with tmux)
 
 If no suitable intercom-connected peer session already exists and the task benefits from a long-lived visible conversation, you may spawn a new `atomic` session.

package/dist/builtin/intercom/stable-delivery-retry.ts

@@ -0,0 +1,32 @@
+export interface StableDeliveryRetryOptions {
+  deliver: () => Promise<void>;
+  isCurrent: () => boolean;
+  schedule?: (retry: () => void) => void;
+}
+
+/** Retries one stable-key delivery until it succeeds or its session generation retires. */
+export function retryStableDelivery(options: StableDeliveryRetryOptions): Promise<void> {
+  const schedule = options.schedule ?? ((retry) => { setTimeout(retry, 100); });
+  return new Promise((resolve, reject) => {
+    let retirementRetryUsed = false;
+    let attempted = false;
+    const attempt = (): void => {
+      if (!options.isCurrent() && (!attempted || retirementRetryUsed)) {
+        reject(new Error("Stable delivery owner retired before delivery succeeded"));
+        return;
+      }
+      if (!options.isCurrent()) retirementRetryUsed = true;
+      attempted = true;
+      const failed = (error: unknown): void => {
+        if (options.isCurrent() || !retirementRetryUsed) schedule(attempt);
+        else reject(error);
+      };
+      try {
+        void Promise.resolve(options.deliver()).then(resolve, failed);
+      } catch (error) {
+        failed(error);
+      }
+    };
+    attempt();
+  });
+}