@bastani/atomic 0.9.39-alpha.2 → 0.9.40-alpha.1

package/dist/builtin/intercom/index.bundle.mjs

@@ -164,7 +164,7 @@ var init_recoverable_disconnect = __esm(() => {
 });
 
 // dist/builtin/intercom/retry-policy.ts
-var ASK_REPLY_TIMEOUT_MS, RETRY_IDENTITY_RETRY_OPPORTUNITY_MS, RETRY_IDENTITY_TTL_MS, DELIVERED_MESSAGE_TTL_MS, RECONNECT_DELAYS_MS;
+var ASK_REPLY_TIMEOUT_MS, RETRY_IDENTITY_RETRY_OPPORTUNITY_MS, RETRY_IDENTITY_TTL_MS, DELIVERED_MESSAGE_TTL_MS, RECONNECT_DELAYS_MS, SEND_RESPONSE_TIMEOUT_MS = 1e4;
 var init_retry_policy = __esm(() => {
   ASK_REPLY_TIMEOUT_MS = 10 * 60 * 1000;
   RETRY_IDENTITY_RETRY_OPPORTUNITY_MS = 60 * 1000;
@@ -182,6 +182,298 @@ var init_reconnect_backoff = __esm(() => {
   BACKOFF_MS = [1000, 2000, 5000, 1e4, 30000];
 });
 
+// dist/builtin/intercom/session-recovery.ts
+async function awaitRestoredIntercomPeers(events, ownerSessionId) {
+  const request = { ownerSessionId };
+  try {
+    events.emit(SUBAGENT_RESTORED_INTERCOM_PEERS_EVENT, request);
+    return request.completion ? await request.completion : [];
+  } catch {
+    return [];
+  }
+}
+function isReserveRestoringChildRequest(value) {
+  if (!value || typeof value !== "object")
+    return false;
+  const request = value;
+  return typeof request.capability === "string" && request.capability.length > 0 && (request.group === undefined || typeof request.group === "string") && (request.dormant === undefined || typeof request.dormant === "boolean") && Array.isArray(request.aliases) && request.aliases.every((alias) => typeof alias === "string");
+}
+function isReleaseRestoringChildRequest(value) {
+  if (!value || typeof value !== "object")
+    return false;
+  const request = value;
+  return typeof request.capability === "string" && request.capability.length > 0 && (request.gone === undefined || typeof request.gone === "string") && (request.refusal === undefined || typeof request.refusal === "string");
+}
+async function awaitSubagentChildRestoration(events, ownerSessionId, target) {
+  const request = { ownerSessionId, target, timeoutMs: CHILD_RESTORATION_WAIT_MS };
+  try {
+    events.emit(SUBAGENT_AWAIT_CHILD_RESTORATION_EVENT, request);
+    return request.completion ? await request.completion : undefined;
+  } catch {
+    return;
+  }
+}
+function isAwaitIntercomPeerRequest(value) {
+  const request = value;
+  return typeof request.name === "string" && request.name.trim().length > 0 && typeof request.timeoutMs === "number" && (request.group === undefined || typeof request.group === "string");
+}
+function hasIntercomHistory(entries) {
+  return entries.some((entry) => entry.type === "custom_message" && entry.customType === "intercom_message" || entry.type === "custom" && entry.customType === "intercom_inbox" || entry.type === "custom" && entry.customType === "subagent-child" || entry.type === "message" && entry.message.role === "toolResult" && (entry.message.toolName === "intercom" || entry.message.toolName === "contact_supervisor"));
+}
+async function waitForIntercomPeer(client, request) {
+  const name = request.name.trim().toLowerCase();
+  const deadline = Date.now() + request.timeoutMs;
+  for (;; ) {
+    const sessions = await client.listSessions(request.group);
+    if (sessions.some((session) => session.name?.trim().toLowerCase() === name))
+      return true;
+    if (Date.now() + PEER_POLL_INTERVAL_MS > deadline)
+      return false;
+    await new Promise((resolve) => setTimeout(resolve, PEER_POLL_INTERVAL_MS));
+  }
+}
+function inboundEntry(delivery) {
+  if (delivery.customType !== "intercom_message")
+    return;
+  const details = delivery.details;
+  return typeof details?.from?.id === "string" && typeof details.message?.id === "string" ? details : undefined;
+}
+function peerLabel(from) {
+  return from.name ? `\`${from.name}\`` : `\`${from.id}\``;
+}
+function isLivePeer(from, peers) {
+  const name = from.name?.trim().toLowerCase();
+  return peers.some((peer) => peer.id === from.id || name !== undefined && peer.name?.trim().toLowerCase() === name);
+}
+function isRestoredPeer(from, restored) {
+  const name = from.name?.trim().toLowerCase();
+  return restored.some((peer) => peer.ids.includes(from.id) || name !== undefined && peer.name.trim().toLowerCase() === name);
+}
+function boundedBody(text) {
+  return text.length > RECOVERED_BODY_MAX_CHARS ? `${text.slice(0, RECOVERED_BODY_MAX_CHARS)}…` : text;
+}
+function planIntercomRecoveryReplay(pending, peers, restored = []) {
+  const decisions = [];
+  const gone = new Map;
+  const deferred = new Map;
+  const reconnecting = new Map;
+  const tally = (counts, key, from) => {
+    const sender = counts.get(key) ?? { from, count: 0 };
+    sender.count += 1;
+    counts.set(key, sender);
+  };
+  for (const delivery of pending) {
+    const entry = inboundEntry(delivery);
+    if (!entry || LOCAL_RELAY_SENDERS.has(entry.from.id))
+      continue;
+    const key = entry.from.name?.trim().toLowerCase() ?? entry.from.id;
+    if (peers === undefined) {
+      decisions.push({ entryId: delivery.entryId, action: "defer" });
+      tally(deferred, key, entry.from);
+      continue;
+    }
+    if (isLivePeer(entry.from, peers)) {
+      decisions.push({ entryId: delivery.entryId, action: "replay" });
+      continue;
+    }
+    if (isRestoredPeer(entry.from, restored)) {
+      decisions.push({ entryId: delivery.entryId, action: "defer" });
+      tally(reconnecting, key, entry.from);
+      continue;
+    }
+    decisions.push({ entryId: delivery.entryId, action: "drop" });
+    const group = gone.get(key) ?? { from: entry.from, entries: [] };
+    group.entries.push(entry);
+    gone.set(key, group);
+  }
+  const notices = [...gone.values()].map(({ from, entries }) => {
+    const history = entries.map((entry) => `- Sent ${new Date(entry.message.timestamp).toISOString()}: ${boundedBody(entry.bodyText)}`).join(`
+`);
+    return `Intercom peer ${peerLabel(from)} is gone: it is no longer connected after the restart. ${entries.length} message(s) it sent before the restart were not replayed as new turns; they are shown here as history only. Do not reply to it or send it new messages; launch a fresh subagent if its work is still needed.
+${history}`;
+  });
+  for (const { from, count } of reconnecting.values()) {
+    notices.push(`Intercom peer ${peerLabel(from)} was relaunched after the restart but has not reconnected to Intercom yet, so ${count === 1 ? "1 interrupted delivery" : `${count} interrupted deliveries`} from it ${count === 1 ? "was" : "were"} deferred: not replayed now and not discarded. It is not gone; treat it as unreachable until it reconnects. The next resume of this session tries them again.`);
+  }
+  if (deferred.size > 0) {
+    const count = [...deferred.values()].reduce((total, sender) => total + sender.count, 0);
+    const senders = [...deferred.values()].map(({ from }) => peerLabel(from)).join(", ");
+    notices.push(`Intercom could not be reached after the restart, so ${count === 1 ? "1 interrupted Intercom delivery" : `${count} interrupted Intercom deliveries`} from ${senders} ${count === 1 ? "was" : "were"} deferred: not replayed now and not discarded. Whether their senders are still connected is unknown. The next resume of this session tries them again.`);
+  }
+  return { decisions, ...notices.length > 0 ? { notices } : {} };
+}
+var SUBAGENT_AWAIT_INTERCOM_PEER_EVENT = "subagent:await-intercom-peer", SUBAGENT_AWAIT_CHILD_RESTORATION_EVENT = "subagent:await-child-restoration", CHILD_RESTORATION_WAIT_MS = 20000, SUBAGENT_RESERVE_RESTORING_CHILD_EVENT = "subagent:reserve-restoring-child", SUBAGENT_RELEASE_RESTORING_CHILD_EVENT = "subagent:release-restoring-child", SUBAGENT_RESTORED_INTERCOM_PEERS_EVENT = "subagent:restored-intercom-peers", INTERCOM_RECOVERY_PEERS_EVENT = "intercom:recovery-peers", PEER_POLL_INTERVAL_MS = 200, RECOVERED_BODY_MAX_CHARS = 2000, LOCAL_RELAY_SENDERS;
+var init_session_recovery = __esm(() => {
+  LOCAL_RELAY_SENDERS = new Set(["subagent-control", "subagent-result"]);
+});
+
+// dist/builtin/intercom/broker/client-message-validation.ts
+function isAttachment(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  const attachment = value;
+  if (attachment.type !== "file" && attachment.type !== "snippet" && attachment.type !== "context")
+    return false;
+  if (typeof attachment.name !== "string" || typeof attachment.content !== "string")
+    return false;
+  return attachment.language === undefined || typeof attachment.language === "string";
+}
+function isMessageSource(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value))
+    return false;
+  const source = value;
+  return typeof source.subagentRunId === "string" && (source.subagentAgent === undefined || typeof source.subagentAgent === "string") && (source.subagentIndex === undefined || typeof source.subagentIndex === "number");
+}
+function isMessage(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  const message = value;
+  if (typeof message.id !== "string" || typeof message.timestamp !== "number")
+    return false;
+  if (message.replyTo !== undefined && typeof message.replyTo !== "string")
+    return false;
+  if (message.expectsReply !== undefined && typeof message.expectsReply !== "boolean")
+    return false;
+  if (message.replyError !== undefined && typeof message.replyError !== "string")
+    return false;
+  if (message.source !== undefined && !isMessageSource(message.source))
+    return false;
+  if (typeof message.content !== "object" || message.content === null)
+    return false;
+  const content = message.content;
+  if (typeof content.text !== "string")
+    return false;
+  return content.attachments === undefined || Array.isArray(content.attachments) && content.attachments.every(isAttachment);
+}
+function isSessionInfo(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  const session = value;
+  if (typeof session.id !== "string" || typeof session.cwd !== "string" || typeof session.model !== "string" || typeof session.pid !== "number" || typeof session.startedAt !== "number" || typeof session.lastActivity !== "number")
+    return false;
+  if (session.name !== undefined && typeof session.name !== "string")
+    return false;
+  if (session.group !== undefined && typeof session.group !== "string")
+    return false;
+  return session.status === undefined || typeof session.status === "string";
+}
+
+// dist/builtin/intercom/durable-inbox.ts
+function inboxRecord(entry) {
+  if (entry.type !== "custom" || entry.customType !== INTERCOM_INBOX_ENTRY)
+    return;
+  const data = entry.data;
+  if (!isMessage(data?.message) || !isSessionInfo(data.from) || typeof data.receivedAt !== "number")
+    return;
+  return {
+    message: data.message,
+    from: data.from,
+    receivedAt: data.receivedAt,
+    ...data.channel === "supervisor" ? { channel: "supervisor" } : {}
+  };
+}
+function consumedIntercomMessageIds(entries) {
+  const ids = new Set;
+  for (const entry of entries) {
+    if (entry.type !== "custom_message" || entry.customType !== "intercom_message")
+      continue;
+    const id = entry.details?.message?.id;
+    if (typeof id === "string")
+      ids.add(id);
+  }
+  return ids;
+}
+function handledIntercomMessageIds(entries) {
+  const ids = new Set;
+  for (const entry of entries) {
+    if (entry.type !== "custom")
+      continue;
+    if (entry.customType !== "intercom_received" && entry.customType !== INTERCOM_INBOX_HANDLED_ENTRY)
+      continue;
+    const id = entry.data?.messageId;
+    if (typeof id === "string")
+      ids.add(id);
+  }
+  return ids;
+}
+function savedIntercomMessageIds(entries) {
+  const ids = new Set;
+  for (const entry of entries) {
+    const record = inboxRecord(entry);
+    if (record !== undefined)
+      ids.add(record.message.id);
+  }
+  return ids;
+}
+function unconsumedIntercomInbox(entries) {
+  const branch = [...entries];
+  const consumed = consumedIntercomMessageIds(branch);
+  for (const id of handledIntercomMessageIds(branch))
+    consumed.add(id);
+  const records = new Map;
+  for (const entry of branch) {
+    const record = inboxRecord(entry);
+    if (record === undefined || consumed.has(record.message.id) || records.has(record.message.id))
+      continue;
+    records.set(record.message.id, record);
+  }
+  return [...records.values()].sort((left, right) => left.receivedAt - right.receivedAt);
+}
+
+class DurableInbox {
+  options;
+  saved = new Set;
+  tail = Promise.resolve();
+  constructor(options) {
+    this.options = options;
+  }
+  receive(from, message, channel, acknowledge) {
+    const arrival = this.tail.then(() => this.save(from, message, channel, acknowledge));
+    this.tail = arrival.then(() => {}, () => {});
+    return arrival;
+  }
+  async handledWithoutCard(messageId) {
+    if (!this.options.durable())
+      return;
+    if (!this.saved.has(messageId) && !savedIntercomMessageIds(this.options.entries()).has(messageId))
+      return;
+    try {
+      await this.options.appendHandled(messageId);
+    } catch {}
+  }
+  async save(from, message, channel, acknowledge) {
+    const confirm = () => {
+      try {
+        acknowledge();
+      } catch {}
+    };
+    if (!this.options.durable()) {
+      confirm();
+      return "fresh";
+    }
+    if (this.saved.has(message.id) || savedIntercomMessageIds(this.options.entries()).has(message.id)) {
+      this.saved.add(message.id);
+      confirm();
+      return "redelivered";
+    }
+    try {
+      await this.options.append({
+        message,
+        from,
+        receivedAt: this.options.now?.() ?? Date.now(),
+        ...channel === undefined ? {} : { channel }
+      });
+    } catch {
+      return "unsaved";
+    }
+    this.saved.add(message.id);
+    confirm();
+    return "fresh";
+  }
+}
+var INTERCOM_INBOX_ENTRY = "intercom_inbox", INTERCOM_INBOX_HANDLED_ENTRY = "intercom_inbox_handled", INTERCOM_INBOX_REPLAY_EVENT = "intercom:inbox-replay";
+var init_durable_inbox = () => {};
+
 // dist/builtin/intercom/subagent-reply-capability.ts
 function registerSubagentReplyCapability(pi, client) {
   let signal;
@@ -213,6 +505,20 @@ function registerSubagentReplyCapability(pi, client) {
   return capability;
 }
 
+// dist/builtin/intercom/session-identity.ts
+function readIntercomSessionIdentity(entries, sessionId) {
+  for (let index = entries.length - 1;index >= 0; index -= 1) {
+    const entry = entries[index];
+    if (entry?.type !== "custom" || entry.customType !== INTERCOM_SESSION_IDENTITY_ENTRY)
+      continue;
+    const data = entry.data;
+    if (data?.sessionId === sessionId && typeof data.intercomSessionId === "string" && data.intercomSessionId)
+      return data.intercomSessionId;
+  }
+  return;
+}
+var INTERCOM_SESSION_IDENTITY_ENTRY = "intercom_session_identity";
+
 // dist/builtin/intercom/broker/framing.ts
 function writeMessage(socket, msg, callback) {
   const json = JSON.stringify(msg);
@@ -308,6 +614,7 @@ function getBrokerSocketPath(platform = process.platform, agentDir = getAgentDir
   }
   return join(getIntercomDirPath(agentDir), "broker.sock");
 }
+var BROKER_STORAGE_ENV = "ATOMIC_STORAGE";
 var init_paths = () => {};
 
 // dist/builtin/intercom/broker/send-signature.ts
@@ -415,6 +722,17 @@ class PendingSendRegistry {
     attempt.resolve(result);
     return true;
   }
+  extend(messageId, attemptId, timeoutMs) {
+    const attempt = this.attempts.get(messageId);
+    if (!attempt || (attemptId === undefined ? !attempt.legacyEligible : attempt.attemptId !== attemptId))
+      return false;
+    if (attempt.timer)
+      clearTimeout(attempt.timer);
+    attempt.timer = setTimeout(() => {
+      this.reject(attempt, new Error("Send timeout"));
+    }, timeoutMs);
+    return true;
+  }
   resolveLegacy(messageId, result) {
     const attempt = this.attempts.get(messageId);
     if (!attempt?.legacyEligible)
@@ -454,57 +772,6 @@ function readSubagentMessageSource(policy) {
   };
 }
 
-// dist/builtin/intercom/broker/client-message-validation.ts
-function isAttachment(value) {
-  if (typeof value !== "object" || value === null)
-    return false;
-  const attachment = value;
-  if (attachment.type !== "file" && attachment.type !== "snippet" && attachment.type !== "context")
-    return false;
-  if (typeof attachment.name !== "string" || typeof attachment.content !== "string")
-    return false;
-  return attachment.language === undefined || typeof attachment.language === "string";
-}
-function isMessageSource(value) {
-  if (typeof value !== "object" || value === null || Array.isArray(value))
-    return false;
-  const source = value;
-  return typeof source.subagentRunId === "string" && (source.subagentAgent === undefined || typeof source.subagentAgent === "string") && (source.subagentIndex === undefined || typeof source.subagentIndex === "number");
-}
-function isMessage(value) {
-  if (typeof value !== "object" || value === null)
-    return false;
-  const message = value;
-  if (typeof message.id !== "string" || typeof message.timestamp !== "number")
-    return false;
-  if (message.replyTo !== undefined && typeof message.replyTo !== "string")
-    return false;
-  if (message.expectsReply !== undefined && typeof message.expectsReply !== "boolean")
-    return false;
-  if (message.replyError !== undefined && typeof message.replyError !== "string")
-    return false;
-  if (message.source !== undefined && !isMessageSource(message.source))
-    return false;
-  if (typeof message.content !== "object" || message.content === null)
-    return false;
-  const content = message.content;
-  if (typeof content.text !== "string")
-    return false;
-  return content.attachments === undefined || Array.isArray(content.attachments) && content.attachments.every(isAttachment);
-}
-function isSessionInfo(value) {
-  if (typeof value !== "object" || value === null)
-    return false;
-  const session = value;
-  if (typeof session.id !== "string" || typeof session.cwd !== "string" || typeof session.model !== "string" || typeof session.pid !== "number" || typeof session.startedAt !== "number" || typeof session.lastActivity !== "number")
-    return false;
-  if (session.name !== undefined && typeof session.name !== "string")
-    return false;
-  if (session.group !== undefined && typeof session.group !== "string")
-    return false;
-  return session.status === undefined || typeof session.status === "string";
-}
-
 // dist/builtin/intercom/group.ts
 function intercomGroupFromEnv() {
   return process.env.ATOMIC_INTERCOM_GROUP ?? process.env.PI_INTERCOM_GROUP;
@@ -571,16 +838,20 @@ function isWorkflowFutureStageRosterEntries(value) {
 function isWorkflowStageRosterEntries(value) {
   return Array.isArray(value) && value.every((entry) => typeof entry === "object" && entry !== null && entry.kind === "workflow-stage" && typeof entry.runId === "string" && typeof entry.stageId === "string" && typeof entry.stageName === "string" && typeof entry.target === "string" && (entry.lifecycle === "pending" || entry.lifecycle === "running") && typeof entry.group === "string" && (entry.sessionId === undefined || typeof entry.sessionId === "string"));
 }
-var BROKER_SOCKET, GROUP_REQUEST_TIMEOUT_MS = 5000, PRESENCE_ACK_TIMEOUT_MS = 5000, IntercomClient;
+var BROKER_SOCKET, GROUP_REQUEST_TIMEOUT_MS = 5000, PRESENCE_ACK_TIMEOUT_MS = 5000, RESTORING_RECIPIENT_REQUEST_TIMEOUT_MS = 5000, HELD_SEND_GRACE_MS = 5000, IntercomClient;
 var init_client = __esm(() => {
   init_paths();
   init_pending_send_registry();
   init_group();
   init_recoverable_disconnect();
   init_live_route_refusal();
+  init_retry_policy();
   BROKER_SOCKET = getBrokerSocketPath();
   IntercomClient = class IntercomClient extends EventEmitter {
     returnAddress;
+    preferredSessionId;
+    acknowledgesReceipt;
+    brokerAcknowledgesReceipt = false;
     socket = null;
     _sessionId = null;
     _supervisorSessionId = null;
@@ -594,13 +865,16 @@ var init_client = __esm(() => {
     _groups = normalizeGroups();
     pendingLiveWorkflowStageRoutes = new Map;
     pendingSupervisorAuthorizations = new Map;
+    pendingRestoringRecipientRequests = new Map;
     disconnecting = false;
     disconnectError = null;
-    constructor(returnAddress = randomUUID2()) {
+    constructor(returnAddress = randomUUID2(), options = {}) {
       super();
       if (returnAddress.length === 0)
         throw new Error("Intercom return address must not be empty");
       this.returnAddress = returnAddress;
+      this.preferredSessionId = options.preferredSessionId;
+      this.acknowledgesReceipt = options.acknowledgesReceipt === true;
     }
     failPending(error) {
       this.pendingSends.rejectAll(error);
@@ -610,6 +884,8 @@ var init_client = __esm(() => {
         pending.reject(error);
       for (const pending of this.pendingSupervisorAuthorizations.values())
         pending.reject(error);
+      for (const pending of this.pendingRestoringRecipientRequests.values())
+        pending.reject(error);
       for (const pending of this.pendingPresence.values())
         pending.reject(error);
       for (const pending of this.pendingMemberships.values())
@@ -619,6 +895,7 @@ var init_client = __esm(() => {
       this.pendingLists.clear();
       this.pendingGroupLists.clear();
       this.pendingSupervisorAuthorizations.clear();
+      this.pendingRestoringRecipientRequests.clear();
       this.pendingPresence.clear();
       this.pendingMemberships.clear();
       this.pendingLiveWorkflowStageRoutes.clear();
@@ -702,6 +979,7 @@ var init_client = __esm(() => {
           }
           this._sessionId = null;
           this._supervisorSessionId = null;
+          this.brokerAcknowledgesReceipt = false;
           this._messageSource = undefined;
           this.disconnectError = null;
           if (connectionEstablished && !wasDisconnecting) {
@@ -753,6 +1031,8 @@ var init_client = __esm(() => {
             session,
             ...registrationGroup !== undefined ? { registrationGroup } : {},
             returnAddress: this.returnAddress,
+            ...this.preferredSessionId === undefined ? {} : { preferredSessionId: this.preferredSessionId },
+            ...this.acknowledgesReceipt ? { acknowledgesReceipt: true } : {},
             ...supervisor ? { supervisor } : {},
             ...supervisorOwnerToken ? { supervisorOwnerToken } : {}
           });
@@ -777,7 +1057,7 @@ var init_client = __esm(() => {
       }
       switch (brokerMessage.type) {
         case "registered": {
-          if (typeof brokerMessage.sessionId !== "string" || brokerMessage.supervisorSessionId !== undefined && typeof brokerMessage.supervisorSessionId !== "string") {
+          if (typeof brokerMessage.sessionId !== "string" || brokerMessage.supervisorSessionId !== undefined && typeof brokerMessage.supervisorSessionId !== "string" || brokerMessage.acknowledgesReceipt !== undefined && brokerMessage.acknowledgesReceipt !== true) {
             throw new Error("Invalid registered message");
           }
           if (this._sessionId !== null) {
@@ -785,6 +1065,7 @@ var init_client = __esm(() => {
           }
           this._sessionId = brokerMessage.sessionId;
           this._supervisorSessionId = typeof brokerMessage.supervisorSessionId === "string" ? brokerMessage.supervisorSessionId : null;
+          this.brokerAcknowledgesReceipt = this.acknowledgesReceipt && brokerMessage.acknowledgesReceipt === true;
           this.emit("_registered", { type: "registered", sessionId: brokerMessage.sessionId });
           break;
         }
@@ -901,6 +1182,13 @@ var init_client = __esm(() => {
           });
           break;
         }
+        case "pending_stage_route_revoked": {
+          const { runId } = brokerMessage;
+          if (typeof runId !== "string")
+            throw new Error("Invalid pending-stage route revocation");
+          this.emit("pending_stage_route_revoked", { runId });
+          break;
+        }
         case "live_workflow_stage_route_registered": {
           const { requestId } = brokerMessage;
           if (typeof requestId !== "string")
@@ -931,6 +1219,29 @@ var init_client = __esm(() => {
             this.pendingSends.resolve(messageId, attemptId, result);
           break;
         }
+        case "send_held": {
+          const { messageId, attemptId, timeoutMs } = brokerMessage;
+          if (typeof messageId !== "string" || attemptId !== undefined && typeof attemptId !== "string" || typeof timeoutMs !== "number" || !Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+            throw new Error("Invalid send_held message");
+          }
+          this.pendingSends.extend(messageId, attemptId, timeoutMs + HELD_SEND_GRACE_MS);
+          break;
+        }
+        case "restoring_recipient_ack": {
+          const { requestId, error } = brokerMessage;
+          if (typeof requestId !== "string" || error !== undefined && typeof error !== "string") {
+            throw new Error("Invalid restoring_recipient_ack message");
+          }
+          const pending = this.pendingRestoringRecipientRequests.get(requestId);
+          if (!pending)
+            return;
+          this.pendingRestoringRecipientRequests.delete(requestId);
+          if (error === undefined)
+            pending.resolve();
+          else
+            pending.reject(new Error(error));
+          break;
+        }
         case "delivered": {
           const { messageId, attemptId } = brokerMessage;
           if (typeof messageId !== "string" || attemptId !== undefined && typeof attemptId !== "string") {
@@ -1228,7 +1539,58 @@ var init_client = __esm(() => {
         }
       });
     }
-    registerPendingStageRoute(runId, group, capability, stages, possibleStages, parent) {
+    reserveRestoringRecipient(capability, options = {}) {
+      return this.restoringRecipientRequest({
+        type: "reserve_restoring_recipient",
+        capability,
+        ...options.group === undefined ? {} : { group: options.group },
+        ...options.aliases === undefined ? {} : { aliases: [...options.aliases] },
+        ...options.dormant === true ? { dormant: true } : {}
+      });
+    }
+    releaseRestoringRecipient(capability, outcome) {
+      const { gone, refusal } = typeof outcome === "string" ? { gone: outcome, refusal: undefined } : outcome ?? {};
+      return this.restoringRecipientRequest({
+        type: "release_restoring_recipient",
+        capability,
+        ...gone === undefined ? {} : { gone },
+        ...refusal === undefined ? {} : { refusal }
+      });
+    }
+    restoringRecipientRequest(frame) {
+      let socket;
+      try {
+        socket = this.requireActiveSocket();
+      } catch (error) {
+        return Promise.reject(toError(error));
+      }
+      const requestId = randomUUID2();
+      return new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+          if (!this.pendingRestoringRecipientRequests.delete(requestId))
+            return;
+          reject(new Error("Restoring-recipient request timeout"));
+        }, RESTORING_RECIPIENT_REQUEST_TIMEOUT_MS);
+        this.pendingRestoringRecipientRequests.set(requestId, {
+          resolve: () => {
+            clearTimeout(timeout);
+            resolve();
+          },
+          reject: (error) => {
+            clearTimeout(timeout);
+            reject(error);
+          }
+        });
+        try {
+          writeMessage(socket, { ...frame, requestId });
+        } catch (error) {
+          clearTimeout(timeout);
+          this.pendingRestoringRecipientRequests.delete(requestId);
+          reject(toError(error));
+        }
+      });
+    }
+    registerPendingStageRoute(runId, group, capability, stages, possibleStages, parent, dormant) {
       writeMessage(this.requireActiveSocket(), {
         type: "register_pending_stage_route",
         runId,
@@ -1236,7 +1598,8 @@ var init_client = __esm(() => {
         capability,
         stages,
         possibleStages,
-        ...parent === undefined ? {} : { parent }
+        ...parent === undefined ? {} : { parent },
+        ...dormant === true ? { dormant: true } : {}
       });
     }
     registerLiveWorkflowStageRoute(runId, stageKeys, capability) {
@@ -1286,6 +1649,11 @@ var init_client = __esm(() => {
     send(to, options) {
       return this.sendFrame("send", to, options);
     }
+    acknowledgeReceived(messageId) {
+      if (!this.brokerAcknowledgesReceipt)
+        return;
+      writeMessage(this.requireActiveSocket(), { type: "received", messageId });
+    }
     sendPendingStageNotification(runId, capability, to, senderRegistrationName, options, senderReturnAddress) {
       return this.sendFrame("send_pending_stage_notification", to, options, {
         runId,
@@ -1313,7 +1681,7 @@ var init_client = __esm(() => {
           requirePendingReply: options.requirePendingReply ?? false,
           ...options.expectedRecipientId === undefined ? {} : { expectedRecipientId: options.expectedRecipientId }
         });
-        acquired = this.pendingSends.acquire(messageId, pendingSignature, 1e4);
+        acquired = this.pendingSends.acquire(messageId, pendingSignature, SEND_RESPONSE_TIMEOUT_MS);
       } catch (error) {
         return Promise.reject(toError(error));
       }
@@ -1339,6 +1707,7 @@ var init_client = __esm(() => {
           ...options.requirePendingReply === undefined ? {} : { requirePendingReply: options.requirePendingReply },
           ...options.expectedRecipientId === undefined ? {} : { expectedRecipientId: options.expectedRecipientId },
           ...options.onReplyTarget === undefined ? {} : { resolveReplyTarget: true },
+          ...type === "send" ? { awaitRestoringRecipient: true } : {},
           message,
           attemptId: acquired.attempt.attemptId,
           ...extra
@@ -1443,7 +1812,7 @@ import { appendFileSync, chmodSync, closeSync, existsSync, mkdirSync, openSync,
 import { join as join2, dirname } from "path";
 import { fileURLToPath } from "url";
 import { createRequire } from "module";
-import { createChildProcessEnvironment, isBunBinary } from "@bastani/atomic";
+import { createChildProcessEnvironment, isBunBinary, processSharedStorageSelection } from "@bastani/atomic";
 function isIntercomPackageRoot(dir) {
   return existsSync(join2(dir, "package.json")) && existsSync(join2(dir, "broker"));
 }
@@ -1557,11 +1926,15 @@ function getBrokerLaunchSpec(brokerPath, brokerCommand, brokerArgs, extensionDir
   };
 }
 function getBrokerSpawnOptions(extensionDir = EXTENSION_DIR, stderr = "ignore") {
+  const storage = processSharedStorageSelection();
   return {
     detached: true,
     stdio: ["ignore", "ignore", stderr],
     cwd: extensionDir,
-    env: createChildProcessEnvironment({ NODE_NO_WARNINGS: "1" }),
+    env: createChildProcessEnvironment({
+      NODE_NO_WARNINGS: "1",
+      ...storage === undefined ? {} : { [BROKER_STORAGE_ENV]: storage }
+    }),
     windowsHide: true
   };
 }
@@ -2081,6 +2454,9 @@ function sessionTargetFailureReason(target, resolution) {
   if (resolution.kind === "ambiguous_id_prefix") {
     return `Session ID prefix "${target}" is ambiguous; matches: ${resolution.matches.map((session) => `${session.name ?? "unnamed"} (${session.id})`).join(", ")}. Use the full UUID.`;
   }
+  if (resolution.kind === "ambiguous_session_id") {
+    return `Session ID "${target}" is registered by more than one Intercom session: ${resolution.matches.map((session) => `${session.name ?? "unnamed"} (${session.id})`).join(", ")}. Use the Intercom session ID shown by intercom list.`;
+  }
   return "Session not found";
 }
 async function resolveSessionTargetId(client, nameOrId) {
@@ -2268,6 +2644,12 @@ var init_parent_ask_handoff = __esm(() => {
 });
 
 // dist/builtin/intercom/intercom-utils.ts
+function mayStartTurn(entry) {
+  return entry.historyOnly !== true;
+}
+function maySupplyReplyContext(entry) {
+  return entry.historyOnly !== true;
+}
 function getErrorMessage(error) {
   return error instanceof Error ? error.message : String(error);
 }
@@ -3698,6 +4080,16 @@ ${message}${attachmentText}`);
                 replyTo,
                 expectsReply: false
               }, retryToken);
+              const goneChild = await awaitSubagentChildRestoration(pi.events, toolSessionId, to);
+              if (goneChild !== undefined) {
+                retryIdentities.release(retryIdentity);
+                retryIdentity = undefined;
+                return {
+                  content: [{ type: "text", text: goneChild }],
+                  isError: true,
+                  details: { error: true, delivered: false, reason: goneChild }
+                };
+              }
               const sendTo = await resolveTarget(connectedClient, to) ?? to;
               if (_signal?.aborted) {
                 const retained = retainInconclusiveRetry(retryIdentities, retryIdentity);
@@ -3861,7 +4253,18 @@ ${message}${attachmentText}`);
                   details: { yielded: true }
                 };
               }
-              const sendTo = await resolveTarget(connectedClient, to) ?? to;
+              const goneChild = await awaitSubagentChildRestoration(pi.events, toolSessionId, to);
+              if (goneChild !== undefined) {
+                retryIdentities.release(retryIdentity);
+                retryIdentity = undefined;
+                return {
+                  content: [{ type: "text", text: goneChild }],
+                  isError: true,
+                  details: { error: true, delivered: false, reason: goneChild }
+                };
+              }
+              const listedTarget = await resolveTarget(connectedClient, to);
+              const sendTo = listedTarget ?? to;
               if (_signal?.aborted) {
                 const retained = retryIdentity === undefined ? undefined : retainInconclusiveRetry(retryIdentities, retryIdentity);
                 retryIdentity = undefined;
@@ -3946,7 +4349,7 @@ ${message}${attachmentText}`);
                 attachments,
                 replyTo,
                 expectsReply: true,
-                ...parseWorkflowStageTarget(to)?.kind === "path" ? { onReplyTarget: wait.bindSender } : {}
+                onReplyTarget: wait.bindSender
               });
               if (sendResult.queued === true) {
                 retryIdentities.release(retryIdentity);
@@ -4308,6 +4711,7 @@ var init_intercom_tool = __esm(() => {
   init_parent_ask_handoff();
   init_result_renderers();
   init_intercom_utils();
+  init_session_recovery();
   init_session_target();
   init_group();
   init_workflow_stage_target();
@@ -5919,11 +6323,12 @@ function routePeerDisconnect(waiters, notice) {
 
 // dist/builtin/intercom/incoming-message-delivery.ts
 function createIncomingMessageSender(input) {
-  return (entry, delivery, generation = input.currentGeneration(), trackReplyContext = true, turnContext, stageAdmissionBarrier) => {
+  return (entry, requested, generation = input.currentGeneration(), trackReplyContext = true, turnContext, stageAdmissionBarrier) => {
     if (!input.canDeliver(generation)) {
       return Promise.reject(new Error("Intercom session retired before inbound delivery"));
     }
-    if ((delivery === "trigger" || delivery === "interrupt") && trackReplyContext) {
+    const delivery = (requested === "trigger" || requested === "interrupt") && !mayStartTurn(entry) ? "prelude" : requested;
+    if ((delivery === "trigger" || delivery === "interrupt") && trackReplyContext && maySupplyReplyContext(entry)) {
       input.queueTurnContext(turnContext ?? { from: entry.from, message: entry.message, receivedAt: Date.now() });
     }
     const baseOptions = {
@@ -5991,16 +6396,39 @@ ${entry.bodyText}`,
     details: entry
   };
 }
+var init_incoming_message_delivery = __esm(() => {
+  init_intercom_utils();
+});
 
 // dist/builtin/intercom/inbound-idle-queue.ts
+function planIdleBatch(entries) {
+  const starter = entries.findIndex(mayStartTurn);
+  return {
+    triggerTurn: starter >= 0,
+    replyContext: starter >= 0 ? entries.find(maySupplyReplyContext) : undefined,
+    sendOptions: entries.map((_, index) => starter < 0 || index < starter ? { triggerTurn: false } : index === starter ? { triggerTurn: true } : { deliverAs: "followUp" })
+  };
+}
+
 class InboundIdleQueue {
+  consumedIds;
   entries = [];
   generation = 0;
+  constructor(consumedIds = () => NONE_CONSUMED) {
+    this.consumedIds = consumedIds;
+  }
+  dropConsumed() {
+    const consumed = this.consumedIds();
+    this.entries = this.entries.filter((entry) => !consumed.has(entry.message.id));
+  }
   get size() {
     return this.entries.length;
   }
   enqueue(entry) {
+    if (this.consumedIds().has(entry.message.id) || this.entries.some((queued) => queued.message.id === entry.message.id))
+      return false;
     this.entries.push(entry);
+    return true;
   }
   has(entry) {
     return this.entries.includes(entry);
@@ -6010,14 +6438,16 @@ class InboundIdleQueue {
     if (index < 0)
       return false;
     this.entries.splice(index, 1);
-    return true;
+    return !this.consumedIds().has(entry.message.id);
   }
   drain() {
+    this.dropConsumed();
     const entries = this.entries;
     this.entries = [];
     return entries;
   }
   claimOrdinarySourceTargets(runId, sourceSessionTargets, terminalAt = Number.POSITIVE_INFINITY) {
+    this.dropConsumed();
     const targets = new Set(sourceSessionTargets);
     const generation = this.generation;
     const original = this.entries;
@@ -6065,6 +6495,11 @@ class InboundIdleQueue {
     this.entries = [];
   }
 }
+var NONE_CONSUMED;
+var init_inbound_idle_queue = __esm(() => {
+  init_intercom_utils();
+  NONE_CONSUMED = new Set;
+});
 
 // dist/builtin/intercom/inbound-message-admission.ts
 class InboundMessageAdmission {
@@ -6175,6 +6610,10 @@ function registerLateStageMessageRouter(pi, admission, getReplyTracker, getOwner
       const entry = message.details;
       if (!entry?.from || !entry.message)
         continue;
+      if (!maySupplyReplyContext(entry)) {
+        accepted.push(message);
+        continue;
+      }
       if (entry.channel !== "supervisor" && !isSubagentRelayHandoff(entry) && normalizeGroup(entry.from.group) !== normalizeGroup(getOwnerGroup()))
         continue;
       const result = admission.admit(entry.from, entry.message);
@@ -6193,11 +6632,18 @@ function registerLateStageMessageRouter(pi, admission, getReplyTracker, getOwner
       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);
+    const delivery = accepted.some((message) => !isHistoryCard(message)) || event.options?.triggerTurn !== true ? event : { ...event, options: { ...event.options, triggerTurn: false } };
+    const ownedCompletion = event.batch && typeof pi.sendMessages === "function" ? deliverAtomicBatch(pi, accepted, delivery, reservations, admission, tracker) : deliverSequentially(pi, accepted, delivery, reservations, admission, tracker);
     event.completion = Promise.all([ownedCompletion, ...joined]).then(() => {});
     return event.completion;
   });
 }
+function isHistoryCard(message) {
+  if (message.customType !== "intercom_message")
+    return false;
+  const entry = message.details;
+  return entry !== undefined && !mayStartTurn(entry);
+}
 function isCompletedStageAskRoute(event) {
   return typeof event.workflowRunId === "string" && typeof event.workflowStageId === "string" && event.messages?.length !== 0 && event.messages?.every((message) => {
     if (message.customType !== "intercom_message")
@@ -6229,13 +6675,14 @@ function deliverAtomicBatch(pi, accepted, event, reservations, admission, tracke
 }
 async function deliverSequentially(pi, accepted, event, reservations, admission, tracker) {
   const pending = new Map(reservations.map((owned) => [owned.message, owned]));
+  const starter = accepted.findIndex((message) => !isHistoryCard(message));
   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" });
+      await pi.sendMessage(message, index === starter ? event.options : starter < 0 || index < starter ? { ...event.options, triggerTurn: false } : { deliverAs: "followUp" });
     } catch (error) {
       if (owned)
         admission.endDelivery(owned.reservation);
@@ -6258,6 +6705,7 @@ function releaseReservations(reservations, admission, tracker, error) {
 }
 var LATE_STAGE_MESSAGE_EVENT = "atomic:workflow-stage-late-message";
 var init_late_stage_message_router = __esm(() => {
+  init_intercom_utils();
   init_group();
 });
 
@@ -6406,10 +6854,12 @@ async function settleOpenStageDeliveryFailure(input, error) {
 }
 
 // dist/builtin/intercom/closed-workflow-stage-message.ts
-function routeClosedWorkflowStageMessage(entry, admission, tracker, waiter, deliver, currentClient, isCurrent, ownsSubagentRun) {
+function routeClosedWorkflowStageMessage(entry, admission, tracker, waiter, deliver, currentClient, isCurrent, ownsSubagentRun, handledWithoutCard = () => {}) {
   const sourceRunId = entry.message.source?.subagentRunId;
-  if (sourceRunId !== undefined && ownsSubagentRun(sourceRunId))
+  if (sourceRunId !== undefined && ownsSubagentRun(sourceRunId)) {
+    handledWithoutCard();
     return;
+  }
   if (entry.message.expectsReply !== true && !isDeliveryFeedback(entry.message)) {
     retryStableDelivery({ deliver, isCurrent }).catch(() => {});
     return;
@@ -6438,6 +6888,7 @@ function routeClosedWorkflowStageMessage(entry, admission, tracker, waiter, deli
     const failure = error instanceof Error ? error : new Error(String(error));
     tracker.forgetIncomingMessage(replyContext);
     if (entry.message.expectsReply === true && await sendWorkflowStageDeliveryFailure(entry, failure, tracker, currentClient, isCurrent, "Completed workflow stage could not process intercom ask")) {
+      handledWithoutCard();
       admission.commit(admitted.reservation);
       return;
     }
@@ -6451,7 +6902,9 @@ function invoke(deliver) {
     return Promise.reject(error);
   }
 }
-var init_closed_workflow_stage_message = () => {};
+var init_closed_workflow_stage_message = __esm(() => {
+  init_incoming_message_delivery();
+});
 
 // dist/builtin/intercom/runtime-group.ts
 import { runtimeIntercomGroupEnvKey } from "@bastani/atomic";
@@ -6731,7 +7184,26 @@ function piIntercomExtension(pi, testOverrides = {}) {
   let replyTracker = new ReplyTracker;
   const replyWaiters = new ReplyWaiterRegistry(DEFAULT_REPLY_TIMEOUT_MS, config.maxPendingAsks);
   const foregroundDetachHandoff = new ForegroundDetachHandoff(pi);
-  const pendingIdleMessages = new InboundIdleQueue;
+  function sessionBranch() {
+    try {
+      return runtimeContext?.sessionManager.getBranch() ?? [];
+    } catch {
+      return [];
+    }
+  }
+  const pendingIdleMessages = new InboundIdleQueue(() => consumedIntercomMessageIds(sessionBranch()));
+  const durableInbox = new DurableInbox({
+    durable: () => {
+      try {
+        return runtimeContext?.sessionManager.getSessionStore?.().descriptor.adapter !== "memory";
+      } catch {
+        return true;
+      }
+    },
+    entries: sessionBranch,
+    append: (record) => pi.appendEntry(INTERCOM_INBOX_ENTRY, record),
+    appendHandled: (messageId) => pi.appendEntry(INTERCOM_INBOX_HANDLED_ENTRY, { messageId })
+  });
   const inboundDeliveries = new InboundMessageAdmission;
   const pendingStageRoutes = new Map;
   const pendingStageRouteClients = new Map;
@@ -6912,16 +7384,79 @@ function piIntercomExtension(pi, testOverrides = {}) {
       return;
     }
     const entries = pendingIdleMessages.drain();
-    const first = entries[0];
-    if (first)
-      replyTracker.queueTurnContext({ from: first.from, message: first.message, receivedAt: Date.now() });
+    const batch = planIdleBatch(entries);
+    if (batch.replyContext)
+      replyTracker.queueTurnContext({ from: batch.replyContext.from, message: batch.replyContext.message, receivedAt: Date.now() });
     const messages = entries.map(buildIncomingCustomMessage);
     retryStableDelivery({
-      deliver: () => typeof pi.sendMessages === "function" ? Promise.resolve(pi.sendMessages(messages, { triggerTurn: true })) : Promise.all(messages.map((message, index) => pi.sendMessage(message, index === 0 ? { triggerTurn: true } : { deliverAs: "followUp" }))).then(() => {}),
+      deliver: () => typeof pi.sendMessages === "function" ? Promise.resolve(pi.sendMessages(messages, { triggerTurn: batch.triggerTurn })) : Promise.all(messages.map((message, index) => pi.sendMessage(message, batch.sendOptions[index]))).then(() => {}),
       isCurrent: () => Boolean(getLiveContext(ctx, generation))
     }).catch(() => {});
   }
   testOverrides.captureInboundHandler?.(handleIncomingMessage);
+  function buildInboundEntry(from, message, channel) {
+    const attachmentText = message.content.attachments?.length ? formatAttachments(message.content.attachments) : "";
+    const bodyText = `${message.content.text}${attachmentText}`;
+    const replyCommand = config.replyHint && message.expectsReply ? `intercom({ action: "reply", message: "..." })` : undefined;
+    const rawEntry = { from, message, replyCommand, bodyText, ...channel ? { channel } : {} };
+    return isDeliveryFeedback(message) ? frameDeliveryFeedback(rawEntry) : frameHistoricalSupervisorUpdate(rawEntry);
+  }
+  function receiveIncomingMessage(receiver, from, message, channel) {
+    const generation = runtimeGeneration;
+    durableInbox.receive(from, message, channel, () => receiver.acknowledgeReceived(message.id)).then((arrival) => {
+      if (arrival !== "fresh")
+        return;
+      const liveContext = getLiveContext(runtimeContext, generation);
+      if (liveContext)
+        handleIncomingMessage(liveContext, from, message, channel);
+    });
+  }
+  async function replayDurableInbox(request) {
+    const liveContext = getLiveContext();
+    if (!liveContext)
+      return [];
+    replyTracker = bindWorkflowReplyTracker(liveContext, replyTracker);
+    const records = unconsumedIntercomInbox(sessionBranch()).map((record) => ({
+      record,
+      entry: buildInboundEntry(record.from, record.message, record.channel)
+    }));
+    const plan = planIntercomRecoveryReplay(records.map(({ record, entry }) => ({
+      entryId: record.message.id,
+      customType: "intercom_message",
+      content: entry.bodyText,
+      details: entry,
+      timestamp: new Date(record.receivedAt).toISOString(),
+      delivery: "followUp"
+    })), request.peers, request.restored);
+    const actions = new Map((plan.decisions ?? []).map((decision) => [decision.entryId, decision.action]));
+    let queued = 0;
+    for (const { record, entry } of records) {
+      const action = actions.get(record.message.id) ?? "replay";
+      if (action === "defer")
+        continue;
+      if (action === "drop") {
+        const historyEntry = { ...entry, replyCommand: undefined, historyOnly: true };
+        if (queued > 0) {
+          pendingIdleMessages.enqueue(historyEntry);
+          continue;
+        }
+        try {
+          await pi.sendMessage(buildIncomingCustomMessage(historyEntry), { triggerTurn: false });
+        } catch {}
+        continue;
+      }
+      const admission = inboundDeliveries.admit(record.from, record.message);
+      if (admission.kind !== "reserved")
+        continue;
+      replyTracker.recordIncomingMessage(record.from, record.message);
+      if (pendingIdleMessages.enqueue(entry))
+        queued += 1;
+      inboundDeliveries.commit(admission.reservation);
+    }
+    if (queued > 0)
+      scheduleInboundFlush();
+    return plan.notices ?? [];
+  }
   function handleIncomingMessage(ctx, from, message, channel, receivedBeforeStageStart = false) {
     const messageGeneration = runtimeGeneration;
     const liveContext = getLiveContext(ctx, messageGeneration);
@@ -6931,11 +7466,7 @@ function piIntercomExtension(pi, testOverrides = {}) {
       return;
     }
     replyTracker = bindWorkflowReplyTracker(liveContext, replyTracker);
-    const attachmentText = message.content.attachments?.length ? formatAttachments(message.content.attachments) : "";
-    const bodyText = `${message.content.text}${attachmentText}`;
-    const replyCommand = config.replyHint && message.expectsReply ? `intercom({ action: "reply", message: "..." })` : undefined;
-    const rawEntry = { from, message, replyCommand, bodyText, ...channel ? { channel } : {} };
-    const framedEntry = isDeliveryFeedback(message) ? frameDeliveryFeedback(rawEntry) : frameHistoricalSupervisorUpdate(rawEntry);
+    const framedEntry = buildInboundEntry(from, message, channel);
     const entry = receivedBeforeStageStart ? framePreStartPendingStageMessage(framedEntry) : framedEntry;
     if (receivedBeforeStageStart) {
       return sendIncomingMessage(entry, "prelude", messageGeneration, false);
@@ -6948,7 +7479,7 @@ function piIntercomExtension(pi, testOverrides = {}) {
           throw new Error("Workflow stage is closed and cannot reply because post-mortem routing is unavailable. Contact a live stage or start new work with explicit context.");
         }
         return sendIncomingMessage(entry, isDeliveryFeedback(message) ? "prelude" : "trigger", messageGeneration, false);
-      }, () => client, () => Boolean(getLiveContext(liveContext, messageGeneration)), (runId) => stageAdmission.boundary.ownsSubagentRun(runId));
+      }, () => client, () => Boolean(getLiveContext(liveContext, messageGeneration)), (runId) => stageAdmission.boundary.ownsSubagentRun(runId), () => durableInbox.handledWithoutCard(message.id));
       return;
     }
     const admission = inboundDeliveries.admit(from, message);
@@ -6976,7 +7507,10 @@ function piIntercomExtension(pi, testOverrides = {}) {
       tracker: replyTracker,
       replyContext,
       currentClient: () => client,
-      commit,
+      commit: () => {
+        durableInbox.handledWithoutCard(message.id);
+        commit();
+      },
       failurePrefix: liveContext.subagentPolicy?.executionEnded === undefined ? undefined : "Subagent could not admit intercom ask"
     });
     const activeDelivery = admitActiveSessionInbound(liveContext, (admissionBarrier) => {
@@ -7013,6 +7547,7 @@ function piIntercomExtension(pi, testOverrides = {}) {
                 }
               } catch {}
             }
+            await durableInbox.handledWithoutCard(message.id);
             commit();
             return;
           }
@@ -7164,11 +7699,10 @@ function piIntercomExtension(pi, testOverrides = {}) {
   }
   function attachClientHandlers(nextClient) {
     nextClient.on("message", (from, message, channel) => {
-      const liveContext = getLiveContext();
-      if (client !== nextClient || !liveContext) {
+      if (client !== nextClient || !getLiveContext()) {
         return;
       }
-      handleIncomingMessage(liveContext, from, message, channel);
+      receiveIncomingMessage(nextClient, from, message, channel);
     });
     nextClient.on("pending_stage_message", (request) => {
       handlePendingStageMessage(nextClient, request, () => client === nextClient);
@@ -7249,6 +7783,20 @@ function piIntercomExtension(pi, testOverrides = {}) {
       if (state.client === nextClient)
         relayStickyLiveDelivered(notice);
     });
+    nextClient.on("pending_stage_route_revoked", (notice) => {
+      if (notice.runId !== runId || state.client !== nextClient)
+        return;
+      state.client = null;
+      if (state.reconnectTimer)
+        clearTimeout(state.reconnectTimer);
+      state.reconnectTimer = null;
+      if (pendingStageRouteClients.get(runId) === state)
+        pendingStageRouteClients.delete(runId);
+      if (samePendingStageRoute(pendingStageRoutes.get(runId), state.route))
+        pendingStageRoutes.delete(runId);
+      nextClient.disconnect().catch(() => {});
+      pi.events.emit(PENDING_STAGE_ROUTE_REVOKED_EVENT, { runId, capability: state.route.capability });
+    });
   }
   async function ensurePendingStageRouteClient(runId, route) {
     const contextAtStart = getLiveContext();
@@ -7281,7 +7829,7 @@ function piIntercomExtension(pi, testOverrides = {}) {
       pendingStageRouteClients.set(runId, state);
     if (state.client?.isConnected()) {
       state.route = route;
-      state.client.registerPendingStageRoute(runId, normalizeGroup(route.group), route.capability, route.stages, route.possibleStages, route.parent);
+      state.client.registerPendingStageRoute(runId, normalizeGroup(route.group), route.capability, route.stages, route.possibleStages, route.parent, route.dormant === true);
       await state.client.listSessions();
       return;
     }
@@ -7299,7 +7847,7 @@ function piIntercomExtension(pi, testOverrides = {}) {
         await nextClient.disconnect();
         throw new Error("Intercom runtime no longer active");
       }
-      nextClient.registerPendingStageRoute(runId, normalizeGroup(route.group), route.capability, route.stages, route.possibleStages, route.parent);
+      nextClient.registerPendingStageRoute(runId, normalizeGroup(route.group), route.capability, route.stages, route.possibleStages, route.parent, route.dormant === true);
       await nextClient.listSessions();
       if (!pendingStageRouteClientIsCurrent(runId, state, contextAtStart, generationAtStart)) {
         await nextClient.disconnect();
@@ -7346,13 +7894,28 @@ function piIntercomExtension(pi, testOverrides = {}) {
   }
   async function registerPendingStageRoute(activeClient, runId, route) {
     const routeGroup = normalizeGroup(route.group);
-    if (clientRegistrationGroup === routeGroup) {
+    if (clientRegistrationGroup === routeGroup && route.dormant !== true) {
       activeClient.registerPendingStageRoute(runId, routeGroup, route.capability, route.stages, route.possibleStages, route.parent);
       await activeClient.listSessions();
       return;
     }
     await ensurePendingStageRouteClient(runId, { ...route, group: routeGroup });
   }
+  function persistedIntercomSessionId(ctx, sessionId) {
+    try {
+      return readIntercomSessionIdentity(ctx.sessionManager.getEntries(), sessionId);
+    } catch {
+      return;
+    }
+  }
+  async function recordIntercomSessionIdentity(sessionId, intercomSessionId) {
+    try {
+      await pi.appendEntry(INTERCOM_SESSION_IDENTITY_ENTRY, {
+        sessionId,
+        intercomSessionId
+      });
+    } catch {}
+  }
   async function ensureConnected(reason) {
     if (disposed || shuttingDown) {
       throw new Error("Intercom shutting down");
@@ -7370,10 +7933,12 @@ function piIntercomExtension(pi, testOverrides = {}) {
       return reconnectPromise;
     }
     const ownershipRecorded = Promise.withResolvers();
+    const sessionIdAtStart = currentSessionId;
+    const preferredSessionId = persistedIntercomSessionId(contextAtStart, sessionIdAtStart);
     const nextReconnectPromise = (async () => {
       let connectFailed = false;
       await ownershipRecorded.promise;
-      const nextClient = new IntercomClient(currentSessionId);
+      const nextClient = new IntercomClient(sessionIdAtStart, { preferredSessionId, acknowledgesReceipt: true });
       client = nextClient;
       attachClientHandlers(nextClient);
       try {
@@ -7404,6 +7969,9 @@ function piIntercomExtension(pi, testOverrides = {}) {
           process.env[INTERCOM_SESSION_ID_ENV] = nextClient.sessionId;
         }
         reconnectAttempt = 0;
+        if (nextClient.sessionId && nextClient.sessionId !== preferredSessionId) {
+          await recordIntercomSessionIdentity(sessionIdAtStart, nextClient.sessionId);
+        }
         return nextClient;
       } catch (error) {
         if (client === nextClient) {
@@ -7438,7 +8006,8 @@ function piIntercomExtension(pi, testOverrides = {}) {
       capability: payload.capability,
       ...payload.stages === undefined ? {} : { stages: payload.stages },
       ...payload.possibleStages === undefined ? {} : { possibleStages: payload.possibleStages },
-      ...payload.parent === undefined ? {} : { parent: payload.parent }
+      ...payload.parent === undefined ? {} : { parent: payload.parent },
+      ...payload.dormant === true ? { dormant: true } : {}
     });
     const completion = ensureConnected("background").then((activeClient) => registerPendingStageRoute(activeClient, payload.runId, payload));
     payload.completion = completion;
@@ -7508,6 +8077,48 @@ function piIntercomExtension(pi, testOverrides = {}) {
     resolveSessionTarget: resolveSessionTargetId,
     homeGroup: currentIntercomGroup
   });
+  pi.events.on(SUBAGENT_AWAIT_INTERCOM_PEER_EVENT, (payload) => {
+    if (!payload || typeof payload !== "object" || !isAwaitIntercomPeerRequest(payload) || payload.completion)
+      return;
+    const request = payload;
+    request.completion = ensureConnected("background").then((activeClient) => waitForIntercomPeer(activeClient, request));
+  });
+  pi.events.on(INTERCOM_INBOX_REPLAY_EVENT, (payload) => {
+    if (!payload || typeof payload !== "object")
+      return;
+    const request = payload;
+    if (request.completion || !Array.isArray(request.restored))
+      return;
+    request.completion = replayDurableInbox(request);
+  });
+  pi.events.on(INTERCOM_RECOVERY_PEERS_EVENT, (payload) => {
+    if (!payload || typeof payload !== "object")
+      return;
+    const request = payload;
+    if (request.completion)
+      return;
+    request.completion = ensureConnected("background").then((activeClient) => activeClient.listSessions());
+  });
+  pi.events.on(SUBAGENT_RESERVE_RESTORING_CHILD_EVENT, (payload) => {
+    if (!isReserveRestoringChildRequest(payload) || payload.completion)
+      return;
+    const request = payload;
+    request.completion = ensureConnected("background").then((activeClient) => activeClient.reserveRestoringRecipient(request.capability, {
+      ...request.group === undefined ? {} : { group: request.group },
+      aliases: request.aliases,
+      ...request.dormant === true ? { dormant: true } : {}
+    }));
+  });
+  pi.events.on(SUBAGENT_RELEASE_RESTORING_CHILD_EVENT, (payload) => {
+    if (!isReleaseRestoringChildRequest(payload) || payload.completion)
+      return;
+    const request = payload;
+    const activeClient = client;
+    request.completion = activeClient?.isConnected() ? activeClient.releaseRestoringRecipient(request.capability, {
+      ...request.gone === undefined ? {} : { gone: request.gone },
+      ...request.refusal === undefined ? {} : { refusal: request.refusal }
+    }) : Promise.resolve();
+  });
   pi.on("session_shutdown", (event) => {
     if (event.reason !== "reload" && currentSessionId)
       sessionMemberships.delete(currentSessionId);
@@ -7635,8 +8246,9 @@ function piIntercomExtension(pi, testOverrides = {}) {
     syncPresenceIdentity
   });
 }
-var INTERCOM_SESSION_ID_ENV, PENDING_STAGE_ROUTE_EVENT = "atomic:workflow-pending-stage-route", PENDING_STAGE_MESSAGE_EVENT = "atomic:workflow-pending-stage-message", PENDING_STAGE_UNDELIVERABLE_EVENT = "atomic:workflow-pending-stage-undeliverable", STICKY_LIVE_DELIVERED_EVENT = "atomic:workflow-sticky-live-delivered";
+var INTERCOM_SESSION_ID_ENV, PENDING_STAGE_ROUTE_EVENT = "atomic:workflow-pending-stage-route", PENDING_STAGE_MESSAGE_EVENT = "atomic:workflow-pending-stage-message", PENDING_STAGE_UNDELIVERABLE_EVENT = "atomic:workflow-pending-stage-undeliverable", STICKY_LIVE_DELIVERED_EVENT = "atomic:workflow-sticky-live-delivered", PENDING_STAGE_ROUTE_REVOKED_EVENT = "atomic:workflow-pending-stage-route-revoked";
 var init_index_heavy = __esm(() => {
+  init_session_recovery();
   init_client();
   init_spawn();
   init_inline_message();
@@ -7650,6 +8262,9 @@ var init_index_heavy = __esm(() => {
   init_subagent_relay();
   init_foreground_detach_handoff();
   init_intercom_utils();
+  init_incoming_message_delivery();
+  init_inbound_idle_queue();
+  init_durable_inbox();
   init_terminal_ordering_barrier();
   init_session_target();
   init_inbound_message_admission();
@@ -7818,6 +8433,8 @@ class IntercomWarmUpExhaustedError extends Error {
 
 // dist/builtin/intercom/index.ts
 init_reconnect_backoff();
+init_session_recovery();
+init_durable_inbox();
 
 // dist/builtin/intercom/lazy-heavy-proxy.ts
 var LIVE_EVENT_SUBSCRIPTIONS = new Set(["pi-intercom:detach-response"]);
@@ -8404,6 +9021,91 @@ function intercom(pi, options = {}) {
       throw error;
     });
   });
+  pi.events.on(SUBAGENT_AWAIT_INTERCOM_PEER_EVENT, (payload) => {
+    if (!payload || typeof payload !== "object" || !isAwaitIntercomPeerRequest(payload) || payload.completion)
+      return;
+    const forwarded = {
+      name: payload.name,
+      timeoutMs: payload.timeoutMs,
+      ...payload.group === undefined ? {} : { group: payload.group }
+    };
+    payload.completion = loadHeavy(latestLifecycleContext()).then(async (handle) => {
+      handle.assertCurrent();
+      await dispatchEventHandlers(handle.heavy, SUBAGENT_AWAIT_INTERCOM_PEER_EVENT, forwarded);
+      return forwarded.completion ? await forwarded.completion : false;
+    }).catch(() => false);
+  });
+  pi.events.on(SUBAGENT_RESERVE_RESTORING_CHILD_EVENT, (payload) => {
+    if (!isReserveRestoringChildRequest(payload) || payload.completion)
+      return;
+    const forwarded = {
+      capability: payload.capability,
+      aliases: [...payload.aliases],
+      ...payload.group === undefined ? {} : { group: payload.group },
+      ...payload.dormant === true ? { dormant: true } : {}
+    };
+    payload.completion = loadHeavy(latestLifecycleContext()).then(async (handle) => {
+      handle.assertCurrent();
+      await dispatchEventHandlers(handle.heavy, SUBAGENT_RESERVE_RESTORING_CHILD_EVENT, forwarded);
+      if (!forwarded.completion)
+        throw new Error("Intercom cannot hold sends for a restoring subagent");
+      await forwarded.completion;
+    });
+  });
+  pi.events.on(SUBAGENT_RELEASE_RESTORING_CHILD_EVENT, (payload) => {
+    if (!isReleaseRestoringChildRequest(payload) || payload.completion)
+      return;
+    const forwarded = {
+      capability: payload.capability,
+      ...payload.gone === undefined ? {} : { gone: payload.gone },
+      ...payload.refusal === undefined ? {} : { refusal: payload.refusal }
+    };
+    const handle = loadedHeavy;
+    payload.completion = !handle ? Promise.resolve() : (async () => {
+      try {
+        handle.assertCurrent();
+        await dispatchEventHandlers(handle.heavy, SUBAGENT_RELEASE_RESTORING_CHILD_EVENT, forwarded);
+        await forwarded.completion;
+      } catch {}
+    })();
+  });
+  async function recoveryPeers(ctx) {
+    try {
+      const handle = await loadHeavy(ctx);
+      handle.assertCurrent();
+      const forwarded = {};
+      await dispatchEventHandlers(handle.heavy, INTERCOM_RECOVERY_PEERS_EVENT, forwarded);
+      return forwarded.completion ? await forwarded.completion : undefined;
+    } catch {
+      return;
+    }
+  }
+  async function replayIntercomInbox(ctx, peers) {
+    try {
+      const restored = await awaitRestoredIntercomPeers(pi.events, ctx.sessionManager.getSessionId());
+      const handle = await loadHeavy(ctx);
+      handle.assertCurrent();
+      const forwarded = { peers, restored };
+      await dispatchEventHandlers(handle.heavy, INTERCOM_INBOX_REPLAY_EVENT, forwarded);
+      return await forwarded.completion ?? [];
+    } catch {
+      return [];
+    }
+  }
+  pi.on("session_recovery_restore", async (_event, ctx) => {
+    const peers = hasIntercomHistory(ctx.sessionManager.getEntries()) ? await recoveryPeers(ctx) : undefined;
+    if (unconsumedIntercomInbox(ctx.sessionManager.getBranch()).length === 0)
+      return;
+    const notices = await replayIntercomInbox(ctx, peers);
+    return notices.length > 0 ? { notices: [...notices] } : undefined;
+  });
+  pi.on("session_recovery_replay", async (event, ctx) => {
+    if (!event.pending.some((delivery) => delivery.customType === "intercom_message"))
+      return;
+    const peers = await recoveryPeers(ctx);
+    const restored = await awaitRestoredIntercomPeers(pi.events, ctx.sessionManager.getSessionId());
+    return planIntercomRecoveryReplay(event.pending, peers, restored);
+  });
   pi.events.on(PENDING_STAGE_UNDELIVERABLE_EVENT2, (payload) => {
     if (!isPendingStageUndeliverableRelay(payload) || payload.handled === true)
       return;