@bastani/atomic 0.9.18 → 0.9.19-alpha.10

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

@@ -12,7 +12,17 @@ var __export = (target, all) => {
       set: __exportSetter.bind(all, name)
     });
 };
-var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __esm = (fn, res, err) => () => {
+  if (fn)
+    try {
+      res = fn(fn = 0);
+    } catch (e) {
+      err = [e];
+    }
+  if (err)
+    throw err[0];
+  return res;
+};
 
 // dist/builtin/intercom/result-renderers.ts
 import { Text } from "@earendil-works/pi-tui";
@@ -80,7 +90,7 @@ function isRecoverableIntercomDisconnect(error) {
   }
   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 RECOVERABLE_DISCONNECT_MESSAGE = "Client disconnected", MAX_CAUSE_DEPTH = 8, IntercomClientDisconnectedError;
 var init_recoverable_disconnect = __esm(() => {
   IntercomClientDisconnectedError = class IntercomClientDisconnectedError extends Error {
     intercomRecoverableDisconnect = true;
@@ -91,6 +101,16 @@ var init_recoverable_disconnect = __esm(() => {
   };
 });
 
+// dist/builtin/intercom/retry-policy.ts
+var ASK_REPLY_TIMEOUT_MS, RETRY_IDENTITY_RETRY_OPPORTUNITY_MS, RETRY_IDENTITY_TTL_MS, DELIVERED_MESSAGE_TTL_MS, RECONNECT_DELAYS_MS;
+var 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;
+  RECONNECT_DELAYS_MS = [1000, 2000, 5000];
+});
+
 // dist/builtin/intercom/reconnect-backoff.ts
 function reconnectDelayMs(attempt) {
   return BACKOFF_MS[Math.min(attempt, BACKOFF_MS.length - 1)];
@@ -100,6 +120,37 @@ var init_reconnect_backoff = __esm(() => {
   BACKOFF_MS = [1000, 2000, 5000, 1e4, 30000];
 });
 
+// dist/builtin/intercom/subagent-reply-capability.ts
+function registerSubagentReplyCapability(pi, client) {
+  let signal;
+  let unbind;
+  const capability = () => {
+    if (!signal)
+      return;
+    return signal.aborted ? "terminal" : "live";
+  };
+  pi.on("session_start", (_event, ctx) => {
+    unbind?.();
+    signal = ctx.subagentPolicy?.executionEnded;
+    const current = signal;
+    const terminal = () => {
+      if (signal !== current)
+        return;
+      client()?.updatePresence({ replyCapability: "terminal" });
+    };
+    current?.addEventListener("abort", terminal, { once: true });
+    unbind = () => current?.removeEventListener("abort", terminal);
+    if (current?.aborted)
+      terminal();
+  });
+  pi.on("session_shutdown", () => {
+    unbind?.();
+    unbind = undefined;
+    signal = undefined;
+  });
+  return capability;
+}
+
 // dist/builtin/intercom/broker/framing.ts
 function writeMessage(socket, msg, callback) {
   const json = JSON.stringify(msg);
@@ -472,6 +523,7 @@ var init_client = __esm(() => {
     _supervisorSessionId = null;
     _messageSource;
     pendingSends = new PendingSendRegistry;
+    pendingReplyTargets = new Map;
     pendingGroupLists = new Map;
     pendingLists = new Map;
     pendingPresence = new Map;
@@ -676,7 +728,24 @@ var init_client = __esm(() => {
         case "registration_failed": {
           if (typeof brokerMessage.reason !== "string")
             throw new Error("Invalid registration_failed message");
-          this.emit("_registration_failed", new Error(brokerMessage.reason));
+          const refusal = new Error(brokerMessage.reason);
+          if (this._sessionId === null) {
+            this.emit("_registration_failed", refusal);
+            break;
+          }
+          this.disconnectError ??= refusal;
+          this.failPending(this.disconnectError);
+          this.socket?.destroy();
+          break;
+        }
+        case "question_target": {
+          const { messageId, attemptId, sessionId } = brokerMessage;
+          if (typeof messageId !== "string" || typeof attemptId !== "string" || typeof sessionId !== "string") {
+            throw new Error("Invalid question_target message");
+          }
+          const pending = this.pendingReplyTargets.get(attemptId);
+          if (pending?.messageId === messageId)
+            pending.bind(sessionId);
           break;
         }
         case "sessions": {
@@ -1096,14 +1165,15 @@ var init_client = __esm(() => {
         }
       });
     }
-    registerPendingStageRoute(runId, group, capability, stages, possibleStages) {
+    registerPendingStageRoute(runId, group, capability, stages, possibleStages, parent) {
       writeMessage(this.requireActiveSocket(), {
         type: "register_pending_stage_route",
         runId,
         group,
         capability,
         stages,
-        possibleStages
+        possibleStages,
+        ...parent === undefined ? {} : { parent }
       });
     }
     registerLiveWorkflowStageRoute(runId, stageKeys, capability) {
@@ -1177,7 +1247,8 @@ var init_client = __esm(() => {
         const pendingSignature = JSON.stringify({
           transportTarget: to,
           logicalSignature: buildSendSignature(options.logicalTarget ?? to, options),
-          requirePendingReply: options.requirePendingReply ?? false
+          requirePendingReply: options.requirePendingReply ?? false,
+          ...options.expectedRecipientId === undefined ? {} : { expectedRecipientId: options.expectedRecipientId }
         });
         acquired = this.pendingSends.acquire(messageId, pendingSignature, 1e4);
       } catch (error) {
@@ -1194,12 +1265,17 @@ var init_client = __esm(() => {
         source: this._messageSource,
         content: { text: options.text, attachments: options.attachments }
       };
+      if (options.onReplyTarget !== undefined) {
+        this.pendingReplyTargets.set(acquired.attempt.attemptId, { messageId, bind: options.onReplyTarget });
+      }
       try {
         writeMessage(socket, {
           type,
           to,
           ...options.logicalTarget === undefined ? {} : { logicalTarget: options.logicalTarget },
           ...options.requirePendingReply === undefined ? {} : { requirePendingReply: options.requirePendingReply },
+          ...options.expectedRecipientId === undefined ? {} : { expectedRecipientId: options.expectedRecipientId },
+          ...options.onReplyTarget === undefined ? {} : { resolveReplyTarget: true },
           message,
           attemptId: acquired.attempt.attemptId,
           ...extra
@@ -1207,6 +1283,10 @@ var init_client = __esm(() => {
       } catch (error) {
         this.pendingSends.reject(acquired.attempt, toError(error));
       }
+      const clearReplyTarget = () => {
+        this.pendingReplyTargets.delete(acquired.attempt.attemptId);
+      };
+      acquired.attempt.promise.then(clearReplyTarget, clearReplyTarget);
       return acquired.attempt.promise;
     }
     updatePresence(updates) {
@@ -1676,15 +1756,6 @@ 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;
@@ -1756,6 +1827,10 @@ class ReplyWaiterRegistry {
       ok: true,
       wait: {
         promise,
+        bindSender: (sender) => {
+          if (this.waiters.get(replyTo) === record)
+            record.from = sender;
+        },
         cancel: (error) => record.reject(error)
       }
     };
@@ -1923,6 +1998,11 @@ class ReplyTracker {
   endTurn() {
     this.currentTurnContext = null;
   }
+  restoreTurnContext() {
+    if (this.currentTurnContext)
+      this.pendingTurnContexts.unshift(this.currentTurnContext);
+    this.currentTurnContext = null;
+  }
   reset() {
     this.pendingAsks.clear();
     this.pendingTurnContexts.length = 0;
@@ -1930,22 +2010,22 @@ class ReplyTracker {
   }
   resolveReplyTarget(options, now = Date.now()) {
     this.pruneExpired(now);
-    if (options.replyTo) {
-      const exact = this.pendingAsks.get(options.replyTo);
-      if (exact) {
-        if (options.to) {
-          const resolution = resolveSessionTarget([exact.from], options.to);
-          if (resolution.kind !== "resolved")
-            throw new Error(`Pending ask "${options.replyTo}" is not from "${options.to}"`);
-        }
-        return exact;
+    if (options.replyTo !== undefined) {
+      const exact = this.pendingAsks.get(options.replyTo) ?? (this.currentTurnContext?.message.id === options.replyTo && !this.currentTurnContext.message.expectsReply ? this.currentTurnContext : undefined);
+      if (!exact)
+        throw new Error(`No reply context for "${options.replyTo}"`);
+      if (options.to !== undefined) {
+        const resolution = resolveSessionTarget([exact.from], options.to);
+        if (resolution.kind !== "resolved")
+          throw new Error(`Reply context "${options.replyTo}" is not from "${options.to}"`);
       }
+      return exact;
     }
-    if (this.currentTurnContext) {
+    if (options.to === undefined && this.currentTurnContext) {
       return this.currentTurnContext;
     }
     const pending = Array.from(this.pendingAsks.values());
-    if (options.to) {
+    if (options.to !== undefined) {
       const senders = [...new Map(pending.map((context) => [context.from.id, context.from])).values()];
       const resolution = resolveSessionTarget(senders, options.to);
       if (resolution.kind !== "resolved") {
@@ -2264,32 +2344,32 @@ function validateSupervisorInterviewReply(value, interview) {
     if (!Object.hasOwn(raw, "value")) {
       throw new Error(`responses[${index}].value is required`);
     }
-    const value2 = raw.value;
+    const value = raw.value;
     if (question.type === "single") {
-      if (typeof value2 !== "string")
+      if (typeof value !== "string")
         throw new Error(`responses[${index}].value must be a string for single questions`);
       const optionLabels = new Set(question.options?.map(interviewOptionLabel));
-      if (!optionLabels.has(value2.trim()))
+      if (!optionLabels.has(value.trim()))
         throw new Error(`responses[${index}].value must match one of the question options`);
-      responses.push({ id, value: value2.trim() });
+      responses.push({ id, value: value.trim() });
       continue;
     }
     if (question.type === "multi") {
-      if (!Array.isArray(value2) || value2.some((item) => typeof item !== "string")) {
+      if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) {
         throw new Error(`responses[${index}].value must be an array of strings for multi questions`);
       }
       const optionLabels = new Set(question.options?.map(interviewOptionLabel));
-      const selected = value2.map((item) => item.trim());
+      const selected = value.map((item) => item.trim());
       const invalid = selected.find((item) => !optionLabels.has(item));
       if (invalid)
         throw new Error(`responses[${index}].value contains an option that is not in the question options: ${invalid}`);
       responses.push({ id, value: selected });
       continue;
     }
-    if (typeof value2 !== "string") {
+    if (typeof value !== "string") {
       throw new Error(`responses[${index}].value must be a string for ${question.type} questions`);
     }
-    responses.push({ id, value: value2 });
+    responses.push({ id, value });
   }
   return { responses };
 }
@@ -2368,12 +2448,13 @@ function formatSessionLabel(session, duplicates) {
   return duplicates.has(session.name.toLowerCase()) ? `${session.name} (${session.id})` : session.name;
 }
 function formatSessionListRow(session, currentCwd, isSelf) {
-  const name = session.name || "Unnamed session";
+  const name = session.name && session.name !== session.id && session.name !== resolveIntercomPresenceName(undefined, session.id) ? ` name: ${session.name}` : "";
   const normalizedGroup = normalizeGroup(session.group);
   const groupTag = normalizedGroup !== DEFAULT_GROUP ? `group: ${normalizedGroup}` : undefined;
-  const tags = [isSelf ? "self" : session.cwd === currentCwd ? "same cwd" : undefined, session.status, groupTag].filter((tag) => Boolean(tag));
+  const capabilityTag = session.replyCapability === undefined ? undefined : `replyCapability: ${session.replyCapability}`;
+  const tags = [isSelf ? "self" : session.cwd === currentCwd ? "same cwd" : undefined, session.status, capabilityTag, groupTag].filter((tag) => Boolean(tag));
   const suffix = tags.length ? ` [${tags.join(", ")}]` : "";
-  return `• ${name} (${session.id}) — ${session.cwd} (${session.model})${suffix}`;
+  return `- \`${session.id}\`${suffix} ${session.cwd} (${session.model})${name}`;
 }
 function previewText(value, maxLength = 72) {
   if (typeof value !== "string") {
@@ -2395,7 +2476,7 @@ import { randomUUID as randomUUID3 } from "crypto";
 import { Type } from "typebox";
 import { Text as Text2 } from "@earendil-works/pi-tui";
 function registerContactSupervisorTool(pi, deps) {
-  const { childOrchestratorMetadata, ensureConnected, syncPresenceIdentity, resolveSessionTarget: resolveSessionTarget2, beginReplyWait } = deps;
+  const { childOrchestratorMetadata, ensureConnected, syncPresenceIdentity, resolveSessionTarget, beginReplyWait } = deps;
   const getMetadata = typeof childOrchestratorMetadata === "function" ? childOrchestratorMetadata : () => childOrchestratorMetadata;
   let supervisorWaitActive = false;
   let supervisorHandoffClaimed = false;
@@ -2508,13 +2589,6 @@ function registerContactSupervisorTool(pi, deps) {
               details: { yielded: true }
             };
           }
-          if (reason === "need_decision" && typeof params.message !== "string") {
-            return {
-              content: [{ type: "text", text: `Missing 'message' parameter for reason '${reason}'.` }],
-              isError: true,
-              details: { error: true }
-            };
-          }
           let connectedClient;
           try {
             connectedClient = await ensureConnected("tool");
@@ -2538,7 +2612,7 @@ function registerContactSupervisorTool(pi, deps) {
             sendTo = connectedClient.supervisorSessionId ?? metadata.supervisor.supervisorSessionId;
           } else {
             try {
-              sendTo = await resolveSessionTarget2(connectedClient, metadata.orchestratorTarget) ?? metadata.orchestratorTarget;
+              sendTo = await resolveSessionTarget(connectedClient, metadata.orchestratorTarget) ?? metadata.orchestratorTarget;
             } catch (error) {
               return {
                 content: [{ type: "text", text: `Failed to resolve supervisor target: ${getErrorMessage(error)}` }],
@@ -2607,7 +2681,7 @@ function registerContactSupervisorTool(pi, deps) {
               };
             }
             wait = admission.wait;
-            const requestText = reason === "interview_request" ? formatChildOrchestratorMessage("interview", metadata, formatSupervisorInterviewRequest(supervisorInterview, typeof params.message === "string" ? params.message : undefined)) : formatChildOrchestratorMessage("ask", metadata, params.message);
+            const requestText = reason === "interview_request" ? formatChildOrchestratorMessage("interview", metadata, formatSupervisorInterviewRequest(supervisorInterview, typeof params.message === "string" ? params.message : undefined)) : formatChildOrchestratorMessage("ask", metadata, typeof params.message === "string" ? params.message : "");
             const sendResult = await connectedClient.sendToSupervisor(sendTo, {
               messageId: questionId,
               text: requestText,
@@ -2808,6 +2882,11 @@ class RetryIdentityReservations {
     }
     this.finishRetained(reservation, "settled");
   }
+  discard(retryToken) {
+    const reservation = this.tokenReservations.get(retryToken);
+    if (reservation !== undefined)
+      this.expire(reservation);
+  }
   remainingRetries(attempt) {
     const reservation = this.currentReservation(attempt);
     return reservation === undefined ? 0 : Math.max(0, this.maxReuses - reservation.reuseCount);
@@ -2961,14 +3040,73 @@ var init_retry_identity = __esm(() => {
   };
 });
 
+// dist/builtin/intercom/tool-retry.ts
+import { setTimeout as delay2 } from "node:timers/promises";
+async function runIntercomOperation(attempt, release, signal) {
+  const deadline = new AbortController;
+  const timer = setTimeout(() => deadline.abort(), RETRY_IDENTITY_TTL_MS);
+  const operationSignal = signal === undefined ? deadline.signal : AbortSignal.any([signal, deadline.signal]);
+  let token;
+  let recovering = false;
+  let retries = 0;
+  let last = {
+    content: [{ type: "text", text: "Cancelled" }],
+    isError: true,
+    details: { error: true }
+  };
+  try {
+    for (;; ) {
+      if (operationSignal.aborted)
+        break;
+      last = await attempt(token, operationSignal);
+      const { retryToken, retryable, deliveryUncertain, ...details } = last.details;
+      last = { ...last, details };
+      if (!last.isError)
+        return last;
+      recovering ||= deliveryUncertain === true || retryable === true;
+      const nextToken = typeof retryToken === "string" ? retryToken : undefined;
+      const canRetry = nextToken !== undefined || token === undefined && retryable === true;
+      token = nextToken ?? token;
+      if (!canRetry) {
+        if (!recovering && retryable !== true)
+          return last;
+        break;
+      }
+      recovering = true;
+      if (retries >= RETRY_IDENTITY_MAX_REUSES || operationSignal.aborted)
+        break;
+      try {
+        await delay2(RECONNECT_DELAYS_MS[retries], undefined, { signal: operationSignal });
+      } catch {
+        break;
+      }
+      retries += 1;
+    }
+    const reason = operationSignal.aborted ? "Cancelled" : last.content.map(({ text }) => text).join(`
+`);
+    return {
+      content: [{
+        type: "text",
+        text: recovering ? `${reason}
+Intercom recovery stopped after ${retries} automatic retries. Delivery may already have occurred. Do not repeat this operation automatically; check with the recipient before intentionally sending a new message.` : reason
+      }],
+      isError: true,
+      details: { error: true, terminal: true, automaticRetries: retries, ...recovering ? { outcome: "unknown" } : {} }
+    };
+  } finally {
+    clearTimeout(timer);
+    if (token !== undefined)
+      release(token);
+  }
+}
+var init_tool_retry = __esm(() => {
+  init_retry_identity();
+  init_retry_policy();
+});
+
 // dist/builtin/intercom/intercom-tool.ts
 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 };
 }
@@ -3056,10 +3194,10 @@ async function resolveReplySender(client, logicalTarget, sendTarget) {
   return { kind: "unresolved" };
 }
 function formatWorkflowStageRow(stage) {
-  return `- **${stage.stageName}** — workflow stage [${stage.lifecycle.toUpperCase()}] — target: \`${stage.target}\`${stage.sessionId === undefined ? "" : ` — intercom session: ${stage.sessionId}`}`;
+  return `- \`${stage.target}\` [${stage.lifecycle.toUpperCase()}] workflow stage: ${stage.stageName}${stage.sessionId === undefined ? "" : ` session: \`${stage.sessionId}\``}`;
 }
 function formatWorkflowFutureStageRow(stage) {
-  return `- future workflow stage \`${stage.target}\` — ${stage.queuedCount} queued message${stage.queuedCount === 1 ? "" : "s"}`;
+  return `- \`${stage.target}\` [future] ${stage.queuedCount} queued message${stage.queuedCount === 1 ? "" : "s"}`;
 }
 function registerIntercomTool(pi, deps) {
   const retryIdentities = new RetryIdentityReservations({ maxEntries: deps.retryIdentityMaxEntries });
@@ -3086,7 +3224,7 @@ A valid target outside the known set queues speculatively with a \`notInKnownSet
 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.
+For send/ask/reply, Intercom retries recoverable disconnects internally up to three times with the same operation identity. Each new tool call is a new operation. If recovery ends with an unknown delivery outcome, do not repeat it automatically.
 
 Usage:
   intercom({ action: "list" })                    → List sessions visible through your groups
@@ -3098,14 +3236,13 @@ 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. For a retryable send/ask/reply failure, repeat the exact operation with its returned retryToken; omit retryToken for fresh operations.",
+    promptSnippet: "Use to coordinate with other local agent sessions that share an intercom group. Send/ask/reply retry reconnects internally; do not automatically repeat an unknown delivery outcome.",
     parameters: Type2.Object({
       action: Type2.String({
         description: "Action: 'list', 'groups', 'join', 'leave', 'send', 'ask', 'reply', 'pending', or 'status'"
@@ -3125,78 +3262,25 @@ 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;
+    async execute(_toolCallId, params, signal, _onUpdate, ctx) {
+      if ("retryToken" in params) {
         return {
-          content: [{
-            type: "text",
-            text: `Intercom not connected: ${getErrorMessage(error)}${retryTokenGuidance(retainedToken, retryPreflightRemaining ?? 0)}`
-          }],
+          content: [{ type: "text", text: "Intercom manages retries internally. Caller-supplied retry tokens are not supported; this call was not sent." }],
           isError: true,
-          details: retryErrorDetails(retainedToken)
+          details: { error: true }
         };
       }
-      syncPresenceIdentity(toolSessionId);
-      const resolveOwnGroups = (sessions) => {
-        if (Array.isArray(connectedClient.groups)) {
-          return connectedClient.groups.map((membership) => normalizeGroup(membership));
-        }
-        const self = sessions?.find((session) => session.id === connectedClient.sessionId);
-        return [...normalizeGroups(self?.groups, self?.group)];
-      };
-      const isOnlyOwnGroup = (candidate, ownGroups) => candidate !== undefined && ownGroups.length === 1 && ownGroups[0] === candidate;
-      const requestedGroup = typeof group === "string" && group.trim() ? normalizeGroup(group) : undefined;
-      if ((action === "send" || action === "ask") && requestedGroup) {
-        const ownGroups = resolveOwnGroups();
-        if (!ownGroups.includes(requestedGroup)) {
-          return {
-            content: [{ type: "text", text: `The 'group' parameter is read-only for 'list'/'status'. '${action}' is always locked to your groups (${ownGroups.join(", ")}); it cannot target group "${requestedGroup}".` }],
-            isError: true,
-            details: { error: true }
-          };
-        }
-      }
-      switch (action) {
-        case "join": {
-          let targetGroup;
-          try {
-            targetGroup = validateRuntimeGroup(group);
-          } catch (error) {
+      const toolSessionId = ctx.sessionManager.getSessionId();
+      const { action, to, message, replyTo, group } = params;
+      const attachments = params.attachments?.map((attachment) => ({ ...attachment }));
+      const executeAttempt = async (retryToken, _signal) => {
+        if (retryToken !== undefined) {
+          if (action !== "send" && action !== "ask" && action !== "reply") {
+            const error = new RetryTokenError("mismatch");
             return {
               content: [{ type: "text", text: getErrorMessage(error) }],
               isError: true,
@@ -3204,174 +3288,256 @@ one shared membership; contact_supervisor remains the only cross-group path.`,
             };
           }
           try {
-            const groups = await connectedClient.joinGroup(targetGroup);
-            deps.setJoinedGroups(groups);
-            return {
-              content: [{ type: "text", text: `Joined intercom group "${targetGroup}". Memberships: ${groups.join(", ")}.` }],
-              isError: false,
-              details: { group: targetGroup, groups }
-            };
+            retryIdentities.validateRetryToken(retryToken, toolSessionId, action);
           } catch (error) {
             return {
-              content: [{ type: "text", text: `Failed to join group: ${getErrorMessage(error)}` }],
+              content: [{ type: "text", text: getErrorMessage(error) }],
               isError: true,
               details: { error: true }
             };
           }
         }
-        case "leave": {
-          let targetGroup;
-          let homeGroup;
-          try {
-            targetGroup = typeof group === "string" && group.trim().length > 0 ? validateRuntimeGroup(group) : undefined;
-            if (targetGroup === undefined)
-              homeGroup = validateRuntimeGroup(deps.homeGroup());
-          } catch (error) {
+        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)}`
+            }],
+            isError: true,
+            details: { ...retryErrorDetails(retainedToken), retryable: isRecoverableIntercomDisconnect(error) }
+          };
+        }
+        syncPresenceIdentity(toolSessionId);
+        const resolveOwnGroups = (sessions) => {
+          if (Array.isArray(connectedClient.groups)) {
+            return connectedClient.groups.map((membership) => normalizeGroup(membership));
+          }
+          const self = sessions?.find((session) => session.id === connectedClient.sessionId);
+          return [...normalizeGroups(self?.groups, self?.group)];
+        };
+        const isOnlyOwnGroup = (candidate, ownGroups) => candidate !== undefined && ownGroups.length === 1 && ownGroups[0] === candidate;
+        const requestedGroup = typeof group === "string" && group.trim() ? normalizeGroup(group) : undefined;
+        if ((action === "send" || action === "ask") && requestedGroup) {
+          const ownGroups = resolveOwnGroups();
+          if (!ownGroups.includes(requestedGroup)) {
             return {
-              content: [{ type: "text", text: `Cannot leave intercom group: ${getErrorMessage(error)}` }],
+              content: [{ type: "text", text: `The 'group' parameter is read-only for 'list'/'status'. '${action}' is always locked to your groups (${ownGroups.join(", ")}); it cannot target group "${requestedGroup}".` }],
               isError: true,
               details: { error: true }
             };
           }
-          try {
-            let groups;
-            if (targetGroup === undefined) {
-              if (homeGroup === undefined)
-                throw new Error("Intercom home group is unavailable");
-              await connectedClient.updatePresenceAcked({ groups: [homeGroup] });
-              groups = connectedClient.groups;
-              deps.clearJoinedGroups();
-            } else {
-              groups = await connectedClient.leaveGroup(targetGroup);
+        }
+        switch (action) {
+          case "join": {
+            let targetGroup;
+            try {
+              targetGroup = validateRuntimeGroup(group);
+            } catch (error) {
+              return {
+                content: [{ type: "text", text: getErrorMessage(error) }],
+                isError: true,
+                details: { error: true }
+              };
+            }
+            try {
+              const groups = await connectedClient.joinGroup(targetGroup);
               deps.setJoinedGroups(groups);
+              return {
+                content: [{ type: "text", text: `Joined intercom group "${targetGroup}". Memberships: ${groups.join(", ")}.` }],
+                isError: false,
+                details: { group: targetGroup, groups }
+              };
+            } catch (error) {
+              return {
+                content: [{ type: "text", text: `Failed to join group: ${getErrorMessage(error)}` }],
+                isError: true,
+                details: { error: true }
+              };
             }
-            const text = targetGroup === undefined ? `Returned to home intercom membership. Memberships: ${groups.join(", ")}.` : `Left intercom group "${targetGroup}". Memberships: ${groups.join(", ")}.`;
-            return {
-              content: [{ type: "text", text }],
-              isError: false,
-              details: targetGroup === undefined ? { group: homeGroup, groups } : { groups }
-            };
-          } catch (error) {
-            return {
-              content: [{ type: "text", text: `Failed to leave group: ${getErrorMessage(error)}` }],
-              isError: true,
-              details: { error: true }
-            };
           }
-        }
-        case "groups": {
-          try {
-            const groups = await connectedClient.listGroups();
-            const lines = groups.map(({ group: groupName, sessionCount, member }) => `- ${groupName} — ${sessionCount} session${sessionCount === 1 ? "" : "s"}${member ? " [member]" : ""}`);
-            return {
-              content: [{ type: "text", text: `**Intercom groups:**
+          case "leave": {
+            let targetGroup;
+            let homeGroup;
+            try {
+              targetGroup = typeof group === "string" && group.trim().length > 0 ? validateRuntimeGroup(group) : undefined;
+              if (targetGroup === undefined)
+                homeGroup = validateRuntimeGroup(deps.homeGroup());
+            } catch (error) {
+              return {
+                content: [{ type: "text", text: `Cannot leave intercom group: ${getErrorMessage(error)}` }],
+                isError: true,
+                details: { error: true }
+              };
+            }
+            try {
+              let groups;
+              if (targetGroup === undefined) {
+                if (homeGroup === undefined)
+                  throw new Error("Intercom home group is unavailable");
+                await connectedClient.updatePresenceAcked({ groups: [homeGroup] });
+                groups = connectedClient.groups;
+                deps.clearJoinedGroups();
+              } else {
+                groups = await connectedClient.leaveGroup(targetGroup);
+                deps.setJoinedGroups(groups);
+              }
+              const text = targetGroup === undefined ? `Returned to home intercom membership. Memberships: ${groups.join(", ")}.` : `Left intercom group "${targetGroup}". Memberships: ${groups.join(", ")}.`;
+              return {
+                content: [{ type: "text", text }],
+                isError: false,
+                details: targetGroup === undefined ? { group: homeGroup, groups } : { groups }
+              };
+            } catch (error) {
+              return {
+                content: [{ type: "text", text: `Failed to leave group: ${getErrorMessage(error)}` }],
+                isError: true,
+                details: { error: true }
+              };
+            }
+          }
+          case "groups": {
+            try {
+              const groups = await connectedClient.listGroups();
+              const lines = groups.map(({ group: groupName, sessionCount, member }) => `- ${groupName} — ${sessionCount} session${sessionCount === 1 ? "" : "s"}${member ? " [member]" : ""}`);
+              return {
+                content: [{ type: "text", text: `**Intercom groups:**
 ${lines.join(`
 `)}` }],
-              isError: false,
-              details: { groups }
-            };
-          } catch (error) {
-            return {
-              content: [{ type: "text", text: `Failed to list groups: ${getErrorMessage(error)}` }],
-              isError: true,
-              details: { error: true }
-            };
-          }
-        }
-        case "list": {
-          try {
-            const mySessionId = connectedClient.sessionId;
-            const ownDirectory = await listDirectory(connectedClient);
-            const ownSessions = ownDirectory.sessions;
-            const currentSession = ownSessions.find((session) => session.id === mySessionId);
-            if (!currentSession) {
+                isError: false,
+                details: { groups }
+              };
+            } catch (error) {
               return {
-                content: [{ type: "text", text: "Current session is missing from intercom session list." }],
+                content: [{ type: "text", text: `Failed to list groups: ${getErrorMessage(error)}` }],
                 isError: true,
                 details: { error: true }
               };
             }
-            const ownGroups = resolveOwnGroups(ownSessions);
-            if (requestedGroup && !isOnlyOwnGroup(requestedGroup, ownGroups)) {
-              const peeked = await listDirectory(connectedClient, requestedGroup);
-              const rows = [
-                ...peeked.sessions.map((session) => formatSessionListRow(session, currentSession.cwd, session.id === mySessionId)),
-                ...peeked.workflowStages.map(formatWorkflowStageRow),
-                ...(peeked.workflowFutureStages ?? []).map(formatWorkflowFutureStageRow)
-              ];
-              const section = rows.length === 0 ? `**Group [${requestedGroup}] (read-only peek):**
+          }
+          case "list": {
+            try {
+              const mySessionId = connectedClient.sessionId;
+              const ownDirectory = await listDirectory(connectedClient);
+              const ownSessions = ownDirectory.sessions;
+              const currentSession = ownSessions.find((session) => session.id === mySessionId);
+              if (!currentSession) {
+                return {
+                  content: [{ type: "text", text: "Current session is missing from intercom session list." }],
+                  isError: true,
+                  details: { error: true }
+                };
+              }
+              const ownGroups = resolveOwnGroups(ownSessions);
+              if (requestedGroup && !isOnlyOwnGroup(requestedGroup, ownGroups)) {
+                const peeked = await listDirectory(connectedClient, requestedGroup);
+                const rows = [
+                  ...peeked.sessions.map((session) => formatSessionListRow(session, currentSession.cwd, session.id === mySessionId)),
+                  ...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):**
 ${rows.join(`
 `)}`;
-              return {
-                content: [{ type: "text", text: `Your groups: ${ownGroups.join(", ")}
+                return {
+                  content: [{ type: "text", text: `Your groups: ${ownGroups.join(", ")}
 
 ${section}` }],
+                  isError: false,
+                  details: {
+                    group: ownGroups.at(-1),
+                    groups: ownGroups,
+                    peekGroup: requestedGroup,
+                    workflowStages: peeked.workflowStages,
+                    ...(peeked.workflowFutureStages?.length ?? 0) === 0 ? {} : { workflowFutureStages: peeked.workflowFutureStages }
+                  }
+                };
+              }
+              const otherSessions = ownSessions.filter((session) => session.id !== mySessionId);
+              const currentSection = `**Current session** (groups: ${ownGroups.join(", ")}):
+${formatSessionListRow(currentSession, currentSession.cwd, true)}`;
+              const visibleRows = [
+                ...otherSessions.map((session) => formatSessionListRow(session, currentSession.cwd, false)),
+                ...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:**
+${visibleRows.join(`
+`)}`;
+              return {
+                content: [{ type: "text", text: `${currentSection}
+
+${otherSection}` }],
                 isError: false,
                 details: {
                   group: ownGroups.at(-1),
                   groups: ownGroups,
-                  peekGroup: requestedGroup,
-                  workflowStages: peeked.workflowStages,
-                  ...(peeked.workflowFutureStages?.length ?? 0) === 0 ? {} : { workflowFutureStages: peeked.workflowFutureStages }
+                  ...ownDirectory.workflowStages.length === 0 ? {} : { workflowStages: ownDirectory.workflowStages },
+                  ...(ownDirectory.workflowFutureStages?.length ?? 0) === 0 ? {} : { workflowFutureStages: ownDirectory.workflowFutureStages }
                 }
               };
+            } catch (error) {
+              return {
+                content: [{ type: "text", text: `Failed to list sessions: ${getErrorMessage(error)}` }],
+                isError: true,
+                details: { error: true }
+              };
             }
-            const otherSessions = ownSessions.filter((session) => session.id !== mySessionId);
-            const currentSection = `**Current session** (groups: ${ownGroups.join(", ")}):
-${formatSessionListRow(currentSession, currentSession.cwd, true)}`;
-            const visibleRows = [
-              ...otherSessions.map((session) => formatSessionListRow(session, currentSession.cwd, false)),
-              ...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:**
-${visibleRows.join(`
-`)}`;
-            return {
-              content: [{ type: "text", text: `${currentSection}
+          }
+          case "send": {
+            if (!to || !message) {
+              const errorText = retryToken === undefined ? "Missing 'to' or 'message' parameter" : getErrorMessage(new RetryTokenError("mismatch"));
+              return {
+                content: [{ type: "text", text: errorText }],
+                isError: true,
+                details: { error: true }
+              };
+            }
+            if (_signal?.aborted) {
+              return {
+                content: [{
+                  type: "text",
+                  text: "Cancelled"
+                }],
+                isError: true,
+                details: retryErrorDetails(retryToken)
+              };
+            }
+            let retryIdentity;
+            try {
+              if (retryToken === undefined) {
+                retryIdentity = retryIdentities.begin({
+                  sessionId: toolSessionId,
+                  action: "send",
+                  target: to,
+                  text: message,
+                  attachments,
+                  replyTo,
+                  expectsReply: false
+                });
+              }
+              if (retryToken === undefined && !replyTo && deps.confirmSend && ctx.hasUI) {
+                const attachmentText = attachments?.length ? formatAttachments(attachments) : "";
+                const confirmed = await ctx.ui.confirm("Send Message", `Send to "${to}":
 
-${otherSection}` }],
-              isError: false,
-              details: {
-                group: ownGroups.at(-1),
-                groups: ownGroups,
-                ...ownDirectory.workflowStages.length === 0 ? {} : { workflowStages: ownDirectory.workflowStages },
-                ...(ownDirectory.workflowFutureStages?.length ?? 0) === 0 ? {} : { workflowFutureStages: ownDirectory.workflowFutureStages }
+${message}${attachmentText}`);
+                if (!confirmed) {
+                  if (retryIdentity !== undefined)
+                    retryIdentities.release(retryIdentity);
+                  retryIdentity = undefined;
+                  return {
+                    content: [{ type: "text", text: "Message cancelled by user" }],
+                    isError: false,
+                    details: {}
+                  };
+                }
               }
-            };
-          } catch (error) {
-            return {
-              content: [{ type: "text", text: `Failed to list sessions: ${getErrorMessage(error)}` }],
-              isError: true,
-              details: { error: true }
-            };
-          }
-        }
-        case "send": {
-          if (!to || !message) {
-            const errorText = retryToken === undefined ? "Missing 'to' or 'message' parameter" : getErrorMessage(new RetryTokenError("mismatch"));
-            return {
-              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 {
-            if (retryToken === undefined) {
-              retryIdentity = retryIdentities.begin({
+              retryIdentity ??= retryIdentities.begin({
                 sessionId: toolSessionId,
                 action: "send",
                 target: to,
@@ -3379,63 +3545,79 @@ ${otherSection}` }],
                 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" }],
+                  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"
+                  }],
+                  isError: true,
+                  details: retryErrorDetails(retained.retryToken)
+                };
+              }
+              const result = await connectedClient.send(sendTo, {
+                messageId: retryIdentity.messageId,
+                logicalTarget: to,
+                text: message,
+                attachments,
+                replyTo
               });
-            }
-            if (!replyTo && deps.confirmSend && ctx.hasUI) {
-              const attachmentText = attachments?.length ? formatAttachments(attachments) : "";
-              const confirmed = await ctx.ui.confirm("Send Message", `Send to "${to}":
-
-${message}${attachmentText}`);
-              if (!confirmed) {
-                if (retryIdentity !== undefined)
-                  retryIdentities.release(retryIdentity);
+              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 cancelled by user" }],
+                  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: {}
+                  details: {
+                    messageId: result.id,
+                    delivered: false,
+                    queued: true,
+                    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}`
+                  }],
+                  isError: true,
+                  details: retryToken === undefined ? { messageId: result.id, delivered: false, reason: result.reason } : {
+                    delivered: false,
+                    reason: result.reason,
+                    ...retained.retryToken === undefined ? {} : { retryToken: retained.retryToken }
+                  }
                 };
               }
-            }
-            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", {
@@ -3444,160 +3626,81 @@ ${message}${attachmentText}`);
                 messageId: result.id,
                 timestamp: Date.now()
               });
-              const notInKnownSet = result.notInKnownSet === true;
+              if (replyTo)
+                activeReplyTracker().markReplied(replyTo);
               return {
-                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}`
-                }],
+                content: [{ type: "text", text: `Message sent to ${to}` }],
                 isError: false,
-                details: {
-                  messageId: result.id,
-                  delivered: false,
-                  queued: true,
-                  target: result.target,
-                  position: result.position,
-                  ...notInKnownSet ? { notInKnownSet: true } : {}
-                }
+                details: { messageId: result.id, delivered: true }
               };
-            }
-            if (!result.delivered) {
-              const retained = retainInconclusiveRetry(retryIdentities, retryIdentity);
-              retryIdentity = undefined;
-              const errorText = result.reason ?? "Session may not exist or has disconnected.";
+            } 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: `Message to "${to}" was not delivered: ${errorText}${retryTokenGuidance(retained.retryToken, retained.remainingRetries)}`
+                  text: `Failed to send: ${getErrorMessage(failure)}`
                 }],
                 isError: true,
-                details: retryToken === undefined ? { messageId: result.id, delivered: false, reason: result.reason } : {
-                  delivered: false,
-                  reason: result.reason,
-                  ...retained.retryToken === undefined ? {} : { retryToken: retained.retryToken }
-                }
+                details: { ...retryErrorDetails(retained?.retryToken), retryable: isRecoverableIntercomDisconnect(error) }
               };
             }
-            retryIdentities.release(retryIdentity);
-            retryIdentity = undefined;
-            pi.appendEntry("intercom_sent", {
-              to,
-              message: { text: message, attachments, replyTo },
-              messageId: result.id,
-              timestamp: Date.now()
-            });
-            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(failure)}${retryTokenGuidance(retained?.retryToken, retained?.remainingRetries ?? 0)}`
-              }],
-              isError: 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: 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 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;
-            const directParentTarget = Boolean(metadata && (to === metadata.orchestratorTarget || to === currentSupervisorId || to === metadataSupervisorId));
-            const claimParentAsk = (resolvedTargetId) => Boolean(metadata && requestParentAskHandoff(pi.events, metadata, {
-              kind: "intercom",
-              question: typeof message === "string" ? message : "",
-              attachments,
-              resolvedTargetId
-            }));
-            if (retryToken === undefined && directParentTarget && claimParentAsk(currentSupervisorId ?? metadataSupervisorId ?? to)) {
-              retryIdentities.release(retryIdentity);
-              retryIdentity = undefined;
+          case "ask": {
+            if (!to) {
+              const errorText = retryToken === undefined ? "Missing 'to' or 'message' parameter" : getErrorMessage(new RetryTokenError("mismatch"));
               return {
-                content: [{ type: "text", text: "Parent ask claimed; this child is ending for a fresh subagent start." }],
-                isError: false,
-                details: { yielded: true }
-              };
-            }
-            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${retryTokenGuidance(retained?.retryToken, retained?.remainingRetries ?? 0)}`
-                }],
+                content: [{ type: "text", text: errorText }],
                 isError: true,
-                details: retryErrorDetails(retained?.retryToken)
+                details: { error: true }
               };
             }
-            if (sendTo === connectedClient.sessionId) {
-              const retained = retryIdentity === undefined ? undefined : retainInconclusiveRetry(retryIdentities, retryIdentity);
-              retryIdentity = undefined;
+            if (_signal?.aborted) {
               return {
                 content: [{
                   type: "text",
-                  text: `Cannot message the current session${retryTokenGuidance(retained?.retryToken, retained?.remainingRetries ?? 0)}`
+                  text: "Cancelled"
                 }],
                 isError: true,
-                details: retryErrorDetails(retained?.retryToken)
+                details: retryErrorDetails(retryToken)
               };
             }
-            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)) {
+            let wait = null;
+            let retryIdentity;
+            let askDelivered = false;
+            try {
+              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;
+              const directParentTarget = Boolean(metadata && (to === metadata.orchestratorTarget || to === currentSupervisorId || to === metadataSupervisorId));
+              let parentTarget = directParentTarget;
+              const claimParentAsk = (resolvedTargetId) => Boolean(metadata && requestParentAskHandoff(pi.events, metadata, {
+                kind: "intercom",
+                question: typeof message === "string" ? message : "",
+                attachments: params.attachments,
+                resolvedTargetId
+              }));
+              if (retryToken === undefined && directParentTarget && claimParentAsk(currentSupervisorId ?? metadataSupervisorId ?? to)) {
                 retryIdentities.release(retryIdentity);
                 retryIdentity = undefined;
                 return {
@@ -3606,214 +3709,297 @@ ${message}${attachmentText}`);
                   details: { yielded: true }
                 };
               }
-            }
-            if (!message) {
-              retryIdentities.release(retryIdentity);
-              retryIdentity = undefined;
-              return {
-                content: [{ type: "text", text: "Missing 'to' or 'message' parameter" }],
-                isError: true,
-                details: { error: true }
-              };
-            }
-            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: `${text}${retryTokenGuidance(retained.retryToken, retained.remainingRetries)}`
-                }],
-                isError: 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}`));
+              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"
+                  }],
+                  isError: 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"
+                  }],
+                  isError: true,
+                  details: retryErrorDetails(retained?.retryToken)
+                };
+              }
+              if (metadata && !directParentTarget) {
+                const authoritativeParent = [currentSupervisorId, metadataSupervisorId].find((candidate) => candidate === sendTo);
+                const resolvedParent = authoritativeParent ?? await resolveTarget(connectedClient, metadata.orchestratorTarget);
+                parentTarget = resolvedParent !== null && resolvedParent === sendTo;
+                if (retryToken === undefined && parentTarget && 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,
+                    details: { yielded: true }
+                  };
+                }
+              }
+              if (!message && !parentTarget) {
+                retryIdentities.release(retryIdentity);
+                retryIdentity = undefined;
+                return {
+                  content: [{ type: "text", text: "Missing 'to' or 'message' parameter" }],
+                  isError: true,
+                  details: { error: true }
+                };
+              }
+              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.`
+                  }],
+                  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
+                  }],
+                  isError: true,
+                  details: retryErrorDetails(retained.retryToken)
+                };
+              }
+              wait = admission.wait;
+              const sendResult = await connectedClient.send(sendTo, {
+                messageId: questionId,
+                logicalTarget: to,
+                text: message ?? "",
+                attachments,
+                replyTo,
+                expectsReply: true,
+                ...parseWorkflowStageTarget(to)?.kind === "path" ? { onReplyTarget: wait.bindSender } : {}
+              });
+              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}`
+                  }],
+                  isError: true,
+                  details: {
+                    ...pendingStageAskRefusal ? {
+                      refusal: "pending_stage_ask_unsupported",
+                      recommendedAction: "send",
+                      reason: errorText
+                    } : {},
+                    ...retryErrorDetails(retained.retryToken)
+                  }
+                };
+              }
+              askDelivered = true;
               pi.appendEntry("intercom_sent", {
                 to,
                 message: { text: message, attachments, replyTo },
                 messageId: sendResult.id,
                 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", {
+                from: to,
+                message: { text: replyText, attachments: replyMessage.content.attachments },
+                messageId: replyMessage.id,
+                timestamp: replyMessage.timestamp
+              });
+              if (replyMessage.replyError !== undefined) {
+                return {
+                  content: [{ type: "text", text: `Failed: ${replyMessage.replyError}` }],
+                  isError: true,
+                  details: { error: true, replyTo: replyMessage.replyTo }
+                };
+              }
               return {
-                content: [{ type: "text", text: `Message queued for ${to}` }],
+                content: [{ type: "text", text: `**Reply from ${to}:**
+${replyText}${replyAttachments}` }],
                 isError: false,
-                details: {
-                  messageId: sendResult.id,
-                  delivered: false,
-                  queued: true,
-                  target: sendResult.target,
-                  position: sendResult.position
-                }
+                details: {}
               };
-            }
-            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.");
+            } 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: `Message to "${to}" was not delivered: ${errorText}${retryTokenGuidance(retained.retryToken, retained.remainingRetries)}`
+                  text: `Failed: ${getErrorMessage(failure)}`
                 }],
                 isError: true,
-                details: {
-                  ...pendingStageAskRefusal ? {
-                    refusal: "pending_stage_ask_unsupported",
-                    recommendedAction: "send",
-                    reason: errorText
-                  } : {},
-                  ...retryErrorDetails(retained.retryToken)
-                }
-              };
-            }
-            pi.appendEntry("intercom_sent", {
-              to,
-              message: { text: message, attachments, replyTo },
-              messageId: sendResult.id,
-              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", {
-              from: to,
-              message: { text: replyText, attachments: replyMessage.content.attachments },
-              messageId: replyMessage.id,
-              timestamp: replyMessage.timestamp
-            });
-            if (replyMessage.replyError !== undefined) {
-              return {
-                content: [{ type: "text", text: `Failed: ${replyMessage.replyError}` }],
-                isError: true,
-                details: { error: true, replyTo: replyMessage.replyTo }
+                details: { ...retryErrorDetails(retained?.retryToken), retryable: isRecoverableIntercomDisconnect(error), deliveryUncertain: askDelivered }
               };
             }
-            return {
-              content: [{ type: "text", text: `**Reply from ${to}:**
-${replyText}${replyAttachments}` }],
-              isError: false,
-              details: {}
-            };
-          } 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(failure)}${retryTokenGuidance(retained?.retryToken, retained?.remainingRetries ?? 0)}`
-              }],
-              isError: 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: errorText }],
-              isError: true,
-              details: { error: true }
-            };
           }
-          let retryIdentity;
-          try {
-            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;
+          case "reply": {
+            if (!message) {
+              const errorText = retryToken === undefined ? "Missing 'message' parameter" : getErrorMessage(new RetryTokenError("mismatch"));
               return {
-                content: [{
-                  type: "text",
-                  text: `Cannot message the current session${retryTokenGuidance(retained.retryToken, retained.remainingRetries)}`
-                }],
+                content: [{ type: "text", text: errorText }],
                 isError: true,
-                details: retryErrorDetails(retained.retryToken)
+                details: { error: true }
               };
             }
-            const replyMessageId = retryIdentity.messageId;
-            const sendReply = (targetId) => connectedClient.send(targetId, {
-              messageId: replyMessageId,
-              logicalTarget: replyLogicalTarget,
-              ...route.expectsReply ? { requirePendingReply: true } : {},
-              text: message,
-              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 (_signal?.aborted) {
+              return { content: [{ type: "text", text: "Cancelled" }], isError: true, details: retryErrorDetails(retryToken) };
             }
-            if (result.queued === true) {
+            let retryIdentity;
+            try {
+              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"
+                  }],
+                  isError: true,
+                  details: retryErrorDetails(retained.retryToken)
+                };
+              }
+              const replyMessageId = retryIdentity.messageId;
+              const sendReply = (targetId) => connectedClient.send(targetId, {
+                messageId: replyMessageId,
+                logicalTarget: replyLogicalTarget,
+                ...route.expectsReply ? { requirePendingReply: true } : {},
+                ...to === undefined && replyTo === undefined ? {} : { expectedRecipientId: route.senderId },
+                text: message,
+                attachments,
+                replyTo: route.messageId
+              });
+              let result = await sendReply(replySendTo);
+              if (to === undefined && replyTo === 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 "${displayTarget}" was not delivered: ${errorText}`
+                  }],
+                  isError: true,
+                  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;
               activeReplyTracker().markReplied(route.messageId);
@@ -3824,136 +4010,101 @@ ${replyText}${replyAttachments}` }],
                 timestamp: Date.now()
               });
               return {
-                content: [{ type: "text", text: `Reply queued for ${displayTarget}` }],
+                content: [{ type: "text", text: `Reply sent to ${displayTarget}` }],
                 isError: false,
-                details: {
-                  messageId: result.id,
-                  delivered: false,
-                  queued: true,
-                  replyTo: route.messageId,
-                  target: result.target,
-                  position: result.position
-                }
+                details: { messageId: result.id, delivered: true, replyTo: route.messageId }
               };
-            }
-            if (!result.delivered) {
-              const retained = retainInconclusiveRetry(retryIdentities, retryIdentity);
-              retryIdentity = undefined;
-              const errorText = result.reason ?? "Session may not exist or has disconnected.";
+            } 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: `Reply to "${displayTarget}" was not delivered: ${errorText}${retryTokenGuidance(retained.retryToken, retained.remainingRetries)}`
+                  text: `Failed to reply: ${getErrorMessage(failure)}`
                 }],
                 isError: true,
-                details: retryToken === undefined ? { messageId: result.id, delivered: false, reason: result.reason } : {
-                  delivered: false,
-                  reason: result.reason,
-                  ...retained.retryToken === undefined ? {} : { retryToken: retained.retryToken }
-                }
+                details: { ...retryErrorDetails(retained?.retryToken), retryable: isRecoverableIntercomDisconnect(error) }
               };
             }
-            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 sent to ${displayTarget}` }],
-              isError: false,
-              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(failure)}${retryTokenGuidance(retained?.retryToken, retained?.remainingRetries ?? 0)}`
-              }],
-              isError: true,
-              details: retryErrorDetails(retained?.retryToken)
-            };
           }
-        }
-        case "pending": {
-          const pendingAsks = activeReplyTracker().listPending();
-          if (pendingAsks.length === 0) {
+          case "pending": {
+            const pendingAsks = activeReplyTracker().listPending();
+            if (pendingAsks.length === 0) {
+              return {
+                content: [{ type: "text", text: "No unresolved inbound asks." }],
+                isError: false,
+                details: {}
+              };
+            }
+            const now = Date.now();
+            const lines = pendingAsks.map(({ from, message, receivedAt }) => {
+              const preview = message.content.text.replace(/\s+/g, " ").slice(0, 80);
+              const elapsedSeconds = Math.max(0, Math.floor((now - receivedAt) / 1000));
+              return `- ${from.name || from.id} · ${message.id} · ${elapsedSeconds}s ago · ${preview}`;
+            });
             return {
-              content: [{ type: "text", text: "No unresolved inbound asks." }],
+              content: [{ type: "text", text: `**Pending asks:**
+${lines.join(`
+`)}` }],
               isError: false,
               details: {}
             };
           }
-          const now = Date.now();
-          const lines = pendingAsks.map(({ from, message: message2, receivedAt }) => {
-            const preview = message2.content.text.replace(/\s+/g, " ").slice(0, 80);
-            const elapsedSeconds = Math.max(0, Math.floor((now - receivedAt) / 1000));
-            return `- ${from.name || from.id} · ${message2.id} · ${elapsedSeconds}s ago · ${preview}`;
-          });
-          return {
-            content: [{ type: "text", text: `**Pending asks:**
-${lines.join(`
-`)}` }],
-            isError: false,
-            details: {}
-          };
-        }
-        case "status": {
-          try {
-            const mySessionId = connectedClient.sessionId;
-            const sessions = await connectedClient.listSessions();
-            const ownGroups = resolveOwnGroups(sessions);
-            const selectedGroup = isOnlyOwnGroup(requestedGroup, ownGroups) ? undefined : requestedGroup;
-            const selectedGroupSessions = selectedGroup === undefined ? undefined : await connectedClient.listSessions(selectedGroup);
-            const selectedSection = selectedGroupSessions === undefined ? "" : `
+          case "status": {
+            try {
+              const mySessionId = connectedClient.sessionId;
+              const sessions = await connectedClient.listSessions();
+              const ownGroups = resolveOwnGroups(sessions);
+              const selectedGroup = isOnlyOwnGroup(requestedGroup, ownGroups) ? undefined : requestedGroup;
+              const selectedGroupSessions = selectedGroup === undefined ? undefined : await connectedClient.listSessions(selectedGroup);
+              const selectedSection = selectedGroupSessions === undefined ? "" : `
 Selected group [${selectedGroup}]: ${selectedGroupSessions.length} session(s)`;
-            return {
-              content: [{
-                type: "text",
-                text: `**Intercom Status:**
+              return {
+                content: [{
+                  type: "text",
+                  text: `**Intercom Status:**
 Connected: Yes
 Session ID: ${mySessionId}
 Groups: ${ownGroups.join(", ")}
 Active visible sessions: ${sessions.length}${selectedSection}`
-              }],
-              isError: false,
-              details: {
-                group: ownGroups.at(-1),
-                groups: ownGroups,
-                ...selectedGroup === undefined ? {} : { selectedGroup, selectedGroupSessionCount: selectedGroupSessions?.length ?? 0 }
-              }
-            };
-          } catch (error) {
+                }],
+                isError: false,
+                details: {
+                  group: ownGroups.at(-1),
+                  groups: ownGroups,
+                  ...selectedGroup === undefined ? {} : { selectedGroup, selectedGroupSessionCount: selectedGroupSessions?.length ?? 0 }
+                }
+              };
+            } catch (error) {
+              return {
+                content: [{ type: "text", text: `Failed to get status: ${getErrorMessage(error)}` }],
+                isError: true,
+                details: { error: true }
+              };
+            }
+          }
+          default:
             return {
-              content: [{ type: "text", text: `Failed to get status: ${getErrorMessage(error)}` }],
+              content: [{ type: "text", text: `Unknown action: ${action}` }],
               isError: true,
               details: { error: true }
             };
-          }
         }
-        default:
-          return {
-            content: [{ type: "text", text: `Unknown action: ${action}` }],
-            isError: true,
-            details: { error: true }
-          };
-      }
+      };
+      if (action !== "send" && action !== "ask" && action !== "reply")
+        return executeAttempt(undefined, signal);
+      return runIntercomOperation(executeAttempt, (token) => retryIdentities.discard(token), signal);
     },
     renderCall(args, theme) {
       const action = typeof args.action === "string" ? args.action : "intercom";
@@ -3985,6 +4136,7 @@ var init_intercom_tool = __esm(() => {
   init_workflow_stage_target();
   init_recoverable_disconnect();
   init_retry_identity();
+  init_tool_retry();
 });
 
 // dist/builtin/intercom/ui/compose.ts
@@ -4375,7 +4527,10 @@ var init_overlay = __esm(() => {
 function registerIntercomLifecycle(pi, deps) {
   const activeReplyTracker = () => typeof deps.replyTracker === "function" ? deps.replyTracker() : deps.replyTracker;
   let hasActiveSession = false;
+  let unbindStageClose;
   async function cleanupRuntime(reason) {
+    unbindStageClose?.();
+    unbindStageClose = undefined;
     deps.setRuntimeStarted(false);
     deps.setShuttingDown(true);
     deps.setDisposed(true);
@@ -4426,6 +4581,12 @@ function registerIntercomLifecycle(pi, deps) {
     deps.setSessionStartedAt(Date.now());
     deps.setAgentRunning(false);
     deps.activeTools.clear();
+    const stage = ctx.orchestrationContext;
+    const closeSignal = stage?.kind === "workflow-stage" ? stage.messageAdmission?.boundary?.closeSignal : undefined;
+    closeSignal?.addEventListener("abort", deps.syncPresenceStatus, { once: true });
+    unbindStageClose = () => closeSignal?.removeEventListener("abort", deps.syncPresenceStatus);
+    if (closeSignal?.aborted)
+      deps.syncPresenceStatus();
   });
   pi.on("session_shutdown", async () => {
     if (!hasActiveSession)
@@ -4433,10 +4594,15 @@ function registerIntercomLifecycle(pi, deps) {
     hasActiveSession = false;
     await cleanupRuntime("Session shutting down");
   });
-  pi.on("turn_end", () => {
+  pi.on("turn_end", (event) => {
     if (!deps.getLiveContext())
       return;
-    activeReplyTracker().endTurn();
+    const message = event.message;
+    const cancelledBeforeReply = message?.role === "assistant" && message.stopReason === "aborted" && message.content?.length === 0;
+    if (cancelledBeforeReply)
+      activeReplyTracker().restoreTurnContext();
+    else
+      activeReplyTracker().endTurn();
     deps.scheduleInboundFlush();
   });
   pi.on("agent_start", () => {
@@ -4564,12 +4730,12 @@ function prepareDurableAuthority(storagePath) {
   if (databaseExists !== keyExists)
     return;
   if (!databaseExists) {
-    const key2 = randomBytes(AUTHORITY_KEY_BYTES);
-    writeFileSync2(keyPath, key2, { flag: "wx", mode: 384 });
+    const key = randomBytes(AUTHORITY_KEY_BYTES);
+    writeFileSync2(keyPath, key, { flag: "wx", mode: 384 });
     const databaseDescriptor = openSync2(storagePath, "wx", 384);
     closeSync2(databaseDescriptor);
     restrictExistingAuthorityArtifacts(storagePath, keyPath);
-    return key2;
+    return key;
   }
   const key = readFileSync3(keyPath);
   if (key.length !== AUTHORITY_KEY_BYTES)
@@ -4878,7 +5044,7 @@ function parseBarrier(value) {
     return null;
   if (typeof record.terminalAt !== "number" || !Number.isFinite(record.terminalAt))
     return null;
-  if (record.source !== "detached-notify" && record.source !== "result-relay")
+  if (record.source !== "detached-notify" && record.source !== "result-relay" && record.source !== "owner-task")
     return null;
   if (!Array.isArray(record.sourceSessionTargets))
     return null;
@@ -4954,11 +5120,17 @@ function registerTerminalOrderingBarrier(pi, options) {
       envelope.completion = currentOwner;
       return;
     }
-    const drainedTargets = drainedTargetsByTerminal.get(terminalKey) ?? new Set;
+    const drainedTargets = barrier.source === "owner-task" ? new Set : drainedTargetsByTerminal.get(terminalKey) ?? new Set;
     const pendingTargets = barrier.sourceSessionTargets.filter((target) => !drainedTargets.has(target));
     if (pendingTargets.length === 0)
       return;
     const claim = options.queue.claimOrdinarySourceTargets(barrier.runId, pendingTargets, barrier.terminalAt);
+    const deliverPrelude = (entry) => {
+      if (!claim.isCurrent() || options.isCurrent?.() === false) {
+        throw new Error("Intercom terminal delivery owner retired");
+      }
+      return options.deliver(entry, "prelude");
+    };
     const ownership = Promise.withResolvers();
     ownership.promise.catch(() => {});
     inFlightByTerminal.set(terminalKey, ownership.promise);
@@ -4968,7 +5140,7 @@ function registerTerminalOrderingBarrier(pi, options) {
       ownership.reject(error);
     };
     const finish = () => {
-      if (barrier.dispatch && options.toMessage || claim.entries.length > 0) {
+      if (barrier.source !== "owner-task" && (barrier.dispatch && options.toMessage || claim.entries.length > 0)) {
         for (const target of pendingTargets)
           drainedTargets.add(target);
         drainedTargetsByTerminal.set(terminalKey, drainedTargets);
@@ -5019,7 +5191,7 @@ function registerTerminalOrderingBarrier(pi, options) {
       let delivered;
       let deliveredAsync;
       try {
-        delivered = options.deliver(claim.entries[index], "prelude");
+        delivered = deliverPrelude(claim.entries[index]);
         deliveredAsync = isPromiseLike(delivered);
       } catch (error) {
         if (barrier.owner)
@@ -5035,7 +5207,7 @@ function registerTerminalOrderingBarrier(pi, options) {
         try {
           await delivered;
           for (current = index + 1;current < claim.entries.length; current++) {
-            await options.deliver(claim.entries[current], "prelude");
+            await deliverPrelude(claim.entries[current]);
           }
           finish();
         } catch (error) {
@@ -5111,7 +5283,7 @@ async function dispatchRelayFallback(pi, prefix, terminalMessage, stageAdmission
   }
 }
 function registerSubagentRelay(pi, deps) {
-  const { getLiveContext, currentSessionTargetMatches, sendIncomingMessage, ensureConnected, resolveSessionTarget: resolveSessionTarget2 } = deps;
+  const { getLiveContext, currentSessionTargetMatches, sendIncomingMessage, ensureConnected, resolveSessionTarget } = deps;
   const localDeliveries = deps.localDeliveryAuthority ?? new DeliveredMessageCache;
   function deliverLocalSubagentRelayMessage(sender, status, messageText, terminalBarrier, requestId) {
     const now = Date.now();
@@ -5268,7 +5440,7 @@ ${messageText}`,
       let target;
       try {
         activeClient = await ensureConnected("background");
-        target = await resolveSessionTarget2(activeClient, parsed.to) ?? parsed.to;
+        target = await resolveSessionTarget(activeClient, parsed.to) ?? parsed.to;
       } catch (error) {
         if (!relayStillLive()) {
           acknowledgeResult(options, parsed.requestId, false, error);
@@ -5522,7 +5694,7 @@ function createIncomingMessageSender(input) {
     if (!input.canDeliver(generation)) {
       return Promise.reject(new Error("Intercom session retired before inbound delivery"));
     }
-    if (delivery === "trigger" && trackReplyContext) {
+    if ((delivery === "trigger" || delivery === "interrupt") && trackReplyContext) {
       input.queueTurnContext(turnContext ?? { from: entry.from, message: entry.message, receivedAt: Date.now() });
     }
     const baseOptions = {
@@ -5530,7 +5702,7 @@ function createIncomingMessageSender(input) {
       persistWhenStreaming: true,
       ...stageAdmissionBarrier ? { stageAdmissionBarrier } : {}
     };
-    const options = delivery === "trigger" ? { ...baseOptions, triggerTurn: true } : delivery === "followUp" ? { ...baseOptions, deliverAs: "followUp" } : baseOptions;
+    const options = delivery === "interrupt" ? { ...baseOptions, triggerTurn: true, deliverAs: "interrupt" } : delivery === "trigger" ? { ...baseOptions, triggerTurn: true } : delivery === "followUp" ? { ...baseOptions, deliverAs: "followUp" } : baseOptions;
     return Promise.resolve(input.pi.sendMessage(buildIncomingCustomMessage(entry), options));
   };
 }
@@ -5545,6 +5717,20 @@ function framePreStartPendingStageMessage(entry) {
 
 Sent: ${framePendingStageTimestamp(entry.message.timestamp)}
 
+${entry.bodyText}`
+  };
+}
+function isDeliveryFeedback(message) {
+  return Boolean(message.replyTo) && message.replyError !== undefined;
+}
+function frameDeliveryFeedback(entry) {
+  return {
+    ...entry,
+    replyCommand: undefined,
+    bodyText: `**Intercom delivery failed**
+
+Sent: ${framePendingStageTimestamp(entry.message.timestamp)}
+
 ${entry.bodyText}`
   };
 }
@@ -5566,6 +5752,7 @@ ${entry.bodyText}`,
 // dist/builtin/intercom/inbound-idle-queue.ts
 class InboundIdleQueue {
   entries = [];
+  generation = 0;
   get size() {
     return this.entries.length;
   }
@@ -5589,6 +5776,7 @@ class InboundIdleQueue {
   }
   claimOrdinarySourceTargets(runId, sourceSessionTargets, terminalAt = Number.POSITIVE_INFINITY) {
     const targets = new Set(sourceSessionTargets);
+    const generation = this.generation;
     const original = this.entries;
     const legacyIdsByName = new Map;
     for (const entry of original) {
@@ -5618,8 +5806,9 @@ class InboundIdleQueue {
     let settled = false;
     return {
       entries: selected,
+      isCurrent: () => generation === this.generation,
       rollbackFrom: (index) => {
-        if (settled)
+        if (settled || generation !== this.generation)
           return;
         settled = true;
         const undelivered = new Set(selected.slice(index));
@@ -5629,6 +5818,7 @@ class InboundIdleQueue {
     };
   }
   clear() {
+    this.generation++;
     this.entries = [];
   }
 }
@@ -5864,13 +6054,15 @@ function retryStableDelivery(options) {
 function admitWorkflowStageInbound(ctx, deliver, firstRefusal, onAdmissionFailure) {
   if (ctx.orchestrationContext?.kind !== "workflow-stage")
     return false;
+  const boundary = ctx.orchestrationContext.messageAdmission?.boundary;
+  const run = (barrier) => boundary?.runMessageDelivery(() => deliver(barrier), () => deliver(), true) ?? Promise.resolve(deliver(barrier));
   try {
     let busy = false;
     try {
       busy = ctx.isIdle?.() === false;
     } catch {}
     if (!busy || !firstRefusal)
-      return Promise.resolve(deliver());
+      return run();
     let firstRefusalPromise;
     const admissionBarrier = () => {
       firstRefusalPromise ??= (async () => {
@@ -5883,12 +6075,29 @@ function admitWorkflowStageInbound(ctx, deliver, firstRefusal, onAdmissionFailur
       })();
       return firstRefusalPromise;
     };
-    return Promise.resolve(deliver(admissionBarrier));
+    return run(admissionBarrier);
   } catch (error) {
     return Promise.reject(error);
   }
 }
 
+// dist/builtin/intercom/active-session-admission.ts
+function admitActiveSessionInbound(ctx, deliver, firstRefusal, onAdmissionFailure) {
+  const executionEnded = ctx.subagentPolicy?.executionEnded;
+  if (executionEnded !== undefined) {
+    if (executionEnded.aborted || ctx.subagentPolicy?.messageAdmission?.isOpen() === false) {
+      return Promise.reject(new Error("Subagent execution is terminal and cannot accept messages"));
+    }
+    try {
+      return ctx.subagentPolicy?.messageAdmission?.run(deliver) ?? Promise.resolve(deliver());
+    } catch (error) {
+      return Promise.reject(error);
+    }
+  }
+  return admitWorkflowStageInbound(ctx, deliver, firstRefusal, onAdmissionFailure);
+}
+var init_active_session_admission = () => {};
+
 // dist/builtin/intercom/workflow-reply-tracker.ts
 function bindWorkflowReplyTracker(ctx, current) {
   const state = ctx.orchestrationContext?.messageAdmission?.extensionState;
@@ -5942,7 +6151,7 @@ async function settleOpenStageDeliveryFailure(input, error) {
     input.admission.release(input.reservation, failure);
     return;
   }
-  const delivered = await sendWorkflowStageDeliveryFailure(input.entry, failure, input.tracker, input.currentClient, () => input.currentClient()?.isConnected() === true, "Running workflow stage could not admit intercom ask");
+  const delivered = await sendWorkflowStageDeliveryFailure(input.entry, failure, input.tracker, input.currentClient, () => input.currentClient()?.isConnected() === true, input.failurePrefix ?? "Running workflow stage could not admit intercom ask");
   if (delivered)
     input.commit();
   else
@@ -5954,7 +6163,7 @@ function routeClosedWorkflowStageMessage(entry, admission, tracker, waiter, deli
   const sourceRunId = entry.message.source?.subagentRunId;
   if (sourceRunId !== undefined && ownsSubagentRun(sourceRunId))
     return;
-  if (entry.message.expectsReply !== true) {
+  if (entry.message.expectsReply !== true && !isDeliveryFeedback(entry.message)) {
     retryStableDelivery({ deliver, isCurrent }).catch(() => {});
     return;
   }
@@ -5965,6 +6174,14 @@ function routeClosedWorkflowStageMessage(entry, admission, tracker, waiter, deli
     admission.commit(admitted.reservation);
     return;
   }
+  if (isDeliveryFeedback(entry.message)) {
+    retryStableDelivery({ deliver, isCurrent }).then(() => {
+      admission.commit(admitted.reservation);
+    }, (error) => {
+      admission.release(admitted.reservation, error instanceof Error ? error : new Error(String(error)));
+    });
+    return;
+  }
   const replyContext = tracker.recordIncomingMessage(entry.from, entry.message);
   tracker.queueTurnContext(replyContext);
   const delivery = invoke(deliver);
@@ -6050,6 +6267,7 @@ function piIntercomExtension(pi, testOverrides = {}) {
   };
   let client = null;
   let clientRegistrationGroup = null;
+  const replyCapability = registerSubagentReplyCapability(pi, () => client);
   const config = loadConfig();
   const legacyChildOrchestratorMetadata = readChildOrchestratorMetadata();
   let runtimeContext = null;
@@ -6118,7 +6336,8 @@ function piIntercomExtension(pi, testOverrides = {}) {
   }
   function currentStatus() {
     const activeToolName = activeTools.values().next().value;
-    const lifecycleStatus = activeToolName ? `tool:${activeToolName}` : agentRunning ? "thinking" : "idle";
+    const stage = getLiveContext()?.orchestrationContext;
+    const lifecycleStatus = stage?.kind === "workflow-stage" && stage.messageAdmission?.isOpen() === false ? `closed · reply: ${stage.lateMessageRouter === undefined ? "unavailable" : "post-mortem only"}` : activeToolName ? `tool:${activeToolName}` : agentRunning ? "thinking" : "idle";
     return config.status ? `${lifecycleStatus} · ${config.status}` : lifecycleStatus;
   }
   function resolveSessionHomeGroup() {
@@ -6156,6 +6375,7 @@ function piIntercomExtension(pi, testOverrides = {}) {
       startedAt: sessionStartedAt,
       lastActivity: Date.now(),
       status: currentStatus(),
+      replyCapability: replyCapability(),
       groups: [...currentIntercomGroups()],
       group: currentIntercomGroup()
     };
@@ -6257,14 +6477,20 @@ function piIntercomExtension(pi, testOverrides = {}) {
     const bodyText = `${message.content.text}${attachmentText}`;
     const replyCommand = config.replyHint && message.expectsReply ? `intercom({ action: "reply", message: "..." })` : undefined;
     const rawEntry = { from, message, replyCommand, bodyText, ...channel ? { channel } : {} };
-    const entry = receivedBeforeStageStart ? framePreStartPendingStageMessage(rawEntry) : rawEntry;
+    const framedEntry = isDeliveryFeedback(message) ? frameDeliveryFeedback(rawEntry) : rawEntry;
+    const entry = receivedBeforeStageStart ? framePreStartPendingStageMessage(framedEntry) : framedEntry;
     if (receivedBeforeStageStart) {
       return sendIncomingMessage(entry, "prelude", messageGeneration, 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)), (runId) => stageAdmission.boundary.ownsSubagentRun(runId));
+      routeClosedWorkflowStageMessage(entry, inboundDeliveries, replyTracker, replyWaiters.pending(), () => {
+        if (message.expectsReply === true && liveContext.orchestrationContext?.lateMessageRouter === undefined) {
+          throw new Error("Workflow stage is closed and cannot reply because post-mortem routing is unavailable. Contact a live stage or start new work with explicit context.");
+        }
+        return sendIncomingMessage(entry, isDeliveryFeedback(message) ? "prelude" : "trigger", messageGeneration, false);
+      }, () => client, () => Boolean(getLiveContext(liveContext, messageGeneration)), (runId) => stageAdmission.boundary.ownsSubagentRun(runId));
       return;
     }
     const admission = inboundDeliveries.admit(from, message);
@@ -6275,6 +6501,12 @@ function piIntercomExtension(pi, testOverrides = {}) {
       inboundDeliveries.commit(reservation);
       return;
     }
+    if (isDeliveryFeedback(message)) {
+      return retryStableDelivery({
+        deliver: () => sendIncomingMessage(entry, "prelude", messageGeneration, false),
+        isCurrent: () => Boolean(getLiveContext(liveContext, messageGeneration))
+      }).then(() => inboundDeliveries.commit(reservation), (error) => inboundDeliveries.release(reservation, toError3(error)));
+    }
     const replyContext = replyTracker.recordIncomingMessage(from, message);
     const commit = () => {
       inboundDeliveries.commit(reservation);
@@ -6286,17 +6518,18 @@ function piIntercomExtension(pi, testOverrides = {}) {
       tracker: replyTracker,
       replyContext,
       currentClient: () => client,
-      commit
+      commit,
+      failurePrefix: liveContext.subagentPolicy?.executionEnded === undefined ? undefined : "Subagent could not admit intercom ask"
     });
-    const stageDelivery = admitWorkflowStageInbound(liveContext, (admissionBarrier) => {
+    const activeDelivery = admitActiveSessionInbound(liveContext, (admissionBarrier) => {
       replyTracker.queueTurnContext(replyContext);
       return retryStableDelivery({
-        deliver: () => sendIncomingMessage(entry, "trigger", messageGeneration, false, undefined, admissionBarrier),
-        isCurrent: () => Boolean(getLiveContext(liveContext, messageGeneration))
+        deliver: () => sendIncomingMessage(entry, "interrupt", messageGeneration, false, undefined, admissionBarrier),
+        isCurrent: () => Boolean(getLiveContext(liveContext, messageGeneration)) && liveContext.subagentPolicy?.executionEnded?.aborted !== true && liveContext.subagentPolicy?.messageAdmission?.isOpen() !== false
       });
     }, () => foregroundDetachHandoff.claim(from, message, messageGeneration, () => Boolean(getLiveContext(liveContext, messageGeneration))), release);
-    if (stageDelivery !== false) {
-      stageDelivery.then(commit, release);
+    if (activeDelivery !== false) {
+      activeDelivery.then(commit, release);
       return;
     }
     return (async () => {
@@ -6306,14 +6539,16 @@ function piIntercomExtension(pi, testOverrides = {}) {
           release(new Error("Intercom session retired before inbound delivery"));
           return;
         }
-        if (!activeContext.isIdle()) {
+        if (!activeContext.isIdle() && !activeContext.getAgentTaskHost?.().hasActiveTaskWaits) {
           if (!activeContext.hasUI) {
             const activeClient = client;
             if (!message.replyTo && activeClient?.isConnected()) {
               try {
+                const refusal = "Message not accepted: recipient was busy in non-interactive mode. Its task was not interrupted.";
                 const result = await activeClient.send(from.id, {
-                  text: "This agent is running in non-interactive mode and cannot respond to intercom messages while it is working. It will continue its current task and exit when done.",
-                  replyTo: message.id
+                  text: refusal,
+                  replyTo: message.id,
+                  replyError: refusal
                 });
                 if (result.delivered && getLiveContext(liveContext, messageGeneration)) {
                   replyTracker.markReplied(message.id);
@@ -6347,6 +6582,13 @@ function piIntercomExtension(pi, testOverrides = {}) {
           });
           return;
         }
+        if (!activeContext.isIdle()) {
+          const disposition = await foregroundDetachHandoff.claim(from, message, messageGeneration, () => Boolean(getLiveContext(liveContext, messageGeneration)));
+          if (disposition === "abandoned") {
+            release(new Error("Intercom session retired during foreground-owner admission"));
+            return;
+          }
+        }
         replyTracker.queueTurnContext(replyContext);
         await retryStableDelivery({ deliver: () => sendIncomingMessage(entry, "trigger", messageGeneration, false), isCurrent: () => Boolean(getLiveContext(liveContext, messageGeneration)) });
         commit();
@@ -6581,7 +6823,8 @@ function piIntercomExtension(pi, testOverrides = {}) {
       pendingStageRouteClients.set(runId, state);
     if (state.client?.isConnected()) {
       state.route = route;
-      state.client.registerPendingStageRoute(runId, normalizeGroup(route.group), route.capability, route.stages, route.possibleStages);
+      state.client.registerPendingStageRoute(runId, normalizeGroup(route.group), route.capability, route.stages, route.possibleStages, route.parent);
+      await state.client.listSessions();
       return;
     }
     if (state.promise) {
@@ -6593,12 +6836,12 @@ function piIntercomExtension(pi, testOverrides = {}) {
       const nextClient = new IntercomClient(`${currentSessionId}:pending-stage-route:${runId}`);
       state.client = nextClient;
       attachPendingStageRouteClientHandlers(runId, state, nextClient);
-      await nextClient.connect({ ...buildRegistration(), name: undefined, groups: [normalizeGroup(route.group)], group: normalizeGroup(route.group) }, undefined, undefined, readSubagentMessageSource(runtimeContext?.subagentPolicy));
+      await nextClient.connect({ ...buildRegistration(), recipientPurpose: "control", name: undefined, groups: [normalizeGroup(route.group)], group: normalizeGroup(route.group) }, undefined, undefined, readSubagentMessageSource(runtimeContext?.subagentPolicy));
       if (!pendingStageRouteClientIsCurrent(runId, state, contextAtStart, generationAtStart)) {
         await nextClient.disconnect();
         throw new Error("Intercom runtime no longer active");
       }
-      nextClient.registerPendingStageRoute(runId, normalizeGroup(route.group), route.capability, route.stages, route.possibleStages);
+      nextClient.registerPendingStageRoute(runId, normalizeGroup(route.group), route.capability, route.stages, route.possibleStages, route.parent);
       await nextClient.listSessions();
       if (!pendingStageRouteClientIsCurrent(runId, state, contextAtStart, generationAtStart)) {
         await nextClient.disconnect();
@@ -6646,7 +6889,8 @@ 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, route.possibleStages);
+      activeClient.registerPendingStageRoute(runId, routeGroup, route.capability, route.stages, route.possibleStages, route.parent);
+      await activeClient.listSessions();
       return;
     }
     await ensurePendingStageRouteClient(runId, { ...route, group: routeGroup });
@@ -6672,15 +6916,16 @@ function piIntercomExtension(pi, testOverrides = {}) {
       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), resolveSessionHomeGroup());
+        await nextClient.connect(buildRegistration(), childMetadata?.supervisor, supervisorAuthorizations.ownerToken, readSubagentMessageSource(runtimeContext?.subagentPolicy), resolveSessionHomeGroup());
         clientRegistrationGroup = resolveSessionHomeGroup();
+        if (replyCapability() === "terminal")
+          nextClient.updatePresence({ replyCapability: "terminal" });
         await supervisorAuthorizations.restore(nextClient);
         for (const [runId, route] of pendingStageRoutes) {
           await registerPendingStageRoute(nextClient, runId, route);
@@ -6734,7 +6979,8 @@ function piIntercomExtension(pi, testOverrides = {}) {
       group: payload.group,
       capability: payload.capability,
       ...payload.stages === undefined ? {} : { stages: payload.stages },
-      ...payload.possibleStages === undefined ? {} : { possibleStages: payload.possibleStages }
+      ...payload.possibleStages === undefined ? {} : { possibleStages: payload.possibleStages },
+      ...payload.parent === undefined ? {} : { parent: payload.parent }
     });
     const completion = ensureConnected("background").then((activeClient) => registerPendingStageRoute(activeClient, payload.runId, payload));
     payload.completion = completion;
@@ -6919,6 +7165,7 @@ var init_index_heavy = __esm(() => {
   init_terminal_ordering_barrier();
   init_inbound_message_admission();
   init_late_stage_message_router();
+  init_active_session_admission();
   init_workflow_reply_tracker();
   init_closed_workflow_stage_message();
   init_group();
@@ -6936,14 +7183,49 @@ var init_index_heavy = __esm(() => {
 });
 
 // dist/builtin/intercom/index.ts
-init_result_renderers();
 import { APP_NAME as APP_NAME2, getEnvValue } from "@bastani/atomic";
 import { Text as Text4 } from "@earendil-works/pi-tui";
 import { Type as Type3 } from "typebox";
 
+// dist/builtin/intercom/context-owner.ts
+var CONTEXT_OWNERS_KEY = Symbol.for("atomic-coding-agent/extension-context-owners@1");
+function getExtensionContextOwner(context) {
+  const owners = globalThis[CONTEXT_OWNERS_KEY];
+  return owners?.get(context) ?? context;
+}
+
+// dist/builtin/intercom/index.ts
+init_result_renderers();
+
 // dist/builtin/intercom/lazy-tool-execution.ts
+init_recoverable_disconnect();
+init_retry_policy();
+import { setTimeout as delay } from "node:timers/promises";
 async function executeHeavyTool(loadHeavy, name, args) {
-  const handle = await loadHeavy(args[4]);
+  const params = args[1];
+  const recoverInitialization = name === "intercom" && ["send", "ask", "reply"].includes(params.action ?? "");
+  let handle;
+  let retries = 0;
+  for (;; ) {
+    if (recoverInitialization && args[2]?.aborted)
+      return initializationFailure("Cancelled", retries);
+    try {
+      handle = await loadHeavy(args[4]);
+      break;
+    } catch (error) {
+      if (!recoverInitialization || !isRecoverableIntercomDisconnect(error))
+        throw error;
+      const delayMs = RECONNECT_DELAYS_MS[retries];
+      if (delayMs === undefined)
+        return initializationFailure("Client disconnected", retries);
+      try {
+        await delay(delayMs, undefined, { signal: args[2] });
+      } catch {
+        return initializationFailure("Cancelled", retries);
+      }
+      retries += 1;
+    }
+  }
   handle.assertCurrent();
   const tool = handle.heavy.tools.get(name);
   if (!tool?.execute)
@@ -6952,6 +7234,13 @@ async function executeHeavyTool(loadHeavy, name, args) {
   handle.assertCurrent();
   return result;
 }
+function initializationFailure(reason, retries) {
+  return {
+    content: [{ type: "text", text: `${reason}. Intercom initialization stopped after ${retries} automatic retries. This operation was not sent.` }],
+    isError: true,
+    details: { error: true, terminal: true, automaticRetries: retries, outcome: "not_sent" }
+  };
+}
 async function runHeavyCommand(loadHeavy, args, ctx) {
   const handle = await loadHeavy(ctx);
   handle.assertCurrent();
@@ -7169,10 +7458,37 @@ function renderHeavyToolResult(loadedHeavy, name, args) {
     return renderer(...args);
   return renderIntercomToolResult(name, args);
 }
-function reportRelayFailure(eventName, error) {
+function diagnosticDetail(error) {
+  try {
+    return String(error instanceof Error ? error.message : error);
+  } catch {
+    return "Unprintable error";
+  }
+}
+function captureDiagnosticRoute(ctx) {
+  try {
+    return ctx?.hasUI && ctx.mode === "tui" ? ctx : "console";
+  } catch {
+    return "silent";
+  }
+}
+function reportDiagnostic(route, message, error, level, consoleMessage = message) {
+  if (route === "console") {
+    console.error(consoleMessage, error);
+    return;
+  }
+  if (route === "silent")
+    return;
+  try {
+    route.ui.notify(message, level);
+  } catch {}
+}
+function reportRelayFailure(route, eventName, error) {
   if (isRecoverableIntercomDisconnect(error))
     return;
-  console.error(`Intercom event relay failed (${eventName}):`, error);
+  const prefix = `Intercom event relay failed (${eventName}):`;
+  const detail = diagnosticDetail(error);
+  reportDiagnostic(route, `${prefix} ${detail}`, error, "error", prefix);
 }
 var WARM_UP_RETRY_ATTEMPTS = 5;
 function intercom(pi, options = {}) {
@@ -7180,6 +7496,7 @@ function intercom(pi, options = {}) {
   let heavyAttempt = null;
   let loadedHeavy = null;
   let sessionSnapshot = null;
+  let shutdownDiagnosticRoute;
   let lifecycleGeneration = 0;
   let nextLeaseId = 1;
   let activeLease = createLifecycleLease(nextLeaseId++);
@@ -7263,6 +7580,8 @@ function intercom(pi, options = {}) {
     await promise;
   }
   async function loadHeavy(ctx) {
+    let diagnosticRoute = captureDiagnosticRoute(ctx);
+    let diagnosticOwner = ctx && getExtensionContextOwner(ctx);
     const lease = activeLease;
     if (lease.retired)
       throw new Error("Intercom initialization unavailable: no active session");
@@ -7279,6 +7598,7 @@ function intercom(pi, options = {}) {
       return handle;
     }
     let promise;
+    let replayCtx = null;
     promise = (async () => {
       const captured = {
         tools: new Map,
@@ -7287,7 +7607,6 @@ function intercom(pi, options = {}) {
         shortcuts: new Map,
         eventHandlers: new Map
       };
-      let replayCtx = null;
       let cleaned = false;
       const cleanupCandidate = async () => {
         const shutdown = lease.shutdown;
@@ -7299,7 +7618,9 @@ function intercom(pi, options = {}) {
         try {
           await dispatchHandlers(captured, "session_shutdown", event, cleanupCtx);
         } catch (cleanupError) {
-          console.error("Intercom failed to clean rejected lazy candidate:", cleanupError);
+          const prefix = "Intercom failed to clean rejected lazy candidate:";
+          const detail = diagnosticDetail(cleanupError);
+          reportDiagnostic(shutdown?.diagnosticRoute ?? diagnosticRoute, `${prefix} ${detail}`, cleanupError, "error", prefix);
         }
       };
       try {
@@ -7311,6 +7632,11 @@ function intercom(pi, options = {}) {
           sessionSnapshot = { event: createSyntheticSessionStartEvent(), ctx, generation: ++lifecycleGeneration, lease };
         }
         await ensureSessionStartReplayed(captured, lease, (replayContext) => {
+          const owner = getExtensionContextOwner(replayContext);
+          if (owner !== diagnosticOwner) {
+            diagnosticRoute = captureDiagnosticRoute(replayContext);
+            diagnosticOwner = owner;
+          }
           replayCtx = replayContext;
         });
         assertLease(lease);
@@ -7329,8 +7655,8 @@ function intercom(pi, options = {}) {
       if (heavyAttempt?.promise === promise)
         heavyAttempt = null;
       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);
+        const message = diagnosticDetail(error);
+        reportDiagnostic(diagnosticRoute, `Intercom heavy initialization failed; a later call will retry: ${message}`, error, "warning");
       }
     });
     return promise;
@@ -7441,6 +7767,7 @@ function intercom(pi, options = {}) {
     }
     const generation = ++lifecycleGeneration;
     sessionSnapshot = { event, ctx, generation, lease };
+    shutdownDiagnosticRoute = undefined;
     cancelWarmUpRetry();
     if (ctx.orchestrationContext?.kind === "workflow-stage" && ctx.orchestrationContext.pendingStageDelivery !== undefined) {
       const pendingStageDelivery = ctx.orchestrationContext.pendingStageDelivery;
@@ -7458,7 +7785,9 @@ function intercom(pi, options = {}) {
   pi.on("session_shutdown", async (event, ctx) => {
     const lease = activeLease;
     const generation = ++lifecycleGeneration;
-    retireLifecycleLease(lease, { event, ctx, generation });
+    const diagnosticRoute = captureDiagnosticRoute(ctx);
+    retireLifecycleLease(lease, { event, ctx, generation, diagnosticRoute });
+    shutdownDiagnosticRoute = diagnosticRoute;
     cancelWarmUpRetry();
     const retiredHeavy = loadedHeavy?.heavy ?? null;
     const retiredAttempt = heavyAttempt?.lease === lease ? heavyAttempt.promise : null;
@@ -7579,13 +7908,15 @@ function intercom(pi, options = {}) {
       return;
     payload.handled = true;
     const forwarded = { ...payload, handled: false, completion: undefined };
-    payload.completion = loadHeavy(latestLifecycleContext()).then(async (handle) => {
+    const ctx = latestLifecycleContext();
+    const diagnosticRoute = ctx ? captureDiagnosticRoute(ctx) : shutdownDiagnosticRoute ?? "console";
+    payload.completion = loadHeavy(ctx).then(async (handle) => {
       handle.assertCurrent();
       await dispatchEventHandlers(handle.heavy, PENDING_STAGE_UNDELIVERABLE_EVENT2, forwarded);
       handle.assertCurrent();
       return forwarded.handled === true && forwarded.completion !== undefined ? await forwarded.completion : false;
     }).catch((error) => {
-      reportRelayFailure(PENDING_STAGE_UNDELIVERABLE_EVENT2, error);
+      reportRelayFailure(diagnosticRoute, PENDING_STAGE_UNDELIVERABLE_EVENT2, error);
       return false;
     });
   });
@@ -7595,7 +7926,9 @@ function intercom(pi, options = {}) {
     PENDING_STAGE_ROUTE_EVENT2
   ]) {
     pi.events.on(eventName, (payload) => {
-      const completion = loadHeavy(latestLifecycleContext()).then(async (handle) => {
+      const ctx = latestLifecycleContext();
+      const diagnosticRoute = ctx ? captureDiagnosticRoute(ctx) : shutdownDiagnosticRoute ?? "console";
+      const completion = loadHeavy(ctx).then(async (handle) => {
         handle.assertCurrent();
         await dispatchEventHandlers(handle.heavy, eventName, payload);
         handle.assertCurrent();
@@ -7610,7 +7943,7 @@ function intercom(pi, options = {}) {
       }
       completion.catch((error) => {
         rejectLazyResultRelay(pi, eventName, payload, error);
-        reportRelayFailure(eventName, error);
+        reportRelayFailure(diagnosticRoute, eventName, error);
       });
     });
   }
@@ -7634,7 +7967,7 @@ function intercom(pi, options = {}) {
 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. 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.
+For send/ask/reply, Intercom retries recoverable disconnects internally up to three times with the same operation identity. Each new tool call is a new operation. If recovery ends with an unknown delivery outcome, do not repeat it automatically.
 Usage:
   intercom({ action: "list" })                    → List sessions in your group
   intercom({ action: "list", group: "name" })     → Read-only peek at another group's sessions
@@ -7643,12 +7976,11 @@ 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. For a retryable send/ask/reply failure, repeat the exact operation with its returned retryToken; omit retryToken for fresh operations.",
+    promptSnippet: "Use to coordinate with other local agent sessions in your intercom group. Send/ask/reply retry reconnects internally; do not automatically repeat an unknown delivery outcome.",
     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 `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')" })),
@@ -7660,10 +7992,15 @@ 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),
+    execute: (...args) => {
+      const invocationLease = activeLease;
+      return executeHeavyTool((ctx) => {
+        assertLease(invocationLease);
+        return loadHeavy(ctx);
+      }, "intercom", args);
+    },
     renderResult: (...args) => renderHeavyToolResult(loadedHeavy?.heavy ?? null, "intercom", args),
     renderCall(args, theme) {
       const input = args;