@bastani/atomic 0.9.16-alpha.7 → 0.9.16-alpha.9

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

@@ -3854,10 +3854,10 @@ function hasAssistantMessage(entries) {
   return entries.some((entry) => entry.type === "message" && entry.message.role === "assistant");
 }
 function persistAppendedEntry(filePath, entries, entry, flushed) {
-  if (!hasAssistantMessage(entries))
-    return false;
   if (flushed)
     appendSessionEntry(filePath, entry);
+  else if (!hasAssistantMessage(entries))
+    return false;
   else
     appendSessionEntries(filePath, entries);
   return true;
@@ -9925,6 +9925,8 @@ function appendDurableDisplayCard(session, message, delivery) {
   const card = { ...message, excludeFromContext: true };
   const admitted = message;
   const intentEntryId = session.sessionManager.appendCustomMessageEntry(card.customType, card.content, card.display, card.details, true, { delivery }, admitted.stageAdmissionKey);
+  if (admitted.stageAdmissionKey !== undefined)
+    session.sessionManager.flush();
   session.agent.state.messages.push(card);
   return { card, intentEntryId };
 }
@@ -10150,12 +10152,17 @@ var init_agent_session_persistent_custom_messages = __esm(() => {
 });
 
 // src/core/agent-session-custom-message-commit.ts
+function appendDurableStageAdmission(session, message) {
+  session._appendCustomMessage(message);
+  if (message.stageAdmissionKey !== undefined)
+    session.sessionManager?.flush();
+}
 async function commitAdmittedCustomMessage(session, appMessage, options) {
   const owner = resolveWorkflowStageDeliveryTarget(session);
   if (owner !== session)
     return commitAdmittedCustomMessage(owner, appMessage, options);
   const self = session;
-  const useProtectedReconciliation = options?.persistWhenStreaming === true && options.triggerTurn === true && options.excludeFromContext !== true;
+  const useProtectedReconciliation = options?.persistWhenStreaming === true && options.excludeFromContext !== true && (options.triggerTurn === true || options.stageAdmissionKey !== undefined);
   if (options?.deliverAs === "nextTurn") {
     self._pendingNextTurnMessages.push(appMessage);
   } else if (self._queuedMessagesPaused) {
@@ -10169,20 +10176,20 @@ async function commitAdmittedCustomMessage(session, appMessage, options) {
     } else if (self.isStreaming) {
       self._pendingCustomMessages.push(appMessage);
     } else {
-      self._appendCustomMessage(appMessage);
+      appendDurableStageAdmission(self, appMessage);
     }
   } else if (options?.deliverAs === "interrupt" && options.triggerTurn) {
     const interrupt = self._enqueueInterruptCustomMessage(appMessage, options);
     self._workflowStageAdmission?.trackAdmittedWork(interrupt);
     interrupt.catch(() => {});
   } else if (self.isStreaming && options?.excludeFromContext === true && options.triggerTurn !== true && options.deliverAs === undefined) {
-    self._appendCustomMessage(appMessage);
+    appendDurableStageAdmission(self, appMessage);
   } else if (self.isStreaming && options?.triggerTurn === false) {
     self._pendingCustomMessages.push(appMessage);
   } else if (self.isStreaming && useProtectedReconciliation) {
     await queueProtectedStreamingCustomMessage(self, appMessage, options?.deliverAs === "followUp" ? "followUp" : "steer");
   } else if (self.isStreaming && options?.persistWhenStreaming === true) {
-    self._appendCustomMessage(appMessage);
+    appendDurableStageAdmission(self, appMessage);
   } else if (self.isStreaming && options?.triggerTurn !== false) {
     self._queueAgentMessage(appMessage, options?.deliverAs === "followUp" ? "followUp" : "steer");
   } else if (options?.triggerTurn) {
@@ -10205,7 +10212,7 @@ async function commitAdmittedCustomMessage(session, appMessage, options) {
       self._continueQueuedAgentMessages().catch(() => {});
     }
   } else {
-    self._appendCustomMessage(appMessage);
+    appendDurableStageAdmission(self, appMessage);
   }
 }
 function _commitAdmittedCustomMessage(appMessage, options) {
@@ -12229,6 +12236,8 @@ class ExtensionRunner {
   shortcutDiagnostics = [];
   commandDiagnostics = [];
   staleMessage;
+  uiPromptBinding = 0;
+  activeUIPrompt;
   constructor(extensions, runtime, cwd, sessionManager, modelRegistry, orchestrationContext, subagentPolicy) {
     this.extensions = extensions;
     this.runtime = runtime;
@@ -12323,9 +12332,71 @@ class ExtensionRunner {
     this.reloadHandler = async () => {};
   }
   setUIContext(uiContext, mode = "print") {
-    this.uiContext = uiContext ?? noOpUIContext;
+    this.endActiveUIPrompt();
+    const binding = ++this.uiPromptBinding;
+    this.uiContext = uiContext ? this.wrapUIPromptContext(uiContext, binding) : noOpUIContext;
     this.mode = mode;
   }
+  wrapUIPromptContext(ui, binding) {
+    return {
+      ...ui,
+      select: (title, options, opts) => this.withUIPrompt(binding, "select", title, () => ui.select(title, options, opts)),
+      confirm: (title, message, opts) => this.withUIPrompt(binding, "confirm", title, () => ui.confirm(title, message, opts)),
+      input: (title, placeholder, opts) => this.withUIPrompt(binding, "input", title, () => ui.input(title, placeholder, opts)),
+      editor: (title, prefill, opts) => this.withUIPrompt(binding, "editor", title, () => ui.editor(title, prefill, opts)),
+      custom: (factory, options) => this.withUIPrompt(binding, "custom", undefined, () => ui.custom(factory, options))
+    };
+  }
+  withUIPrompt(binding, kind, title, run) {
+    if (binding !== this.uiPromptBinding)
+      return run();
+    let prompt = this.activeUIPrompt;
+    if (!prompt) {
+      prompt = { depth: 0, kind, title };
+      this.activeUIPrompt = prompt;
+      this.emitUIPromptEvent({
+        type: "ui_prompt_start",
+        reason: "ui_prompt",
+        kind,
+        ...title === undefined ? {} : { title }
+      });
+    }
+    prompt.depth += 1;
+    let finished = false;
+    const finish = () => {
+      if (finished)
+        return;
+      finished = true;
+      if (this.activeUIPrompt !== prompt)
+        return;
+      prompt.depth -= 1;
+      if (prompt.depth === 0)
+        this.endActiveUIPrompt(prompt);
+    };
+    try {
+      return run().finally(finish);
+    } catch (error) {
+      finish();
+      throw error;
+    }
+  }
+  endActiveUIPrompt(prompt = this.activeUIPrompt) {
+    if (!prompt || this.activeUIPrompt !== prompt)
+      return;
+    this.activeUIPrompt = undefined;
+    prompt.depth = 0;
+    this.emitUIPromptEvent({
+      type: "ui_prompt_end",
+      reason: "ui_prompt",
+      kind: prompt.kind,
+      ...prompt.title === undefined ? {} : { title: prompt.title }
+    });
+  }
+  emitUIPromptEvent(event) {
+    queueMicrotask(() => {
+      this.emit(event);
+    });
+  }
   getUIContext() {
     return this.uiContext;
   }
@@ -21607,11 +21678,20 @@ import {
 function isCodexFastModeSupportedProvider(provider) {
   return provider === "openai" || provider === "openai-codex";
 }
-function isCodexFastModeSupportedModel(model) {
-  return isCodexFastModeSupportedProvider(model.provider) || model.api === "openai-codex-responses";
+function isGitHubCopilotModel(model) {
+  return model.provider === "github-copilot";
+}
+function isGitHubCopilotFastModeSupportedModel(model, credential) {
+  if (!isGitHubCopilotModel(model) || credential?.type !== "oauth")
+    return false;
+  const fastModelIds = credential.fastModelIds;
+  return Array.isArray(fastModelIds) && fastModelIds.every((modelId) => typeof modelId === "string") && fastModelIds.includes(`${model.id}-fast`);
 }
-function hasSupportedCodexFastModeModel(models) {
-  return models.some(isCodexFastModeSupportedModel);
+function isCodexFastModeSupportedModel(model, copilotCredential) {
+  return isCodexFastModeSupportedProvider(model.provider) || model.api === "openai-codex-responses" || model.id !== undefined && isGitHubCopilotFastModeSupportedModel({ provider: model.provider, id: model.id }, copilotCredential);
+}
+function hasSupportedCodexFastModeModel(models, copilotCredential) {
+  return models.some((model) => isCodexFastModeSupportedModel(model, copilotCredential));
 }
 function isWorkflowStageOrchestrationContext(context) {
   return context?.kind === "workflow-stage";
@@ -21622,11 +21702,11 @@ function getCodexFastModeScope(context) {
 function isCodexFastModeEnabledForScope(settings, scope) {
   return settings[scope];
 }
-function shouldApplyCodexFastModeForScope(model, settings, scope) {
-  return isCodexFastModeSupportedModel(model) && isCodexFastModeEnabledForScope(settings, scope);
+function shouldApplyCodexFastModeForScope(model, settings, scope, copilotCredential) {
+  return isCodexFastModeSupportedModel(model, copilotCredential) && isCodexFastModeEnabledForScope(settings, scope);
 }
-function shouldApplyCodexFastMode(model, settings, context) {
-  return shouldApplyCodexFastModeForScope(model, settings, getCodexFastModeScope(context));
+function shouldApplyCodexFastMode(model, settings, context, copilotCredential) {
+  return shouldApplyCodexFastModeForScope(model, settings, getCodexFastModeScope(context), copilotCredential);
 }
 function formatCodexFastModeModelLabel(modelName, enabled) {
   return enabled ? `${modelName} fast` : modelName;
@@ -21767,7 +21847,7 @@ class FooterComponent {
       pwd += ` • ${sessionName}`;
     const modelName = state.model?.id || "no-model";
     const fastModeSettings = this.session.settingsManager.getCodexFastModeSettings();
-    const fastModeEnabled = state.model ? shouldApplyCodexFastMode(state.model, fastModeSettings, this.session.orchestrationContext) : false;
+    const fastModeEnabled = state.model ? shouldApplyCodexFastMode(state.model, fastModeSettings, this.session.orchestrationContext, this.session.modelRuntime.getCredentialSnapshot?.("github-copilot")) : false;
     let modelLabel2 = modelName;
     if (state.model?.reasoning) {
       const thinkingLevel = state.thinkingLevel || "off";
@@ -39355,14 +39435,18 @@ import { AsyncLocalStorage } from "node:async_hooks";
 
 class WorkflowStageAdmissionBoundary {
   open = true;
-  completed = new Set;
+  completed;
   inFlight = new Map;
   pending = new Set;
   invocationContext = new AsyncLocalStorage;
   closePromise;
   drainAdmittedWork;
-  constructor(drainAdmittedWork = async () => {}) {
-    this.drainAdmittedWork = drainAdmittedWork;
+  constructor(drainAdmittedWork = undefined, completedKeys = []) {
+    this.drainAdmittedWork = drainAdmittedWork ?? (async () => {});
+    this.completed = new Set(completedKeys);
+  }
+  static restore(entries, drainAdmittedWork) {
+    return new WorkflowStageAdmissionBoundary(drainAdmittedWork, Array.from(entries).flatMap((entry) => entry.type === "custom_message" && typeof entry.stageAdmissionKey === "string" ? [entry.stageAdmissionKey] : []));
   }
   admit(key, deliver, routeLate) {
     if (key !== undefined) {
@@ -39601,7 +39685,7 @@ class AgentSessionBase {
     this._subagentPolicy = config.subagentPolicy;
     this._systemPromptTransform = config.systemPromptTransform;
     const stageContext = config.orchestrationContext?.kind === "workflow-stage" ? config.orchestrationContext : undefined;
-    this._workflowStageAdmission = stageContext?.messageAdmission?.boundary ?? (stageContext ? new WorkflowStageAdmissionBoundary : undefined);
+    this._workflowStageAdmission = stageContext?.messageAdmission?.boundary ?? (stageContext ? WorkflowStageAdmissionBoundary.restore(this.sessionManager.getBranch()) : undefined);
     if (this._workflowStageAdmission && stageContext && stageContext.messageAdmission === undefined) {
       stageContext.messageAdmission = {
         boundary: this._workflowStageAdmission,
@@ -46560,6 +46644,31 @@ class RemoteQueuePause {
 var init_remote_queue_pause = () => {};
 
 // src/modes/interactive-engine/isolated-runtime.ts
+import { clampThinkingLevel as clampThinkingLevel5 } from "@bastani/pi-ai/compat";
+function applyPersistedModelDefault(session, model, alreadyInScope) {
+  session.settingsManager.setDefaultModelAndProvider(model.provider, model.id);
+  if (alreadyInScope || session.scopedModels.length === 0)
+    return;
+  const enabledModels = session.settingsManager.getEnabledModels();
+  if (!enabledModels?.length)
+    return;
+  const modelReference = `${model.provider}/${model.id}`;
+  if (enabledModels.some((pattern) => pattern.toLowerCase() === modelReference.toLowerCase()))
+    return;
+  session.settingsManager.setEnabledModels([...enabledModels, modelReference]);
+}
+function thinkingPersistTarget(result) {
+  if (!result.provider || !result.modelId)
+    return;
+  return { provider: result.provider, modelId: result.modelId };
+}
+function applyPersistedThinkingDefault(session, level, target) {
+  if (target) {
+    session.settingsManager.setModelThinkingLevel(target.provider, target.modelId, level);
+    return;
+  }
+  session.settingsManager.setDefaultThinkingLevel(level);
+}
 var IsolatedInteractiveRuntime;
 var init_isolated_runtime = __esm(() => {
   init_agent_session_runtime();
@@ -46578,6 +46687,7 @@ var init_isolated_runtime = __esm(() => {
     steeringMessages = [];
     followUpMessages = [];
     queueUpdateGeneration = 0;
+    thinkingEpoch = 0;
     pendingQueueClear;
     engineCallbackActive = false;
     queuePause;
@@ -46942,43 +47052,56 @@ var init_isolated_runtime = __esm(() => {
         },
         setModel: {
           configurable: true,
-          value: async (model) => {
-            const selected = await this.client.setModel(model.provider, model.id);
-            session.agent.state.model = session.modelRuntime.getModel(selected.provider, selected.id) ?? model;
+          value: async (model, options) => {
+            const selected = await this.client.setModel(model.provider, model.id, options);
+            const nextModel = session.modelRuntime.getModel(selected.provider, selected.id) ?? model;
+            session.agent.state.model = nextModel;
             this.resolveModelFallback();
+            if (options?.persist === true)
+              await this.syncPersistedModelCatalog(session, nextModel);
           }
         },
         setThinkingLevel: {
           configurable: true,
-          value: (level) => {
-            session.agent.state.thinkingLevel = level;
-            this.dispatchBestEffort("set thinking level", this.client.setThinkingLevel(level));
+          value: (level, options) => {
+            const availableLevels = session.getAvailableThinkingLevels();
+            const effectiveLevel = availableLevels.includes(level) ? level : session.model ? clampThinkingLevel5(session.model, level) : "off";
+            session.agent.state.thinkingLevel = effectiveLevel;
+            const epoch = ++this.thinkingEpoch;
+            this.dispatchBestEffort("set thinking level", this.client.setThinkingLevelAck(level, options).then((result) => {
+              this.applyThinkingAck(session, epoch, result, options?.persist === true);
+            }));
           }
         },
         cycleModel: {
           configurable: true,
-          value: async (direction) => {
+          value: async (direction, options) => {
             const previousModel = session.model;
-            const result = await this.client.cycleModel(direction);
+            const result = await this.client.cycleModel(direction, options);
             if (!result)
               return;
             const model = session.modelRuntime.getModel(result.model.provider, result.model.id) ?? result.model;
             session.agent.state.model = model;
             session.agent.state.thinkingLevel = result.thinkingLevel;
             this.resolveModelFallbackAfterExplicitModelSelection(previousModel, model);
+            if (options?.persist === true)
+              await this.syncPersistedModelCatalog(session, model);
             return { ...result, model };
           }
         },
         cycleThinkingLevel: {
           configurable: true,
-          value: () => {
+          value: (options) => {
             const levels = session.getAvailableThinkingLevels();
             if (levels.length <= 1)
               return;
             const current = levels.indexOf(session.thinkingLevel);
             const level = levels[(current + 1) % levels.length];
             session.agent.state.thinkingLevel = level;
-            this.dispatchBestEffort("cycle thinking level", this.client.setThinkingLevel(level));
+            const epoch = ++this.thinkingEpoch;
+            this.dispatchBestEffort("cycle thinking level", this.client.setThinkingLevelAck(level, options).then((result) => {
+              this.applyThinkingAck(session, epoch, result, options?.persist === true);
+            }));
             return level;
           }
         },
@@ -47022,6 +47145,14 @@ var init_isolated_runtime = __esm(() => {
         this.engineCallbackActive = false;
       }
     }
+    applyThinkingAck(session, epoch, result, persist) {
+      if (persist) {
+        applyPersistedThinkingDefault(session, result.level, thinkingPersistTarget(result));
+      }
+      if (epoch === this.thinkingEpoch) {
+        session.agent.state.thinkingLevel = result.level;
+      }
+    }
     dispatchBestEffort(label, operation) {
       operation.catch((error) => {
         if (this.health.isRecovering())
@@ -47062,6 +47193,12 @@ var init_isolated_runtime = __esm(() => {
         }
       });
     }
+    async syncPersistedModelCatalog(session, model) {
+      const alreadyInScope = session.scopedModels.some((scoped) => scoped.model.provider === model.provider && scoped.model.id === model.id);
+      const catalog = await this.client.requestInternal({ type: "get_available_models" });
+      this.remoteModelCatalog.apply(catalog);
+      applyPersistedModelDefault(session, model, alreadyInScope);
+    }
     refreshSessionView() {
       const session = super.session;
       const sessionFile = session.sessionFile;
@@ -47101,6 +47238,7 @@ var init_isolated_runtime = __esm(() => {
           session.agent.state.model = event.model;
           break;
         case "thinking_level_changed":
+          this.thinkingEpoch += 1;
           session.agent.state.thinkingLevel = event.level;
           break;
         case "session_info_changed":
@@ -48314,7 +48452,7 @@ var init_slash_commands = __esm(() => {
     { name: "tree", description: "Navigate session tree (switch branches)" },
     { name: "thinking", description: "Set thinking level", argumentHint: "<level>" },
     { name: "scoped-models", description: "Enable/disable models for ctrl+p cycling" },
-    { name: "fast", description: "Configure Codex fast mode for chat and workflows" },
+    { name: "fast", description: "Configure OpenAI fast mode for chat and workflows in supported models" },
     { name: "export", description: "Export session (HTML default, or specify path: .html/.jsonl)" },
     { name: "import", description: "Import and resume a session from a JSONL file" },
     { name: "share", description: "Share session as a secret GitHub gist" },
@@ -49766,7 +49904,7 @@ var init_interactive_autocomplete = __esm(() => {
     return [...this.session.modelRuntime.getAvailableSnapshot()];
   };
   InteractiveModeBase.prototype.hasCodexFastModeSupportedModels = function() {
-    return hasSupportedCodexFastModeModel(this.getCodexFastModeCandidateModels());
+    return hasSupportedCodexFastModeModel(this.getCodexFastModeCandidateModels(), this.session.modelRuntime.getCredentialSnapshot?.("github-copilot"));
   };
   InteractiveModeBase.prototype.buildRemoteSlashCommands = function(localCommands) {
     const remote = getInteractiveEngineRemoteCommands(this.runtimeHost);
@@ -50454,7 +50592,7 @@ var init_interactive_startup = __esm(() => {
     if (!model) {
       return modelLabel2;
     }
-    const fastModeEnabled = shouldApplyCodexFastMode(model, this.session.settingsManager.getCodexFastModeSettings(), this.session.orchestrationContext);
+    const fastModeEnabled = shouldApplyCodexFastMode(model, this.session.settingsManager.getCodexFastModeSettings(), this.session.orchestrationContext, this.session.modelRuntime.getCredentialSnapshot?.("github-copilot"));
     return formatCodexFastModeModelLabel(modelLabel2, fastModeEnabled);
   };
   InteractiveModeBase.prototype.getStartupIdentityText = function(maxWidth, gap = 0, manifestoPhase = 4) {
@@ -51380,7 +51518,7 @@ var init_interactive_extension_runtime = __esm(() => {
     if (shortcuts.size === 0)
       return;
     const createContext = () => ({
-      ui: this.createExtensionUIContext(),
+      ui: extensionRunner.getUIContext(),
       mode: "tui",
       hasUI: true,
       cwd: this.sessionManager.getCwd(),
@@ -54969,7 +55107,7 @@ var init_interactive_selectors = __esm(() => {
 });
 
 // src/modes/interactive/interactive-model-routing.ts
-import { clampThinkingLevel as clampThinkingLevel5 } from "@bastani/pi-ai/compat";
+import { clampThinkingLevel as clampThinkingLevel6 } from "@bastani/pi-ai/compat";
 function resolveThinkingSelectorDefault(rawDefault, availableLevels, model) {
   if (rawDefault === undefined)
     return;
@@ -54977,7 +55115,7 @@ function resolveThinkingSelectorDefault(rawDefault, availableLevels, model) {
     return rawDefault;
   if (!model)
     return availableLevels.includes("off") ? "off" : availableLevels[0];
-  const clamped = clampThinkingLevel5(model, rawDefault);
+  const clamped = clampThinkingLevel6(model, rawDefault);
   if (availableLevels.includes(clamped))
     return clamped;
   return availableLevels.includes("off") ? "off" : availableLevels[0];
@@ -57195,6 +57333,12 @@ function isAttachment(value) {
     return false;
   return attachment.language === undefined || typeof attachment.language === "string";
 }
+function isMessageSource(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value))
+    return false;
+  const source = value;
+  return typeof source.subagentRunId === "string" && (source.subagentAgent === undefined || typeof source.subagentAgent === "string") && (source.subagentIndex === undefined || typeof source.subagentIndex === "number");
+}
 function isMessage(value) {
   if (typeof value !== "object" || value === null)
     return false;
@@ -57207,6 +57351,8 @@ function isMessage(value) {
     return false;
   if (message.replyError !== undefined && typeof message.replyError !== "string")
     return false;
+  if (message.source !== undefined && !isMessageSource(message.source))
+    return false;
   if (typeof message.content !== "object" || message.content === null)
     return false;
   const content = message.content;
@@ -57240,6 +57386,7 @@ var init_client = __esm(() => {
   init_pending_send_registry();
   BROKER_SOCKET = getBrokerSocketPath();
   IntercomClient = class IntercomClient extends EventEmitter2 {
+    returnAddress;
     socket = null;
     _sessionId = null;
     _supervisorSessionId = null;
@@ -57247,9 +57394,16 @@ var init_client = __esm(() => {
     pendingSends = new PendingSendRegistry;
     pendingLists = new Map;
     pendingPresence = new Map;
+    pendingLiveWorkflowStageRoutes = new Map;
     pendingSupervisorAuthorizations = new Map;
     disconnecting = false;
     disconnectError = null;
+    constructor(returnAddress = randomUUID8()) {
+      super();
+      if (returnAddress.length === 0)
+        throw new Error("Intercom return address must not be empty");
+      this.returnAddress = returnAddress;
+    }
     failPending(error) {
       this.pendingSends.rejectAll(error);
       for (const pending of this.pendingLists.values())
@@ -57258,9 +57412,12 @@ var init_client = __esm(() => {
         pending.reject(error);
       for (const pending of this.pendingPresence.values())
         pending.reject(error);
+      for (const pending of this.pendingLiveWorkflowStageRoutes.values())
+        pending.reject(error);
       this.pendingLists.clear();
       this.pendingSupervisorAuthorizations.clear();
       this.pendingPresence.clear();
+      this.pendingLiveWorkflowStageRoutes.clear();
     }
     get sessionId() {
       return this._sessionId;
@@ -57386,6 +57543,7 @@ var init_client = __esm(() => {
           writeMessage(socket, {
             type: "register",
             session,
+            returnAddress: this.returnAddress,
             ...supervisor ? { supervisor } : {},
             ...supervisorOwnerToken ? { supervisorOwnerToken } : {}
           });
@@ -57460,6 +57618,58 @@ var init_client = __esm(() => {
           this.emit("message", from, message, channel);
           break;
         }
+        case "pending_stage_message": {
+          const { requestId, from, senderRegistrationName, senderReturnAddress, runId, stageKey, message, live } = brokerMessage;
+          if (typeof requestId !== "string" || !isSessionInfo(from) || senderRegistrationName !== undefined && typeof senderRegistrationName !== "string" || senderReturnAddress !== undefined && typeof senderReturnAddress !== "string" || typeof runId !== "string" || typeof stageKey !== "string" || !isMessage(message) || live !== undefined && typeof live !== "boolean") {
+            throw new Error("Invalid pending-stage message event");
+          }
+          this.emit("pending_stage_message", {
+            requestId,
+            from,
+            ...senderRegistrationName === undefined ? {} : { senderRegistrationName },
+            ...senderReturnAddress === undefined ? {} : { senderReturnAddress },
+            runId,
+            stageKey,
+            message,
+            ...live === true ? { live: true } : {}
+          });
+          break;
+        }
+        case "pending_stage_notification": {
+          const { requestId, from, message } = brokerMessage;
+          if (typeof requestId !== "string" || !isSessionInfo(from) || !isMessage(message)) {
+            throw new Error("Invalid pending-stage notification event");
+          }
+          this.emit("pending_stage_notification", {
+            requestId,
+            from,
+            message
+          });
+          break;
+        }
+        case "live_workflow_stage_route_registered": {
+          const { requestId } = brokerMessage;
+          if (typeof requestId !== "string")
+            throw new Error("Invalid live workflow-stage route registration");
+          const pending = this.pendingLiveWorkflowStageRoutes.get(requestId);
+          if (!pending)
+            return;
+          this.pendingLiveWorkflowStageRoutes.delete(requestId);
+          pending.resolve();
+          break;
+        }
+        case "queued": {
+          const { messageId, attemptId, runId, stageKey, position } = brokerMessage;
+          if (typeof messageId !== "string" || attemptId !== undefined && typeof attemptId !== "string" || typeof runId !== "string" || typeof stageKey !== "string" || typeof position !== "number" || position < 1) {
+            throw new Error("Invalid queued message");
+          }
+          const result = { id: messageId, delivered: false, queued: true, runId, stageKey, position };
+          if (attemptId === undefined)
+            this.pendingSends.resolveLegacy(messageId, result);
+          else
+            this.pendingSends.resolve(messageId, attemptId, result);
+          break;
+        }
         case "delivered": {
           const { messageId, attemptId } = brokerMessage;
           if (typeof messageId !== "string" || attemptId !== undefined && typeof attemptId !== "string") {
@@ -57473,11 +57683,16 @@ var init_client = __esm(() => {
           break;
         }
         case "delivery_failed": {
-          const { messageId, attemptId, reason } = brokerMessage;
-          if (typeof messageId !== "string" || attemptId !== undefined && typeof attemptId !== "string" || typeof reason !== "string") {
+          const { messageId, attemptId, reason, reasonCode } = brokerMessage;
+          if (typeof messageId !== "string" || attemptId !== undefined && typeof attemptId !== "string" || typeof reason !== "string" || reasonCode !== undefined && reasonCode !== "message_id_conflict") {
             throw new Error("Invalid delivery_failed message");
           }
-          const result = { id: messageId, delivered: false, reason };
+          const result = {
+            id: messageId,
+            delivered: false,
+            reason,
+            ...reasonCode === undefined ? {} : { reasonCode }
+          };
           if (attemptId === undefined)
             this.pendingSends.resolveLegacy(messageId, result);
           else
@@ -57656,13 +57871,61 @@ var init_client = __esm(() => {
         }
       });
     }
+    registerPendingStageRoute(runId, group, capability) {
+      writeMessage(this.requireActiveSocket(), { type: "register_pending_stage_route", runId, group, capability });
+    }
+    registerLiveWorkflowStageRoute(runId, stageKeys, capability) {
+      let socket;
+      try {
+        socket = this.requireActiveSocket();
+      } catch (error) {
+        return Promise.reject(toError(error));
+      }
+      const requestId = randomUUID8();
+      return new Promise((resolve15, reject) => {
+        this.pendingLiveWorkflowStageRoutes.set(requestId, { resolve: resolve15, reject });
+        try {
+          writeMessage(socket, {
+            type: "register_live_workflow_stage_route",
+            requestId,
+            runId,
+            stageKeys: [...stageKeys],
+            capability
+          });
+        } catch (error) {
+          this.pendingLiveWorkflowStageRoutes.delete(requestId);
+          reject(toError(error));
+        }
+      });
+    }
+    respondPendingStageMessage(requestId, result) {
+      const socket = this.requireActiveSocket();
+      writeMessage(socket, result.outcome === "queued" ? { type: "pending_stage_message_result", requestId, outcome: "queued", position: result.position } : result.outcome === "refused" ? {
+        type: "pending_stage_message_result",
+        requestId,
+        outcome: "refused",
+        reason: result.reason,
+        ...result.reasonCode === undefined ? {} : { reasonCode: result.reasonCode }
+      } : { type: "pending_stage_message_result", requestId, outcome: result.outcome });
+    }
+    respondPendingStageNotification(requestId, delivered) {
+      writeMessage(this.requireActiveSocket(), { type: "pending_stage_notification_result", requestId, delivered });
+    }
     send(to, options) {
       return this.sendFrame("send", to, options);
     }
+    sendPendingStageNotification(runId, capability, to, senderRegistrationName, options, senderReturnAddress) {
+      return this.sendFrame("send_pending_stage_notification", to, options, {
+        runId,
+        capability,
+        ...senderRegistrationName === undefined ? {} : { senderRegistrationName },
+        ...senderReturnAddress === undefined ? {} : { senderReturnAddress }
+      });
+    }
     sendToSupervisor(to, options) {
       return this.sendFrame("supervisor_send", to, options);
     }
-    sendFrame(type, to, options) {
+    sendFrame(type, to, options, extra = undefined) {
       let socket;
       try {
         socket = this.requireActiveSocket();
@@ -57688,7 +57951,7 @@ var init_client = __esm(() => {
         content: { text: options.text, attachments: options.attachments }
       };
       try {
-        writeMessage(socket, { type, to, message, attemptId: acquired.attempt.attemptId });
+        writeMessage(socket, { type, to, message, attemptId: acquired.attempt.attemptId, ...extra });
       } catch (error) {
         this.pendingSends.reject(acquired.attempt, toError(error));
       }
@@ -59216,6 +59479,10 @@ Use this to communicate findings, request help, or coordinate work with other se
 Sessions belong to an intercom group and can ONLY message sessions in the same group;
 cross-group sends are rejected by the broker. Ungrouped sessions share the "default" group.
 
+For send, live session names and exact full session IDs remain supported. For a known
+workflow stage, use the exact \`<runId>:<stageKey>\` target; send messages to pending stages
+queue automatically.
+
 Usage:
   intercom({ action: "list" })                    → List sessions in your group
   intercom({ action: "list", group: "name" })     → Read-only peek at another group's sessions
@@ -59236,7 +59503,7 @@ does not grant cross-group access: contact_supervisor is the only cross-group pa
         description: "Action: 'list', 'join', 'leave', 'send', 'ask', 'reply', 'pending', or 'status'"
       }),
       to: Type14.Optional(Type14.String({
-        description: "Exact session name or exact full session ID (for 'send', 'ask', or targeted 'reply')"
+        description: "Live session name, exact full session ID, or exact `<runId>:<stageKey>` for a known workflow stage; send messages to pending stages queue automatically (for 'send', 'ask', or targeted 'reply')"
       })),
       message: Type14.Optional(Type14.String({
         description: "Message to send (for 'send', 'ask', or 'reply' action)"
@@ -59435,6 +59702,26 @@ ${message}${attachmentText}`);
               attachments,
               replyTo
             });
+            if (result.queued === true) {
+              pi.appendEntry("intercom_sent", {
+                to,
+                message: { text: message, attachments, replyTo },
+                messageId: result.id,
+                timestamp: Date.now()
+              });
+              return {
+                content: [{ type: "text", text: `Message queued for ${to}` }],
+                isError: false,
+                details: {
+                  messageId: result.id,
+                  delivered: false,
+                  queued: true,
+                  runId: result.runId,
+                  stageKey: result.stageKey,
+                  position: result.position
+                }
+              };
+            }
             if (!result.delivered) {
               const errorText = result.reason ?? "Session may not exist or has disconnected.";
               return {
@@ -59553,10 +59840,16 @@ ${message}${attachmentText}`);
             if (!sendResult.delivered) {
               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: { error: true }
+                details: pendingStageAskRefusal ? {
+                  error: true,
+                  refusal: "pending_stage_ask_unsupported",
+                  recommendedAction: "send",
+                  reason: errorText
+                } : { error: true }
               };
             }
             pi.appendEntry("intercom_sent", {
@@ -60127,6 +60420,13 @@ function registerIntercomLifecycle(pi, deps) {
         console.error(`Intercom failed to disconnect during ${reason.toLowerCase()}; continuing cleanup:`, error);
       }
     }
+    if (deps.disconnectAuxiliaryClients) {
+      try {
+        await deps.disconnectAuxiliaryClients();
+      } catch (error) {
+        console.error(`Intercom failed to disconnect auxiliary clients during ${reason.toLowerCase()}; continuing cleanup:`, error);
+      }
+    }
     deps.restoreIntercomSessionIdEnv?.();
     deps.setRuntimeContext(null);
     deps.setCurrentSessionId(null);
@@ -60921,12 +61221,27 @@ function createIncomingMessageSender(input2) {
     }
     const baseOptions = {
       stageAdmissionKey: `intercom:${entry.message.id}`,
+      persistWhenStreaming: true,
       ...stageAdmissionBarrier ? { stageAdmissionBarrier } : {}
     };
     const options = delivery === "trigger" ? { ...baseOptions, triggerTurn: true } : delivery === "followUp" ? { ...baseOptions, deliverAs: "followUp" } : baseOptions;
     return Promise.resolve(input2.pi.sendMessage(buildIncomingCustomMessage(entry), options));
   };
 }
+function framePendingStageTimestamp(timestamp) {
+  const date = new Date(timestamp);
+  return Number.isNaN(date.getTime()) ? String(timestamp) : date.toISOString();
+}
+function framePreStartPendingStageMessage(entry) {
+  return {
+    ...entry,
+    bodyText: `**Messages received before you started**
+
+Sent: ${framePendingStageTimestamp(entry.message.timestamp)}
+
+${entry.bodyText}`
+  };
+}
 function buildIncomingCustomMessage(entry) {
   const senderDisplay = entry.from.name || entry.from.id;
   const replyInstruction = entry.replyCommand ? `
@@ -61016,7 +61331,28 @@ class InboundIdleQueue {
 class InboundMessageAdmission {
   delivered = new DeliveredMessageCache;
   pending = new Map;
+  persistentlyDelivered = new Set;
+  restore(entries) {
+    this.persistentlyDelivered.clear();
+    for (const value of entries) {
+      if (typeof value !== "object" || value === null)
+        continue;
+      const entry = value;
+      if (entry.customType !== "intercom_message" || typeof entry.stageAdmissionKey !== "string")
+        continue;
+      if (typeof entry.details !== "object" || entry.details === null)
+        continue;
+      const details = entry.details;
+      if (!isSessionInfo(details.from) || !isMessage(details.message))
+        continue;
+      if (entry.stageAdmissionKey !== `intercom:${details.message.id}`)
+        continue;
+      this.persistentlyDelivered.add(details.message.id);
+    }
+  }
   admit(from, message) {
+    if (this.persistentlyDelivered.has(message.id))
+      return { kind: "duplicate" };
     const signature = JSON.stringify({ from: from.id, message });
     if (this.delivered.lookup(message.id, signature) !== "miss")
       return { kind: "duplicate" };
@@ -61052,6 +61388,7 @@ class InboundMessageAdmission {
       return;
     this.pending.delete(reservation.messageId);
     this.delivered.record(reservation.messageId, reservation.signature);
+    this.persistentlyDelivered.add(reservation.messageId);
     pending.resolve();
   }
   release(reservation, error = new Error("Inbound message admission released")) {
@@ -61391,6 +61728,18 @@ __export(exports_index_heavy, {
   default: () => piIntercomExtension
 });
 import { appendFileSync as appendFileSync2 } from "node:fs";
+function isPendingStageUndeliverableEvent(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  const event = value;
+  return typeof event.runId === "string" && typeof event.handled === "boolean" && typeof event.senderId === "string" && (event.senderRegistrationName === undefined || typeof event.senderRegistrationName === "string") && (event.senderReturnAddress === undefined || typeof event.senderReturnAddress === "string") && typeof event.messageId === "string" && typeof event.notificationId === "string" && typeof event.reason === "string";
+}
+function isPendingStageRouteRegistrationEvent(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  const event = value;
+  return typeof event.runId === "string" && event.runId.length > 0 && typeof event.group === "string" && typeof event.capability === "string" && event.capability.length > 0;
+}
 function piIntercomExtension(pi, testOverrides = {}) {
   const inheritedIntercomSessionId = process.env[INTERCOM_SESSION_ID_ENV];
   const restoreIntercomSessionIdEnv = () => {
@@ -61400,6 +61749,7 @@ function piIntercomExtension(pi, testOverrides = {}) {
       process.env[INTERCOM_SESSION_ID_ENV] = inheritedIntercomSessionId;
   };
   let client = null;
+  let clientRegistrationGroup = null;
   const config = loadConfig2();
   const legacyChildOrchestratorMetadata = readChildOrchestratorMetadata();
   let runtimeContext = null;
@@ -61426,6 +61776,8 @@ function piIntercomExtension(pi, testOverrides = {}) {
   const foregroundDetachHandoff = new ForegroundDetachHandoff(pi);
   const pendingIdleMessages = new InboundIdleQueue;
   const inboundDeliveries = new InboundMessageAdmission;
+  const pendingStageRoutes = new Map;
+  const pendingStageRouteClients = new Map;
   const supervisorAuthorizations = new SupervisorAuthorizationRegistry;
   let inboundFlushTimer = null;
   function rejectReplyWaiter(error) {
@@ -61591,7 +61943,7 @@ function piIntercomExtension(pi, testOverrides = {}) {
     }).catch(() => {});
   }
   testOverrides.captureInboundHandler?.(handleIncomingMessage);
-  function handleIncomingMessage(ctx, from, message, channel) {
+  function handleIncomingMessage(ctx, from, message, channel, receivedBeforeStageStart = false) {
     const messageGeneration = runtimeGeneration;
     const liveContext = getLiveContext(ctx, messageGeneration);
     if (!liveContext) {
@@ -61601,7 +61953,11 @@ function piIntercomExtension(pi, testOverrides = {}) {
     const attachmentText = message.content.attachments?.length ? formatAttachments(message.content.attachments) : "";
     const bodyText = `${message.content.text}${attachmentText}`;
     const replyCommand = config.replyHint && message.expectsReply ? `intercom({ action: "reply", message: "..." })` : undefined;
-    const entry = { from, message, replyCommand, bodyText, ...channel ? { channel } : {} };
+    const rawEntry = { from, message, replyCommand, bodyText, ...channel ? { channel } : {} };
+    const entry = receivedBeforeStageStart ? framePreStartPendingStageMessage(rawEntry) : rawEntry;
+    if (receivedBeforeStageStart) {
+      return sendIncomingMessage(entry, "prelude", messageGeneration, false);
+    }
     const stageClosed = liveContext.orchestrationContext?.kind === "workflow-stage" && liveContext.orchestrationContext.messageAdmission?.isOpen() === false;
     if (stageClosed) {
       routeClosedWorkflowStageMessage(entry, inboundDeliveries, replyTracker, replyWaiters.pending(), () => sendIncomingMessage(entry, "trigger", messageGeneration, false), () => client, () => Boolean(getLiveContext(liveContext, messageGeneration)));
@@ -61639,7 +61995,7 @@ function piIntercomExtension(pi, testOverrides = {}) {
       stageDelivery.then(commit, release);
       return;
     }
-    (async () => {
+    return (async () => {
       try {
         const activeContext = getLiveContext(liveContext, messageGeneration);
         if (!activeContext) {
@@ -61695,6 +62051,110 @@ function piIntercomExtension(pi, testOverrides = {}) {
       }
     })();
   }
+  function handlePendingStageMessage(nextClient, request, isCurrent) {
+    if (!isCurrent())
+      return;
+    const event = { ...request, handled: false };
+    try {
+      pi.events.emit(PENDING_STAGE_MESSAGE_EVENT, event);
+    } catch (error) {
+      nextClient.respondPendingStageMessage(request.requestId, { outcome: "refused", reason: toError3(error).message });
+      return;
+    }
+    if (!event.handled || event.completion === undefined) {
+      nextClient.respondPendingStageMessage(request.requestId, {
+        outcome: "refused",
+        reason: "Session not found"
+      });
+      return;
+    }
+    event.completion.then((result) => nextClient.respondPendingStageMessage(request.requestId, result), (error) => nextClient.respondPendingStageMessage(request.requestId, {
+      outcome: "refused",
+      reason: toError3(error).message
+    }));
+  }
+  async function admitPendingStageNotification(nextClient, request) {
+    const messageGeneration = runtimeGeneration;
+    const liveContext = client === nextClient ? getLiveContext() : null;
+    if (liveContext === null)
+      return false;
+    const attachmentText = request.message.content.attachments?.length ? formatAttachments(request.message.content.attachments) : "";
+    const bodyText = `${request.message.content.text}${attachmentText}`;
+    const replyCommand = config.replyHint && request.message.expectsReply ? `intercom({ action: "reply", message: "..." })` : undefined;
+    const entry = { from: request.from, message: request.message, replyCommand, bodyText };
+    const admission = inboundDeliveries.admit(request.from, request.message);
+    if (admission.kind === "duplicate")
+      return true;
+    if (admission.kind === "pending") {
+      return admission.completion.then(() => true, () => false);
+    }
+    const reservation = admission.reservation;
+    const commit = () => {
+      inboundDeliveries.commit(reservation);
+    };
+    replyTracker = bindWorkflowReplyTracker(liveContext, replyTracker);
+    if (routeIncomingReply(replyWaiters.pending(), request.from, request.message)) {
+      commit();
+      return true;
+    }
+    const replyContext = replyTracker.recordIncomingMessage(request.from, request.message);
+    const release = createWorkflowStageDeliveryFailureHandler({
+      entry,
+      admission: inboundDeliveries,
+      reservation,
+      tracker: replyTracker,
+      replyContext,
+      currentClient: () => client,
+      commit
+    });
+    const reject = async (error) => {
+      await release(error);
+      return false;
+    };
+    const stageClosed = liveContext.orchestrationContext?.kind === "workflow-stage" && liveContext.orchestrationContext.messageAdmission?.isOpen() === false;
+    if (stageClosed)
+      return reject(new Error("Workflow stage is closed before notification admission"));
+    const stageDelivery = admitWorkflowStageInbound(liveContext, (admissionBarrier) => {
+      replyTracker.queueTurnContext(replyContext);
+      return retryStableDelivery({
+        deliver: () => sendIncomingMessage(entry, "trigger", messageGeneration, false, undefined, admissionBarrier),
+        isCurrent: () => Boolean(getLiveContext(liveContext, messageGeneration))
+      });
+    }, () => foregroundDetachHandoff.claim(request.from, request.message, messageGeneration, () => Boolean(getLiveContext(liveContext, messageGeneration))), release);
+    if (stageDelivery !== false) {
+      try {
+        await stageDelivery;
+        commit();
+        return true;
+      } catch (error) {
+        return reject(error);
+      }
+    }
+    try {
+      const activeContext = getLiveContext(liveContext, messageGeneration);
+      if (activeContext === null || !activeContext.isIdle()) {
+        return reject(new Error("Intercom session is not ready for acknowledged notification delivery"));
+      }
+      replyTracker.queueTurnContext(replyContext);
+      await retryStableDelivery({
+        deliver: () => sendIncomingMessage(entry, "trigger", messageGeneration, false),
+        isCurrent: () => Boolean(getLiveContext(liveContext, messageGeneration))
+      });
+      commit();
+      return true;
+    } catch (error) {
+      return reject(error);
+    }
+  }
+  function handlePendingStageNotification(nextClient, request) {
+    admitPendingStageNotification(nextClient, request).catch(() => false).then((delivered) => {
+      if (client !== nextClient || !nextClient.isConnected())
+        return;
+      try {
+        nextClient.respondPendingStageNotification(request.requestId, delivered);
+      } catch {}
+    });
+  }
   function attachClientHandlers(nextClient) {
     nextClient.on("message", (from, message, channel) => {
       const liveContext = getLiveContext();
@@ -61703,6 +62163,12 @@ function piIntercomExtension(pi, testOverrides = {}) {
       }
       handleIncomingMessage(liveContext, from, message, channel);
     });
+    nextClient.on("pending_stage_message", (request) => {
+      handlePendingStageMessage(nextClient, request, () => client === nextClient);
+    });
+    nextClient.on("pending_stage_notification", (request) => {
+      handlePendingStageNotification(nextClient, request);
+    });
     nextClient.on("peer_disconnected", (notice) => {
       if (client !== nextClient) {
         return;
@@ -61715,6 +62181,7 @@ function piIntercomExtension(pi, testOverrides = {}) {
       }
       rejectReplyWaiter(new Error(`Disconnected while waiting for reply: ${error.message}`, { cause: error }));
       client = null;
+      clientRegistrationGroup = null;
       if (process.env[INTERCOM_SESSION_ID_ENV] === nextClient.sessionId)
         restoreIntercomSessionIdEnv();
       if (!shuttingDown && !disposed) {
@@ -61738,6 +62205,132 @@ function piIntercomExtension(pi, testOverrides = {}) {
       ensureConnected("background").catch(() => {});
     }, reconnectDelayMs(reconnectAttempt));
   }
+  function samePendingStageRoute(left, right) {
+    return left !== undefined && normalizeGroup(left.group) === normalizeGroup(right.group) && left.capability === right.capability;
+  }
+  function pendingStageRouteClientIsCurrent(runId, state, context = runtimeContext, generation = runtimeGeneration) {
+    return pendingStageRouteClients.get(runId) === state && samePendingStageRoute(pendingStageRoutes.get(runId), state.route) && Boolean(getLiveContext(context, generation));
+  }
+  function schedulePendingStageRouteReconnect(runId, state) {
+    if (state.reconnectTimer || state.promise || !pendingStageRouteClientIsCurrent(runId, state))
+      return;
+    const scheduledGeneration = runtimeGeneration;
+    state.reconnectTimer = setTimeout(() => {
+      state.reconnectTimer = null;
+      if (!pendingStageRouteClientIsCurrent(runId, state, runtimeContext, scheduledGeneration))
+        return;
+      state.reconnectAttempt += 1;
+      ensurePendingStageRouteClient(runId, state.route).catch(() => {});
+    }, reconnectDelayMs(state.reconnectAttempt));
+  }
+  function attachPendingStageRouteClientHandlers(runId, state, nextClient) {
+    nextClient.on("pending_stage_message", (request) => {
+      handlePendingStageMessage(nextClient, request, () => state.client === nextClient && pendingStageRouteClientIsCurrent(runId, state));
+    });
+    nextClient.on("disconnected", () => {
+      if (state.client !== nextClient)
+        return;
+      state.client = null;
+      schedulePendingStageRouteReconnect(runId, state);
+    });
+    nextClient.on("error", () => {});
+  }
+  async function ensurePendingStageRouteClient(runId, route) {
+    const contextAtStart = getLiveContext();
+    const generationAtStart = runtimeGeneration;
+    if (!contextAtStart)
+      throw new Error("Intercom runtime not initialized");
+    let existing = pendingStageRouteClients.get(runId);
+    if (existing && !samePendingStageRoute(existing.route, route)) {
+      pendingStageRouteClients.delete(runId);
+      if (existing.reconnectTimer)
+        clearTimeout(existing.reconnectTimer);
+      try {
+        await existing.promise;
+      } catch {}
+      if (existing.client) {
+        try {
+          await existing.client.disconnect();
+        } catch {}
+      }
+      existing = undefined;
+    }
+    const state = existing ?? {
+      route,
+      client: null,
+      promise: null,
+      reconnectTimer: null,
+      reconnectAttempt: 0
+    };
+    if (!existing)
+      pendingStageRouteClients.set(runId, state);
+    if (state.client?.isConnected())
+      return;
+    if (state.promise)
+      return state.promise;
+    const promise = (async () => {
+      await spawnBrokerIfNeeded(config.brokerCommand, config.brokerArgs);
+      const nextClient = new IntercomClient(`${currentSessionId}:pending-stage-route:${runId}`);
+      state.client = nextClient;
+      attachPendingStageRouteClientHandlers(runId, state, nextClient);
+      await nextClient.connect({ ...buildRegistration(), name: undefined, 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);
+      await nextClient.listSessions();
+      if (!pendingStageRouteClientIsCurrent(runId, state, contextAtStart, generationAtStart)) {
+        await nextClient.disconnect();
+        throw new Error("Intercom runtime no longer active");
+      }
+      state.reconnectAttempt = 0;
+    })();
+    state.promise = promise;
+    try {
+      await promise;
+    } catch (error) {
+      const failedClient = state.client;
+      state.client = null;
+      if (failedClient) {
+        try {
+          await failedClient.disconnect();
+        } catch {}
+      }
+      if (state.promise === promise)
+        state.promise = null;
+      schedulePendingStageRouteReconnect(runId, state);
+      throw toError3(error);
+    } finally {
+      if (state.promise === promise)
+        state.promise = null;
+    }
+  }
+  async function disconnectPendingStageRouteClients() {
+    const states = [...pendingStageRouteClients.values()];
+    pendingStageRouteClients.clear();
+    for (const state of states) {
+      if (state.reconnectTimer)
+        clearTimeout(state.reconnectTimer);
+      try {
+        await state.promise;
+      } catch {}
+      if (!state.client)
+        continue;
+      try {
+        await state.client.disconnect();
+      } catch {}
+      state.client = null;
+    }
+  }
+  async function registerPendingStageRoute(activeClient, runId, route) {
+    const routeGroup = normalizeGroup(route.group);
+    if (clientRegistrationGroup === routeGroup) {
+      activeClient.registerPendingStageRoute(runId, routeGroup, route.capability);
+      return;
+    }
+    await ensurePendingStageRouteClient(runId, { ...route, group: routeGroup });
+  }
   async function ensureConnected(reason) {
     if (!config.enabled) {
       throw new Error("Intercom disabled");
@@ -61758,14 +62351,23 @@ function piIntercomExtension(pi, testOverrides = {}) {
       return reconnectPromise;
     }
     const nextReconnectPromise = (async () => {
-      const nextClient = new IntercomClient;
+      const nextClient = new IntercomClient(currentSessionId);
+      const registration = buildRegistration();
       client = nextClient;
       attachClientHandlers(nextClient);
       try {
         await spawnBrokerIfNeeded(config.brokerCommand, config.brokerArgs);
         const childMetadata = currentChildOrchestratorMetadata();
-        await nextClient.connect(buildRegistration(), childMetadata?.supervisor, supervisorAuthorizations.ownerToken, readSubagentMessageSource(runtimeContext?.subagentPolicy));
+        await nextClient.connect(registration, childMetadata?.supervisor, supervisorAuthorizations.ownerToken, readSubagentMessageSource(runtimeContext?.subagentPolicy));
+        clientRegistrationGroup = normalizeGroup(registration.group);
         await supervisorAuthorizations.restore(nextClient);
+        for (const [runId, route] of pendingStageRoutes) {
+          await registerPendingStageRoute(nextClient, runId, route);
+        }
+        const orchestration = contextAtStart.orchestrationContext;
+        if (orchestration?.kind === "workflow-stage" && orchestration.pendingStageDelivery !== undefined) {
+          await nextClient.registerLiveWorkflowStageRoute(orchestration.workflowRunId, [orchestration.workflowStageId, orchestration.workflowStageName], orchestration.pendingStageDelivery.routeCapability);
+        }
         if (!getLiveContext(contextAtStart, generationAtStart)) {
           await nextClient.disconnect();
           throw new Error("Intercom runtime no longer active");
@@ -61779,6 +62381,7 @@ function piIntercomExtension(pi, testOverrides = {}) {
       } catch (error) {
         if (client === nextClient) {
           client = null;
+          clientRegistrationGroup = null;
         }
         if (reason === "background" && getLiveContext(contextAtStart, generationAtStart)) {
           scheduleReconnect();
@@ -61795,6 +62398,43 @@ function piIntercomExtension(pi, testOverrides = {}) {
     reconnectPromiseGeneration = generationAtStart;
     return nextReconnectPromise;
   }
+  pi.events.on(PENDING_STAGE_ROUTE_EVENT, (payload) => {
+    if (!isPendingStageRouteRegistrationEvent(payload))
+      return;
+    pendingStageRoutes.set(payload.runId, { group: payload.group, capability: payload.capability });
+    const completion = ensureConnected("background").then((activeClient) => registerPendingStageRoute(activeClient, payload.runId, payload));
+    payload.completion = completion;
+    completion.catch(() => {});
+  });
+  async function pendingStageNotificationClient(runId) {
+    const route = pendingStageRoutes.get(runId);
+    if (route === undefined)
+      throw new Error("Pending workflow route is unavailable");
+    if (client?.isConnected() && clientRegistrationGroup === normalizeGroup(route.group))
+      return client;
+    await ensurePendingStageRouteClient(runId, route);
+    const routeClient = pendingStageRouteClients.get(runId)?.client;
+    if (!routeClient?.isConnected())
+      throw new Error("Pending workflow route is disconnected");
+    return routeClient;
+  }
+  pi.events.on(PENDING_STAGE_UNDELIVERABLE_EVENT, (payload) => {
+    if (!isPendingStageUndeliverableEvent(payload) || payload.handled)
+      return;
+    payload.handled = true;
+    const actionable = `Pending workflow stage could not receive intercom message: ${payload.reason}`;
+    payload.completion = pendingStageNotificationClient(payload.runId).then((activeClient) => {
+      const route = pendingStageRoutes.get(payload.runId);
+      if (route === undefined)
+        throw new Error("Pending workflow route is unavailable");
+      return activeClient.sendPendingStageNotification(payload.runId, route.capability, payload.senderId, payload.senderRegistrationName, {
+        text: actionable,
+        replyTo: payload.messageId,
+        replyError: actionable,
+        messageId: payload.notificationId
+      }, payload.senderReturnAddress);
+    }).then((result) => result.delivered).catch(() => false);
+  });
   registerSubagentRelay(pi, {
     runtimeGeneration: () => runtimeGeneration,
     runtimeStarted: () => runtimeStarted,
@@ -61810,8 +62450,11 @@ function piIntercomExtension(pi, testOverrides = {}) {
   registerIntercomLifecycle(pi, {
     config,
     client: () => client,
+    disconnectAuxiliaryClients: disconnectPendingStageRouteClients,
     setClient: (value) => {
       client = value;
+      if (value === null)
+        clientRegistrationGroup = null;
     },
     setShuttingDown: (value) => {
       shuttingDown = value;
@@ -61837,6 +62480,7 @@ function piIntercomExtension(pi, testOverrides = {}) {
         sessionHomeGroup = null;
       } else {
         sessionHomeGroup = resolveHomeGroup(config, value);
+        inboundDeliveries.restore(value.sessionManager.getBranch());
       }
       runtimeContext = value;
     },
@@ -61868,6 +62512,13 @@ function piIntercomExtension(pi, testOverrides = {}) {
     restoreIntercomSessionIdEnv,
     currentStatus
   });
+  pi.on("session_start", async (_event, ctx) => {
+    const pendingStageDelivery = ctx.orchestrationContext?.kind === "workflow-stage" ? ctx.orchestrationContext.pendingStageDelivery : undefined;
+    if (pendingStageDelivery === undefined)
+      return;
+    await ensureConnected("startup");
+    await pendingStageDelivery.deliverPending((from, message) => handleIncomingMessage(ctx, from, message, undefined, true));
+  });
   pi.registerMessageRenderer("intercom_message", (message, _options, theme2) => {
     const details = message.details;
     if (!details)
@@ -61900,7 +62551,7 @@ function piIntercomExtension(pi, testOverrides = {}) {
     syncPresenceIdentity
   });
 }
-var INTERCOM_SESSION_ID_ENV;
+var INTERCOM_SESSION_ID_ENV, PENDING_STAGE_ROUTE_EVENT = "atomic:workflow-pending-stage-route", PENDING_STAGE_MESSAGE_EVENT = "atomic:workflow-pending-stage-message", PENDING_STAGE_UNDELIVERABLE_EVENT = "atomic:workflow-pending-stage-undeliverable";
 var init_index_heavy = __esm(() => {
   init_src();
   init_client();
@@ -62124,6 +62775,14 @@ function createHeavyProxy(pi, captured) {
 var SUBAGENT_CONTROL_INTERCOM_EVENT2 = "subagent:control-intercom";
 var SUBAGENT_SUPERVISOR_AUTHORIZATION_EVENT2 = "subagent:supervisor-authorization";
 var WORKFLOW_STAGE_LATE_MESSAGE_EVENT = "atomic:workflow-stage-late-message";
+var PENDING_STAGE_ROUTE_EVENT2 = "atomic:workflow-pending-stage-route";
+var PENDING_STAGE_UNDELIVERABLE_EVENT2 = "atomic:workflow-pending-stage-undeliverable";
+function isPendingStageUndeliverableRelay(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  const event = value;
+  return typeof event.runId === "string" && typeof event.senderId === "string" && (event.senderRegistrationName === undefined || typeof event.senderRegistrationName === "string") && (event.senderReturnAddress === undefined || typeof event.senderReturnAddress === "string") && typeof event.messageId === "string" && typeof event.notificationId === "string" && typeof event.reason === "string";
+}
 function isCompletedStageAskRoute2(event) {
   return typeof event.workflowRunId === "string" && event.workflowRunId.length > 0 && typeof event.workflowStageId === "string" && event.workflowStageId.length > 0 && Array.isArray(event.messages) && event.messages.length > 0 && event.messages.every((message) => message.customType === "intercom_message" && typeof message.content === "string" && message.details?.message?.expectsReply === true);
 }
@@ -62349,8 +63008,11 @@ function intercom(pi, options = {}) {
     }
     const generation = ++lifecycleGeneration;
     sessionSnapshot = { event, ctx, generation, lease };
-    if (loadedHeavy)
+    if (ctx.orchestrationContext?.kind === "workflow-stage" && ctx.orchestrationContext.pendingStageDelivery !== undefined) {
+      await loadHeavy(ctx);
+    } else if (loadedHeavy) {
       await ensureSessionStartReplayed(loadedHeavy.heavy, lease);
+    }
   });
   pi.on("session_shutdown", async (event, ctx) => {
     const lease = activeLease;
@@ -62466,13 +63128,41 @@ function intercom(pi, options = {}) {
       return await forwarded.completion;
     });
   });
-  for (const eventName of [SUBAGENT_CONTROL_INTERCOM_EVENT2, SUBAGENT_RESULT_INTERCOM_EVENT3]) {
+  pi.events.on(PENDING_STAGE_UNDELIVERABLE_EVENT2, (payload) => {
+    if (!isPendingStageUndeliverableRelay(payload) || payload.handled === true)
+      return;
+    payload.handled = true;
+    const forwarded = { ...payload, handled: false, completion: undefined };
+    payload.completion = loadHeavy(latestLifecycleContext()).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) => {
+      console.error(`Intercom event relay failed (${PENDING_STAGE_UNDELIVERABLE_EVENT2}):`, error);
+      return false;
+    });
+  });
+  for (const eventName of [
+    SUBAGENT_CONTROL_INTERCOM_EVENT2,
+    SUBAGENT_RESULT_INTERCOM_EVENT3,
+    PENDING_STAGE_ROUTE_EVENT2
+  ]) {
     pi.events.on(eventName, (payload) => {
-      loadHeavy(latestLifecycleContext()).then(async (handle) => {
+      const completion = loadHeavy(latestLifecycleContext()).then(async (handle) => {
         handle.assertCurrent();
         await dispatchEventHandlers(handle.heavy, eventName, payload);
         handle.assertCurrent();
-      }).catch((error) => {
+        if (eventName === PENDING_STAGE_ROUTE_EVENT2 && payload && typeof payload === "object") {
+          const routeCompletion = payload.completion;
+          if (routeCompletion !== undefined && routeCompletion !== completion)
+            await routeCompletion;
+        }
+      });
+      if (eventName === PENDING_STAGE_ROUTE_EVENT2 && payload && typeof payload === "object") {
+        payload.completion = completion;
+      }
+      completion.catch((error) => {
         rejectLazyResultRelay(pi, eventName, payload, error);
         console.error(`Intercom event relay failed (${eventName}):`, error);
       });
@@ -62497,6 +63187,7 @@ function intercom(pi, options = {}) {
     description: `Send a message to another local agent session running on this machine.
 Use this to communicate findings, request help, or coordinate work with other sessions.
 Sessions belong to an intercom group and can ONLY message sessions in the same group; cross-group sends are rejected by the broker. Ungrouped sessions share the "default" group.
+For send, live session names and exact full session IDs remain supported. For a known workflow stage, use the exact \`<runId>:<stageKey>\` target; send messages to pending stages queue automatically.
 Usage:
   intercom({ action: "list" })                    → List sessions in your group
   intercom({ action: "list", group: "name" })     → Read-only peek at another group's sessions
@@ -62512,7 +63203,7 @@ Usage:
     promptSnippet: "Use to coordinate with other local agent sessions in your intercom group: list peers, send updates, ask for help, or check intercom connectivity. Groups are isolated; you can only message sessions in your own group.",
     parameters: Type15.Object({
       action: Type15.String({ description: "Action: 'list', 'join', 'leave', 'send', 'ask', 'reply', 'pending', or 'status'" }),
-      to: Type15.Optional(Type15.String({ description: "Exact session name or exact full session ID (for 'send', 'ask', or targeted 'reply')" })),
+      to: Type15.Optional(Type15.String({ description: "Live session name, exact full session ID, or exact `<runId>:<stageKey>` for a known workflow stage; send messages to pending stages queue automatically (for 'send', 'ask', or targeted 'reply')" })),
       message: Type15.Optional(Type15.String({ description: "Message to send (for 'send', 'ask', or 'reply' action)" })),
       attachments: Type15.Optional(Type15.Array(Type15.Object({
         type: Type15.Union([Type15.Literal("file"), Type15.Literal("snippet"), Type15.Literal("context")]),