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

package/dist/builtin/workflows/src/{index.bundle.mjs → index.js}

@@ -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) {
@@ -12226,6 +12233,8 @@ class ExtensionRunner {
   shortcutDiagnostics = [];
   commandDiagnostics = [];
   staleMessage;
+  uiPromptBinding = 0;
+  activeUIPrompt;
   constructor(extensions, runtime, cwd, sessionManager, modelRegistry, orchestrationContext, subagentPolicy) {
     this.extensions = extensions;
     this.runtime = runtime;
@@ -12320,9 +12329,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;
   }
@@ -21628,11 +21699,20 @@ function isCodexFastModeCandidateModelId(modelId) {
   const provider = modelId?.split("/", 1)[0];
   return provider !== undefined && isCodexFastModeSupportedProvider(provider);
 }
-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";
@@ -21643,11 +21723,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;
@@ -21788,7 +21868,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";
@@ -39432,14 +39512,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) {
@@ -39678,7 +39762,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,
@@ -46657,6 +46741,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();
@@ -46675,6 +46784,7 @@ var init_isolated_runtime = __esm(() => {
     steeringMessages = [];
     followUpMessages = [];
     queueUpdateGeneration = 0;
+    thinkingEpoch = 0;
     pendingQueueClear;
     engineCallbackActive = false;
     queuePause;
@@ -47039,43 +47149,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;
           }
         },
@@ -47119,6 +47242,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())
@@ -47159,6 +47290,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;
@@ -47198,6 +47335,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":
@@ -48411,7 +48549,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" },
@@ -49863,7 +50001,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);
@@ -50551,7 +50689,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) {
@@ -51477,7 +51615,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(),
@@ -55066,7 +55204,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;
@@ -55074,7 +55212,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];
@@ -57931,6 +58069,152 @@ function buildStagePromptAdapter(id, kind, args, createdAt) {
 // dist/builtin/workflows/src/shared/stage-ui-broker.ts
 import { randomUUID as randomUUID7 } from "node:crypto";
 
+// dist/builtin/workflows/src/shared/pending-stage-delivery.ts
+var PENDING_STAGE_MESSAGE_LIMIT = 50;
+var PENDING_STAGE_UNDELIVERABLE_NOTIFICATION_PREFIX = "atomic-pending-stage-undeliverable";
+function queueStageMessage(messages2, input2, senderGroup, runGroup, stageIdentity) {
+  if (normalizeDeliveryGroup(senderGroup) !== normalizeDeliveryGroup(runGroup)) {
+    return { ok: false, reason: "group_mismatch", runId: input2.runId, stageKey: input2.stageKey };
+  }
+  const messageId = input2.message.id;
+  const queued = pendingStageMessagesFor(messages2, input2.runId, input2.stageKey, stageIdentity);
+  const existing = messages2.find((entry2) => entry2.runId === input2.runId && entry2.id === messageId);
+  if (existing !== undefined) {
+    if (pendingStageMessageSignature(existing, stageIdentity) !== pendingStageMessageSignature(input2, stageIdentity)) {
+      return {
+        ok: false,
+        reason: "message_id_conflict",
+        runId: input2.runId,
+        stageKey: input2.stageKey,
+        messageId
+      };
+    }
+    const queuedPosition = queued.indexOf(existing);
+    return {
+      ok: true,
+      messages: messages2,
+      entry: existing,
+      ...queuedPosition >= 0 ? { position: queuedPosition + 1 } : {},
+      deduplicated: true
+    };
+  }
+  if (queued.length >= PENDING_STAGE_MESSAGE_LIMIT) {
+    return {
+      ok: false,
+      reason: "capacity",
+      limit: PENDING_STAGE_MESSAGE_LIMIT,
+      runId: input2.runId,
+      stageKey: input2.stageKey
+    };
+  }
+  const entry = {
+    ...input2,
+    id: messageId,
+    ...stageIdentity !== undefined ? { stageId: stageIdentity.id } : {},
+    ...stageIdentity?.replayKey !== undefined ? { stageReplayKey: stageIdentity.replayKey } : {},
+    admissionOrder: nextAdmissionOrder(messages2, input2.runId),
+    status: "queued"
+  };
+  return {
+    ok: true,
+    messages: [...messages2, entry],
+    entry,
+    position: queued.length + 1,
+    deduplicated: false
+  };
+}
+function pendingStageMessagesFor(messages2, runId, stageKey, stageIdentity) {
+  return messages2.map((entry, index) => ({ entry, index })).filter(({ entry }) => matchesPendingStage(entry, runId, stageKey, stageIdentity) && entry.status === "queued").sort((left, right) => (left.entry.admissionOrder ?? left.index + 1) - (right.entry.admissionOrder ?? right.index + 1) || left.index - right.index).map(({ entry }) => entry);
+}
+function markPendingStageMessageDelivered(messages2, runId, stageKey, messageId, deliveredAt, stageIdentity) {
+  return updateQueuedPendingStageMessage(messages2, runId, stageKey, messageId, stageIdentity, (entry) => ({
+    ...entry,
+    status: "delivered",
+    deliveredAt
+  }));
+}
+function markPendingStageMessageUndeliverable(messages2, runId, stageKey, messageId, reason, stageIdentity) {
+  return updateQueuedPendingStageMessage(messages2, runId, stageKey, messageId, stageIdentity, (entry) => ({
+    ...entry,
+    status: "undeliverable",
+    undeliverableReason: reason,
+    undeliverableNotificationId: pendingStageUndeliverableNotificationId(entry)
+  }));
+}
+function markPendingStageMessageUndeliverableNotified(messages2, runId, stageKey, messageId, notificationId, notifiedAt) {
+  const index = messages2.findIndex((entry) => matchesPendingStage(entry, runId, stageKey) && entry.id === messageId && entry.status === "undeliverable" && entry.undeliverableNotificationId === notificationId && entry.undeliverableNotifiedAt === undefined);
+  if (index < 0)
+    return messages2;
+  const next = [...messages2];
+  next[index] = { ...next[index], undeliverableNotifiedAt: notifiedAt };
+  return next;
+}
+function pendingStageUndeliverableNotificationId(entry) {
+  return [
+    PENDING_STAGE_UNDELIVERABLE_NOTIFICATION_PREFIX,
+    encodeURIComponent(entry.runId),
+    encodeURIComponent(entry.stageKey),
+    encodeURIComponent(entry.id)
+  ].join(":");
+}
+function updateQueuedPendingStageMessage(messages2, runId, stageKey, messageId, stageIdentity, update2) {
+  const index = messages2.findIndex((entry) => matchesPendingStage(entry, runId, stageKey, stageIdentity) && entry.id === messageId && entry.status === "queued");
+  if (index < 0)
+    return messages2;
+  const next = [...messages2];
+  next[index] = update2(next[index]);
+  return next;
+}
+function matchesPendingStage(entry, runId, stageKey, stageIdentity) {
+  if (entry.runId !== runId)
+    return false;
+  if (stageIdentity === undefined)
+    return entry.stageKey === stageKey;
+  return entry.stageId === stageIdentity.id || entry.stageReplayKey !== undefined && entry.stageReplayKey === stageIdentity.replayKey || entry.stageId === undefined && stageIdentity.aliases.includes(entry.stageKey);
+}
+function nextAdmissionOrder(messages2, runId) {
+  let greatest = 0;
+  let legacyPosition = 0;
+  for (const entry of messages2) {
+    if (entry.runId !== runId)
+      continue;
+    legacyPosition += 1;
+    greatest = Math.max(greatest, entry.admissionOrder ?? legacyPosition);
+  }
+  return greatest + 1;
+}
+function pendingStageMessageSignature(entry, stageIdentity) {
+  const storedTarget = "status" in entry ? entry.stageReplayKey ?? entry.stageId : undefined;
+  const { timestamp: transportTimestamp, ...logicalMessage } = entry.message;
+  return stableJson({
+    target: storedTarget ?? stageIdentity?.replayKey ?? stageIdentity?.id ?? entry.stageKey,
+    sender: entry.senderReturnAddress ?? entry.from.id,
+    message: {
+      ...logicalMessage,
+      expectsReply: logicalMessage.expectsReply ?? false,
+      content: {
+        ...logicalMessage.content,
+        attachments: logicalMessage.content.attachments ?? []
+      }
+    }
+  });
+}
+function stableJson(value) {
+  return JSON.stringify(sortJsonValue(value));
+}
+function sortJsonValue(value) {
+  if (Array.isArray(value))
+    return value.map(sortJsonValue);
+  if (typeof value !== "object" || value === null)
+    return value;
+  return Object.fromEntries(Object.entries(value).filter(([, nested]) => nested !== undefined).sort(([left], [right]) => left.localeCompare(right)).map(([key, nested]) => [key, sortJsonValue(nested)]));
+}
+function normalizeDeliveryGroup(value) {
+  if (typeof value !== "string")
+    return "default";
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : "default";
+}
 // dist/builtin/workflows/src/shared/flat-string.ts
 function flattenTruncatedString(value) {
   return value.split("").join("");
@@ -58238,6 +58522,7 @@ function compactStage(stage) {
     inputRequest,
     notices,
     mcpScope: _mcpScope,
+    pendingStageDeliveryAvailable: _pendingStageDeliveryAvailable,
     attemptedModels: _attemptedModels,
     modelAttempts: _modelAttempts,
     result: _result,
@@ -58493,6 +58778,133 @@ function createStoreContext(state = createStoreState()) {
   };
 }
 
+// dist/builtin/workflows/src/shared/store-pending-stage-delivery-methods.ts
+function createPendingStageDeliveryStoreMethods(context) {
+  const transitions = new Map;
+  const serialize = async (runId, transition) => {
+    const previous2 = transitions.get(runId) ?? Promise.resolve();
+    const result = previous2.catch(() => {
+      return;
+    }).then(transition);
+    const settled = result.then(() => {
+      return;
+    }, () => {
+      return;
+    });
+    transitions.set(runId, settled);
+    settled.finally(() => {
+      if (transitions.get(runId) === settled)
+        transitions.delete(runId);
+    });
+    return await result;
+  };
+  return {
+    async queueStageMessage(input2, senderGroup, runGroup, backend) {
+      return await serialize(input2.runId, async () => {
+        const run = context.findRun(input2.runId);
+        if (run === undefined)
+          return;
+        const stageIdentity = resolvePendingStageIdentity(run, input2.stageKey);
+        const result = queueStageMessage(run.pendingStageMessages ?? [], input2, senderGroup, runGroup, stageIdentity);
+        if (result.ok && !result.deduplicated) {
+          await persistTransition(backend, input2.runId, result.messages);
+          run.pendingStageMessages = [...result.messages];
+          context.bumpAndNotify();
+        }
+        return result;
+      });
+    },
+    async validateLiveStageMessage(input2) {
+      return await serialize(input2.runId, async () => {
+        const run = context.findRun(input2.runId);
+        if (run === undefined)
+          return;
+        const result = queueStageMessage(run.pendingStageMessages ?? [], input2, undefined, undefined, resolvePendingStageIdentity(run, input2.stageKey));
+        if (!result.ok) {
+          return result.reason === "message_id_conflict" ? { outcome: "message_id_conflict", messageId: result.messageId } : { outcome: "forward" };
+        }
+        if (!result.deduplicated)
+          return { outcome: "forward" };
+        if (result.entry.status === "delivered")
+          return { outcome: "delivered" };
+        if (result.entry.status === "undeliverable") {
+          return { outcome: "undeliverable", reason: result.entry.undeliverableReason };
+        }
+        if (result.position === undefined) {
+          throw new Error(`atomic-workflows: queued message ${input2.message.id} has no active position`);
+        }
+        return { outcome: "queued", position: result.position };
+      });
+    },
+    pendingStageMessagesFor(runId, stageKey) {
+      const run = context.findRun(runId);
+      return pendingStageMessagesFor(run?.pendingStageMessages ?? [], runId, stageKey, run === undefined ? undefined : resolvePendingStageIdentity(run, stageKey));
+    },
+    async markPendingStageMessageDelivered(runId, stageKey, messageId, deliveredAt, backend) {
+      return await serialize(runId, async () => {
+        const run = context.findRun(runId);
+        if (run === undefined)
+          return false;
+        const current = run.pendingStageMessages ?? [];
+        const next = markPendingStageMessageDelivered(current, runId, stageKey, messageId, deliveredAt, resolvePendingStageIdentity(run, stageKey));
+        if (next === current)
+          return false;
+        await persistTransition(backend, runId, next);
+        run.pendingStageMessages = [...next];
+        context.bumpAndNotify();
+        return true;
+      });
+    },
+    async markPendingStageMessageUndeliverable(runId, stageKey, messageId, reason, backend) {
+      return await serialize(runId, async () => {
+        const run = context.findRun(runId);
+        if (run === undefined)
+          return false;
+        const current = run.pendingStageMessages ?? [];
+        const next = markPendingStageMessageUndeliverable(current, runId, stageKey, messageId, reason, resolvePendingStageIdentity(run, stageKey));
+        if (next === current)
+          return false;
+        await persistTransition(backend, runId, next);
+        run.pendingStageMessages = [...next];
+        context.bumpAndNotify();
+        return true;
+      });
+    },
+    async markPendingStageMessageUndeliverableNotified(runId, stageKey, messageId, notificationId, notifiedAt, backend) {
+      return await serialize(runId, async () => {
+        const run = context.findRun(runId);
+        if (run === undefined)
+          return false;
+        const current = run.pendingStageMessages ?? [];
+        const next = markPendingStageMessageUndeliverableNotified(current, runId, stageKey, messageId, notificationId, notifiedAt);
+        if (next === current)
+          return false;
+        await persistTransition(backend, runId, next);
+        run.pendingStageMessages = [...next];
+        context.bumpAndNotify();
+        return true;
+      });
+    }
+  };
+}
+function resolvePendingStageIdentity(run, stageKey) {
+  const exactIds = run.stages.filter((stage2) => stage2.id === stageKey);
+  const candidates = exactIds.length > 0 ? exactIds : run.stages.filter((stage2) => stage2.name === stageKey);
+  if (candidates.length !== 1)
+    return;
+  const stage = candidates[0];
+  return {
+    id: stage.id,
+    ...stage.replayKey !== undefined ? { replayKey: stage.replayKey } : {},
+    aliases: stage.id === stage.name ? [stage.id] : [stage.id, stage.name]
+  };
+}
+async function persistTransition(backend, runId, messages2) {
+  if (!await backend.persistPendingStageMessages(runId, messages2)) {
+    throw new Error(`atomic-workflows: durable workflow ${runId} is unavailable for pending-stage persistence`);
+  }
+}
+
 // dist/builtin/workflows/src/shared/store-prompt-methods.ts
 function createPromptStoreMethods(context) {
   const { state } = context;
@@ -59407,6 +59819,7 @@ function createStore() {
   const context = createStoreContext();
   return {
     ...createRunStoreMethods(context),
+    ...createPendingStageDeliveryStoreMethods(context),
     ...createStageStoreMethods(context),
     ...createToolNodeStoreMethods(context),
     ...createPromptStoreMethods(context)
@@ -60148,6 +60561,381 @@ ${formatValidationErrors(errors)}`);
   }
   return resolved;
 }
+// dist/builtin/workflows/src/shared/workflow-failures-signals.ts
+function asRecord2(value) {
+  return value !== null && typeof value === "object" ? value : undefined;
+}
+function field2(value, key2) {
+  return asRecord2(value)?.[key2];
+}
+function safeField(value, key2) {
+  try {
+    return field2(value, key2);
+  } catch {
+    return;
+  }
+}
+function nonZeroExitCode(value) {
+  if (typeof value === "number")
+    return Number.isFinite(value) && value !== 0;
+  if (typeof value !== "string")
+    return false;
+  const parsed = Number(value.trim());
+  return Number.isFinite(parsed) && parsed !== 0;
+}
+function nonEmptyProcessOutput(value) {
+  if (typeof value === "string")
+    return value.length > 0;
+  if (value instanceof ArrayBuffer)
+    return value.byteLength > 0;
+  return ArrayBuffer.isView(value) && value.byteLength > 0;
+}
+function findProcessFailureError(value, seen, depth) {
+  if (value === null || typeof value !== "object" || depth >= 8 || seen.has(value))
+    return;
+  seen.add(value);
+  if (nonZeroExitCode(safeField(value, "exitCode")))
+    return value;
+  if (nonEmptyProcessOutput(safeField(value, "stdout")))
+    return value;
+  if (nonEmptyProcessOutput(safeField(value, "stderr")))
+    return value;
+  for (const key2 of ["cause", "error", "response", "body"]) {
+    const selected = findProcessFailureError(safeField(value, key2), seen, depth + 1);
+    if (selected !== undefined)
+      return selected;
+  }
+  const diagnostics = safeField(value, "diagnostics");
+  if (Array.isArray(diagnostics)) {
+    for (const diagnostic of diagnostics) {
+      const selected = findProcessFailureError(safeField(diagnostic, "error") ?? diagnostic, seen, depth + 1);
+      if (selected !== undefined)
+        return selected;
+    }
+  }
+  const errors = safeField(value, "errors");
+  if (!Array.isArray(errors))
+    return;
+  for (const error of errors) {
+    const selected = findProcessFailureError(error, seen, depth + 1);
+    if (selected !== undefined)
+      return selected;
+  }
+  return;
+}
+function selectProcessFailureError(error) {
+  return findProcessFailureError(error, new Set, 0) ?? error;
+}
+function hasProcessFailureEvidence(error) {
+  return findProcessFailureError(error, new Set, 0) !== undefined;
+}
+function stringField4(value, key2) {
+  const raw = field2(value, key2);
+  return typeof raw === "string" && raw.length > 0 ? raw : undefined;
+}
+function errorMessage3(error) {
+  const structuredMessage = structuredErrorMessage(error);
+  if (structuredMessage !== undefined)
+    return structuredMessage;
+  if (error instanceof Error && typeof error.message === "string")
+    return error.message;
+  if (typeof error === "string")
+    return error;
+  return String(error);
+}
+function errorName2(error) {
+  return error instanceof Error ? error.name : stringField4(error, "name");
+}
+function structuredErrorMessage(error) {
+  return stringField4(error, "errorMessage") ?? stringField4(error, "message") ?? stringField4(error, "statusText");
+}
+function integerFrom2(value) {
+  if (typeof value === "number" && Number.isInteger(value))
+    return value;
+  if (typeof value !== "string" || value.trim().length === 0)
+    return;
+  const parsed = Number(value.trim());
+  return Number.isInteger(parsed) ? parsed : undefined;
+}
+function numberFrom(value) {
+  if (typeof value === "number" && Number.isFinite(value))
+    return value;
+  if (typeof value !== "string" || value.trim().length === 0)
+    return;
+  const parsed = Number(value.trim());
+  return Number.isFinite(parsed) ? parsed : undefined;
+}
+function retryAfterHeaderMs(value) {
+  const numeric = numberFrom(value);
+  if (numeric !== undefined && numeric >= 0)
+    return Math.round(numeric * 1000);
+  if (typeof value !== "string" || value.trim().length === 0)
+    return;
+  const dateMs = Date.parse(value);
+  if (!Number.isFinite(dateMs))
+    return;
+  return Math.max(0, dateMs - Date.now());
+}
+function retryAfterMsFrom(error) {
+  const directMs = numberFrom(field2(error, "retryAfterMs"));
+  if (directMs !== undefined && directMs >= 0)
+    return Math.round(directMs);
+  const seconds = numberFrom(field2(error, "retryAfterSeconds"));
+  if (seconds !== undefined && seconds >= 0)
+    return Math.round(seconds * 1000);
+  const retryAfter = retryAfterHeaderMs(field2(error, "retryAfter"));
+  if (retryAfter !== undefined)
+    return retryAfter;
+  const retryAfterHeader = retryAfterHeaderMs(field2(error, "retry-after"));
+  if (retryAfterHeader !== undefined)
+    return retryAfterHeader;
+  const headers = field2(error, "headers");
+  const headerRecord = asRecord2(headers);
+  const headerValue = headerRecord?.["retry-after"] ?? headerRecord?.["Retry-After"];
+  return retryAfterHeaderMs(headerValue);
+}
+function structuredSignal2(error) {
+  const status = integerFrom2(field2(error, "status")) ?? integerFrom2(field2(error, "statusCode")) ?? integerFrom2(field2(error, "httpStatus"));
+  const rawCode = field2(error, "code");
+  const code = typeof rawCode === "string" || typeof rawCode === "number" ? rawCode : undefined;
+  const name = errorName2(error);
+  const stopReason = stringField4(error, "stopReason");
+  const message = structuredErrorMessage(error);
+  const retryAfterMs = retryAfterMsFrom(error);
+  return {
+    ...status !== undefined ? { status } : {},
+    ...code !== undefined ? { code } : {},
+    ...name !== undefined ? { name } : {},
+    ...stopReason !== undefined ? { stopReason } : {},
+    ...message !== undefined ? { message } : {},
+    ...retryAfterMs !== undefined ? { retryAfterMs } : {}
+  };
+}
+function causeOf2(error) {
+  if (error instanceof Error)
+    return error.cause;
+  return field2(error, "cause");
+}
+function diagnosticErrors2(error) {
+  const diagnostics = field2(error, "diagnostics");
+  if (!Array.isArray(diagnostics))
+    return [];
+  const errors = [];
+  for (const diagnostic of diagnostics) {
+    const diagnosticError = field2(diagnostic, "error");
+    errors.push(diagnosticError ?? diagnostic);
+  }
+  return errors;
+}
+function nestedProviderError(error) {
+  return field2(error, "error") ?? field2(error, "response") ?? field2(error, "body");
+}
+function normalizeCode2(value) {
+  if (value === undefined)
+    return;
+  return String(value).trim().toLowerCase().replaceAll("-", "_").replaceAll(" ", "_");
+}
+function httpStatusFromCode(value) {
+  if (value === undefined)
+    return;
+  if (typeof value === "number") {
+    return Number.isInteger(value) && value >= 100 && value <= 599 ? value : undefined;
+  }
+  const trimmed = value.trim();
+  if (!/^\d{3}$/.test(trimmed))
+    return;
+  const parsed = Number(trimmed);
+  return parsed >= 100 && parsed <= 599 ? parsed : undefined;
+}
+function codeEvidenceFrom(value) {
+  const status = httpStatusFromCode(value);
+  if (status !== undefined)
+    return { kind: "wrapper_http_status", status };
+  const normalized = normalizeCode2(value);
+  return normalized !== undefined && normalized.length > 0 ? { kind: "semantic_code", normalized } : undefined;
+}
+function tokenize(value) {
+  const tokens = [];
+  let current = "";
+  for (const char of value.toLowerCase()) {
+    if (char >= "a" && char <= "z" || char >= "0" && char <= "9") {
+      current += char;
+    } else if (current.length > 0) {
+      tokens.push(current);
+      current = "";
+    }
+  }
+  if (current.length > 0)
+    tokens.push(current);
+  return tokens;
+}
+function hasPhrase(tokens, phrase) {
+  if (phrase.length === 0 || phrase.length > tokens.length)
+    return false;
+  for (let index = 0;index <= tokens.length - phrase.length; index += 1) {
+    let matched = true;
+    for (let offset = 0;offset < phrase.length; offset += 1) {
+      if (tokens[index + offset] !== phrase[offset]) {
+        matched = false;
+        break;
+      }
+    }
+    if (matched)
+      return true;
+  }
+  return false;
+}
+function hasAnyPhrase(tokens, phrases) {
+  return phrases.some((phrase) => hasPhrase(tokens, phrase));
+}
+function tokenNearAny(tokens, anchor, candidates, distance) {
+  for (let index = 0;index < tokens.length; index += 1) {
+    if (tokens[index] !== anchor)
+      continue;
+    const start = Math.max(0, index - distance);
+    const end = Math.min(tokens.length - 1, index + distance);
+    for (let cursor = start;cursor <= end; cursor += 1) {
+      if (cursor !== index && candidates.has(tokens[cursor]))
+        return true;
+    }
+  }
+  return false;
+}
+function redactedSecretReplacement(prefix) {
+  return `${prefix}[redacted]`;
+}
+function redactSensitiveText(value) {
+  return value.replace(/(sk-[A-Za-z0-9_-]{8})[A-Za-z0-9_-]+/g, redactedSecretReplacement("$1")).replace(/\b(authorization\s*:\s*bearer\s+)[^\s,;]+/gi, "$1[redacted]").replace(/\b(bearer\s+)[A-Za-z0-9._~+/-]{8,}=*/gi, "$1[redacted]").replace(/((?:api[_-]?key|token|credential|secret)\s*[:=]\s*)[^\s,;]+/gi, "$1[redacted]");
+}
+
+// dist/builtin/workflows/src/durable/tool-outcome.ts
+var TOOL_FAILURE_TEXT_LIMIT_BYTES = 16384;
+var TRUNCATION_PREFIX = `[workflow tool output truncated; showing final bytes]
+`;
+function safeField2(error, key2) {
+  try {
+    return field2(error, key2);
+  } catch {
+    return;
+  }
+}
+function exposedText(error, key2) {
+  const value = safeField2(error, key2);
+  if (typeof value === "string")
+    return value;
+  try {
+    if (value instanceof ArrayBuffer)
+      return new TextDecoder().decode(value);
+    if (ArrayBuffer.isView(value)) {
+      return new TextDecoder().decode(new Uint8Array(value.buffer, value.byteOffset, value.byteLength));
+    }
+  } catch {
+    return;
+  }
+  return;
+}
+function boundedSafeToolFailureText(value) {
+  const redacted = redactSensitiveText(value);
+  const bytes = new TextEncoder().encode(redacted);
+  if (bytes.byteLength <= TOOL_FAILURE_TEXT_LIMIT_BYTES)
+    return redacted;
+  const prefix = new TextEncoder().encode(TRUNCATION_PREFIX);
+  const tailLength = Math.max(0, TOOL_FAILURE_TEXT_LIMIT_BYTES - prefix.byteLength);
+  let start = bytes.byteLength - tailLength;
+  const decoder = new TextDecoder("utf-8", { fatal: true });
+  while (start < bytes.byteLength) {
+    try {
+      return TRUNCATION_PREFIX + decoder.decode(bytes.slice(start));
+    } catch {
+      start += 1;
+    }
+  }
+  return TRUNCATION_PREFIX.slice(0, TOOL_FAILURE_TEXT_LIMIT_BYTES);
+}
+function safeErrorText(error) {
+  try {
+    return String(error);
+  } catch {
+    return "Tool callback failed";
+  }
+}
+function normalizeWorkflowToolError(error) {
+  error = selectProcessFailureError(error);
+  const exitCode = safeField2(error, "exitCode");
+  const stdout = exposedText(error, "stdout");
+  const stderr = exposedText(error, "stderr");
+  let message;
+  let name;
+  try {
+    message = errorMessage3(error);
+  } catch {
+    message = safeErrorText(error);
+  }
+  try {
+    name = errorName2(error) ?? "Error";
+  } catch {
+    name = "Error";
+  }
+  return {
+    name: boundedSafeToolFailureText(name),
+    message: boundedSafeToolFailureText(message),
+    ...typeof exitCode === "number" && Number.isInteger(exitCode) ? { exitCode } : {},
+    ...stdout !== undefined ? { stdout: boundedSafeToolFailureText(stdout) } : {},
+    ...stderr !== undefined ? { stderr: boundedSafeToolFailureText(stderr) } : {}
+  };
+}
+function workflowToolSuccess(value, attempts, cached) {
+  return { ok: true, value, attempts, cached };
+}
+function workflowToolFailure(error, attempts, cached) {
+  return { ok: false, error: normalizeWorkflowToolError(error), attempts, cached };
+}
+function workflowToolOutcomeFromValue(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value))
+    return;
+  const candidate = value;
+  if (!Number.isInteger(candidate.attempts) || typeof candidate.cached !== "boolean")
+    return;
+  if (candidate.ok === true && "value" in candidate)
+    return candidate;
+  const error = candidate.error;
+  if (candidate.ok !== false || error === null || typeof error !== "object" || Array.isArray(error))
+    return;
+  const details = error;
+  if (typeof details.name !== "string" || typeof details.message !== "string" || details.exitCode !== undefined && !Number.isInteger(details.exitCode) || details.stdout !== undefined && typeof details.stdout !== "string" || details.stderr !== undefined && typeof details.stderr !== "string")
+    return;
+  return candidate;
+}
+function replayedWorkflowToolOutcome(outcome) {
+  return { ...outcome, cached: true };
+}
+
+// dist/builtin/workflows/src/durable/types.ts
+var DURABLE_TOOL_TOPOLOGY_VERSION = 1;
+var DURABLE_STAGE_TOPOLOGY_VERSION = 1;
+var DURABLE_BOUNDARY_TOPOLOGY_VERSION = 1;
+
+// dist/builtin/workflows/src/durable/durable-hash.ts
+import { createHash as createHash6 } from "node:crypto";
+function durableHash(value) {
+  const canonical = canonicalJsonString(value);
+  const digest = createHash6("sha256").update(canonical).digest("hex");
+  return `h${digest.slice(0, 32)}`;
+}
+function canonicalJsonString(value) {
+  if (value === null || typeof value !== "object")
+    return JSON.stringify(value);
+  if (Array.isArray(value))
+    return `[${value.map(canonicalJsonString).join(",")}]`;
+  const object = value;
+  const keys = Object.keys(object).sort();
+  return `{${keys.map((key2) => `${JSON.stringify(key2)}:${canonicalJsonString(object[key2])}`).join(",")}}`;
+}
+// dist/builtin/workflows/src/durable/backend.ts
+function pendingStageMessagesForDurableRun(backend, logicalRunId, rootWorkflowId = logicalRunId) {
+  return (backend.getWorkflow(rootWorkflowId)?.pendingStageMessages ?? []).filter((entry) => entry.runId === logicalRunId);
+}
+
 // dist/builtin/workflows/src/runs/foreground/executor-child-helpers.ts
 function cloneWorkflowChildValue(value) {
   return structuredClone(value);
@@ -60201,11 +60989,6 @@ function workflowChildReplaySnapshot(alias, childResult) {
   };
 }
 
-// dist/builtin/workflows/src/durable/types.ts
-var DURABLE_TOOL_TOPOLOGY_VERSION = 1;
-var DURABLE_STAGE_TOPOLOGY_VERSION = 1;
-var DURABLE_BOUNDARY_TOPOLOGY_VERSION = 1;
-
 // dist/builtin/workflows/src/durable/stage-topology-validation.ts
 function immutableStageGroupError(stages) {
   const occurrenceError = promptOccurrenceIdentityError(stages);
@@ -60779,23 +61562,6 @@ function validatedInvocationRecords(input2) {
   return { stages, start };
 }
 
-// dist/builtin/workflows/src/durable/durable-hash.ts
-import { createHash as createHash6 } from "node:crypto";
-function durableHash(value) {
-  const canonical = canonicalJsonString(value);
-  const digest = createHash6("sha256").update(canonical).digest("hex");
-  return `h${digest.slice(0, 32)}`;
-}
-function canonicalJsonString(value) {
-  if (value === null || typeof value !== "object")
-    return JSON.stringify(value);
-  if (Array.isArray(value))
-    return `[${value.map(canonicalJsonString).join(",")}]`;
-  const object = value;
-  const keys = Object.keys(object).sort();
-  return `{${keys.map((key2) => `${JSON.stringify(key2)}:${canonicalJsonString(object[key2])}`).join(",")}}`;
-}
-
 // dist/builtin/workflows/src/durable/child-invocation.ts
 function durableChildInvocationFingerprint(child, inputs) {
   return durableHash({
@@ -60804,354 +61570,6 @@ function durableChildInvocationFingerprint(child, inputs) {
   });
 }
 
-// dist/builtin/workflows/src/shared/workflow-failures-signals.ts
-function asRecord2(value) {
-  return value !== null && typeof value === "object" ? value : undefined;
-}
-function field2(value, key2) {
-  return asRecord2(value)?.[key2];
-}
-function safeField(value, key2) {
-  try {
-    return field2(value, key2);
-  } catch {
-    return;
-  }
-}
-function nonZeroExitCode(value) {
-  if (typeof value === "number")
-    return Number.isFinite(value) && value !== 0;
-  if (typeof value !== "string")
-    return false;
-  const parsed = Number(value.trim());
-  return Number.isFinite(parsed) && parsed !== 0;
-}
-function nonEmptyProcessOutput(value) {
-  if (typeof value === "string")
-    return value.length > 0;
-  if (value instanceof ArrayBuffer)
-    return value.byteLength > 0;
-  return ArrayBuffer.isView(value) && value.byteLength > 0;
-}
-function findProcessFailureError(value, seen, depth) {
-  if (value === null || typeof value !== "object" || depth >= 8 || seen.has(value))
-    return;
-  seen.add(value);
-  if (nonZeroExitCode(safeField(value, "exitCode")))
-    return value;
-  if (nonEmptyProcessOutput(safeField(value, "stdout")))
-    return value;
-  if (nonEmptyProcessOutput(safeField(value, "stderr")))
-    return value;
-  for (const key2 of ["cause", "error", "response", "body"]) {
-    const selected = findProcessFailureError(safeField(value, key2), seen, depth + 1);
-    if (selected !== undefined)
-      return selected;
-  }
-  const diagnostics = safeField(value, "diagnostics");
-  if (Array.isArray(diagnostics)) {
-    for (const diagnostic of diagnostics) {
-      const selected = findProcessFailureError(safeField(diagnostic, "error") ?? diagnostic, seen, depth + 1);
-      if (selected !== undefined)
-        return selected;
-    }
-  }
-  const errors = safeField(value, "errors");
-  if (!Array.isArray(errors))
-    return;
-  for (const error of errors) {
-    const selected = findProcessFailureError(error, seen, depth + 1);
-    if (selected !== undefined)
-      return selected;
-  }
-  return;
-}
-function selectProcessFailureError(error) {
-  return findProcessFailureError(error, new Set, 0) ?? error;
-}
-function hasProcessFailureEvidence(error) {
-  return findProcessFailureError(error, new Set, 0) !== undefined;
-}
-function stringField4(value, key2) {
-  const raw = field2(value, key2);
-  return typeof raw === "string" && raw.length > 0 ? raw : undefined;
-}
-function errorMessage3(error) {
-  const structuredMessage = structuredErrorMessage(error);
-  if (structuredMessage !== undefined)
-    return structuredMessage;
-  if (error instanceof Error && typeof error.message === "string")
-    return error.message;
-  if (typeof error === "string")
-    return error;
-  return String(error);
-}
-function errorName2(error) {
-  return error instanceof Error ? error.name : stringField4(error, "name");
-}
-function structuredErrorMessage(error) {
-  return stringField4(error, "errorMessage") ?? stringField4(error, "message") ?? stringField4(error, "statusText");
-}
-function integerFrom2(value) {
-  if (typeof value === "number" && Number.isInteger(value))
-    return value;
-  if (typeof value !== "string" || value.trim().length === 0)
-    return;
-  const parsed = Number(value.trim());
-  return Number.isInteger(parsed) ? parsed : undefined;
-}
-function numberFrom(value) {
-  if (typeof value === "number" && Number.isFinite(value))
-    return value;
-  if (typeof value !== "string" || value.trim().length === 0)
-    return;
-  const parsed = Number(value.trim());
-  return Number.isFinite(parsed) ? parsed : undefined;
-}
-function retryAfterHeaderMs(value) {
-  const numeric = numberFrom(value);
-  if (numeric !== undefined && numeric >= 0)
-    return Math.round(numeric * 1000);
-  if (typeof value !== "string" || value.trim().length === 0)
-    return;
-  const dateMs = Date.parse(value);
-  if (!Number.isFinite(dateMs))
-    return;
-  return Math.max(0, dateMs - Date.now());
-}
-function retryAfterMsFrom(error) {
-  const directMs = numberFrom(field2(error, "retryAfterMs"));
-  if (directMs !== undefined && directMs >= 0)
-    return Math.round(directMs);
-  const seconds = numberFrom(field2(error, "retryAfterSeconds"));
-  if (seconds !== undefined && seconds >= 0)
-    return Math.round(seconds * 1000);
-  const retryAfter = retryAfterHeaderMs(field2(error, "retryAfter"));
-  if (retryAfter !== undefined)
-    return retryAfter;
-  const retryAfterHeader = retryAfterHeaderMs(field2(error, "retry-after"));
-  if (retryAfterHeader !== undefined)
-    return retryAfterHeader;
-  const headers = field2(error, "headers");
-  const headerRecord = asRecord2(headers);
-  const headerValue = headerRecord?.["retry-after"] ?? headerRecord?.["Retry-After"];
-  return retryAfterHeaderMs(headerValue);
-}
-function structuredSignal2(error) {
-  const status = integerFrom2(field2(error, "status")) ?? integerFrom2(field2(error, "statusCode")) ?? integerFrom2(field2(error, "httpStatus"));
-  const rawCode = field2(error, "code");
-  const code = typeof rawCode === "string" || typeof rawCode === "number" ? rawCode : undefined;
-  const name = errorName2(error);
-  const stopReason = stringField4(error, "stopReason");
-  const message = structuredErrorMessage(error);
-  const retryAfterMs = retryAfterMsFrom(error);
-  return {
-    ...status !== undefined ? { status } : {},
-    ...code !== undefined ? { code } : {},
-    ...name !== undefined ? { name } : {},
-    ...stopReason !== undefined ? { stopReason } : {},
-    ...message !== undefined ? { message } : {},
-    ...retryAfterMs !== undefined ? { retryAfterMs } : {}
-  };
-}
-function causeOf2(error) {
-  if (error instanceof Error)
-    return error.cause;
-  return field2(error, "cause");
-}
-function diagnosticErrors2(error) {
-  const diagnostics = field2(error, "diagnostics");
-  if (!Array.isArray(diagnostics))
-    return [];
-  const errors = [];
-  for (const diagnostic of diagnostics) {
-    const diagnosticError = field2(diagnostic, "error");
-    errors.push(diagnosticError ?? diagnostic);
-  }
-  return errors;
-}
-function nestedProviderError(error) {
-  return field2(error, "error") ?? field2(error, "response") ?? field2(error, "body");
-}
-function normalizeCode2(value) {
-  if (value === undefined)
-    return;
-  return String(value).trim().toLowerCase().replaceAll("-", "_").replaceAll(" ", "_");
-}
-function httpStatusFromCode(value) {
-  if (value === undefined)
-    return;
-  if (typeof value === "number") {
-    return Number.isInteger(value) && value >= 100 && value <= 599 ? value : undefined;
-  }
-  const trimmed = value.trim();
-  if (!/^\d{3}$/.test(trimmed))
-    return;
-  const parsed = Number(trimmed);
-  return parsed >= 100 && parsed <= 599 ? parsed : undefined;
-}
-function codeEvidenceFrom(value) {
-  const status = httpStatusFromCode(value);
-  if (status !== undefined)
-    return { kind: "wrapper_http_status", status };
-  const normalized = normalizeCode2(value);
-  return normalized !== undefined && normalized.length > 0 ? { kind: "semantic_code", normalized } : undefined;
-}
-function tokenize(value) {
-  const tokens = [];
-  let current = "";
-  for (const char of value.toLowerCase()) {
-    if (char >= "a" && char <= "z" || char >= "0" && char <= "9") {
-      current += char;
-    } else if (current.length > 0) {
-      tokens.push(current);
-      current = "";
-    }
-  }
-  if (current.length > 0)
-    tokens.push(current);
-  return tokens;
-}
-function hasPhrase(tokens, phrase) {
-  if (phrase.length === 0 || phrase.length > tokens.length)
-    return false;
-  for (let index = 0;index <= tokens.length - phrase.length; index += 1) {
-    let matched = true;
-    for (let offset = 0;offset < phrase.length; offset += 1) {
-      if (tokens[index + offset] !== phrase[offset]) {
-        matched = false;
-        break;
-      }
-    }
-    if (matched)
-      return true;
-  }
-  return false;
-}
-function hasAnyPhrase(tokens, phrases) {
-  return phrases.some((phrase) => hasPhrase(tokens, phrase));
-}
-function tokenNearAny(tokens, anchor, candidates, distance) {
-  for (let index = 0;index < tokens.length; index += 1) {
-    if (tokens[index] !== anchor)
-      continue;
-    const start = Math.max(0, index - distance);
-    const end = Math.min(tokens.length - 1, index + distance);
-    for (let cursor = start;cursor <= end; cursor += 1) {
-      if (cursor !== index && candidates.has(tokens[cursor]))
-        return true;
-    }
-  }
-  return false;
-}
-function redactedSecretReplacement(prefix) {
-  return `${prefix}[redacted]`;
-}
-function redactSensitiveText(value) {
-  return value.replace(/(sk-[A-Za-z0-9_-]{8})[A-Za-z0-9_-]+/g, redactedSecretReplacement("$1")).replace(/\b(authorization\s*:\s*bearer\s+)[^\s,;]+/gi, "$1[redacted]").replace(/\b(bearer\s+)[A-Za-z0-9._~+/-]{8,}=*/gi, "$1[redacted]").replace(/((?:api[_-]?key|token|credential|secret)\s*[:=]\s*)[^\s,;]+/gi, "$1[redacted]");
-}
-
-// dist/builtin/workflows/src/durable/tool-outcome.ts
-var TOOL_FAILURE_TEXT_LIMIT_BYTES = 16384;
-var TRUNCATION_PREFIX = `[workflow tool output truncated; showing final bytes]
-`;
-function safeField2(error, key2) {
-  try {
-    return field2(error, key2);
-  } catch {
-    return;
-  }
-}
-function exposedText(error, key2) {
-  const value = safeField2(error, key2);
-  if (typeof value === "string")
-    return value;
-  try {
-    if (value instanceof ArrayBuffer)
-      return new TextDecoder().decode(value);
-    if (ArrayBuffer.isView(value)) {
-      return new TextDecoder().decode(new Uint8Array(value.buffer, value.byteOffset, value.byteLength));
-    }
-  } catch {
-    return;
-  }
-  return;
-}
-function boundedSafeToolFailureText(value) {
-  const redacted = redactSensitiveText(value);
-  const bytes = new TextEncoder().encode(redacted);
-  if (bytes.byteLength <= TOOL_FAILURE_TEXT_LIMIT_BYTES)
-    return redacted;
-  const prefix = new TextEncoder().encode(TRUNCATION_PREFIX);
-  const tailLength = Math.max(0, TOOL_FAILURE_TEXT_LIMIT_BYTES - prefix.byteLength);
-  let start = bytes.byteLength - tailLength;
-  const decoder = new TextDecoder("utf-8", { fatal: true });
-  while (start < bytes.byteLength) {
-    try {
-      return TRUNCATION_PREFIX + decoder.decode(bytes.slice(start));
-    } catch {
-      start += 1;
-    }
-  }
-  return TRUNCATION_PREFIX.slice(0, TOOL_FAILURE_TEXT_LIMIT_BYTES);
-}
-function safeErrorText(error) {
-  try {
-    return String(error);
-  } catch {
-    return "Tool callback failed";
-  }
-}
-function normalizeWorkflowToolError(error) {
-  error = selectProcessFailureError(error);
-  const exitCode = safeField2(error, "exitCode");
-  const stdout = exposedText(error, "stdout");
-  const stderr = exposedText(error, "stderr");
-  let message;
-  let name;
-  try {
-    message = errorMessage3(error);
-  } catch {
-    message = safeErrorText(error);
-  }
-  try {
-    name = errorName2(error) ?? "Error";
-  } catch {
-    name = "Error";
-  }
-  return {
-    name: boundedSafeToolFailureText(name),
-    message: boundedSafeToolFailureText(message),
-    ...typeof exitCode === "number" && Number.isInteger(exitCode) ? { exitCode } : {},
-    ...stdout !== undefined ? { stdout: boundedSafeToolFailureText(stdout) } : {},
-    ...stderr !== undefined ? { stderr: boundedSafeToolFailureText(stderr) } : {}
-  };
-}
-function workflowToolSuccess(value, attempts, cached) {
-  return { ok: true, value, attempts, cached };
-}
-function workflowToolFailure(error, attempts, cached) {
-  return { ok: false, error: normalizeWorkflowToolError(error), attempts, cached };
-}
-function workflowToolOutcomeFromValue(value) {
-  if (value === null || typeof value !== "object" || Array.isArray(value))
-    return;
-  const candidate = value;
-  if (!Number.isInteger(candidate.attempts) || typeof candidate.cached !== "boolean")
-    return;
-  if (candidate.ok === true && "value" in candidate)
-    return candidate;
-  const error = candidate.error;
-  if (candidate.ok !== false || error === null || typeof error !== "object" || Array.isArray(error))
-    return;
-  const details = error;
-  if (typeof details.name !== "string" || typeof details.message !== "string" || details.exitCode !== undefined && !Number.isInteger(details.exitCode) || details.stdout !== undefined && typeof details.stdout !== "string" || details.stderr !== undefined && typeof details.stderr !== "string")
-    return;
-  return candidate;
-}
-function replayedWorkflowToolOutcome(outcome) {
-  return { ...outcome, cached: true };
-}
 // dist/builtin/workflows/src/durable/stage-topology.ts
 function activeStageTopology(backend, workflowId, replayKey) {
   const checkpoints = backend.listCheckpoints(workflowId);
@@ -61887,6 +62305,10 @@ function withMidSessionResumePrompt(stage, enabled) {
   });
   return stage;
 }
+function pendingStageIdForReplay(backend, workflowId, replayKey, stageName) {
+  const candidates = new Set((backend.getWorkflow(workflowId)?.pendingStageMessages ?? []).filter((entry) => entry.stageReplayKey === replayKey || entry.stageReplayKey === undefined && entry.stageKey === stageName).map((entry) => entry.stageId).filter((stageId) => stageId !== undefined));
+  return candidates.size === 1 ? candidates.values().next().value : undefined;
+}
 function createDurableStagePrimitive(input2) {
   return (name, options) => {
     const replayKey = input2.nextReplayKey(name);
@@ -61898,13 +62320,12 @@ function createDurableStagePrimitive(input2) {
     const session = input2.backend.getStageSession(input2.workflowId, replayKey);
     const isMidSessionResume = session?.sessionFile !== undefined;
     const topology = activeStageTopology(input2.backend, input2.workflowId, replayKey);
+    const durableStageId = topology?.stageId ?? pendingStageIdForReplay(input2.backend, input2.workflowId, replayKey, name);
     const liveOptions = {
       ...options ?? {},
       durableReplayKey: replayKey,
-      ...topology !== undefined ? {
-        durableStageId: topology.stageId,
-        durableParentIds: [...topology.parentIds]
-      } : {},
+      ...durableStageId !== undefined ? { durableStageId } : {},
+      ...topology !== undefined ? { durableParentIds: [...topology.parentIds] } : {},
       ...isMidSessionResume ? {
         resumeFromSessionFile: session.sessionFile,
         durableAccumulatedDurationMs: session.durationMs ?? 0
@@ -63171,6 +63592,9 @@ class ScopedDurableBackend {
     this.persistent = inner.persistent;
   }
   registerWorkflow(_handle) {}
+  persistPendingStageMessages(workflowId, messages2, logicalRunId = workflowId) {
+    return this.inner.persistPendingStageMessages(this.scope.rootWorkflowId, messages2, logicalRunId);
+  }
   recordCheckpoint(checkpoint) {
     this.inner.recordCheckpoint(this.remap(checkpoint));
   }
@@ -65308,6 +65732,7 @@ function appendStageStart(api, payload) {
     name: payload.name,
     parentIds: [...payload.parentIds],
     ...payload.model !== undefined ? { model: payload.model } : {},
+    ...payload.pendingStageDeliveryAvailable !== undefined ? { pendingStageDeliveryAvailable: payload.pendingStageDeliveryAvailable } : {},
     ...payload.replayKey !== undefined ? { replayKey: payload.replayKey } : {},
     ...payload.replayedFromStageId !== undefined ? { replayedFromStageId: payload.replayedFromStageId } : {},
     ...payload.replayed !== undefined ? { replayed: payload.replayed } : {},
@@ -67034,6 +67459,7 @@ import { randomUUID as randomUUID9 } from "node:crypto";
 
 // dist/builtin/workflows/src/shared/intercom-group.ts
 import { randomUUID as randomUUID8 } from "node:crypto";
+var DEFAULT_INTERCOM_GROUP = "default";
 function workflowInvocationIntercomGroup(rootRunId) {
   return `workflow:${rootRunId}`;
 }
@@ -67043,6 +67469,12 @@ function normalizeAutoGroupSentinel(group) {
   const sentinel = group.trim().toLowerCase();
   return sentinel === "true" || sentinel === "auto" ? true : group;
 }
+function normalizeGroup(value) {
+  if (typeof value !== "string")
+    return DEFAULT_INTERCOM_GROUP;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : DEFAULT_INTERCOM_GROUP;
+}
 function resolveStageGroup(stageOptions, workflowGroup) {
   if (!stageOptions)
     return workflowGroup;
@@ -67067,6 +67499,11 @@ function stageHasIntercomAccess(stageOptions) {
     return false;
   return true;
 }
+function stageCanUseWorkflowPendingStageRoute(stageOptions, workflowGroup) {
+  if (!stageHasIntercomAccess(stageOptions) || stageOptions?.group === true)
+    return false;
+  return normalizeGroup(resolveStageGroup(stageOptions, workflowGroup)) === normalizeGroup(workflowGroup);
+}
 
 // dist/builtin/workflows/builtin/verification-usage.ts
 function fold_usage(results) {
@@ -67353,9 +67790,9 @@ function createRunBudgetController(input2) {
 function createParallelPrimitive(input2) {
   return async (steps, options = {}) => {
     input2.runtime.exit.throwIfWorkflowExitSelected();
-    const normalizeGroup = (value) => value.group === undefined ? value : { ...value, group: normalizeAutoGroupSentinel(value.group) };
-    const normalizedOptions = normalizeGroup(options);
-    const normalizedSteps = steps.map(normalizeGroup);
+    const normalizeGroup2 = (value) => value.group === undefined ? value : { ...value, group: normalizeAutoGroupSentinel(value.group) };
+    const normalizedOptions = normalizeGroup2(options);
+    const normalizedSteps = steps.map(normalizeGroup2);
     const needsAutoGroup = normalizedOptions.group === true || normalizedSteps.some((step) => step.group === true);
     const autoGroup = needsAutoGroup ? randomUUID9() : undefined;
     const resolveAutoGroup = (value) => value.group === true && autoGroup ? { ...value, group: autoGroup } : value;
@@ -69230,7 +69667,7 @@ function createAdmittedToolExecutionTracker(options = {}) {
   const inFlight = new Set;
   const admissions = [];
   const failures = [];
-  let nextAdmissionOrder = 0;
+  let nextAdmissionOrder2 = 0;
   let state = "OPEN";
   let closing;
   const abandonment = Promise.withResolvers();
@@ -69281,7 +69718,7 @@ function createAdmittedToolExecutionTracker(options = {}) {
         return { accepted: false, error, bindNode() {}, noteCancelled() {} };
       }
       const admission = {
-        admissionOrder: ++nextAdmissionOrder,
+        admissionOrder: ++nextAdmissionOrder2,
         nodeId: undefined,
         failure: undefined,
         cancelled: false,
@@ -70623,6 +71060,150 @@ function createReplayStageContext(input2) {
   };
 }
 
+// dist/builtin/workflows/src/durable/run-owner-backend.ts
+function durableRootRunIdForRun(runs, runId) {
+  return reciprocalWorkflowRootRunId(new Map(runs.map((run2) => [run2.id, run2])), runId);
+}
+function durableBackendForRun(backend, runs, runId) {
+  const rootRunId = durableRootRunIdForRun(runs, runId);
+  if (rootRunId === undefined)
+    return;
+  const runById = new Map(runs.map((run2) => [run2.id, run2]));
+  if (rootRunId === runId)
+    return backend;
+  const scopes = [];
+  let current = runById.get(runId);
+  while (current !== undefined && current.id !== rootRunId) {
+    const parent = current.parentRunId === undefined ? undefined : runById.get(current.parentRunId);
+    const boundary = parent?.stages.find((stage) => stage.id === current?.parentStageId);
+    if (parent === undefined || boundary?.replayKey === undefined)
+      return;
+    scopes.push(boundary.replayKey);
+    current = parent;
+  }
+  if (current?.id !== rootRunId)
+    return;
+  let view = backend;
+  for (const scopePrefix of scopes.reverse()) {
+    view = new ScopedDurableBackend(view, { rootWorkflowId: rootRunId, scopePrefix });
+  }
+  return view;
+}
+
+// dist/builtin/workflows/src/shared/pending-stage-route-capability.ts
+import { randomUUID as randomUUID10 } from "node:crypto";
+var routeCapabilities = new WeakMap;
+function workflowPendingStageRouteCapability(store2, runId) {
+  let capabilities = routeCapabilities.get(store2);
+  if (capabilities === undefined) {
+    capabilities = new Map;
+    routeCapabilities.set(store2, capabilities);
+  }
+  let capability = capabilities.get(runId);
+  if (capability === undefined) {
+    capability = randomUUID10();
+    capabilities.set(runId, capability);
+  }
+  return capability;
+}
+
+// dist/builtin/workflows/src/runs/foreground/pending-stage-delivery.ts
+var pendingDeliveryClaims = new WeakMap;
+function createWorkflowPendingStageDelivery(activeStore, runId, stageId, stageName) {
+  let resolveReady;
+  let rejectReady;
+  let readyPromise;
+  let drainError;
+  let drainPromise;
+  const pendingReady = () => {
+    if (readyPromise === undefined) {
+      readyPromise = new Promise((resolve23, reject) => {
+        resolveReady = resolve23;
+        rejectReady = reject;
+      });
+    }
+    return readyPromise;
+  };
+  return {
+    routeCapability: workflowPendingStageRouteCapability(activeStore, runId),
+    deliverPending(deliver) {
+      if (drainPromise === undefined) {
+        drainError = undefined;
+        const attempt = deliverPendingStageMessages(activeStore, runId, stageId, stageName, deliver);
+        const drain2 = attempt.then(() => resolveReady?.(), (error) => {
+          drainError = error;
+          rejectReady?.(error);
+          readyPromise = undefined;
+          resolveReady = undefined;
+          rejectReady = undefined;
+          if (drainPromise === drain2)
+            drainPromise = undefined;
+          throw error;
+        });
+        drainPromise = drain2;
+      }
+      return drainPromise;
+    },
+    ready() {
+      if (activeStore.pendingStageMessagesFor(runId, stageId).length === 0 && (stageId === stageName || activeStore.pendingStageMessagesFor(runId, stageName).length === 0)) {
+        return;
+      }
+      return drainError === undefined ? pendingReady() : Promise.reject(drainError);
+    }
+  };
+}
+async function deliverPendingStageMessages(activeStore, runId, stageId, stageName, deliver) {
+  const candidateIds = new Set([
+    ...activeStore.pendingStageMessagesFor(runId, stageId),
+    ...activeStore.pendingStageMessagesFor(runId, stageName)
+  ].map((entry) => entry.id));
+  const entries = (activeStore.runs().find((run2) => run2.id === runId)?.pendingStageMessages ?? []).map((entry, index) => ({ entry, index })).filter(({ entry }) => candidateIds.has(entry.id)).sort((left, right) => (left.entry.admissionOrder ?? left.index + 1) - (right.entry.admissionOrder ?? right.index + 1) || left.index - right.index).map(({ entry }) => entry);
+  const rootBackend = getDurableBackend();
+  const backend = durableBackendForRun(rootBackend, activeStore.runs(), runId);
+  if (backend === undefined) {
+    throw new Error(`atomic-workflows: workflow run ${runId} has no durable owner for pending-stage delivery`);
+  }
+  for (const entry of entries) {
+    const releaseClaim = claimPendingDelivery(activeStore, runId, entry.stageKey, entry.id);
+    if (releaseClaim === undefined)
+      continue;
+    try {
+      await deliver(toPendingStageSender(entry), entry.message);
+      if (!await activeStore.markPendingStageMessageDelivered(runId, entry.stageKey, entry.id, new Date().toISOString(), backend)) {
+        throw new Error(`atomic-workflows: pending-stage message ${entry.id} changed during delivery`);
+      }
+    } finally {
+      releaseClaim();
+    }
+  }
+}
+function claimPendingDelivery(store2, runId, stageKey, messageId) {
+  let claims = pendingDeliveryClaims.get(store2);
+  if (claims === undefined) {
+    claims = new Set;
+    pendingDeliveryClaims.set(store2, claims);
+  }
+  const key2 = JSON.stringify([runId, stageKey, messageId]);
+  if (claims.has(key2))
+    return;
+  claims.add(key2);
+  return () => {
+    claims?.delete(key2);
+    if (claims?.size === 0)
+      pendingDeliveryClaims.delete(store2);
+  };
+}
+function toPendingStageSender(entry) {
+  return {
+    ...entry.from,
+    cwd: entry.from.cwd ?? "",
+    model: entry.from.model ?? "unknown",
+    pid: entry.from.pid ?? 0,
+    startedAt: entry.from.startedAt ?? entry.message.timestamp,
+    lastActivity: entry.from.lastActivity ?? entry.message.timestamp
+  };
+}
+
 // dist/builtin/workflows/src/runs/foreground/stage-runner-context.ts
 init_src();
 
@@ -71014,7 +71595,7 @@ function workflowSessionOptions(meta2) {
     workflow: { runId: meta2.runId, stageId: meta2.stageId, stageName: meta2.stageName }
   };
 }
-function workflowOrchestrationContext(meta2, stageOptions) {
+function workflowOrchestrationContext(meta2, stageOptions, pendingStageDelivery) {
   const base = {
     kind: "workflow-stage",
     workflowRunId: meta2.runId,
@@ -71023,11 +71604,12 @@ function workflowOrchestrationContext(meta2, stageOptions) {
     constraints: { disableWorkflowTool: true }
   };
   const intercomGroup = stageHasIntercomAccess(stageOptions) ? resolveStageGroup(stageOptions, meta2.workflowIntercomGroup) : undefined;
-  return intercomGroup ? { ...base, intercomGroup } : base;
+  const context = intercomGroup ? { ...base, intercomGroup } : base;
+  return pendingStageDelivery === undefined ? context : { ...context, pendingStageDelivery };
 }
-function stripWorkflowOnlyOptions(options, defaultSessionDir, meta2) {
+function stripWorkflowOnlyOptions(options, defaultSessionDir, meta2, pendingStageDelivery) {
   const classification = workflowSessionOptions(meta2);
-  const orchestrationContext = workflowOrchestrationContext(meta2, options);
+  const orchestrationContext = workflowOrchestrationContext(meta2, options, pendingStageDelivery);
   if (!options) {
     return defaultSessionDir === undefined ? { orchestrationContext } : {
       orchestrationContext,
@@ -72393,7 +72975,7 @@ class StageSessionController {
     });
     let created;
     try {
-      created = this.opts.adapters.agentSession ? await this.opts.adapters.agentSession.create(stripWorkflowOnlyOptions(stageOptions, this.opts.defaultSessionDir, this.meta), {
+      created = this.opts.adapters.agentSession ? await this.opts.adapters.agentSession.create(stripWorkflowOnlyOptions(stageOptions, this.opts.defaultSessionDir, this.meta, this.opts.pendingStageDelivery), {
         ...this.meta,
         stageOptions,
         ...this.sharedOrchestrationContext !== undefined ? { orchestrationContext: this.sharedOrchestrationContext } : {}
@@ -72410,10 +72992,12 @@ class StageSessionController {
       throw this.staleCreationReason(startGeneration);
     }
     const session = attachCreatedStageSession(created, this.disposed, this.opts.stageName, (result) => this.attachSession(result));
-    if (session instanceof Promise)
-      return await session;
+    const attachedSession = session instanceof Promise ? await session : session;
+    const pendingStageDeliveryReady = this.sharedOrchestrationContext?.pendingStageDelivery?.ready();
+    if (pendingStageDeliveryReady !== undefined)
+      await pendingStageDeliveryReady;
     await this.opts.onSessionReady?.();
-    return session;
+    return attachedSession;
   }
   attachSession(created) {
     const result = normalizeSessionCreateResult(created);
@@ -73165,6 +73749,12 @@ function createWorkflowStageFactory(input2) {
     const replaySource = replayDecision.kind === "replay" ? replayDecision.source : undefined;
     const executeReplaySource = replayDecision.kind === "execute" ? replayDecision.source : undefined;
     const shouldReplay = replaySource !== undefined;
+    const stageOptionsForContext = executeReplaySource?.sessionFile === undefined ? options : {
+      ...options ?? {},
+      context: options?.context ?? "fork",
+      forkFromSessionFile: options?.forkFromSessionFile ?? executeReplaySource.sessionFile
+    };
+    const pendingStageDeliveryAvailable = stageCanUseWorkflowPendingStageRoute(stageOptionsForContext, input2.workflowIntercomGroup);
     const stageSnapshot = {
       id: stageId,
       name,
@@ -73172,6 +73762,7 @@ function createWorkflowStageFactory(input2) {
       status: shouldReplay ? "completed" : "pending",
       parentIds: Object.freeze(parentIds),
       toolEvents: [],
+      pendingStageDeliveryAvailable,
       ...shouldReplay ? {
         startedAt: Date.now(),
         endedAt: Date.now(),
@@ -73200,11 +73791,6 @@ function createWorkflowStageFactory(input2) {
         throwIfWorkflowExitSelected: input2.exit.throwIfWorkflowExitSelected
       });
     }
-    const stageOptionsForContext = executeReplaySource?.sessionFile === undefined ? options : {
-      ...options ?? {},
-      context: options?.context ?? "fork",
-      forkFromSessionFile: options?.forkFromSessionFile ?? executeReplaySource.sessionFile
-    };
     const applyModelFallbackMeta = (meta2) => {
       if (meta2.model !== undefined)
         stageSnapshot.model = meta2.model;
@@ -73242,6 +73828,9 @@ function createWorkflowStageFactory(input2) {
       workflowIntercomGroup: input2.workflowIntercomGroup,
       signal: input2.signal,
       stageOptions: stageOptionsForContext,
+      ...pendingStageDeliveryAvailable ? {
+        pendingStageDelivery: createWorkflowPendingStageDelivery(input2.activeStore, input2.runId, stageId, name)
+      } : {},
       models: input2.opts.models,
       executionMode: input2.opts.executionMode,
       defaultSessionDir: input2.opts.defaultSessionDir,
@@ -73367,6 +73956,7 @@ function createWorkflowStageFactory(input2) {
         name,
         parentIds: stageSnapshot.parentIds,
         ...stageReplayFields(stageSnapshot),
+        pendingStageDeliveryAvailable,
         ts: stageSnapshot.startedAt ?? Date.now()
       });
     };
@@ -73729,6 +74319,9 @@ async function run(def, inputs, opts = {}) {
     status: "running",
     stages: [],
     toolNodes: [],
+    pendingStageMessages: [
+      ...pendingStageMessagesForDurableRun(rootBackend, runId, opts.parentRun?.rootRunId ?? runId)
+    ],
     startedAt: Date.now(),
     ...opts.parentRun !== undefined ? {
       parentRunId: opts.parentRun.runId,