@bastani/atomic 0.9.18-alpha.4 → 0.9.18-alpha.6

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

@@ -68,13 +68,49 @@ var renderContactSupervisorResult = (result, { isPartial }, theme, context) => {
 };
 var init_result_renderers = () => {};
 
+// dist/builtin/intercom/recoverable-disconnect.ts
+function isRecoverableIntercomDisconnect(error) {
+  let current = error;
+  for (let depth = 0;depth <= MAX_CAUSE_DEPTH; depth += 1) {
+    if (!(current instanceof Error))
+      return false;
+    if (current instanceof IntercomClientDisconnectedError)
+      return true;
+    current = current.cause;
+  }
+  return false;
+}
+var RECOVERABLE_DISCONNECT_MESSAGE = "Client disconnected. Retry the same Intercom call up to three times to reconnect.", MAX_CAUSE_DEPTH = 8, IntercomClientDisconnectedError;
+var init_recoverable_disconnect = __esm(() => {
+  IntercomClientDisconnectedError = class IntercomClientDisconnectedError extends Error {
+    intercomRecoverableDisconnect = true;
+    constructor(options) {
+      super(RECOVERABLE_DISCONNECT_MESSAGE, options);
+      this.name = "IntercomClientDisconnectedError";
+    }
+  };
+});
+
+// dist/builtin/intercom/reconnect-backoff.ts
+function reconnectDelayMs(attempt) {
+  return BACKOFF_MS[Math.min(attempt, BACKOFF_MS.length - 1)];
+}
+var BACKOFF_MS;
+var init_reconnect_backoff = __esm(() => {
+  BACKOFF_MS = [1000, 2000, 5000, 1e4, 30000];
+});
+
 // dist/builtin/intercom/broker/framing.ts
-function writeMessage(socket, msg) {
+function writeMessage(socket, msg, callback) {
   const json = JSON.stringify(msg);
   const payload = Buffer.from(json, "utf-8");
   const header = Buffer.alloc(4);
   header.writeUInt32BE(payload.length, 0);
-  socket.write(Buffer.concat([header, payload]));
+  const frame = Buffer.concat([header, payload]);
+  if (callback === undefined)
+    socket.write(frame);
+  else
+    socket.write(frame, callback);
 }
 function createMessageReader(onMessage, onError) {
   let buffer = Buffer.alloc(0);
@@ -162,7 +198,7 @@ function getBrokerSocketPath(platform = process.platform, agentDir = getAgentDir
 var init_paths = () => {};
 
 // dist/builtin/intercom/broker/send-signature.ts
-function normalizeAttachments(attachments) {
+function canonicalizeAttachmentsForSendSignature(attachments) {
   return attachments?.map((attachment) => ({
     type: attachment.type,
     name: attachment.name,
@@ -174,7 +210,7 @@ function buildSendSignature(to, options) {
   return JSON.stringify({
     to,
     text: options.text,
-    attachments: normalizeAttachments(options.attachments) ?? [],
+    attachments: canonicalizeAttachmentsForSendSignature(options.attachments) ?? [],
     replyTo: options.replyTo ?? null,
     expectsReply: options.expectsReply ?? false,
     replyError: options.replyError ?? null
@@ -416,6 +452,9 @@ import { randomUUID as randomUUID2 } from "crypto";
 function toError(error) {
   return error instanceof Error ? error : new Error(String(error));
 }
+function isWorkflowFutureStageRosterEntries(value) {
+  return Array.isArray(value) && value.every((entry) => typeof entry === "object" && entry !== null && entry.kind === "workflow-future-stage" && typeof entry.runId === "string" && typeof entry.target === "string" && typeof entry.queuedCount === "number" && Number.isInteger(entry.queuedCount) && entry.queuedCount >= 0 && typeof entry.group === "string");
+}
 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"));
 }
@@ -424,6 +463,7 @@ var init_client = __esm(() => {
   init_paths();
   init_pending_send_registry();
   init_group();
+  init_recoverable_disconnect();
   BROKER_SOCKET = getBrokerSocketPath();
   IntercomClient = class IntercomClient extends EventEmitter {
     returnAddress;
@@ -490,7 +530,7 @@ var init_client = __esm(() => {
         throw new Error("Not connected");
       }
       if (socket.destroyed || socket.writableEnded || !socket.writable) {
-        throw new Error("Client disconnected");
+        throw new IntercomClientDisconnectedError;
       }
       return socket;
     }
@@ -537,7 +577,7 @@ var init_client = __esm(() => {
         const onClose = () => {
           const wasConnecting = !settled && !this._sessionId;
           const wasDisconnecting = this.disconnecting;
-          const disconnectError = this.disconnectError ?? new Error("Client disconnected");
+          const disconnectError = this.disconnectError ?? new IntercomClientDisconnectedError;
           this.disconnecting = false;
           cleanupConnectionAttempt();
           cleanupSocketListeners();
@@ -558,7 +598,7 @@ var init_client = __esm(() => {
         };
         const onSocketError = (err) => {
           if (connectionEstablished) {
-            this.disconnectError = err;
+            this.disconnectError ??= new IntercomClientDisconnectedError({ cause: err });
             this.emit("error", err);
           }
         };
@@ -639,15 +679,19 @@ var init_client = __esm(() => {
           break;
         }
         case "sessions": {
-          const { requestId, sessions, workflowStages } = brokerMessage;
-          if (typeof requestId !== "string" || !Array.isArray(sessions) || !sessions.every(isSessionInfo) || workflowStages !== undefined && !isWorkflowStageRosterEntries(workflowStages)) {
+          const { requestId, sessions, workflowStages, workflowFutureStages } = brokerMessage;
+          if (typeof requestId !== "string" || !Array.isArray(sessions) || !sessions.every(isSessionInfo) || workflowStages !== undefined && !isWorkflowStageRosterEntries(workflowStages) || workflowFutureStages !== undefined && !isWorkflowFutureStageRosterEntries(workflowFutureStages)) {
             throw new Error("Invalid sessions message");
           }
           const pending = this.pendingLists.get(requestId);
           if (!pending)
             return;
           this.pendingLists.delete(requestId);
-          pending.resolve({ sessions, workflowStages: workflowStages ?? [] });
+          pending.resolve({
+            sessions,
+            workflowStages: workflowStages ?? [],
+            workflowFutureStages: workflowFutureStages ?? []
+          });
           break;
         }
         case "groups": {
@@ -683,8 +727,8 @@ var init_client = __esm(() => {
           break;
         }
         case "pending_stage_message": {
-          const { requestId, from, senderRegistrationName, senderReturnAddress, runId, stageKey, message, live } = brokerMessage;
-          if (typeof requestId !== "string" || !isSessionInfo(from) || senderRegistrationName !== undefined && typeof senderRegistrationName !== "string" || senderReturnAddress !== undefined && typeof senderReturnAddress !== "string" || typeof runId !== "string" || typeof stageKey !== "string" || !isMessage(message) || live !== undefined && typeof live !== "boolean") {
+          const { requestId, from, senderRegistrationName, senderReturnAddress, runId, target, message, live } = brokerMessage;
+          if (typeof requestId !== "string" || !isSessionInfo(from) || senderRegistrationName !== undefined && typeof senderRegistrationName !== "string" || senderReturnAddress !== undefined && typeof senderReturnAddress !== "string" || typeof runId !== "string" || typeof target !== "string" || !isMessage(message) || live !== undefined && typeof live !== "boolean") {
             throw new Error("Invalid pending-stage message event");
           }
           this.emit("pending_stage_message", {
@@ -693,7 +737,7 @@ var init_client = __esm(() => {
             ...senderRegistrationName === undefined ? {} : { senderRegistrationName },
             ...senderReturnAddress === undefined ? {} : { senderReturnAddress },
             runId,
-            stageKey,
+            target,
             message,
             ...live === true ? { live: true } : {}
           });
@@ -711,6 +755,19 @@ var init_client = __esm(() => {
           });
           break;
         }
+        case "sticky_live_delivered": {
+          const { runId, messageId, target, deliveredTargets } = brokerMessage;
+          if (typeof runId !== "string" || typeof messageId !== "string" || typeof target !== "string" || !Array.isArray(deliveredTargets) || !deliveredTargets.every((entry) => typeof entry === "string")) {
+            throw new Error("Invalid sticky live-delivery event");
+          }
+          this.emit("sticky_live_delivered", {
+            runId,
+            messageId,
+            target,
+            deliveredTargets
+          });
+          break;
+        }
         case "live_workflow_stage_route_registered": {
           const { requestId } = brokerMessage;
           if (typeof requestId !== "string")
@@ -723,11 +780,18 @@ var init_client = __esm(() => {
           break;
         }
         case "queued": {
-          const { messageId, attemptId, runId, stageKey, position } = brokerMessage;
-          if (typeof messageId !== "string" || attemptId !== undefined && typeof attemptId !== "string" || typeof runId !== "string" || typeof stageKey !== "string" || typeof position !== "number" || position < 1) {
+          const { messageId, attemptId, target, position, notInKnownSet } = brokerMessage;
+          if (typeof messageId !== "string" || attemptId !== undefined && typeof attemptId !== "string" || typeof target !== "string" || typeof position !== "number" || position < 1 || notInKnownSet !== undefined && notInKnownSet !== true) {
             throw new Error("Invalid queued message");
           }
-          const result = { id: messageId, delivered: false, queued: true, runId, stageKey, position };
+          const result = {
+            id: messageId,
+            delivered: false,
+            queued: true,
+            target,
+            position,
+            ...notInKnownSet === true ? { notInKnownSet: true } : {}
+          };
           if (attemptId === undefined)
             this.pendingSends.resolveLegacy(messageId, result);
           else
@@ -748,7 +812,7 @@ var init_client = __esm(() => {
         }
         case "delivery_failed": {
           const { messageId, attemptId, reason, reasonCode } = brokerMessage;
-          if (typeof messageId !== "string" || attemptId !== undefined && typeof attemptId !== "string" || typeof reason !== "string" || reasonCode !== undefined && reasonCode !== "message_id_conflict") {
+          if (typeof messageId !== "string" || attemptId !== undefined && typeof attemptId !== "string" || typeof reason !== "string" || reasonCode !== undefined && reasonCode !== "message_id_conflict" && reasonCode !== "session_not_found") {
             throw new Error("Invalid delivery_failed message");
           }
           const result = {
@@ -857,7 +921,7 @@ var init_client = __esm(() => {
       }
       this.disconnecting = true;
       this.disconnectError = null;
-      this.failPending(new Error("Client disconnected"));
+      this.failPending(new IntercomClientDisconnectedError);
       await new Promise((resolve) => {
         let settled = false;
         const finish = () => {
@@ -1031,8 +1095,15 @@ var init_client = __esm(() => {
         }
       });
     }
-    registerPendingStageRoute(runId, group, capability, stages) {
-      writeMessage(this.requireActiveSocket(), { type: "register_pending_stage_route", runId, group, capability, stages });
+    registerPendingStageRoute(runId, group, capability, stages, possibleStages) {
+      writeMessage(this.requireActiveSocket(), {
+        type: "register_pending_stage_route",
+        runId,
+        group,
+        capability,
+        stages,
+        possibleStages
+      });
     }
     registerLiveWorkflowStageRoute(runId, stageKeys, capability) {
       let socket;
@@ -1060,7 +1131,14 @@ var init_client = __esm(() => {
     }
     respondPendingStageMessage(requestId, result) {
       const socket = this.requireActiveSocket();
-      writeMessage(socket, result.outcome === "queued" ? { type: "pending_stage_message_result", requestId, outcome: "queued", position: result.position } : result.outcome === "refused" ? {
+      writeMessage(socket, result.outcome === "queued" ? {
+        type: "pending_stage_message_result",
+        requestId,
+        outcome: "queued",
+        position: result.position,
+        ...result.notInKnownSet === true ? { notInKnownSet: true } : {},
+        ...result.forwardTargets === undefined ? {} : { forwardTargets: [...result.forwardTargets] }
+      } : result.outcome === "forward" ? { type: "pending_stage_message_result", requestId, outcome: "forward", target: result.target } : result.outcome === "refused" ? {
         type: "pending_stage_message_result",
         requestId,
         outcome: "refused",
@@ -1095,7 +1173,12 @@ var init_client = __esm(() => {
       const messageId = options.messageId ?? randomUUID2();
       let acquired;
       try {
-        acquired = this.pendingSends.acquire(messageId, buildSendSignature(to, options), 1e4);
+        const pendingSignature = JSON.stringify({
+          transportTarget: to,
+          logicalSignature: buildSendSignature(options.logicalTarget ?? to, options),
+          requirePendingReply: options.requirePendingReply ?? false
+        });
+        acquired = this.pendingSends.acquire(messageId, pendingSignature, 1e4);
       } catch (error) {
         return Promise.reject(toError(error));
       }
@@ -1111,7 +1194,15 @@ var init_client = __esm(() => {
         content: { text: options.text, attachments: options.attachments }
       };
       try {
-        writeMessage(socket, { type, to, message, attemptId: acquired.attempt.attemptId, ...extra });
+        writeMessage(socket, {
+          type,
+          to,
+          ...options.logicalTarget === undefined ? {} : { logicalTarget: options.logicalTarget },
+          ...options.requirePendingReply === undefined ? {} : { requirePendingReply: options.requirePendingReply },
+          message,
+          attemptId: acquired.attempt.attemptId,
+          ...extra
+        });
       } catch (error) {
         this.pendingSends.reject(acquired.attempt, toError(error));
       }
@@ -1173,7 +1264,7 @@ var init_client = __esm(() => {
 
 // dist/builtin/intercom/broker/spawn.ts
 import { spawn } from "child_process";
-import { closeSync, existsSync, mkdirSync, openSync, readFileSync, readSync, statSync, unlinkSync, writeFileSync } from "fs";
+import { chmodSync, closeSync, existsSync, mkdirSync, openSync, readFileSync, readSync, statSync, unlinkSync, writeFileSync } from "fs";
 import { join as join2, dirname } from "path";
 import { fileURLToPath } from "url";
 import { createRequire } from "module";
@@ -1192,6 +1283,11 @@ function resolveBrokerEntrypoint(packageRoot) {
   const bundled = join2(packageRoot, "broker", "broker.bundle.mjs");
   return existsSync(bundled) ? bundled : join2(packageRoot, "broker", "broker.ts");
 }
+function ensurePrivateDirectory(path) {
+  mkdirSync(path, { recursive: true, mode: 448 });
+  if (process.platform !== "win32")
+    chmodSync(path, 448);
+}
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -1257,7 +1353,7 @@ function getWindowsHiddenLauncherScript(commandLine) {
 `);
 }
 function writeWindowsHiddenLauncher(commandLine, launcherPath = getWindowsHiddenLauncherPath()) {
-  mkdirSync(dirname(launcherPath), { recursive: true });
+  ensurePrivateDirectory(dirname(launcherPath));
   writeFileSync(launcherPath, getWindowsHiddenLauncherScript(commandLine), "utf-8");
   return launcherPath;
 }
@@ -1296,7 +1392,7 @@ function getBrokerSpawnOptions(extensionDir = EXTENSION_DIR, stderr = "ignore")
   };
 }
 function resetBrokerLog(logPath = BROKER_LOG) {
-  mkdirSync(dirname(logPath), { recursive: true });
+  ensurePrivateDirectory(dirname(logPath));
   closeSync(openSync(logPath, "w"));
 }
 function readBrokerLogTail(logPath = BROKER_LOG, maxBytes = BROKER_LOG_TAIL_BYTES) {
@@ -1332,7 +1428,7 @@ function toError2(error) {
   return error instanceof Error ? error : new Error(String(error));
 }
 async function spawnBrokerIfNeeded(brokerCommand, brokerArgs) {
-  mkdirSync(INTERCOM_DIR, { recursive: true });
+  ensurePrivateDirectory(INTERCOM_DIR);
   if (await isBrokerRunning()) {
     return;
   }
@@ -1579,6 +1675,15 @@ class InlineMessageComponent {
 }
 var init_inline_message = () => {};
 
+// dist/builtin/intercom/retry-policy.ts
+var ASK_REPLY_TIMEOUT_MS, RETRY_IDENTITY_RETRY_OPPORTUNITY_MS, RETRY_IDENTITY_TTL_MS, DELIVERED_MESSAGE_TTL_MS;
+var init_retry_policy = __esm(() => {
+  ASK_REPLY_TIMEOUT_MS = 10 * 60 * 1000;
+  RETRY_IDENTITY_RETRY_OPPORTUNITY_MS = 60 * 1000;
+  RETRY_IDENTITY_TTL_MS = ASK_REPLY_TIMEOUT_MS + RETRY_IDENTITY_RETRY_OPPORTUNITY_MS;
+  DELIVERED_MESSAGE_TTL_MS = RETRY_IDENTITY_TTL_MS + RETRY_IDENTITY_RETRY_OPPORTUNITY_MS;
+});
+
 // dist/builtin/intercom/reply-waiter.ts
 class ReplyWaiterRegistry {
   timeoutMs;
@@ -1657,7 +1762,8 @@ class ReplyWaiterRegistry {
 }
 var DEFAULT_REPLY_TIMEOUT_MS, DEFAULT_MAX_PENDING_REPLY_WAITS = 6;
 var init_reply_waiter = __esm(() => {
-  DEFAULT_REPLY_TIMEOUT_MS = 10 * 60 * 1000;
+  init_retry_policy();
+  DEFAULT_REPLY_TIMEOUT_MS = ASK_REPLY_TIMEOUT_MS;
 });
 
 // dist/builtin/intercom/config.ts
@@ -1786,7 +1892,7 @@ class ReplyTracker {
   pendingAsks = new Map;
   pendingTurnContexts = [];
   currentTurnContext = null;
-  constructor(askTimeoutMs = 10 * 60 * 1000) {
+  constructor(askTimeoutMs = ASK_REPLY_TIMEOUT_MS) {
     this.askTimeoutMs = askTimeoutMs;
   }
   recordIncomingMessage(from, message, receivedAt = Date.now()) {
@@ -1885,7 +1991,9 @@ class ReplyTracker {
     }
   }
 }
-var init_reply_tracker = () => {};
+var init_reply_tracker = __esm(() => {
+  init_retry_policy();
+});
 
 // dist/builtin/intercom/parent-ask-handoff.ts
 import { isStaleExtensionContextError as isStaleExtensionContextError2 } from "@bastani/atomic";
@@ -2579,59 +2687,381 @@ var init_contact_supervisor_tool = __esm(() => {
   init_intercom_utils();
 });
 
-// dist/builtin/intercom/broker/supervisor-channel.ts
-var DEFAULT_TTL_MS;
-var init_supervisor_channel = __esm(() => {
-  DEFAULT_TTL_MS = 10 * 60 * 1000;
+// dist/builtin/intercom/workflow-stage-target.ts
+function parseWorkflowStageTarget(target) {
+  if (!target.startsWith(WORKFLOW_TARGET_PREFIX))
+    return;
+  const slash = target.indexOf("/", WORKFLOW_TARGET_PREFIX.length);
+  if (slash < 0)
+    return;
+  const rootRunId = target.slice(WORKFLOW_TARGET_PREFIX.length, slash);
+  if (!WORKFLOW_RUN_ID_PATTERN.test(rootRunId))
+    return;
+  const segments = target.slice(slash + 1).split("/");
+  if (segments.length === 0 || segments.some((segment) => segment.length === 0))
+    return;
+  const kind = segments.includes("**") ? "deep-pattern" : segments.some((segment) => segment.includes("*")) ? "pattern" : "path";
+  return { rootRunId, segments, kind };
+}
+function formatWorkflowStageTarget(rootRunId, ...segments) {
+  return `${WORKFLOW_TARGET_PREFIX}${rootRunId}/${segments.join("/")}`;
+}
+function withWorkflowStageTargetFinalSegment(target, segment) {
+  const parsed = parseWorkflowStageTarget(target);
+  if (parsed === undefined || segment.length === 0 || segment.includes("/"))
+    return;
+  return formatWorkflowStageTarget(parsed.rootRunId, ...parsed.segments.slice(0, -1), segment);
+}
+var WORKFLOW_RUN_ID_PATTERN, WORKFLOW_TARGET_PREFIX = "workflow:";
+var init_workflow_stage_target = __esm(() => {
+  WORKFLOW_RUN_ID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
 });
 
-// dist/builtin/intercom/broker/group-membership.ts
-var init_group_membership = __esm(() => {
-  init_group();
-});
+// dist/builtin/intercom/retry-identity.ts
+import { randomUUID as randomUUID4 } from "node:crypto";
+function operationKey(input) {
+  return JSON.stringify([
+    input.sessionId,
+    input.action,
+    input.target,
+    input.text,
+    canonicalizeAttachmentsForSendSignature(input.attachments),
+    input.replyTo,
+    input.expectsReply
+  ]);
+}
 
-// dist/builtin/intercom/broker/group-isolation.ts
-var init_group_isolation = __esm(() => {
-  init_group_membership();
-});
-// dist/builtin/intercom/broker/send-handler.ts
-function parsePendingStageTarget(target) {
-  const separator = target.indexOf(":");
-  if (separator < 0)
-    return;
-  const runId = target.slice(0, separator);
-  const stageKey = target.slice(separator + 1);
-  return WORKFLOW_RUN_ID_PATTERN.test(runId) && stageKey.length > 0 ? { runId, stageKey } : undefined;
-}
-var WORKFLOW_RUN_ID_PATTERN;
-var init_send_handler = __esm(() => {
-  init_supervisor_channel();
-  init_group_isolation();
-  init_group_membership();
-  WORKFLOW_RUN_ID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+class RetryIdentityReservations {
+  tokenReservations = new Map;
+  attemptStates = new WeakMap;
+  ttlMs;
+  maxEntries;
+  maxReuses;
+  now;
+  createId;
+  createToken;
+  freshInFlightCount = 0;
+  constructor(options = {}) {
+    this.ttlMs = options.ttlMs ?? RETRY_IDENTITY_TTL_MS;
+    this.maxEntries = options.maxEntries ?? RETRY_IDENTITY_MAX_ENTRIES;
+    this.maxReuses = options.maxReuses ?? RETRY_IDENTITY_MAX_REUSES;
+    this.now = options.now ?? Date.now;
+    this.createId = options.createId ?? randomUUID4;
+    this.createToken = options.createToken ?? randomUUID4;
+  }
+  begin(input, retryToken) {
+    const now = this.now();
+    const key = operationKey(input);
+    if (retryToken !== undefined)
+      return this.claimRetry(key, retryToken, now);
+    this.prune(now);
+    this.discardSettledTombstonesForCapacity();
+    if (this.tokenReservations.size + this.freshInFlightCount >= this.maxEntries) {
+      throw new RetryIdentityCapacityError;
+    }
+    const reservation = {
+      key,
+      messageId: this.createId(),
+      expiresAt: now + this.ttlMs,
+      sessionId: input.sessionId,
+      action: input.action,
+      reuseCount: 0,
+      state: "fresh-in-flight"
+    };
+    this.freshInFlightCount += 1;
+    return this.attempt(reservation);
+  }
+  validateRetryToken(retryToken, sessionId, action) {
+    const reservation = this.tokenReservation(retryToken, this.now());
+    if (reservation.sessionId !== sessionId || reservation.action !== action) {
+      throw new RetryTokenError("mismatch");
+    }
+    this.requireClaimable(reservation);
+    return Math.max(0, this.maxReuses - reservation.reuseCount);
+  }
+  bindReplyRoute(attempt, route) {
+    const reservation = this.currentReservation(attempt);
+    if (reservation === undefined || reservation.action !== "reply" || reservation.state !== "fresh-in-flight" || reservation.replyRoute !== undefined || route.senderId.length === 0 || route.messageId.length === 0) {
+      throw new RetryTokenError("invalid");
+    }
+    reservation.replyRoute = { ...route };
+  }
+  replyRoute(attempt) {
+    const route = this.currentReservation(attempt)?.replyRoute;
+    return route === undefined ? undefined : { ...route };
+  }
+  retainAfterRecoverableDisconnect(attempt) {
+    return this.retain(attempt, true);
+  }
+  retainAfterInconclusiveRetry(attempt) {
+    return this.retain(attempt, false);
+  }
+  release(attempt) {
+    const reservation = this.currentReservation(attempt);
+    if (reservation === undefined || reservation.state === "released" || reservation.state === "settled")
+      return;
+    if (reservation.retryToken === undefined) {
+      this.releaseFreshCapacity(reservation);
+      reservation.state = "released";
+      return;
+    }
+    this.finishRetained(reservation, "settled");
+  }
+  remainingRetries(attempt) {
+    const reservation = this.currentReservation(attempt);
+    return reservation === undefined ? 0 : Math.max(0, this.maxReuses - reservation.reuseCount);
+  }
+  claimRetry(key, retryToken, now) {
+    const reservation = this.tokenReservation(retryToken, now);
+    if (reservation.key !== key)
+      throw new RetryTokenError("mismatch");
+    this.requireClaimable(reservation);
+    reservation.state = "retry-in-flight";
+    reservation.reuseCount += 1;
+    return this.attempt(reservation);
+  }
+  tokenReservation(retryToken, now) {
+    const reservation = this.tokenReservations.get(retryToken);
+    if (reservation === undefined)
+      throw new RetryTokenError("invalid");
+    if (reservation.expiresAt <= now) {
+      this.expire(reservation);
+      throw new RetryTokenError("expired");
+    }
+    return reservation;
+  }
+  requireClaimable(reservation) {
+    if (reservation.state === "settled")
+      throw new RetryTokenError("settled");
+    if (reservation.state === "exhausted" || reservation.reuseCount >= this.maxReuses) {
+      reservation.state = "exhausted";
+      throw new RetryTokenError("exhausted");
+    }
+    if (reservation.state === "retry-in-flight")
+      throw new RetryTokenError("in_flight");
+    if (reservation.state !== "retained")
+      throw new RetryTokenError("invalid");
+  }
+  retain(attempt, allowFresh) {
+    const now = this.now();
+    this.prune(now);
+    const reservation = this.currentReservation(attempt);
+    if (reservation === undefined)
+      return;
+    const fresh = reservation.state === "fresh-in-flight";
+    if (!fresh && reservation.state !== "retry-in-flight")
+      return;
+    if (fresh && !allowFresh) {
+      this.releaseFreshCapacity(reservation);
+      reservation.state = "released";
+      return;
+    }
+    if (reservation.expiresAt <= now) {
+      if (reservation.retryToken === undefined) {
+        this.releaseFreshCapacity(reservation);
+        reservation.state = "released";
+      } else
+        this.expire(reservation);
+      return;
+    }
+    if (reservation.reuseCount >= this.maxReuses) {
+      if (reservation.retryToken === undefined) {
+        this.releaseFreshCapacity(reservation);
+        reservation.state = "released";
+      } else
+        reservation.state = "exhausted";
+      return;
+    }
+    if (fresh) {
+      reservation.retryToken = this.uniqueToken();
+      this.tokenReservations.set(reservation.retryToken, reservation);
+      this.releaseFreshCapacity(reservation);
+    }
+    reservation.state = "retained";
+    return reservation.retryToken;
+  }
+  discardSettledTombstonesForCapacity() {
+    if (this.tokenReservations.size + this.freshInFlightCount < this.maxEntries)
+      return;
+    for (const [token, reservation] of this.tokenReservations) {
+      if (reservation.state !== "settled")
+        continue;
+      this.tokenReservations.delete(token);
+      if (this.tokenReservations.size + this.freshInFlightCount < this.maxEntries)
+        return;
+    }
+  }
+  uniqueToken() {
+    for (;; ) {
+      const token = this.createToken();
+      if (token.length > 0 && !this.tokenReservations.has(token))
+        return token;
+    }
+  }
+  attempt(reservation) {
+    const attempt = {
+      key: reservation.key,
+      messageId: reservation.messageId,
+      reuseCount: reservation.reuseCount,
+      expiresAt: reservation.expiresAt,
+      ...reservation.state === "retry-in-flight" && reservation.retryToken !== undefined ? { retryToken: reservation.retryToken } : {}
+    };
+    this.attemptStates.set(attempt, reservation);
+    return attempt;
+  }
+  currentReservation(attempt) {
+    const reservation = this.attemptStates.get(attempt);
+    return reservation?.reuseCount === attempt.reuseCount ? reservation : undefined;
+  }
+  releaseFreshCapacity(reservation) {
+    if (reservation.state !== "fresh-in-flight")
+      return;
+    this.freshInFlightCount = Math.max(0, this.freshInFlightCount - 1);
+  }
+  finishRetained(reservation, state) {
+    reservation.state = state;
+  }
+  expire(reservation) {
+    if (reservation.retryToken !== undefined)
+      this.tokenReservations.delete(reservation.retryToken);
+    this.finishRetained(reservation, "released");
+  }
+  prune(now) {
+    for (const reservation of this.tokenReservations.values()) {
+      if (reservation.expiresAt <= now)
+        this.expire(reservation);
+    }
+  }
+}
+var RETRY_IDENTITY_MAX_ENTRIES = 1000, RETRY_IDENTITY_MAX_REUSES = 3, RetryIdentityCapacityError, RetryTokenError;
+var init_retry_identity = __esm(() => {
+  init_retry_policy();
+  RetryIdentityCapacityError = class RetryIdentityCapacityError extends Error {
+    constructor() {
+      super("Intercom retry identity capacity is exhausted; refusing delivery until an in-flight or retained identity is released or expires");
+      this.name = "RetryIdentityCapacityError";
+    }
+  };
+  RetryTokenError = class RetryTokenError extends Error {
+    code;
+    constructor(code) {
+      const reason = {
+        invalid: "is invalid or belongs to another Intercom tool session",
+        expired: "has expired",
+        mismatch: "does not match this Intercom operation",
+        in_flight: "is already claimed by an in-flight retry",
+        settled: "belongs to an operation that is already settled",
+        exhausted: `has exhausted its ${RETRY_IDENTITY_MAX_REUSES} retry attempts`
+      }[code];
+      super(`Intercom retry token ${reason}; refusing delivery`);
+      this.code = code;
+      this.name = "RetryTokenError";
+    }
+  };
 });
 
 // dist/builtin/intercom/intercom-tool.ts
-import { randomUUID as randomUUID4 } from "crypto";
 import { Type as Type2 } from "typebox";
 import { Text as Text3 } from "@earendil-works/pi-tui";
+function retryTokenGuidance(retryToken, remainingRetries) {
+  if (retryToken === undefined)
+    return "";
+  return ` Retry this exact operation with retryToken \`${retryToken}\` (${remainingRetries} claimed ${remainingRetries === 1 ? "attempt" : "attempts"} remain; the original deadline is unchanged).`;
+}
+function retryErrorDetails(retryToken) {
+  return retryToken === undefined ? { error: true } : { error: true, retryToken };
+}
+function retainRecoverableRetry(reservations, attempt) {
+  const retryToken = reservations.retainAfterRecoverableDisconnect(attempt);
+  return {
+    ...retryToken === undefined ? {} : { retryToken },
+    remainingRetries: reservations.remainingRetries(attempt)
+  };
+}
+function retainInconclusiveRetry(reservations, attempt) {
+  const retryToken = reservations.retainAfterInconclusiveRetry(attempt);
+  return {
+    ...retryToken === undefined ? {} : { retryToken },
+    remainingRetries: reservations.remainingRetries(attempt)
+  };
+}
 async function listDirectory(client, group) {
   if (typeof client.listDirectory === "function")
     return client.listDirectory(group);
-  return { sessions: await client.listSessions(group), workflowStages: [] };
+  return { sessions: await client.listSessions(group), workflowStages: [], workflowFutureStages: [] };
 }
 async function resolveReplySender(client, logicalTarget, sendTarget) {
   if (logicalTarget !== sendTarget)
-    return sendTarget;
-  if (parsePendingStageTarget(logicalTarget) === undefined)
-    return sendTarget;
-  const stage = (await listDirectory(client)).workflowStages.find((candidate) => candidate.sessionId !== undefined && (candidate.target === logicalTarget || `${candidate.runId}:${candidate.stageName}` === logicalTarget));
-  return stage?.sessionId ?? sendTarget;
+    return { kind: "unresolved" };
+  const parsedTarget = parseWorkflowStageTarget(logicalTarget);
+  if (parsedTarget?.kind !== "path")
+    return { kind: "unresolved" };
+  const stages = (await listDirectory(client)).workflowStages;
+  const aliasMatches = stages.filter((candidate) => candidate.sessionId !== undefined && (candidate.target === logicalTarget || withWorkflowStageTargetFinalSegment(candidate.target, candidate.stageName) === logicalTarget));
+  const aliasSessionIds = new Set(aliasMatches.map((candidate) => candidate.sessionId));
+  if (aliasSessionIds.size > 1) {
+    return {
+      kind: "ambiguous",
+      reason: `multiple live workflow stages share the target "${logicalTarget}"`
+    };
+  }
+  if (aliasSessionIds.size === 1) {
+    const [onlySessionId] = aliasSessionIds;
+    if (onlySessionId !== undefined)
+      return { kind: "resolved", sessionId: onlySessionId };
+  }
+  const finalSegment = parsedTarget.segments.at(-1);
+  const middleSegments = parsedTarget.segments.slice(0, -1);
+  const boundaryAgrees = (candidate) => {
+    const parsedCandidate = parseWorkflowStageTarget(candidate.target);
+    if (parsedCandidate === undefined || parsedCandidate.rootRunId !== parsedTarget.rootRunId || parsedCandidate.segments.length < 2) {
+      return false;
+    }
+    if (middleSegments.length === 0)
+      return true;
+    const candidateMiddles = parsedCandidate.segments.slice(0, -1);
+    return middleSegments.every((segment, index) => {
+      const owningRunIdentity = index === candidateMiddles.length - 1 ? candidate.runId : undefined;
+      return segment === candidateMiddles[index] || segment === owningRunIdentity;
+    });
+  };
+  const looseCandidates = stages.filter((candidate) => {
+    if (candidate.sessionId === undefined)
+      return false;
+    if (candidate.stageId !== finalSegment && candidate.stageName !== finalSegment)
+      return false;
+    const parsedCandidate = parseWorkflowStageTarget(candidate.target);
+    return parsedCandidate !== undefined && parsedCandidate.rootRunId === parsedTarget.rootRunId && parsedCandidate.segments.length >= 2;
+  });
+  const strictMatches = looseCandidates.filter(boundaryAgrees);
+  const strictSessionIds = new Set(strictMatches.map((candidate) => candidate.sessionId));
+  if (strictSessionIds.size === 1) {
+    const [onlySessionId] = strictSessionIds;
+    if (onlySessionId !== undefined)
+      return { kind: "resolved", sessionId: onlySessionId };
+  }
+  const looseSessionIds = new Set(looseCandidates.map((candidate) => candidate.sessionId));
+  if (looseSessionIds.size > 1 || strictSessionIds.size > 1) {
+    return {
+      kind: "ambiguous",
+      reason: `multiple live workflow stages share the final segment "${finalSegment}" under different boundaries`
+    };
+  }
+  if (looseSessionIds.size === 1) {
+    const [onlySessionId] = looseSessionIds;
+    if (onlySessionId !== undefined)
+      return { kind: "resolved", sessionId: onlySessionId };
+  }
+  return { kind: "unresolved" };
 }
 function formatWorkflowStageRow(stage) {
   return `- **${stage.stageName}** — workflow stage [${stage.lifecycle.toUpperCase()}] — target: \`${stage.target}\`${stage.sessionId === undefined ? "" : ` — intercom session: ${stage.sessionId}`}`;
 }
+function formatWorkflowFutureStageRow(stage) {
+  return `- future workflow stage \`${stage.target}\` — ${stage.queuedCount} queued message${stage.queuedCount === 1 ? "" : "s"}`;
+}
 function registerIntercomTool(pi, deps) {
+  const retryIdentities = new RetryIdentityReservations({ maxEntries: deps.retryIdentityMaxEntries });
   const { childOrchestratorMetadata, ensureConnected, syncPresenceIdentity, beginReplyWait } = deps;
   const resolveTarget = deps.resolveSessionTarget ?? resolveSessionTargetId;
   const getMetadata = typeof childOrchestratorMetadata === "function" ? childOrchestratorMetadata : () => childOrchestratorMetadata ?? null;
@@ -2645,9 +3075,17 @@ Use this to communicate findings, request help, or coordinate work with other se
 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.
 
-For send, live session names and exact full session IDs remain supported. For a known
-workflow stage, use the exact \`<runId>:<stageKey>\` target; send messages to pending stages
-queue automatically.
+For send, live session names and exact full session IDs remain supported. Workflow-stage targets use
+\`workflow:<rootRunId>/<segment>[/<segment>...]\`; a segment may be a stage name, run id, or glob
+(\`*\` matches one segment and may be embedded, while \`**\` matches any depth). Use \`intercom list\`
+inside the invocation group to see live, pending, and possible future targets with queued counts.
+\`workflow:<rootRunId>/**\` reaches every live stage immediately and remains sticky for every future
+stage until the root run terminates; narrower name or pattern sends likewise reach every future match.
+A valid target outside the known set queues speculatively with a \`notInKnownSet\` warning and settles
+undeliverable at terminal only if never delivered. Use \`ask\` only for a live, reply-capable target.
+Stage paths win over same-named owned subgroups for send/ask; \`list\` with \`group\` continues to
+select the group.
+If a \`send\`, \`ask\`, or \`reply\` fails with \`Client disconnected\`, retry that exact operation with the returned \`retryToken\`, up to three claimed attempts; a call without the token is always a distinct operation.
 
 Usage:
   intercom({ action: "list" })                    → List sessions visible through your groups
@@ -2659,19 +3097,20 @@ Usage:
   intercom({ action: "send", to: "session-name", message: "..." })  → Send message (shared group only)
   intercom({ action: "ask", to: "session-name", message: "..." })   → Ask and wait for reply
   intercom({ action: "reply", message: "..." })                      → Reply to the active or exact pending ask
+  intercom({ action: "send", to: "session-name", message: "...", retryToken: "..." }) → Claim the exact retry returned by a retryable failure
   intercom({ action: "pending" })                                      → List unresolved inbound asks
   intercom({ action: "status" })                  → Show connection status and all your groups
 
 The "join" action is additive. "default" is the shared default group; "true" and
 "auto" are reserved for subagent auto-groups. Ordinary delivery requires at least
 one shared membership; contact_supervisor remains the only cross-group path.`,
-    promptSnippet: "Use to coordinate with other local agent sessions that share an intercom group: discover groups or peers, send updates, ask for help, or check connectivity. Ordinary messages require a shared membership.",
+    promptSnippet: "Use to coordinate with other local agent sessions that share an intercom group. For a retryable send/ask/reply failure, repeat the exact operation with its returned retryToken; omit retryToken for fresh operations.",
     parameters: Type2.Object({
       action: Type2.String({
         description: "Action: 'list', 'groups', 'join', 'leave', 'send', 'ask', 'reply', 'pending', or 'status'"
       }),
       to: Type2.Optional(Type2.String({
-        description: "Live session name, exact full session ID, or exact `<runId>:<stageKey>` for a known workflow stage; send messages to pending stages queue automatically (for 'send', 'ask', or targeted 'reply')"
+        description: "Live session name, exact full session ID, or `workflow:<rootRunId>/<segment>[/<segment>...]` path; `*` matches one segment and `**` any depth. Send queues sticky delivery for pending/future matches; `workflow:<rootRunId>/**` broadcasts to live and future stages. Use `ask` only on live targets (for 'send', 'ask', or targeted 'reply')"
       })),
       message: Type2.Optional(Type2.String({
         description: "Message to send (for 'send', 'ask', or 'reply' action)"
@@ -2685,23 +3124,53 @@ one shared membership; contact_supervisor remains the only cross-group path.`,
       replyTo: Type2.Optional(Type2.String({
         description: "Exact pending-ask message ID; disambiguates concurrent asks, including asks from one sender"
       })),
+      retryToken: Type2.Optional(Type2.String({
+        minLength: 1,
+        maxLength: 128,
+        description: "Opaque token returned after a retryable send/ask/reply failure. Repeat the exact same action and arguments with this token; omit it for every fresh operation."
+      })),
       group: Type2.Optional(Type2.String({
         description: "Group name for 'join' or optional targeted 'leave'; read-only group filter for 'list'/'status'. 'send'/'ask' use shared memberships."
       }))
     }),
     async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+      const toolSessionId = ctx.sessionManager.getSessionId();
+      const { action, to, message, attachments, replyTo, retryToken, group } = params;
+      let retryPreflightRemaining;
+      if (retryToken !== undefined) {
+        if (action !== "send" && action !== "ask" && action !== "reply") {
+          const error = new RetryTokenError("mismatch");
+          return {
+            content: [{ type: "text", text: getErrorMessage(error) }],
+            isError: true,
+            details: { error: true }
+          };
+        }
+        try {
+          retryPreflightRemaining = retryIdentities.validateRetryToken(retryToken, toolSessionId, action);
+        } catch (error) {
+          return {
+            content: [{ type: "text", text: getErrorMessage(error) }],
+            isError: true,
+            details: { error: true }
+          };
+        }
+      }
       let connectedClient;
       try {
         connectedClient = await ensureConnected("tool");
       } catch (error) {
+        const retainedToken = retryToken !== undefined && isRecoverableIntercomDisconnect(error) ? retryToken : undefined;
         return {
-          content: [{ type: "text", text: `Intercom not connected: ${getErrorMessage(error)}` }],
+          content: [{
+            type: "text",
+            text: `Intercom not connected: ${getErrorMessage(error)}${retryTokenGuidance(retainedToken, retryPreflightRemaining ?? 0)}`
+          }],
           isError: true,
-          details: { error: true }
+          details: retryErrorDetails(retainedToken)
         };
       }
-      syncPresenceIdentity(ctx.sessionManager.getSessionId());
-      const { action, to, message, attachments, replyTo, group } = params;
+      syncPresenceIdentity(toolSessionId);
       const resolveOwnGroups = (sessions) => {
         if (Array.isArray(connectedClient.groups)) {
           return connectedClient.groups.map((membership) => normalizeGroup(membership));
@@ -2826,7 +3295,8 @@ ${lines.join(`
               const peeked = await listDirectory(connectedClient, requestedGroup);
               const rows = [
                 ...peeked.sessions.map((session) => formatSessionListRow(session, currentSession.cwd, session.id === mySessionId)),
-                ...peeked.workflowStages.map(formatWorkflowStageRow)
+                ...peeked.workflowStages.map(formatWorkflowStageRow),
+                ...(peeked.workflowFutureStages ?? []).map(formatWorkflowFutureStageRow)
               ];
               const section = rows.length === 0 ? `**Group [${requestedGroup}] (read-only peek):**
 No sessions or workflow stages in this group.` : `**Group [${requestedGroup}] (read-only peek):**
@@ -2841,7 +3311,8 @@ ${section}` }],
                   group: ownGroups.at(-1),
                   groups: ownGroups,
                   peekGroup: requestedGroup,
-                  workflowStages: peeked.workflowStages
+                  workflowStages: peeked.workflowStages,
+                  ...(peeked.workflowFutureStages?.length ?? 0) === 0 ? {} : { workflowFutureStages: peeked.workflowFutureStages }
                 }
               };
             }
@@ -2850,7 +3321,8 @@ ${section}` }],
 ${formatSessionListRow(currentSession, currentSession.cwd, true)}`;
             const visibleRows = [
               ...otherSessions.map((session) => formatSessionListRow(session, currentSession.cwd, false)),
-              ...ownDirectory.workflowStages.map(formatWorkflowStageRow)
+              ...ownDirectory.workflowStages.map(formatWorkflowStageRow),
+              ...(ownDirectory.workflowFutureStages ?? []).map(formatWorkflowFutureStageRow)
             ];
             const otherSection = visibleRows.length === 0 ? `**Other sessions and workflow stages:**
 No other sessions or workflow stages share any of your groups.` : `**Other visible sessions and workflow stages:**
@@ -2864,7 +3336,8 @@ ${otherSection}` }],
               details: {
                 group: ownGroups.at(-1),
                 groups: ownGroups,
-                ...ownDirectory.workflowStages.length === 0 ? {} : { workflowStages: ownDirectory.workflowStages }
+                ...ownDirectory.workflowStages.length === 0 ? {} : { workflowStages: ownDirectory.workflowStages },
+                ...(ownDirectory.workflowFutureStages?.length ?? 0) === 0 ? {} : { workflowFutureStages: ownDirectory.workflowFutureStages }
               }
             };
           } catch (error) {
@@ -2877,20 +3350,35 @@ ${otherSection}` }],
         }
         case "send": {
           if (!to || !message) {
+            const errorText = retryToken === undefined ? "Missing 'to' or 'message' parameter" : getErrorMessage(new RetryTokenError("mismatch"));
             return {
-              content: [{ type: "text", text: "Missing 'to' or 'message' parameter" }],
+              content: [{ type: "text", text: errorText }],
               isError: true,
               details: { error: true }
             };
           }
+          if (_signal?.aborted) {
+            return {
+              content: [{
+                type: "text",
+                text: `Cancelled${retryTokenGuidance(retryToken, retryPreflightRemaining ?? 0)}`
+              }],
+              isError: true,
+              details: retryErrorDetails(retryToken)
+            };
+          }
+          let retryIdentity;
           try {
-            const sendTo = await resolveTarget(connectedClient, to) ?? to;
-            if (sendTo === connectedClient.sessionId) {
-              return {
-                content: [{ type: "text", text: "Cannot message the current session" }],
-                isError: true,
-                details: { error: true }
-              };
+            if (retryToken === undefined) {
+              retryIdentity = retryIdentities.begin({
+                sessionId: toolSessionId,
+                action: "send",
+                target: to,
+                text: message,
+                attachments,
+                replyTo,
+                expectsReply: false
+              });
             }
             if (!replyTo && deps.confirmSend && ctx.hasUI) {
               const attachmentText = attachments?.length ? formatAttachments(attachments) : "";
@@ -2898,6 +3386,9 @@ ${otherSection}` }],
 
 ${message}${attachmentText}`);
               if (!confirmed) {
+                if (retryIdentity !== undefined)
+                  retryIdentities.release(retryIdentity);
+                retryIdentity = undefined;
                 return {
                   content: [{ type: "text", text: "Message cancelled by user" }],
                   isError: false,
@@ -2905,78 +3396,159 @@ ${message}${attachmentText}`);
                 };
               }
             }
+            retryIdentity ??= retryIdentities.begin({
+              sessionId: toolSessionId,
+              action: "send",
+              target: to,
+              text: message,
+              attachments,
+              replyTo,
+              expectsReply: false
+            }, retryToken);
+            const sendTo = await resolveTarget(connectedClient, to) ?? to;
+            if (_signal?.aborted) {
+              const retained = retainInconclusiveRetry(retryIdentities, retryIdentity);
+              retryIdentity = undefined;
+              return {
+                content: [{ type: "text", text: `Cancelled${retryTokenGuidance(retained.retryToken, retained.remainingRetries)}` }],
+                isError: true,
+                details: retryErrorDetails(retained.retryToken)
+              };
+            }
+            if (sendTo === connectedClient.sessionId) {
+              const retained = retainInconclusiveRetry(retryIdentities, retryIdentity);
+              retryIdentity = undefined;
+              return {
+                content: [{
+                  type: "text",
+                  text: `Cannot message the current session${retryTokenGuidance(retained.retryToken, retained.remainingRetries)}`
+                }],
+                isError: true,
+                details: retryErrorDetails(retained.retryToken)
+              };
+            }
             const result = await connectedClient.send(sendTo, {
+              messageId: retryIdentity.messageId,
+              logicalTarget: to,
               text: message,
               attachments,
               replyTo
             });
             if (result.queued === true) {
+              retryIdentities.release(retryIdentity);
+              retryIdentity = undefined;
               pi.appendEntry("intercom_sent", {
                 to,
                 message: { text: message, attachments, replyTo },
                 messageId: result.id,
                 timestamp: Date.now()
               });
+              const notInKnownSet = result.notInKnownSet === true;
               return {
-                content: [{ type: "text", text: `Message queued for ${to}` }],
+                content: [{
+                  type: "text",
+                  text: notInKnownSet ? `Message queued for ${to} (not in the workflow's known stage set; it will be delivered to every matching stage that starts before the run terminates)` : `Message queued for ${to}`
+                }],
                 isError: false,
                 details: {
                   messageId: result.id,
                   delivered: false,
                   queued: true,
-                  runId: result.runId,
-                  stageKey: result.stageKey,
-                  position: result.position
+                  target: result.target,
+                  position: result.position,
+                  ...notInKnownSet ? { notInKnownSet: true } : {}
                 }
               };
             }
             if (!result.delivered) {
+              const retained = retainInconclusiveRetry(retryIdentities, retryIdentity);
+              retryIdentity = undefined;
               const errorText = result.reason ?? "Session may not exist or has disconnected.";
               return {
-                content: [{ type: "text", text: `Message to "${to}" was not delivered: ${errorText}` }],
+                content: [{
+                  type: "text",
+                  text: `Message to "${to}" was not delivered: ${errorText}${retryTokenGuidance(retained.retryToken, retained.remainingRetries)}`
+                }],
                 isError: true,
-                details: { messageId: result.id, delivered: false, reason: result.reason }
+                details: retryToken === undefined ? { messageId: result.id, delivered: false, reason: result.reason } : {
+                  delivered: false,
+                  reason: result.reason,
+                  ...retained.retryToken === undefined ? {} : { retryToken: retained.retryToken }
+                }
               };
             }
+            retryIdentities.release(retryIdentity);
+            retryIdentity = undefined;
             pi.appendEntry("intercom_sent", {
               to,
               message: { text: message, attachments, replyTo },
               messageId: result.id,
               timestamp: Date.now()
             });
-            if (replyTo) {
+            if (replyTo)
               activeReplyTracker().markReplied(replyTo);
-            }
             return {
               content: [{ type: "text", text: `Message sent to ${to}` }],
               isError: false,
               details: { messageId: result.id, delivered: true }
             };
           } catch (error) {
+            let failure = error;
+            let retained;
+            if (retryIdentity !== undefined) {
+              if (isRecoverableIntercomDisconnect(error)) {
+                try {
+                  retained = retainRecoverableRetry(retryIdentities, retryIdentity);
+                } catch (retentionError) {
+                  failure = retentionError;
+                }
+              } else {
+                retryIdentities.release(retryIdentity);
+              }
+            }
             return {
-              content: [{ type: "text", text: `Failed to send: ${getErrorMessage(error)}` }],
+              content: [{
+                type: "text",
+                text: `Failed to send: ${getErrorMessage(failure)}${retryTokenGuidance(retained?.retryToken, retained?.remainingRetries ?? 0)}`
+              }],
               isError: true,
-              details: { error: true }
+              details: retryErrorDetails(retained?.retryToken)
             };
           }
         }
         case "ask": {
           if (!to) {
+            const errorText = retryToken === undefined ? "Missing 'to' or 'message' parameter" : getErrorMessage(new RetryTokenError("mismatch"));
             return {
-              content: [{ type: "text", text: "Missing 'to' or 'message' parameter" }],
+              content: [{ type: "text", text: errorText }],
               isError: true,
               details: { error: true }
             };
           }
           if (_signal?.aborted) {
             return {
-              content: [{ type: "text", text: "Cancelled" }],
+              content: [{
+                type: "text",
+                text: `Cancelled${retryTokenGuidance(retryToken, retryPreflightRemaining ?? 0)}`
+              }],
               isError: true,
-              details: { error: true }
+              details: retryErrorDetails(retryToken)
             };
           }
           let wait = null;
+          let retryIdentity;
           try {
+            if (retryToken !== undefined && !message)
+              throw new RetryTokenError("mismatch");
+            retryIdentity = retryIdentities.begin({
+              sessionId: toolSessionId,
+              action: "ask",
+              target: to,
+              text: message ?? "",
+              attachments,
+              replyTo,
+              expectsReply: true
+            }, retryToken);
             const metadata = getMetadata();
             const currentSupervisorId = connectedClient.supervisorSessionId ?? undefined;
             const metadataSupervisorId = metadata?.supervisor?.supervisorSessionId;
@@ -2987,7 +3559,9 @@ ${message}${attachmentText}`);
               attachments,
               resolvedTargetId
             }));
-            if (directParentTarget && claimParentAsk(currentSupervisorId ?? metadataSupervisorId ?? to)) {
+            if (retryToken === undefined && directParentTarget && claimParentAsk(currentSupervisorId ?? metadataSupervisorId ?? to)) {
+              retryIdentities.release(retryIdentity);
+              retryIdentity = undefined;
               return {
                 content: [{ type: "text", text: "Parent ask claimed; this child is ending for a fresh subagent start." }],
                 isError: false,
@@ -2996,23 +3570,35 @@ ${message}${attachmentText}`);
             }
             const sendTo = await resolveTarget(connectedClient, to) ?? to;
             if (_signal?.aborted) {
+              const retained = retryIdentity === undefined ? undefined : retainInconclusiveRetry(retryIdentities, retryIdentity);
+              retryIdentity = undefined;
               return {
-                content: [{ type: "text", text: "Cancelled" }],
+                content: [{
+                  type: "text",
+                  text: `Cancelled${retryTokenGuidance(retained?.retryToken, retained?.remainingRetries ?? 0)}`
+                }],
                 isError: true,
-                details: { error: true }
+                details: retryErrorDetails(retained?.retryToken)
               };
             }
             if (sendTo === connectedClient.sessionId) {
+              const retained = retryIdentity === undefined ? undefined : retainInconclusiveRetry(retryIdentities, retryIdentity);
+              retryIdentity = undefined;
               return {
-                content: [{ type: "text", text: "Cannot message the current session" }],
+                content: [{
+                  type: "text",
+                  text: `Cannot message the current session${retryTokenGuidance(retained?.retryToken, retained?.remainingRetries ?? 0)}`
+                }],
                 isError: true,
-                details: { error: true }
+                details: retryErrorDetails(retained?.retryToken)
               };
             }
-            if (metadata && !directParentTarget) {
+            if (retryToken === undefined && metadata && !directParentTarget) {
               const authoritativeParent = [currentSupervisorId, metadataSupervisorId].find((candidate) => candidate === sendTo);
               const resolvedParent = authoritativeParent ?? await resolveTarget(connectedClient, metadata.orchestratorTarget);
               if (resolvedParent !== null && resolvedParent === sendTo && claimParentAsk(sendTo)) {
+                retryIdentities.release(retryIdentity);
+                retryIdentity = undefined;
                 return {
                   content: [{ type: "text", text: "Parent ask claimed; this child is ending for a fresh subagent start." }],
                   isError: false,
@@ -3021,44 +3607,94 @@ ${message}${attachmentText}`);
               }
             }
             if (!message) {
+              retryIdentities.release(retryIdentity);
+              retryIdentity = undefined;
               return {
                 content: [{ type: "text", text: "Missing 'to' or 'message' parameter" }],
                 isError: true,
                 details: { error: true }
               };
             }
-            const questionId = randomUUID4();
-            const replyFrom = await resolveReplySender(connectedClient, to, sendTo);
+            const replySender = await resolveReplySender(connectedClient, to, sendTo);
+            if (replySender.kind === "ambiguous") {
+              const retained = retryIdentity === undefined ? undefined : retainInconclusiveRetry(retryIdentities, retryIdentity);
+              retryIdentity = undefined;
+              return {
+                content: [{
+                  type: "text",
+                  text: `Message to "${to}" is ambiguous: ${replySender.reason}. Use the exact target shown by intercom list.${retryTokenGuidance(retained?.retryToken, retained?.remainingRetries ?? 0)}`
+                }],
+                isError: true,
+                details: retryErrorDetails(retained?.retryToken)
+              };
+            }
+            const questionId = retryIdentity.messageId;
+            const replyFrom = replySender.kind === "resolved" ? replySender.sessionId : sendTo;
             const admission = beginReplyWait(replyFrom, questionId, _signal);
             if (!admission.ok) {
+              const retained = retainInconclusiveRetry(retryIdentities, retryIdentity);
+              retryIdentity = undefined;
               const text = admission.reason === "busy" ? `Too many pending asks (${admission.limit}); reply-wait slots are full` : "Cancelled";
               return {
-                content: [{ type: "text", text }],
+                content: [{
+                  type: "text",
+                  text: `${text}${retryTokenGuidance(retained.retryToken, retained.remainingRetries)}`
+                }],
                 isError: true,
-                details: { error: true }
+                details: retryErrorDetails(retained.retryToken)
               };
             }
             wait = admission.wait;
             const sendResult = await connectedClient.send(sendTo, {
               messageId: questionId,
+              logicalTarget: to,
               text: message,
               attachments,
               replyTo,
               expectsReply: true
             });
+            if (sendResult.queued === true) {
+              retryIdentities.release(retryIdentity);
+              retryIdentity = undefined;
+              wait.cancel(new Error(`Message queued for ${to}`));
+              pi.appendEntry("intercom_sent", {
+                to,
+                message: { text: message, attachments, replyTo },
+                messageId: sendResult.id,
+                timestamp: Date.now()
+              });
+              return {
+                content: [{ type: "text", text: `Message queued for ${to}` }],
+                isError: false,
+                details: {
+                  messageId: sendResult.id,
+                  delivered: false,
+                  queued: true,
+                  target: sendResult.target,
+                  position: sendResult.position
+                }
+              };
+            }
             if (!sendResult.delivered) {
+              const retained = retainInconclusiveRetry(retryIdentities, retryIdentity);
+              retryIdentity = undefined;
               const errorText = sendResult.reason ?? "Session may not exist or has disconnected.";
               wait.cancel(new Error(`Message to "${to}" was not delivered: ${errorText}`));
               const pendingStageAskRefusal = errorText.startsWith("Cannot ask a workflow stage whose session has not initialized.");
               return {
-                content: [{ type: "text", text: `Message to "${to}" was not delivered: ${errorText}` }],
+                content: [{
+                  type: "text",
+                  text: `Message to "${to}" was not delivered: ${errorText}${retryTokenGuidance(retained.retryToken, retained.remainingRetries)}`
+                }],
                 isError: true,
-                details: pendingStageAskRefusal ? {
-                  error: true,
-                  refusal: "pending_stage_ask_unsupported",
-                  recommendedAction: "send",
-                  reason: errorText
-                } : { error: true }
+                details: {
+                  ...pendingStageAskRefusal ? {
+                    refusal: "pending_stage_ask_unsupported",
+                    recommendedAction: "send",
+                    reason: errorText
+                  } : {},
+                  ...retryErrorDetails(retained.retryToken)
+                }
               };
             }
             pi.appendEntry("intercom_sent", {
@@ -3068,6 +3704,8 @@ ${message}${attachmentText}`);
               timestamp: Date.now()
             });
             const replyMessage = await wait.promise;
+            retryIdentities.release(retryIdentity);
+            retryIdentity = undefined;
             const replyText = replyMessage.content.text;
             const replyAttachments = replyMessage.content.attachments?.length ? formatAttachments(replyMessage.content.attachments) : "";
             pi.appendEntry("intercom_received", {
@@ -3091,59 +3729,164 @@ ${replyText}${replyAttachments}` }],
             };
           } catch (error) {
             wait?.cancel(toError3(error));
+            let failure = error;
+            let retained;
+            if (retryIdentity !== undefined) {
+              if (isRecoverableIntercomDisconnect(error)) {
+                try {
+                  retained = retainRecoverableRetry(retryIdentities, retryIdentity);
+                } catch (retentionError) {
+                  failure = retentionError;
+                }
+              } else {
+                retryIdentities.release(retryIdentity);
+              }
+            }
             return {
-              content: [{ type: "text", text: `Failed: ${getErrorMessage(error)}` }],
+              content: [{
+                type: "text",
+                text: `Failed: ${getErrorMessage(failure)}${retryTokenGuidance(retained?.retryToken, retained?.remainingRetries ?? 0)}`
+              }],
               isError: true,
-              details: { error: true }
+              details: retryErrorDetails(retained?.retryToken)
             };
           }
         }
         case "reply": {
           if (!message) {
+            const errorText = retryToken === undefined ? "Missing 'message' parameter" : getErrorMessage(new RetryTokenError("mismatch"));
             return {
-              content: [{ type: "text", text: "Missing 'message' parameter" }],
+              content: [{ type: "text", text: errorText }],
               isError: true,
               details: { error: true }
             };
           }
+          let retryIdentity;
           try {
-            const target = activeReplyTracker().resolveReplyTarget({ to, replyTo });
-            if (target.from.id === connectedClient.sessionId) {
+            retryIdentity = retryIdentities.begin({
+              sessionId: toolSessionId,
+              action: "reply",
+              target: to,
+              text: message,
+              attachments,
+              replyTo,
+              expectsReply: false
+            }, retryToken);
+            if (retryToken === undefined) {
+              const target = activeReplyTracker().resolveReplyTarget({ to, replyTo });
+              retryIdentities.bindReplyRoute(retryIdentity, {
+                senderId: target.from.id,
+                ...target.from.name === undefined ? {} : { senderName: target.from.name },
+                messageId: target.message.id,
+                expectsReply: target.message.expectsReply === true
+              });
+            }
+            const route = retryIdentities.replyRoute(retryIdentity);
+            if (route === undefined)
+              throw new RetryTokenError("invalid");
+            const replySendTo = to ?? route.senderId;
+            const replyLogicalTarget = to ?? route.senderId;
+            const displayTarget = route.senderName || route.senderId;
+            if (route.senderId === connectedClient.sessionId) {
+              const retained = retainInconclusiveRetry(retryIdentities, retryIdentity);
+              retryIdentity = undefined;
               return {
-                content: [{ type: "text", text: "Cannot message the current session" }],
+                content: [{
+                  type: "text",
+                  text: `Cannot message the current session${retryTokenGuidance(retained.retryToken, retained.remainingRetries)}`
+                }],
                 isError: true,
-                details: { error: true }
+                details: retryErrorDetails(retained.retryToken)
               };
             }
-            const result = await connectedClient.send(target.from.id, {
+            const replyMessageId = retryIdentity.messageId;
+            const sendReply = (targetId) => connectedClient.send(targetId, {
+              messageId: replyMessageId,
+              logicalTarget: replyLogicalTarget,
+              ...route.expectsReply ? { requirePendingReply: true } : {},
               text: message,
-              replyTo: target.message.id
+              attachments,
+              replyTo: route.messageId
             });
+            let result = await sendReply(replySendTo);
+            if (to === undefined && result.delivered === false && result.reasonCode === "session_not_found" && route.senderName !== undefined) {
+              result = await sendReply(route.senderName);
+            }
+            if (result.queued === true) {
+              retryIdentities.release(retryIdentity);
+              retryIdentity = undefined;
+              activeReplyTracker().markReplied(route.messageId);
+              pi.appendEntry("intercom_sent", {
+                to: displayTarget,
+                message: { text: message, attachments, replyTo: route.messageId },
+                messageId: result.id,
+                timestamp: Date.now()
+              });
+              return {
+                content: [{ type: "text", text: `Reply queued for ${displayTarget}` }],
+                isError: false,
+                details: {
+                  messageId: result.id,
+                  delivered: false,
+                  queued: true,
+                  replyTo: route.messageId,
+                  target: result.target,
+                  position: result.position
+                }
+              };
+            }
             if (!result.delivered) {
+              const retained = retainInconclusiveRetry(retryIdentities, retryIdentity);
+              retryIdentity = undefined;
               const errorText = result.reason ?? "Session may not exist or has disconnected.";
               return {
-                content: [{ type: "text", text: `Reply to "${target.from.name || target.from.id}" was not delivered: ${errorText}` }],
+                content: [{
+                  type: "text",
+                  text: `Reply to "${displayTarget}" was not delivered: ${errorText}${retryTokenGuidance(retained.retryToken, retained.remainingRetries)}`
+                }],
                 isError: true,
-                details: { messageId: result.id, delivered: false, reason: result.reason }
+                details: retryToken === undefined ? { messageId: result.id, delivered: false, reason: result.reason } : {
+                  delivered: false,
+                  reason: result.reason,
+                  ...retained.retryToken === undefined ? {} : { retryToken: retained.retryToken }
+                }
               };
             }
-            activeReplyTracker().markReplied(target.message.id);
+            retryIdentities.release(retryIdentity);
+            retryIdentity = undefined;
+            activeReplyTracker().markReplied(route.messageId);
             pi.appendEntry("intercom_sent", {
-              to: target.from.name || target.from.id,
-              message: { text: message, replyTo: target.message.id },
+              to: displayTarget,
+              message: { text: message, attachments, replyTo: route.messageId },
               messageId: result.id,
               timestamp: Date.now()
             });
             return {
-              content: [{ type: "text", text: `Reply sent to ${target.from.name || target.from.id}` }],
+              content: [{ type: "text", text: `Reply sent to ${displayTarget}` }],
               isError: false,
-              details: { messageId: result.id, delivered: true, replyTo: target.message.id }
+              details: { messageId: result.id, delivered: true, replyTo: route.messageId }
             };
           } catch (error) {
+            let failure = error;
+            let retained;
+            if (retryIdentity !== undefined) {
+              if (isRecoverableIntercomDisconnect(error)) {
+                try {
+                  retained = retainRecoverableRetry(retryIdentities, retryIdentity);
+                } catch (retentionError) {
+                  failure = retentionError;
+                }
+              } else {
+                retryIdentities.release(retryIdentity);
+              }
+            }
             return {
-              content: [{ type: "text", text: `Failed to reply: ${getErrorMessage(error)}` }],
+              content: [{
+                type: "text",
+                text: `Failed to reply: ${getErrorMessage(failure)}${retryTokenGuidance(retained?.retryToken, retained?.remainingRetries ?? 0)}`
+              }],
               isError: true,
-              details: { error: true }
+              details: retryErrorDetails(retained?.retryToken)
             };
           }
         }
@@ -3238,7 +3981,9 @@ var init_intercom_tool = __esm(() => {
   init_result_renderers();
   init_intercom_utils();
   init_group();
-  init_send_handler();
+  init_workflow_stage_target();
+  init_recoverable_disconnect();
+  init_retry_identity();
 });
 
 // dist/builtin/intercom/ui/compose.ts
@@ -3747,43 +4492,379 @@ var init_lifecycle = __esm(() => {
 });
 
 // dist/builtin/intercom/broker/delivered-message-cache.ts
+import { createHmac, randomBytes } from "node:crypto";
+import {
+  chmodSync as chmodSync2,
+  closeSync as closeSync2,
+  existsSync as existsSync3,
+  mkdirSync as mkdirSync2,
+  openSync as openSync2,
+  readFileSync as readFileSync3,
+  writeFileSync as writeFileSync2
+} from "node:fs";
+import { dirname as dirname2 } from "node:path";
+import { DatabaseSync } from "node:sqlite";
+function validStoredString(value) {
+  return typeof value === "string" && value.length > 0;
+}
+function entryByteSize(messageId, delivered) {
+  return [
+    messageId,
+    delivered.signature,
+    delivered.targetIdentity,
+    delivered.questionRoute?.targetSessionId,
+    delivered.questionRoute?.senderGroupIdentity
+  ].reduce((total, value) => total + (value === undefined ? 0 : Buffer.byteLength(value)), 0);
+}
+function parseStoredMessage(row) {
+  if (row === undefined)
+    return;
+  if (row.state !== "reserved" && row.state !== "accepted" || !validStoredString(row.signature) || !AUTHORITY_DIGEST_PATTERN.test(row.signature) || typeof row.delivered_at !== "number" || !Number.isSafeInteger(row.delivered_at) || row.delivered_at < 0 || row.target_identity !== null && !validStoredString(row.target_identity)) {
+    return "invalid";
+  }
+  const questionValues = [row.question_target_session_id, row.question_sender_group_identity];
+  const hasQuestionRoute = questionValues.some((value) => value !== null);
+  if (hasQuestionRoute && !questionValues.every(validStoredString))
+    return "invalid";
+  return {
+    state: row.state,
+    deliveredAt: row.delivered_at,
+    signature: row.signature,
+    ...typeof row.target_identity === "string" ? { targetIdentity: row.target_identity } : {},
+    ...hasQuestionRoute ? {
+      questionRoute: {
+        targetSessionId: row.question_target_session_id,
+        senderGroupIdentity: row.question_sender_group_identity
+      }
+    } : {}
+  };
+}
+function getDeliveredMessageAuthorityKeyPath(storagePath) {
+  return storagePath.endsWith(".sqlite") ? `${storagePath.slice(0, -".sqlite".length)}.key` : `${storagePath}.key`;
+}
+function restrictMode(path, mode) {
+  if (process.platform !== "win32")
+    chmodSync2(path, mode);
+}
+function restrictExistingAuthorityArtifacts(storagePath, keyPath) {
+  for (const path of [storagePath, `${storagePath}-wal`, `${storagePath}-shm`, keyPath]) {
+    if (existsSync3(path))
+      restrictMode(path, 384);
+  }
+}
+function prepareDurableAuthority(storagePath) {
+  const directory = dirname2(storagePath);
+  const keyPath = getDeliveredMessageAuthorityKeyPath(storagePath);
+  mkdirSync2(directory, { recursive: true, mode: 448 });
+  restrictMode(directory, 448);
+  restrictExistingAuthorityArtifacts(storagePath, keyPath);
+  const databaseExists = existsSync3(storagePath);
+  const keyExists = existsSync3(keyPath);
+  if (databaseExists !== keyExists)
+    return;
+  if (!databaseExists) {
+    const key2 = randomBytes(AUTHORITY_KEY_BYTES);
+    writeFileSync2(keyPath, key2, { flag: "wx", mode: 384 });
+    const databaseDescriptor = openSync2(storagePath, "wx", 384);
+    closeSync2(databaseDescriptor);
+    restrictExistingAuthorityArtifacts(storagePath, keyPath);
+    return key2;
+  }
+  const key = readFileSync3(keyPath);
+  if (key.length !== AUTHORITY_KEY_BYTES)
+    return;
+  return key;
+}
+
 class DeliveredMessageCache {
   ttlMs;
   maxEntries;
+  maxBytes;
   delivered = new Map;
-  constructor(ttlMs = DEFAULT_TTL_MS2, maxEntries = DEFAULT_MAX_ENTRIES) {
+  retainedBytes = 0;
+  database;
+  authorityKey;
+  storagePath;
+  storageInvalid = false;
+  constructor(ttlMs = DELIVERED_MESSAGE_TTL_MS, maxEntries = DELIVERED_MESSAGE_MAX_ENTRIES, storagePath, maxBytes = DELIVERED_MESSAGE_MAX_BYTES) {
     this.ttlMs = ttlMs;
     this.maxEntries = maxEntries;
+    this.maxBytes = maxBytes;
+    if (storagePath === undefined)
+      return;
+    this.storagePath = storagePath;
+    let database;
+    try {
+      const authorityKey = prepareDurableAuthority(storagePath);
+      if (authorityKey === undefined) {
+        this.storageInvalid = true;
+        return;
+      }
+      this.authorityKey = authorityKey;
+      database = new DatabaseSync(storagePath);
+      database.exec("PRAGMA busy_timeout = 5000");
+      database.exec("PRAGMA journal_mode = WAL");
+      database.exec("PRAGMA synchronous = FULL");
+      database.exec("PRAGMA trusted_schema = OFF");
+      database.exec(`
+				CREATE TABLE IF NOT EXISTS delivered_messages (
+					state TEXT NOT NULL CHECK (state IN ('reserved', 'accepted')),
+					message_id TEXT PRIMARY KEY NOT NULL,
+					signature TEXT NOT NULL,
+					delivered_at INTEGER NOT NULL,
+					target_identity TEXT,
+					question_target_session_id TEXT,
+					question_sender_group_identity TEXT
+				) STRICT;
+				CREATE INDEX IF NOT EXISTS delivered_messages_age
+					ON delivered_messages(delivered_at);
+			`);
+      database.prepare("SELECT state, signature, delivered_at, target_identity FROM delivered_messages LIMIT 0").get();
+      restrictExistingAuthorityArtifacts(storagePath, getDeliveredMessageAuthorityKeyPath(storagePath));
+    } catch {
+      database?.close();
+      try {
+        restrictExistingAuthorityArtifacts(storagePath, getDeliveredMessageAuthorityKeyPath(storagePath));
+      } catch {}
+      this.storageInvalid = true;
+      return;
+    }
+    this.database = database;
   }
   lookup(messageId, signature, now = Date.now()) {
+    const authority = this.signatureAuthority(signature);
+    return authority === undefined ? "invalid" : this.lookupEntry(messageId, authority, undefined, false, now);
+  }
+  lookupForTarget(messageId, signature, targetIdentity, now = Date.now()) {
+    const authority = this.signatureAuthority(signature);
+    return authority === undefined ? "invalid" : this.lookupEntry(messageId, authority, targetIdentity, true, now);
+  }
+  lookupQuestionTarget(messageId, signature, senderGroupIdentity, now = Date.now()) {
+    const authority = this.signatureAuthority(signature);
+    if (authority === undefined)
+      return;
     this.prune(now);
-    const delivered = this.delivered.get(messageId);
-    if (!delivered || now - delivered.deliveredAt > this.ttlMs)
-      return "miss";
-    return delivered.signature === signature ? "match" : "conflict";
+    const delivered = this.read(messageId);
+    if (delivered === undefined || delivered === "invalid" || delivered.state !== "accepted" || now - delivered.deliveredAt > this.ttlMs || delivered.signature !== authority || delivered.questionRoute?.senderGroupIdentity !== senderGroupIdentity) {
+      return;
+    }
+    return delivered.questionRoute.targetSessionId;
+  }
+  record(messageId, signature, now = Date.now(), targetIdentity) {
+    return this.recordWithSignature(messageId, { state: "accepted", deliveredAt: now, signature, targetIdentity });
+  }
+  recordQuestion(messageId, signature, questionRoute, now = Date.now(), targetIdentity) {
+    return this.recordWithSignature(messageId, {
+      state: "accepted",
+      deliveredAt: now,
+      signature,
+      targetIdentity,
+      questionRoute
+    });
+  }
+  reserve(messageId, signature, now = Date.now(), targetIdentity) {
+    return this.recordWithSignature(messageId, { state: "reserved", deliveredAt: now, signature, targetIdentity });
+  }
+  reserveQuestion(messageId, signature, questionRoute, now = Date.now(), targetIdentity) {
+    return this.recordWithSignature(messageId, {
+      state: "reserved",
+      deliveredAt: now,
+      signature,
+      targetIdentity,
+      questionRoute
+    });
+  }
+  accept(messageId, signature, targetIdentity) {
+    const authority = this.signatureAuthority(signature);
+    if (authority === undefined)
+      return "invalid";
+    const existing = this.read(messageId);
+    if (existing === undefined || existing === "invalid")
+      return "invalid";
+    if (existing.signature !== authority || existing.targetIdentity !== targetIdentity)
+      return "conflict";
+    if (existing.state === "accepted")
+      return "accepted";
+    if (this.database === undefined) {
+      existing.state = "accepted";
+      return "accepted";
+    }
+    const updated = this.database.prepare("UPDATE delivered_messages SET state = 'accepted' WHERE message_id = ? AND signature = ?").run(messageId, authority);
+    this.restrictArtifacts();
+    return Number(updated.changes) === 1 ? "accepted" : "invalid";
+  }
+  forget(messageId, signature) {
+    const authority = this.signatureAuthority(signature);
+    if (authority === undefined)
+      return;
+    if (this.database === undefined) {
+      const delivered = this.delivered.get(messageId);
+      if (delivered?.signature === authority) {
+        this.retainedBytes -= entryByteSize(messageId, delivered);
+        this.delivered.delete(messageId);
+      }
+      return;
+    }
+    this.database.prepare("DELETE FROM delivered_messages WHERE message_id = ? AND signature = ?").run(messageId, authority);
+    this.restrictArtifacts();
+  }
+  close() {
+    this.restrictArtifacts();
+    this.database?.close();
+    this.restrictArtifacts();
+  }
+  signatureAuthority(signature) {
+    if (this.storageInvalid || !validStoredString(signature))
+      return;
+    if (this.storagePath === undefined)
+      return signature;
+    if (this.authorityKey === undefined)
+      return;
+    return createHmac("sha256", this.authorityKey).update(signature).digest("hex");
+  }
+  recordWithSignature(messageId, delivered) {
+    const authority = this.signatureAuthority(delivered.signature);
+    if (authority === undefined)
+      return "invalid";
+    return this.recordEntry(messageId, { ...delivered, signature: authority });
   }
-  record(messageId, signature, now = Date.now()) {
+  lookupEntry(messageId, signature, targetIdentity, requireTargetIdentity, now) {
+    if (this.storageInvalid)
+      return "invalid";
     this.prune(now);
-    this.delivered.delete(messageId);
-    this.delivered.set(messageId, { deliveredAt: now, signature });
-    while (this.delivered.size > this.maxEntries) {
-      const oldest = this.delivered.keys().next().value;
-      if (oldest === undefined)
-        break;
-      this.delivered.delete(oldest);
+    const delivered = this.read(messageId);
+    if (delivered === "invalid")
+      return "invalid";
+    if (delivered === undefined || now - delivered.deliveredAt > this.ttlMs)
+      return "miss";
+    if (delivered.signature !== signature)
+      return "conflict";
+    if (requireTargetIdentity && delivered.targetIdentity !== targetIdentity)
+      return "conflict";
+    if (delivered.state === "reserved")
+      return "uncertain";
+    return "match";
+  }
+  recordEntry(messageId, delivered) {
+    if (this.storageInvalid)
+      return "invalid";
+    if (!validStoredString(messageId) || !validStoredString(delivered.signature))
+      return "invalid";
+    if (!Number.isSafeInteger(delivered.deliveredAt) || delivered.deliveredAt < 0 || delivered.targetIdentity !== undefined && !validStoredString(delivered.targetIdentity) || delivered.questionRoute !== undefined && (!validStoredString(delivered.questionRoute.targetSessionId) || !validStoredString(delivered.questionRoute.senderGroupIdentity))) {
+      return "invalid";
+    }
+    if (entryByteSize(messageId, delivered) > this.maxBytes)
+      return "capacity";
+    if (this.database === undefined)
+      return this.recordMemory(messageId, delivered);
+    return this.recordDurable(messageId, delivered);
+  }
+  recordMemory(messageId, delivered) {
+    this.pruneMemory(delivered.deliveredAt);
+    const existing = this.delivered.get(messageId);
+    if (existing !== undefined)
+      return this.compare(existing, delivered);
+    const size = entryByteSize(messageId, delivered);
+    if (this.delivered.size >= this.maxEntries || this.retainedBytes + size > this.maxBytes)
+      return "capacity";
+    this.delivered.set(messageId, delivered);
+    this.retainedBytes += size;
+    return "recorded";
+  }
+  recordDurable(messageId, delivered) {
+    const database = this.database;
+    if (database === undefined)
+      return "invalid";
+    database.exec("BEGIN IMMEDIATE");
+    try {
+      this.pruneDurable(delivered.deliveredAt);
+      const existing = this.readDurable(messageId);
+      if (existing !== undefined) {
+        database.exec("COMMIT");
+        return existing === "invalid" ? "invalid" : this.compare(existing, delivered);
+      }
+      const totals = database.prepare(`
+				SELECT COUNT(*) AS count,
+					COALESCE(SUM(
+						length(CAST(message_id AS BLOB)) + length(CAST(signature AS BLOB)) +
+						COALESCE(length(CAST(target_identity AS BLOB)), 0) +
+						COALESCE(length(CAST(question_target_session_id AS BLOB)), 0) +
+						COALESCE(length(CAST(question_sender_group_identity AS BLOB)), 0)
+					), 0) AS bytes
+				FROM delivered_messages
+			`).get();
+      const count = totals?.count;
+      const bytes = totals?.bytes;
+      if (typeof count !== "number" || !Number.isSafeInteger(count) || count < 0 || typeof bytes !== "number" || !Number.isSafeInteger(bytes) || bytes < 0) {
+        database.exec("COMMIT");
+        return "invalid";
+      }
+      if (count >= this.maxEntries || bytes + entryByteSize(messageId, delivered) > this.maxBytes) {
+        database.exec("COMMIT");
+        return "capacity";
+      }
+      database.prepare(`
+					INSERT INTO delivered_messages (
+						message_id, state, signature, delivered_at, target_identity,
+						question_target_session_id, question_sender_group_identity
+					) VALUES (?, ?, ?, ?, ?, ?, ?)
+				`).run(messageId, delivered.state, delivered.signature, delivered.deliveredAt, delivered.targetIdentity ?? null, delivered.questionRoute?.targetSessionId ?? null, delivered.questionRoute?.senderGroupIdentity ?? null);
+      database.exec("COMMIT");
+      this.restrictArtifacts();
+      return "recorded";
+    } catch (error) {
+      try {
+        database.exec("ROLLBACK");
+      } catch {}
+      throw error;
+    }
+  }
+  compare(existing, incoming) {
+    if (existing.signature !== incoming.signature || existing.targetIdentity !== incoming.targetIdentity) {
+      return "conflict";
     }
+    return existing.state === "accepted" ? "match" : "uncertain";
+  }
+  read(messageId) {
+    return this.database === undefined ? this.delivered.get(messageId) : this.readDurable(messageId);
+  }
+  readDurable(messageId) {
+    const row = this.database?.prepare(`
+				SELECT state, signature, delivered_at, target_identity,
+					question_target_session_id, question_sender_group_identity
+				FROM delivered_messages WHERE message_id = ?
+			`).get(messageId);
+    return parseStoredMessage(row);
   }
   prune(now) {
+    if (this.database === undefined)
+      this.pruneMemory(now);
+    else
+      this.pruneDurable(now);
+  }
+  pruneMemory(now) {
     for (const [messageId, delivered] of this.delivered) {
       if (now - delivered.deliveredAt <= this.ttlMs)
-        break;
+        continue;
       this.delivered.delete(messageId);
+      this.retainedBytes -= entryByteSize(messageId, delivered);
     }
   }
+  pruneDurable(now) {
+    this.database?.prepare("DELETE FROM delivered_messages WHERE typeof(delivered_at) = 'integer' AND ? - delivered_at > ?").run(now, this.ttlMs);
+    this.restrictArtifacts();
+  }
+  restrictArtifacts() {
+    if (this.storagePath === undefined || this.storageInvalid)
+      return;
+    restrictExistingAuthorityArtifacts(this.storagePath, getDeliveredMessageAuthorityKeyPath(this.storagePath));
+  }
 }
-var DEFAULT_TTL_MS2, DEFAULT_MAX_ENTRIES = 1e4;
+var DELIVERED_MESSAGE_MAX_ENTRIES = 1e4, DELIVERED_MESSAGE_MAX_BYTES, AUTHORITY_KEY_BYTES = 32, AUTHORITY_DIGEST_PATTERN;
 var init_delivered_message_cache = __esm(() => {
-  DEFAULT_TTL_MS2 = 10 * 60 * 1000;
+  init_retry_policy();
+  DELIVERED_MESSAGE_MAX_BYTES = 64 * 1024 * 1024;
+  AUTHORITY_DIGEST_PATTERN = /^[a-f0-9]{64}$/u;
 });
 
 // dist/builtin/intercom/terminal-ordering-barrier.ts
@@ -4030,8 +5111,7 @@ async function dispatchRelayFallback(pi, prefix, terminalMessage, stageAdmission
 }
 function registerSubagentRelay(pi, deps) {
   const { getLiveContext, currentSessionTargetMatches, sendIncomingMessage, ensureConnected, resolveSessionTarget: resolveSessionTarget2 } = deps;
-  const localDeliveries = new DeliveredMessageCache;
-  const localDeliveriesInFlight = new Map;
+  const localDeliveries = deps.localDeliveryAuthority ?? new DeliveredMessageCache;
   function deliverLocalSubagentRelayMessage(sender, status, messageText, terminalBarrier, requestId) {
     const now = Date.now();
     const entry = {
@@ -4124,37 +5204,33 @@ ${messageText}`,
   }
   async function deliverLocal(parsed, options) {
     try {
-      const signature = buildSendSignature(parsed.to, { text: parsed.message });
-      const match = parsed.requestId ? localDeliveries.lookup(parsed.requestId, signature) : "miss";
-      if (match === "conflict") {
-        throw new Error(`Intercom message ID '${parsed.requestId}' was already delivered with a different target or payload`);
+      const signature = JSON.stringify({
+        sender: options.sender,
+        send: buildSendSignature(parsed.to, { text: parsed.message })
+      });
+      if (!parsed.requestId) {
+        await deliverLocalSubagentRelayMessage(options.sender, options.status, parsed.message, options.terminalBarrier);
+        acknowledgeResult(options, parsed.requestId, true);
+        return;
       }
-      if (match === "miss") {
-        const pending = parsed.requestId ? localDeliveriesInFlight.get(parsed.requestId) : undefined;
-        if (pending && pending.signature !== signature) {
-          await pending.completion;
-          throw new Error(`Intercom message ID '${parsed.requestId}' was already delivered with a different target or payload`);
-        }
-        let delivery = pending?.completion;
-        if (!delivery && parsed.requestId) {
-          const deferred = Promise.withResolvers();
-          delivery = deferred.promise;
-          delivery.catch(() => {});
-          localDeliveriesInFlight.set(parsed.requestId, { signature, completion: delivery });
-          try {
-            deliverLocalSubagentRelayMessage(options.sender, options.status, parsed.message, options.terminalBarrier, parsed.requestId).then(deferred.resolve, deferred.reject);
-          } catch (error) {
-            deferred.reject(error);
-          }
-          delivery.finally(() => {
-            localDeliveriesInFlight.delete(parsed.requestId);
-          }).catch(() => {});
-        } else if (!delivery) {
-          delivery = deliverLocalSubagentRelayMessage(options.sender, options.status, parsed.message, options.terminalBarrier, parsed.requestId);
-        }
-        await delivery;
-        if (parsed.requestId)
-          localDeliveries.record(parsed.requestId, signature);
+      const reservation = localDeliveries.reserve(parsed.requestId, signature);
+      if (reservation === "match") {
+        acknowledgeResult(options, parsed.requestId, true);
+        return;
+      }
+      if (reservation !== "recorded") {
+        const reason = reservation === "conflict" ? `Intercom message ID '${parsed.requestId}' was already delivered with a different sender, target, or payload` : reservation === "capacity" ? "Local Intercom delivery authority is at capacity; refusing delivery" : reservation === "uncertain" ? `Intercom message ID '${parsed.requestId}' has uncertain local delivery state; refusing replay` : "Local Intercom delivery authority is invalid; refusing delivery";
+        throw new Error(reason);
+      }
+      try {
+        await deliverLocalSubagentRelayMessage(options.sender, options.status, parsed.message, options.terminalBarrier, parsed.requestId);
+      } catch (error) {
+        localDeliveries.forget(parsed.requestId, signature);
+        throw error;
+      }
+      const accepted = localDeliveries.accept(parsed.requestId, signature);
+      if (accepted !== "accepted") {
+        throw new Error(`Local Intercom delivery authority could not accept message '${parsed.requestId}'; refusing acknowledgement`);
       }
       acknowledgeResult(options, parsed.requestId, true);
     } catch (error) {
@@ -4873,7 +5949,10 @@ async function settleOpenStageDeliveryFailure(input, error) {
 }
 
 // dist/builtin/intercom/closed-workflow-stage-message.ts
-function routeClosedWorkflowStageMessage(entry, admission, tracker, waiter, deliver, currentClient, isCurrent) {
+function routeClosedWorkflowStageMessage(entry, admission, tracker, waiter, deliver, currentClient, isCurrent, ownsSubagentRun) {
+  const sourceRunId = entry.message.source?.subagentRunId;
+  if (sourceRunId !== undefined && ownsSubagentRun(sourceRunId))
+    return;
   if (entry.message.expectsReply !== true) {
     retryStableDelivery({ deliver, isCurrent }).catch(() => {});
     return;
@@ -4920,15 +5999,6 @@ function clearRuntimeIntercomGroup(sessionId) {
 }
 var init_runtime_group = () => {};
 
-// dist/builtin/intercom/reconnect-backoff.ts
-function reconnectDelayMs(attempt) {
-  return BACKOFF_MS[Math.min(attempt, BACKOFF_MS.length - 1)];
-}
-var BACKOFF_MS;
-var init_reconnect_backoff = __esm(() => {
-  BACKOFF_MS = [1000, 2000, 5000, 1e4, 30000];
-});
-
 // dist/builtin/intercom/supervisor-authorization-registry.ts
 import { randomUUID as randomUUID6 } from "node:crypto";
 
@@ -5190,9 +6260,10 @@ function piIntercomExtension(pi, testOverrides = {}) {
     if (receivedBeforeStageStart) {
       return sendIncomingMessage(entry, "prelude", messageGeneration, false);
     }
-    const stageClosed = liveContext.orchestrationContext?.kind === "workflow-stage" && liveContext.orchestrationContext.messageAdmission?.isOpen() === false;
+    const stageAdmission = liveContext.orchestrationContext?.kind === "workflow-stage" ? liveContext.orchestrationContext.messageAdmission : undefined;
+    const stageClosed = stageAdmission?.isOpen() === false;
     if (stageClosed) {
-      routeClosedWorkflowStageMessage(entry, inboundDeliveries, replyTracker, replyWaiters.pending(), () => sendIncomingMessage(entry, "trigger", messageGeneration, false), () => client, () => Boolean(getLiveContext(liveContext, messageGeneration)));
+      routeClosedWorkflowStageMessage(entry, inboundDeliveries, replyTracker, replyWaiters.pending(), () => sendIncomingMessage(entry, "trigger", messageGeneration, false), () => client, () => Boolean(getLiveContext(liveContext, messageGeneration)), (runId) => stageAdmission.boundary.ownsSubagentRun(runId));
       return;
     }
     const admission = inboundDeliveries.admit(from, message);
@@ -5378,6 +6449,9 @@ function piIntercomExtension(pi, testOverrides = {}) {
       return reject(error);
     }
   }
+  function relayStickyLiveDelivered(notice) {
+    pi.events.emit(STICKY_LIVE_DELIVERED_EVENT, { handled: false, ...notice });
+  }
   function handlePendingStageNotification(nextClient, request) {
     admitPendingStageNotification(nextClient, request).catch(() => false).then((delivered) => {
       if (client !== nextClient || !nextClient.isConnected())
@@ -5401,6 +6475,10 @@ function piIntercomExtension(pi, testOverrides = {}) {
     nextClient.on("pending_stage_notification", (request) => {
       handlePendingStageNotification(nextClient, request);
     });
+    nextClient.on("sticky_live_delivered", (notice) => {
+      if (client === nextClient)
+        relayStickyLiveDelivered(notice);
+    });
     nextClient.on("peer_disconnected", (notice) => {
       if (client !== nextClient) {
         return;
@@ -5424,7 +6502,7 @@ function piIntercomExtension(pi, testOverrides = {}) {
     nextClient.on("error", () => {});
   }
   function scheduleReconnect() {
-    if (disposed || shuttingDown || reconnectTimer || reconnectPromise || !getLiveContext()) {
+    if (disposed || shuttingDown || reconnectTimer || reconnectPromise || client?.isConnected() || !getLiveContext()) {
       return;
     }
     const scheduledGeneration = runtimeGeneration;
@@ -5466,6 +6544,10 @@ function piIntercomExtension(pi, testOverrides = {}) {
       schedulePendingStageRouteReconnect(runId, state);
     });
     nextClient.on("error", () => {});
+    nextClient.on("sticky_live_delivered", (notice) => {
+      if (state.client === nextClient)
+        relayStickyLiveDelivered(notice);
+    });
   }
   async function ensurePendingStageRouteClient(runId, route) {
     const contextAtStart = getLiveContext();
@@ -5498,7 +6580,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);
+      state.client.registerPendingStageRoute(runId, normalizeGroup(route.group), route.capability, route.stages, route.possibleStages);
       return;
     }
     if (state.promise) {
@@ -5515,7 +6597,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);
+      nextClient.registerPendingStageRoute(runId, normalizeGroup(route.group), route.capability, route.stages, route.possibleStages);
       await nextClient.listSessions();
       if (!pendingStageRouteClientIsCurrent(runId, state, contextAtStart, generationAtStart)) {
         await nextClient.disconnect();
@@ -5563,7 +6645,7 @@ function piIntercomExtension(pi, testOverrides = {}) {
   async function registerPendingStageRoute(activeClient, runId, route) {
     const routeGroup = normalizeGroup(route.group);
     if (clientRegistrationGroup === routeGroup) {
-      activeClient.registerPendingStageRoute(runId, routeGroup, route.capability, route.stages);
+      activeClient.registerPendingStageRoute(runId, routeGroup, route.capability, route.stages, route.possibleStages);
       return;
     }
     await ensurePendingStageRouteClient(runId, { ...route, group: routeGroup });
@@ -5584,12 +6666,16 @@ function piIntercomExtension(pi, testOverrides = {}) {
     if (reconnectPromise && reconnectPromiseGeneration === generationAtStart) {
       return reconnectPromise;
     }
+    const ownershipRecorded = Promise.withResolvers();
     const nextReconnectPromise = (async () => {
+      let connectFailed = false;
+      await ownershipRecorded.promise;
       const nextClient = new IntercomClient(currentSessionId);
       const registration = buildRegistration();
       client = nextClient;
       attachClientHandlers(nextClient);
       try {
+        await testOverrides.beforeConnectAttempt?.(reason);
         await spawnBrokerIfNeeded(config.brokerCommand, config.brokerArgs);
         const childMetadata = currentChildOrchestratorMetadata();
         await nextClient.connect(registration, childMetadata?.supervisor, supervisorAuthorizations.ownerToken, readSubagentMessageSource(runtimeContext?.subagentPolicy));
@@ -5600,7 +6686,10 @@ function piIntercomExtension(pi, testOverrides = {}) {
         }
         const orchestration = contextAtStart.orchestrationContext;
         if (orchestration?.kind === "workflow-stage" && orchestration.pendingStageDelivery !== undefined) {
-          await nextClient.registerLiveWorkflowStageRoute(orchestration.workflowRunId, [orchestration.workflowStageId, orchestration.workflowStageName], orchestration.pendingStageDelivery.routeCapability);
+          const liveStageKeys = [orchestration.workflowStageId, orchestration.workflowStageName].filter((stageKey) => !stageKey.includes("/") && !stageKey.includes("*"));
+          if (liveStageKeys.length > 0) {
+            await nextClient.registerLiveWorkflowStageRoute(orchestration.workflowRunId, liveStageKeys, orchestration.pendingStageDelivery.routeCapability);
+          }
         }
         if (!getLiveContext(contextAtStart, generationAtStart)) {
           await nextClient.disconnect();
@@ -5617,19 +6706,24 @@ function piIntercomExtension(pi, testOverrides = {}) {
           client = null;
           clientRegistrationGroup = null;
         }
-        if (reason === "background" && getLiveContext(contextAtStart, generationAtStart)) {
-          scheduleReconnect();
-        }
+        connectFailed = true;
+        try {
+          await nextClient.disconnect();
+        } catch {}
         throw toError3(error);
       } finally {
         if (reconnectPromiseGeneration === generationAtStart) {
           reconnectPromise = null;
           reconnectPromiseGeneration = null;
         }
+        if (connectFailed && getLiveContext(contextAtStart, generationAtStart)) {
+          scheduleReconnect();
+        }
       }
     })();
     reconnectPromise = nextReconnectPromise;
     reconnectPromiseGeneration = generationAtStart;
+    ownershipRecorded.resolve();
     return nextReconnectPromise;
   }
   pi.events.on(PENDING_STAGE_ROUTE_EVENT, (payload) => {
@@ -5638,7 +6732,8 @@ function piIntercomExtension(pi, testOverrides = {}) {
     pendingStageRoutes.set(payload.runId, {
       group: payload.group,
       capability: payload.capability,
-      ...payload.stages === undefined ? {} : { stages: payload.stages }
+      ...payload.stages === undefined ? {} : { stages: payload.stages },
+      ...payload.possibleStages === undefined ? {} : { possibleStages: payload.possibleStages }
     });
     const completion = ensureConnected("background").then((activeClient) => registerPendingStageRoute(activeClient, payload.runId, payload));
     payload.completion = completion;
@@ -5661,6 +6756,22 @@ function piIntercomExtension(pi, testOverrides = {}) {
       return;
     payload.handled = true;
     const actionable = `Pending workflow stage could not receive intercom message: ${payload.reason}`;
+    const selfClient = client;
+    const notifiesThisSession = selfClient !== null && selfClient.isConnected() && (payload.senderId === selfClient.sessionId || payload.senderReturnAddress !== undefined && payload.senderReturnAddress === currentSessionId);
+    if (notifiesThisSession && selfClient.sessionId !== null) {
+      payload.completion = admitPendingStageNotification(selfClient, {
+        requestId: `local:${payload.notificationId}`,
+        from: { id: selfClient.sessionId, ...buildRegistration() },
+        message: {
+          id: payload.notificationId,
+          timestamp: Date.now(),
+          replyTo: payload.messageId,
+          replyError: actionable,
+          content: { text: actionable }
+        }
+      }).catch(() => false);
+      return;
+    }
     payload.completion = pendingStageNotificationClient(payload.runId).then((activeClient) => {
       const route = pendingStageRoutes.get(payload.runId);
       if (route === undefined)
@@ -5789,7 +6900,7 @@ 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";
+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 init_index_heavy = __esm(() => {
   init_client();
   init_spawn();
@@ -5911,6 +7022,22 @@ function rejectLazyResultRelay(pi, eventName, payload, error) {
   }
 }
 
+// dist/builtin/intercom/index.ts
+init_recoverable_disconnect();
+
+// dist/builtin/intercom/warm-up-exhaustion.ts
+class IntercomWarmUpExhaustedError extends Error {
+  attempts;
+  constructor(attempts, options) {
+    super(`Intercom could not reach the broker after ${attempts} warm-up attempts.`, options);
+    this.name = "IntercomWarmUpExhaustedError";
+    this.attempts = attempts;
+  }
+}
+
+// dist/builtin/intercom/index.ts
+init_reconnect_backoff();
+
 // dist/builtin/intercom/lazy-heavy-proxy.ts
 var LIVE_EVENT_SUBSCRIPTIONS = new Set(["pi-intercom:detach-response"]);
 function createForwardedHandlerMap() {
@@ -6041,9 +7168,12 @@ function renderHeavyToolResult(loadedHeavy, name, args) {
     return renderer(...args);
   return renderIntercomToolResult(name, args);
 }
-function isRecoverableHeavyInitializationDisconnect(error) {
-  return error instanceof Error && error.message === "Client disconnected";
+function reportRelayFailure(eventName, error) {
+  if (isRecoverableIntercomDisconnect(error))
+    return;
+  console.error(`Intercom event relay failed (${eventName}):`, error);
 }
+var WARM_UP_RETRY_ATTEMPTS = 5;
 function intercom(pi, options = {}) {
   const inheritedDelegatedSessionName = readSubagentEnv("INTERCOM_SESSION_NAME");
   let heavyAttempt = null;
@@ -6197,13 +7327,73 @@ function intercom(pi, options = {}) {
     }, (error) => {
       if (heavyAttempt?.promise === promise)
         heavyAttempt = null;
-      if (!isRecoverableHeavyInitializationDisconnect(error)) {
+      if (!isRecoverableIntercomDisconnect(error)) {
         const message = error instanceof Error ? error.message : String(error);
         console.error(`Intercom heavy initialization failed; a later call will retry: ${message}`, error);
       }
     });
     return promise;
   }
+  let warmUpRetry = null;
+  function cancelWarmUpRetry() {
+    if (!warmUpRetry)
+      return;
+    warmUpRetry.cancelled = true;
+    if (warmUpRetry.timer)
+      clearTimeout(warmUpRetry.timer);
+    warmUpRetry = null;
+  }
+  function warmUpRetryDelay(attempt) {
+    const schedule = options.warmUpRetryDelaysMs;
+    if (schedule)
+      return schedule[attempt];
+    return attempt < WARM_UP_RETRY_ATTEMPTS ? reconnectDelayMs(attempt) : undefined;
+  }
+  function scheduleWarmUpRetry(ctx, lease, generation, pendingStageDelivery, initialError) {
+    if (warmUpRetry)
+      return;
+    const state = { lease, generation, timer: null, cancelled: false };
+    warmUpRetry = state;
+    let lastError = initialError;
+    const clearOwner = () => {
+      if (warmUpRetry === state)
+        warmUpRetry = null;
+    };
+    const stale = () => state.cancelled || activeLease !== lease || lease.retired || sessionSnapshot?.generation !== generation;
+    const attemptAt = (attempt) => {
+      const delay = warmUpRetryDelay(attempt);
+      if (delay === undefined) {
+        clearOwner();
+        const exhausted = new IntercomWarmUpExhaustedError(attempt, lastError instanceof Error ? { cause: lastError } : undefined);
+        try {
+          pendingStageDelivery.fail(exhausted);
+        } catch {}
+        return;
+      }
+      const timer = setTimeout(() => {
+        state.timer = null;
+        if (stale()) {
+          clearOwner();
+          return;
+        }
+        loadHeavy(ctx).then(clearOwner, (error) => {
+          lastError = error;
+          if (stale()) {
+            clearOwner();
+            return;
+          }
+          if (!isRecoverableIntercomDisconnect(error)) {
+            clearOwner();
+            return;
+          }
+          attemptAt(attempt + 1);
+        });
+      }, delay);
+      timer.unref?.();
+      state.timer = timer;
+    };
+    attemptAt(0);
+  }
   let typedContactSupervisorRegistered = hasSubagentIntercomEnv();
   const activateTypedContactSupervisor = () => {
     const activeTools = pi.getActiveTools();
@@ -6250,8 +7440,16 @@ function intercom(pi, options = {}) {
     }
     const generation = ++lifecycleGeneration;
     sessionSnapshot = { event, ctx, generation, lease };
+    cancelWarmUpRetry();
     if (ctx.orchestrationContext?.kind === "workflow-stage" && ctx.orchestrationContext.pendingStageDelivery !== undefined) {
-      await loadHeavy(ctx);
+      const pendingStageDelivery = ctx.orchestrationContext.pendingStageDelivery;
+      try {
+        await loadHeavy(ctx);
+      } catch (error) {
+        if (!isRecoverableIntercomDisconnect(error))
+          throw error;
+        scheduleWarmUpRetry(ctx, lease, generation, pendingStageDelivery, error);
+      }
     } else if (loadedHeavy) {
       await ensureSessionStartReplayed(loadedHeavy.heavy, lease);
     }
@@ -6260,6 +7458,7 @@ function intercom(pi, options = {}) {
     const lease = activeLease;
     const generation = ++lifecycleGeneration;
     retireLifecycleLease(lease, { event, ctx, generation });
+    cancelWarmUpRetry();
     const retiredHeavy = loadedHeavy?.heavy ?? null;
     const retiredAttempt = heavyAttempt?.lease === lease ? heavyAttempt.promise : null;
     const retiredReplay = replayAttempt?.lease === lease ? replayAttempt.promise : null;
@@ -6368,6 +7567,10 @@ function intercom(pi, options = {}) {
       if (!forwarded.completion)
         throw new Error("Intercom supervisor authorization provider is unavailable");
       return await forwarded.completion;
+    }).catch((error) => {
+      if (isRecoverableIntercomDisconnect(error))
+        return;
+      throw error;
     });
   });
   pi.events.on(PENDING_STAGE_UNDELIVERABLE_EVENT2, (payload) => {
@@ -6381,7 +7584,7 @@ function intercom(pi, options = {}) {
       handle.assertCurrent();
       return forwarded.handled === true && forwarded.completion !== undefined ? await forwarded.completion : false;
     }).catch((error) => {
-      console.error(`Intercom event relay failed (${PENDING_STAGE_UNDELIVERABLE_EVENT2}):`, error);
+      reportRelayFailure(PENDING_STAGE_UNDELIVERABLE_EVENT2, error);
       return false;
     });
   });
@@ -6406,7 +7609,7 @@ function intercom(pi, options = {}) {
       }
       completion.catch((error) => {
         rejectLazyResultRelay(pi, eventName, payload, error);
-        console.error(`Intercom event relay failed (${eventName}):`, error);
+        reportRelayFailure(eventName, error);
       });
     });
   }
@@ -6429,7 +7632,8 @@ function intercom(pi, options = {}) {
     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.
-For send, live session names and exact full session IDs remain supported. For a known workflow stage, use the exact \`<runId>:<stageKey>\` target; send messages to pending stages queue automatically.
+For send, live session names and exact full session IDs remain supported. Workflow-stage targets use \`workflow:<rootRunId>/<segment>[/<segment>...]\`; \`*\` matches one segment and \`**\` any depth. Use \`intercom list\` inside the invocation group to see live, pending, and possible future targets with queued counts. \`workflow:<rootRunId>/**\` reaches live stages now and remains sticky for every future stage until root termination; valid targets outside the known set queue with a \`notInKnownSet\` warning and settle undeliverable at terminal only if never delivered. Use \`ask\` only on live targets.
+If a \`send\`, \`ask\`, or \`reply\` fails with \`Client disconnected\`, retry that exact operation with the returned \`retryToken\`, up to three claimed attempts; omit the token for every fresh operation.
 Usage:
   intercom({ action: "list" })                    → List sessions in your group
   intercom({ action: "list", group: "name" })     → Read-only peek at another group's sessions
@@ -6438,14 +7642,15 @@ Usage:
   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 or exact pending ask
+  intercom({ action: "send", to: "session-name", message: "...", retryToken: "..." }) → Claim the exact retry returned by a retryable failure
   intercom({ action: "pending" })                                      → List unresolved inbound asks
   intercom({ action: "status" })                  → Show connection status and your group
 
 "default" is the shared group; "true" and "auto" are reserved for subagent auto-groups. Joining does not grant cross-group access; contact_supervisor remains the only cross-group path.`,
-    promptSnippet: "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.",
+    promptSnippet: "Use to coordinate with other local agent sessions in your intercom group. For a retryable send/ask/reply failure, repeat the exact operation with its returned retryToken; omit retryToken for fresh operations.",
     parameters: Type3.Object({
       action: Type3.String({ description: "Action: 'list', 'join', 'leave', 'send', 'ask', 'reply', 'pending', or 'status'" }),
-      to: Type3.Optional(Type3.String({ description: "Live session name, exact full session ID, or exact `<runId>:<stageKey>` for a known workflow stage; send messages to pending stages queue automatically (for 'send', 'ask', or targeted 'reply')" })),
+      to: Type3.Optional(Type3.String({ description: "Live session name, exact full session ID, or `workflow:<rootRunId>/<segment>[/<segment>...]` path; `*` matches one segment and `**` any depth. Send queues sticky pending/future delivery and `workflow:<rootRunId>/**` broadcasts to live and future stages; use `ask` only on live targets (for 'send', 'ask', or targeted 'reply')" })),
       message: Type3.Optional(Type3.String({ description: "Message to send (for 'send', 'ask', or 'reply' action)" })),
       attachments: Type3.Optional(Type3.Array(Type3.Object({
         type: Type3.Union([Type3.Literal("file"), Type3.Literal("snippet"), Type3.Literal("context")]),
@@ -6454,6 +7659,7 @@ Usage:
         language: Type3.Optional(Type3.String())
       }))),
       replyTo: Type3.Optional(Type3.String({ description: "Exact pending-ask message ID; disambiguates concurrent asks, including asks from one sender" })),
+      retryToken: Type3.Optional(Type3.String({ minLength: 1, maxLength: 128, description: "Opaque token returned after a retryable send/ask/reply failure. Repeat the exact same action and arguments with it; omit it for fresh operations." })),
       group: Type3.Optional(Type3.String({ description: "Group name for 'join'; read-only group filter for 'list'/'status'. 'send'/'ask' are locked to your own group." }))
     }),
     execute: (...args) => executeHeavyTool(loadHeavy, "intercom", args),