@bastani/atomic 0.9.16-alpha.6 → 0.9.16-alpha.8

package/dist/builtin/workflows/src/extension/index.bundle.mjs

@@ -4589,10 +4589,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;
@@ -10723,6 +10723,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 };
 }
@@ -10948,12 +10950,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) {
@@ -10967,20 +10974,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) {
@@ -11003,7 +11010,7 @@ async function commitAdmittedCustomMessage(session, appMessage, options) {
       self._continueQueuedAgentMessages().catch(() => {});
     }
   } else {
-    self._appendCustomMessage(appMessage);
+    appendDurableStageAdmission(self, appMessage);
   }
 }
 function _commitAdmittedCustomMessage(appMessage, options) {
@@ -19160,6 +19167,7 @@ async function loadVirtualModules() {
     piAi,
     piAiOauth,
     piAiCloudflareGatewayBinding,
+    properLockfile,
     piCodingAgent
   ] = await Promise.all([
     import("typebox"),
@@ -19171,6 +19179,7 @@ async function loadVirtualModules() {
     import("@bastani/pi-ai/compat"),
     import("@bastani/pi-ai/oauth"),
     import("@bastani/pi-ai/api/cloudflare-gateway-binding"),
+    import("proper-lockfile"),
     Promise.resolve().then(() => (init_src(), exports_src))
   ]);
   return {
@@ -19191,6 +19200,7 @@ async function loadVirtualModules() {
     "@earendil-works/pi-ai/compat": piAi,
     "@earendil-works/pi-ai/oauth": piAiOauth,
     "@earendil-works/pi-ai/api/cloudflare-gateway-binding": piAiCloudflareGatewayBinding,
+    "proper-lockfile": properLockfile,
     "@bastani/atomic": piCodingAgent,
     "@mariozechner/pi-agent-core": piAgentCore,
     "@mariozechner/pi-tui": piTui,
@@ -26320,11 +26330,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 hasSupportedCodexFastModeModel(models) {
-  return models.some(isCodexFastModeSupportedModel);
+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 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";
@@ -26335,11 +26354,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 usesFirstPartyCodexRouting(model) {
   return model.provider === "openai-codex" && isFirstPartyCodexBaseUrl(model.baseUrl);
@@ -26365,8 +26384,8 @@ function withCodexFastModeHeaders(model, headers, enabled) {
   setHeader(fastHeaders, CODEX_FAST_MODE_ROUTING_HEADER, `model=${model.id};tier=${CODEX_FAST_MODE_SERVICE_TIER}`);
   return fastHeaders;
 }
-function withCodexFastModeStreamOptions(_model, options, enabled) {
-  if (!enabled) {
+function withCodexFastModeStreamOptions(model, options, enabled) {
+  if (!enabled || model.provider === "github-copilot") {
     return options;
   }
   return {
@@ -26500,10 +26519,14 @@ function streamWithCodexFastMode(model, context, options, streamers = DEFAULT_CO
 function isObjectPayload(payload) {
   return typeof payload === "object" && payload !== null && !Array.isArray(payload);
 }
-function withCodexFastModePayload(payload, enabled) {
-  if (!enabled || !isObjectPayload(payload) || payload.service_tier !== undefined) {
+function withCodexFastModePayload(payload, enabled, model) {
+  if (!enabled || !isObjectPayload(payload))
     return payload;
+  if (model?.provider === "github-copilot") {
+    return payload.model === model.id ? { ...payload, model: `${model.id}-fast` } : payload;
   }
+  if (payload.service_tier !== undefined)
+    return payload;
   return {
     ...payload,
     service_tier: CODEX_FAST_MODE_SERVICE_TIER
@@ -26653,7 +26676,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";
@@ -45421,14 +45444,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) {
@@ -45667,7 +45694,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,
@@ -45999,6 +46026,9 @@ class AuthStorage {
       this.data = this.parseStorageData(content);
     } catch {}
   }
+  peek(provider) {
+    return this.data[provider];
+  }
   async read(provider) {
     const credential = this.data[provider];
     if (credential?.type !== "api_key")
@@ -47052,6 +47082,10 @@ function getReloadableStore(store) {
   const reloadable = store;
   return typeof reloadable.reload === "function" ? reloadable : undefined;
 }
+function getSnapshotStore(store) {
+  const snapshotStore = store;
+  return typeof snapshotStore.peek === "function" ? snapshotStore : undefined;
+}
 
 class RuntimeCredentials {
   store;
@@ -47071,6 +47105,10 @@ class RuntimeCredentials {
   async reload() {
     await getReloadableStore(this.store)?.reload();
   }
+  peek(providerId) {
+    const override = this.overrides.get(providerId);
+    return override ? { type: "api_key", key: override } : getSnapshotStore(this.store)?.peek(providerId);
+  }
   async read(providerId, options) {
     const override = this.overrides.get(providerId);
     return override ? { type: "api_key", key: override } : this.store.read(providerId, options);
@@ -47506,6 +47544,9 @@ class ModelRuntime {
   hasConfiguredAuth(providerId) {
     return this.snapshot.configuredProviders.has(providerId);
   }
+  getCredentialSnapshot(providerId) {
+    return this.credentials.peek(providerId);
+  }
   async getAuth(providerOrModel, overrides = {}) {
     if (typeof providerOrModel === "string")
       return this.models.getAuth(providerOrModel, overrides);
@@ -55461,7 +55502,7 @@ async function createAgentSession(options = {}) {
     return filtered;
   };
   const extensionRunnerRef = {};
-  const isCodexFastModeEnabled = (requestModel) => shouldApplyCodexFastMode(requestModel, settingsManager.getCodexFastModeSettings(), options.orchestrationContext);
+  const isCodexFastModeEnabled = (requestModel) => shouldApplyCodexFastMode(requestModel, settingsManager.getCodexFastModeSettings(), options.orchestrationContext, modelRuntime.getCredentialSnapshot("github-copilot"));
   agent = new Agent2({
     initialState: {
       systemPrompt: "",
@@ -55497,7 +55538,7 @@ async function createAgentSession(options = {}) {
       const extensionProvider = modelRuntime.getRegisteredProviderConfig(requestModel.provider);
       const usesExtensionStream = extensionProvider?.streamSimple !== undefined && requestModel.api === extensionProvider.api;
       const transportHeaders = usesExtensionStream ? assembledHeaders : removeUnownedModelHeaders(assembledHeaders, model2.headers, requestHeaders);
-      if (fastModeEnabled && !usesExtensionStream && !authResult) {
+      if (fastModeEnabled && !isGitHubCopilotModel(model2) && !usesExtensionStream && !authResult) {
         throw new Error(`No API key found for "${model2.provider}"`);
       }
       const codexFastModeStreamOptions = withCodexFastModeStreamOptions(requestModel, {
@@ -55514,7 +55555,7 @@ async function createAgentSession(options = {}) {
       if (usesExtensionStream) {
         return modelRuntime.streamSimple(requestModel, context, codexFastModeStreamOptions);
       }
-      if (fastModeEnabled) {
+      if (fastModeEnabled && !isGitHubCopilotModel(requestModel)) {
         return streamWithCodexFastMode(requestModel, context, codexFastModeStreamOptions);
       }
       const transportOptions = usesChatGptCodexTransport(requestModel) && codexFastModeStreamOptions ? withChatGptCodexTransportRouting(requestModel, codexFastModeStreamOptions, false) : codexFastModeStreamOptions;
@@ -55522,7 +55563,7 @@ async function createAgentSession(options = {}) {
     },
     onPayload: async (payload, model2) => {
       const fastModeEnabled = isCodexFastModeEnabled(model2);
-      const guardedPayload = withCodexFastModePayload(payload, fastModeEnabled);
+      const guardedPayload = withCodexFastModePayload(payload, fastModeEnabled, model2);
       const sourceMessages = lastConvertedLlmMessages;
       const replayGuardedPayload = sourceMessages ? restoreAnthropicReplayThinkingBlocks(guardedPayload, sourceMessages, model2) : guardedPayload;
       const runner = extensionRunnerRef.current;
@@ -59987,6 +60028,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();
@@ -60005,6 +60071,7 @@ var init_isolated_runtime = __esm(() => {
     steeringMessages = [];
     followUpMessages = [];
     queueUpdateGeneration = 0;
+    thinkingEpoch = 0;
     pendingQueueClear;
     engineCallbackActive = false;
     queuePause;
@@ -60369,43 +60436,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;
           }
         },
@@ -60449,6 +60529,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())
@@ -60489,6 +60577,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;
@@ -60528,6 +60622,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":
@@ -61741,7 +61836,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" },
@@ -63203,7 +63298,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);
@@ -63891,7 +63986,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) {
@@ -68406,7 +68501,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;
@@ -68414,7 +68509,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];
@@ -70778,11 +70873,20 @@ class RpcClientApi {
   async getState() {
     return this.data(await this.request({ type: "get_state" }));
   }
-  async setModel(provider, modelId) {
-    return this.data(await this.request({ type: "set_model", provider, modelId }));
+  async setModel(provider, modelId, options) {
+    return this.data(await this.request({
+      type: "set_model",
+      provider,
+      modelId,
+      ...options?.persist === true ? { persist: true } : {}
+    }));
   }
-  async cycleModel(direction) {
-    return this.data(await this.request({ type: "cycle_model", direction }));
+  async cycleModel(direction, options) {
+    return this.data(await this.request({
+      type: "cycle_model",
+      direction,
+      ...options?.persist === true ? { persist: true } : {}
+    }));
   }
   async getAvailableModels() {
     return this.data(await this.request({ type: "get_available_models" })).models;
@@ -70816,6 +70920,20 @@ class RpcClientApi {
   async setThinkingLevel(level) {
     await this.request({ type: "set_thinking_level", level });
   }
+  async setThinkingLevelAck(level, options) {
+    const response = await this.request({
+      type: "set_thinking_level",
+      level,
+      ...options?.persist === true ? { persist: true } : {}
+    });
+    if (!response.success) {
+      return this.data(response);
+    }
+    if (response.command === "set_thinking_level" && "data" in response && response.data) {
+      return response.data;
+    }
+    return { level };
+  }
   async cycleThinkingLevel() {
     return this.data(await this.request({ type: "cycle_thinking_level" }));
   }
@@ -72834,13 +72952,13 @@ function createRpcCommandHandler({
         if (!model) {
           return createRpcErrorResponse(id, "set_model", `Model not found: ${command.provider}/${command.modelId}`);
         }
-        await session.setModel(model);
+        await session.setModel(model, command.persist === true ? { persist: true } : {});
         runtimeHost.resolveModelFallback();
         return createRpcSuccessResponse(id, "set_model", session.model ?? model);
       }
       case "cycle_model": {
         const previousModel = session.model;
-        const result = await session.cycleModel(command.direction);
+        const result = await session.cycleModel(command.direction, command.persist === true ? { persist: true } : {});
         runtimeHost.resolveModelFallbackAfterExplicitModelSelection(previousModel, result?.model);
         return createRpcSuccessResponse(id, "cycle_model", result ?? null);
       }
@@ -72903,8 +73021,12 @@ function createRpcCommandHandler({
         }
       }
       case "set_thinking_level": {
-        session.setThinkingLevel(command.level);
-        return createRpcSuccessResponse(id, "set_thinking_level");
+        session.setThinkingLevel(command.level, command.persist === true ? { persist: true } : {});
+        const model = session.model;
+        return createRpcSuccessResponse(id, "set_thinking_level", {
+          level: session.thinkingLevel,
+          ...model ? { provider: model.provider, modelId: model.id } : {}
+        });
       }
       case "cycle_thinking_level": {
         const level = session.cycleThinkingLevel();
@@ -76717,6 +76839,152 @@ function subscribeIntercomControl(pi, callbacks) {
   };
 }
 
+// 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/session-scoped-singleton.ts
 init_src();
 var SHARED_STATES_KEY = Symbol.for("atomic-workflows/session-scoped-singleton-pre-adoption@1");
@@ -77229,6 +77497,7 @@ function compactStage(stage) {
     inputRequest,
     notices,
     mcpScope: _mcpScope,
+    pendingStageDeliveryAvailable: _pendingStageDeliveryAvailable,
     attemptedModels: _attemptedModels,
     modelAttempts: _modelAttempts,
     result: _result,
@@ -77484,6 +77753,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;
@@ -78401,6 +78797,7 @@ function createStore() {
   const context = createStoreContext();
   return {
     ...createRunStoreMethods(context),
+    ...createPendingStageDeliveryStoreMethods(context),
     ...createStageStoreMethods(context),
     ...createToolNodeStoreMethods(context),
     ...createPromptStoreMethods(context)
@@ -90556,6 +90953,26 @@ function canonicalJsonString(value) {
 }
 
 // dist/builtin/workflows/src/durable/backend.ts
+function replacePendingStageMessagesForRun(existing, logicalRunId, messages2) {
+  if (messages2.some((entry) => entry.runId !== logicalRunId)) {
+    throw new Error(`atomic-workflows: pending-stage persistence mixed logical run ${logicalRunId}`);
+  }
+  const firstOwnedIndex = existing.findIndex((entry) => entry.runId === logicalRunId);
+  if (firstOwnedIndex < 0)
+    return [...existing, ...messages2];
+  const merged = [];
+  for (let index = 0;index < existing.length; index += 1) {
+    const entry = existing[index];
+    if (index === firstOwnedIndex)
+      merged.push(...messages2);
+    if (entry.runId !== logicalRunId)
+      merged.push(entry);
+  }
+  return merged;
+}
+function pendingStageMessagesForDurableRun(backend, logicalRunId, rootWorkflowId = logicalRunId) {
+  return (backend.getWorkflow(rootWorkflowId)?.pendingStageMessages ?? []).filter((entry) => entry.runId === logicalRunId);
+}
 function checkpointKey(c2) {
   return `${c2.kind}:${c2.checkpointId}`;
 }
@@ -90582,6 +90999,7 @@ class InMemoryDurableBackend {
       ...handle.workflowCwd !== undefined ? { workflowCwd: handle.workflowCwd } : existing?.handle.workflowCwd !== undefined ? { workflowCwd: existing.handle.workflowCwd } : {},
       ...handle.repositoryRoot !== undefined ? { repositoryRoot: handle.repositoryRoot } : existing?.handle.repositoryRoot !== undefined ? { repositoryRoot: existing.handle.repositoryRoot } : {},
       ...handle.gitWorktreeRoot !== undefined ? { gitWorktreeRoot: handle.gitWorktreeRoot } : existing?.handle.gitWorktreeRoot !== undefined ? { gitWorktreeRoot: existing.handle.gitWorktreeRoot } : {},
+      pendingStageMessages: handle.pendingStageMessages ?? existing?.handle.pendingStageMessages ?? [],
       ...handle.sessionFile !== undefined ? { sessionFile: handle.sessionFile } : {},
       completedCheckpoints,
       pendingPrompts,
@@ -90606,6 +91024,17 @@ class InMemoryDurableBackend {
     if (handle.pendingPrompts !== undefined)
       this.promptReservations.delete(handle.workflowId);
   }
+  async persistPendingStageMessages(workflowId, messages2, logicalRunId = workflowId) {
+    const handle = this.getWorkflow(workflowId);
+    if (handle === undefined)
+      return false;
+    this.registerWorkflow({
+      ...handle,
+      pendingStageMessages: replacePendingStageMessagesForRun(handle.pendingStageMessages ?? [], logicalRunId, messages2),
+      updatedAt: nextMetadataTimestamp(handle.updatedAt)
+    });
+    return true;
+  }
   recordCheckpoint(checkpoint) {
     const currentCheckpoint = withCurrentStageTopology(checkpoint);
     const rec = this.workflows.get(currentCheckpoint.workflowId);
@@ -90798,6 +91227,7 @@ class InMemoryDurableBackend {
       createdAt: h.createdAt,
       completedCheckpoints: h.completedCheckpoints,
       pendingPrompts: h.pendingPrompts,
+      pendingStageMessages: h.pendingStageMessages ?? [],
       ...h.ownerExecutorId !== undefined ? { ownerExecutorId: h.ownerExecutorId } : {},
       ...h.sessionFile !== undefined ? { sessionFile: h.sessionFile } : {},
       ...h.label !== undefined ? { label: h.label } : {},
@@ -90886,6 +91316,9 @@ function toResumableEntry(handle) {
     updatedAt: handle.updatedAt
   };
 }
+function nextMetadataTimestamp(previous2) {
+  return Math.max(Date.now(), previous2 + 1);
+}
 
 // dist/builtin/workflows/src/durable/stage-topology-validation.ts
 function immutableStageGroupError(stages) {
@@ -92076,6 +92509,7 @@ function encodeMetadata(metadata) {
       completedCheckpoints: metadata.completedCheckpoints,
       pendingPrompts: metadata.pendingPrompts,
       promptReservationEpoch: metadata.promptReservationEpoch,
+      ...metadata.pendingStageMessages !== undefined ? { pendingStageMessages: serializePendingStageMessages(metadata.pendingStageMessages) } : {},
       ...metadata.ownerExecutorId !== undefined ? { ownerExecutorId: metadata.ownerExecutorId } : {},
       ...metadata.transitionClaimId !== undefined ? { transitionClaimId: metadata.transitionClaimId } : {},
       ...metadata.sessionFile !== undefined ? { sessionFile: metadata.sessionFile } : {},
@@ -92133,15 +92567,101 @@ function metadataTimestamp(record) {
 function parseDurableWorkflowMetadata(value, workflowId) {
   if (typeof value !== "object" || value === null || Array.isArray(value))
     return;
+  const serialized = value;
+  const pendingStageMessages = parsePendingStageMessages(serialized.pendingStageMessages);
+  if (pendingStageMessages === null)
+    return;
   const metadata = value;
   if (metadata.workflowId !== workflowId || typeof metadata.workflowId !== "string" || typeof metadata.name !== "string" || typeof metadata.inputs !== "object" || metadata.inputs === null || Array.isArray(metadata.inputs) || typeof metadata.status !== "string" || !isDurableWorkflowStatus(metadata.status) || typeof metadata.completedCheckpoints !== "number" || typeof metadata.createdAt !== "number" || typeof metadata.pendingPrompts !== "number" || typeof metadata.promptReservationEpoch !== "string" || typeof metadata.updatedAt !== "number" || metadata.ownerExecutorId !== undefined && typeof metadata.ownerExecutorId !== "string" || metadata.transitionClaimId !== undefined && typeof metadata.transitionClaimId !== "string" || metadata.sessionFile !== undefined && typeof metadata.sessionFile !== "string" || metadata.label !== undefined && typeof metadata.label !== "string" || metadata.rootWorkflowId !== undefined && typeof metadata.rootWorkflowId !== "string" || metadata.resumable !== undefined && typeof metadata.resumable !== "boolean" || metadata.exited !== undefined && typeof metadata.exited !== "boolean" || metadata.exitReason !== undefined && typeof metadata.exitReason !== "string" || metadata.error !== undefined && typeof metadata.error !== "string" || metadata.failureKind !== undefined && !isWorkflowFailureKind(metadata.failureKind) || metadata.failureCode !== undefined && !isWorkflowFailureCode(metadata.failureCode) || metadata.failureRecoverability !== undefined && !isWorkflowFailureRecoverability(metadata.failureRecoverability) || metadata.failureDisposition !== undefined && !isWorkflowFailureDisposition(metadata.failureDisposition) || metadata.failedToolNodeId !== undefined && typeof metadata.failedToolNodeId !== "string" || metadata.invocationCwd !== undefined && typeof metadata.invocationCwd !== "string" || metadata.workflowCwd !== undefined && typeof metadata.workflowCwd !== "string" || metadata.repositoryRoot !== undefined && typeof metadata.repositoryRoot !== "string" || metadata.gitWorktreeRoot !== undefined && typeof metadata.gitWorktreeRoot !== "string")
     return;
   const { origin, ...metadataWithoutOrigin } = metadata;
   return {
     ...metadataWithoutOrigin,
+    pendingStageMessages,
     ...isWorkflowActor(origin) ? { origin } : {}
   };
 }
+function serializePendingStageMessages(messages2) {
+  return messages2.map((entry) => ({
+    id: entry.id,
+    runId: entry.runId,
+    stageKey: entry.stageKey,
+    ...entry.stageId !== undefined ? { stageId: entry.stageId } : {},
+    ...entry.stageReplayKey !== undefined ? { stageReplayKey: entry.stageReplayKey } : {},
+    ...entry.senderRegistrationName !== undefined ? { senderRegistrationName: entry.senderRegistrationName } : {},
+    ...entry.senderReturnAddress !== undefined ? { senderReturnAddress: entry.senderReturnAddress } : {},
+    from: {
+      id: entry.from.id,
+      ...entry.from.name !== undefined ? { name: entry.from.name } : {},
+      ...entry.from.group !== undefined ? { group: entry.from.group } : {},
+      ...entry.from.cwd !== undefined ? { cwd: entry.from.cwd } : {},
+      ...entry.from.model !== undefined ? { model: entry.from.model } : {},
+      ...entry.from.pid !== undefined ? { pid: entry.from.pid } : {},
+      ...entry.from.startedAt !== undefined ? { startedAt: entry.from.startedAt } : {},
+      ...entry.from.lastActivity !== undefined ? { lastActivity: entry.from.lastActivity } : {},
+      ...entry.from.status !== undefined ? { status: entry.from.status } : {}
+    },
+    message: {
+      id: entry.message.id,
+      timestamp: entry.message.timestamp,
+      ...entry.message.replyTo !== undefined ? { replyTo: entry.message.replyTo } : {},
+      ...entry.message.expectsReply !== undefined ? { expectsReply: entry.message.expectsReply } : {},
+      ...entry.message.replyError !== undefined ? { replyError: entry.message.replyError } : {},
+      ...entry.message.source !== undefined ? { source: { ...entry.message.source } } : {},
+      content: {
+        text: entry.message.content.text,
+        ...entry.message.content.attachments !== undefined ? { attachments: entry.message.content.attachments.map((attachment) => ({ ...attachment })) } : {}
+      }
+    },
+    queuedAt: entry.queuedAt,
+    ...entry.admissionOrder !== undefined ? { admissionOrder: entry.admissionOrder } : {},
+    status: entry.status,
+    ...entry.deliveredAt !== undefined ? { deliveredAt: entry.deliveredAt } : {},
+    ...entry.undeliverableReason !== undefined ? { undeliverableReason: entry.undeliverableReason } : {},
+    ...entry.undeliverableNotificationId !== undefined ? { undeliverableNotificationId: entry.undeliverableNotificationId } : {},
+    ...entry.undeliverableNotifiedAt !== undefined ? { undeliverableNotifiedAt: entry.undeliverableNotifiedAt } : {}
+  }));
+}
+function parsePendingStageMessages(value) {
+  if (value === undefined)
+    return [];
+  if (!Array.isArray(value) || !value.every(isPendingStageMessage))
+    return null;
+  return value;
+}
+function isPendingStageMessage(value) {
+  if (!isSerializableObject(value))
+    return false;
+  return typeof value.id === "string" && typeof value.runId === "string" && typeof value.stageKey === "string" && (value.stageId === undefined || typeof value.stageId === "string") && (value.stageReplayKey === undefined || typeof value.stageReplayKey === "string") && (value.senderRegistrationName === undefined || typeof value.senderRegistrationName === "string") && (value.senderReturnAddress === undefined || typeof value.senderReturnAddress === "string") && typeof value.queuedAt === "string" && (value.admissionOrder === undefined || typeof value.admissionOrder === "number" && Number.isSafeInteger(value.admissionOrder) && value.admissionOrder > 0) && (value.status === "queued" || value.status === "delivered" || value.status === "undeliverable") && (value.deliveredAt === undefined || typeof value.deliveredAt === "string") && (value.undeliverableReason === undefined || typeof value.undeliverableReason === "string") && (value.undeliverableNotificationId === undefined || typeof value.undeliverableNotificationId === "string") && (value.undeliverableNotifiedAt === undefined || typeof value.undeliverableNotifiedAt === "string") && isPendingStageSender(value.from) && isPendingStageIntercomMessage(value.message);
+}
+function isPendingStageSender(value) {
+  return isSerializableObject(value) && typeof value.id === "string" && (value.name === undefined || typeof value.name === "string") && (value.group === undefined || typeof value.group === "string") && (value.cwd === undefined || typeof value.cwd === "string") && (value.model === undefined || typeof value.model === "string") && (value.pid === undefined || typeof value.pid === "number") && (value.startedAt === undefined || typeof value.startedAt === "number") && (value.lastActivity === undefined || typeof value.lastActivity === "number") && (value.status === undefined || typeof value.status === "string");
+}
+function isPendingStageIntercomMessage(value) {
+  if (!isSerializableObject(value) || typeof value.id !== "string" || typeof value.timestamp !== "number")
+    return false;
+  if (value.replyTo !== undefined && typeof value.replyTo !== "string")
+    return false;
+  if (value.expectsReply !== undefined && typeof value.expectsReply !== "boolean")
+    return false;
+  if (value.replyError !== undefined && typeof value.replyError !== "string")
+    return false;
+  if (!isSerializableObject(value.content) || typeof value.content.text !== "string")
+    return false;
+  const attachments = value.content.attachments;
+  if (attachments !== undefined && (!Array.isArray(attachments) || !attachments.every(isPendingStageAttachment)))
+    return false;
+  return value.source === undefined || isPendingStageSource(value.source);
+}
+function isPendingStageAttachment(value) {
+  return isSerializableObject(value) && (value.type === "file" || value.type === "snippet" || value.type === "context") && typeof value.name === "string" && typeof value.content === "string" && (value.language === undefined || typeof value.language === "string");
+}
+function isPendingStageSource(value) {
+  return isSerializableObject(value) && typeof value.subagentRunId === "string" && (value.subagentAgent === undefined || typeof value.subagentAgent === "string") && (value.subagentIndex === undefined || typeof value.subagentIndex === "number");
+}
+function isSerializableObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
 function isWorkflowActor(value) {
   return value === "user" || value === "agent";
 }
@@ -92676,6 +93196,29 @@ class DbosDurableBackend {
       await this.writeMetadata(handle.workflowId);
     });
   }
+  async persistPendingStageMessages(workflowId, messages2, logicalRunId = workflowId) {
+    let persisted = false;
+    await this.enqueueWrite(async () => {
+      if (!this.isWorkflowLoadable(workflowId))
+        return;
+      const handle = this.mem.getWorkflow(workflowId);
+      const value = this.mem.toMetadata(workflowId);
+      if (handle === undefined || value === undefined)
+        return;
+      const updatedAt = Math.max(Date.now(), handle.updatedAt + 1);
+      const pendingStageMessages = replacePendingStageMessagesForRun(handle.pendingStageMessages ?? [], logicalRunId, messages2);
+      const metadata = {
+        ...this.promptReservations.metadata(workflowId, value),
+        pendingStageMessages,
+        ownerExecutorId: this.executorId,
+        updatedAt
+      };
+      await this.sdk.recordStepOutput(workflowId, metadataStepName(updatedAt), encodeMetadata(metadata));
+      this.mem.registerWorkflow({ ...handle, pendingStageMessages, updatedAt });
+      persisted = true;
+    });
+    return persisted;
+  }
   recordCheckpoint(checkpoint) {
     if (!this.isWorkflowLoadable(checkpoint.workflowId))
       return;
@@ -95378,6 +95921,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);
@@ -95389,13 +95936,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
@@ -96093,6 +96639,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 } : {},
@@ -96636,6 +97183,7 @@ function installCompactionHook(api, store2) {
           stageId: stage.id,
           name: stage.name,
           parentIds: [...stage.parentIds],
+          pendingStageDeliveryAvailable: stage.pendingStageDeliveryAvailable,
           ts: stage.startedAt ?? now
         });
       }
@@ -97212,7 +97760,7 @@ function formatWorkflowLifecycleNoticeText(details) {
     return `？ Workflow "${workflowName}" needs input (run ${details.runId}).${prompt2} Respond: /workflow connect ${details.runId} to answer this run-level prompt.`;
   }
   const stage = details.stageName ?? details.stageId ?? "unknown";
-  const responseHint = details.stageId && details.promptId ? `/workflow connect ${details.runId} or workflow({ action: "send", runId: ${jsonString(details.runId)}, stageId: ${jsonString(details.stageId)}, promptId: ${jsonString(details.promptId)}, response: ... })` : `/workflow connect ${details.runId}`;
+  const responseHint = details.stageId && details.promptId ? `/workflow connect ${details.runId} or workflow({ action: "answer", runId: ${jsonString(details.runId)}, stageId: ${jsonString(details.stageId)}, promptId: ${jsonString(details.promptId)}, response: ... })` : `/workflow connect ${details.runId}`;
   return `？ Workflow "${workflowName}" needs input (run ${details.runId}, stage ${stage}).${prompt2} Respond: ${responseHint}.`;
 }
 function makeTerminalNotice(run, kind) {
@@ -98512,6 +99060,12 @@ function workflow(spec) {
   return Object.freeze(branded);
 }
 
+// dist/builtin/workflows/builtin/steering-context.ts
+var exports_steering_context = {};
+__export(exports_steering_context, {
+  withSteeringPropagationContext: () => withSteeringPropagationContext
+});
+
 // dist/builtin/workflows/src/authoring/keep-context.ts
 var KEEP_CONTEXT_OPEN_TAG = "<keepContext>";
 var KEEP_CONTEXT_CLOSE_TAG = "</keepContext>";
@@ -98525,6 +99079,12 @@ ${KEEP_CONTEXT_CLOSE_TAG}`;
 }
 
 // dist/builtin/workflows/builtin/shared-prompts.ts
+var PENDING_STAGE_DELIVERY_GUIDANCE_LINES = [
+  "Send material updates through Intercom to every affected workflow stage, including stages that have not started.",
+  "Atomic queues messages for known pending stages addressed as `<runId>:<stageKey>` and delivers them when their sessions initialize."
+];
+var PENDING_STAGE_DELIVERY_GUIDANCE = PENDING_STAGE_DELIVERY_GUIDANCE_LINES.join(`
+`);
 var STEERING_PROPAGATION_CONTRACT = [
   "Steering propagation contract:",
   "- Mid-run user messages (steering, follow-ups, resume text) are authoritative and may amend this run's objective or acceptance criteria. Adopt an amendment as required behavior from the moment you receive it.",
@@ -98532,6 +99092,7 @@ var STEERING_PROPAGATION_CONTRACT = [
   "- Keep user-authored amendments visibly separate from your own observations, so later stages can tell a required clause from an agent proposal.",
   "- Treat amendments inherited from an upstream stage as contract clauses. Cover them in acceptance and traceability work; never classify inherited user amendments as beyond_objective, unrequested scope, or speculative expansion.",
   "- If an amendment is ambiguous, or conflicts with the launch contract or another amendment, resolve it before implementing: ask through `intercom` when a supervisor or originating stage is reachable, otherwise state the conflict in your report and implement the narrowest reading consistent with the launch contract.",
+  ...PENDING_STAGE_DELIVERY_GUIDANCE_LINES.map((line) => `- ${line}`),
   "- Propagate nothing else this way. Guidance about how to work, tool preferences, and your own improvement ideas are not amendments; those follow the scope discipline contract."
 ].join(`
 `);
@@ -98572,6 +99133,19 @@ var E2E_VERIFICATION_GUIDANCE = [
   "If E2E remains impractical, record the commands attempted, observed failure output, smallest missing prerequisite, and narrower validation run; an unattempted assumption is never valid grounds to skip."
 ].join(`
 `);
+var CODE_QUALITY_VERIFICATION_GUIDANCE = [
+  'For code-quality verification — linting, auto-formatting, complexity and duplication metrics, and code smells — use the qlty skill or delegate with `skill: "qlty"`; it drives one CLI across the repository\'s languages instead of ad-hoc per-tool linter invocations.',
+  "Weight this higher when the objective asks for verifiers or high code quality: enable the qlty plugins that fit this codebase, then run the check/format/metrics/smells loop and act on what it reports.",
+  "Repository-defined checks in AGENTS.md/CLAUDE.md, package scripts, and CI stay authoritative; qlty supplements them rather than replacing them, and its findings count as evidence only with the command and observed output recorded."
+].join(`
+`);
+var REPO_INTENT_MINING_GUIDANCE = [
+  "Infer maintainer and requesting-user intent from repository behavior, not only written docs: mine git history (`git log`, `git log --show-signature`), merged PRs, issues and their comments, review comments, commit subjects and trailers, and CI/branch-protection config for unwritten conventions.",
+  "Read for commit-signing habits, commit-message style and issue linking, changelog discipline, PR size and stacking norms, review etiquette, formatting and lint norms, and branch naming. Prefer the dominant, recent, intentional pattern over accidental drift; when signals conflict, the requesting user's own commits, PRs, and comments weigh highest — different users of one repository keep different preferences.",
+  "Match inferred conventions in delivered work (for example, sign commits when the surrounding history is signed rather than skipping signing because no doc required it); in review, report deviations as convention findings backed by the mined evidence.",
+  "Behavioral evidence fills gaps where the contract is silent; it never overrides the literal objective, acceptance criteria, or explicit AGENTS.md/CLAUDE.md guidance, and it does not license new contract requirements."
+].join(`
+`);
 function renderE2eQaVideoReviewGuidance(knownVideoPath) {
   const target = knownVideoPath === undefined || knownVideoPath.length === 0 ? "Look for QA E2E video references in the goal ledger, implementation receipt, implementation notes, orchestrator report, or other review context artifacts." : `Known QA E2E video path for this run: ${knownVideoPath}`;
   return [
@@ -101269,6 +101843,8 @@ function renderGoalContinuationPrompt(ledger, ledgerPath, blockerThreshold, late
     ["worktree_discipline", WORKTREE_DISCIPLINE_CONTRACT],
     ["pr_handoff_policy", INTERMEDIATE_PR_HANDOFF_GUARDRAIL],
     ["e2e_verification", E2E_VERIFICATION_GUIDANCE],
+    ["code_quality_verification", CODE_QUALITY_VERIFICATION_GUIDANCE],
+    ["repository_intent", REPO_INTENT_MINING_GUIDANCE],
     ["goal_guidelines", GOAL_CONTINUATION_REFERENCE],
     ["objective", ["Continue working toward the active goal using the ledger as authoritative state for status, receipts, reviews, blockers, reducer decisions, and lifecycle events.", `The same blocker must repeat for at least ${blockerThreshold} controller observations before blocked status is available.`, "Reviewer quorum plus the reducer decides completion from reviewers' authoritative stop_review_loop signals."].join(`
 `)]
@@ -101294,6 +101870,8 @@ function renderReviewerPrompt(args) {
     ["pr_handoff_policy", INTERMEDIATE_PR_HANDOFF_GUARDRAIL],
     ["auditability", RECEIPT_EXPECTATIONS],
     ["e2e_verification", E2E_VERIFICATION_GUIDANCE],
+    ["code_quality_verification", CODE_QUALITY_VERIFICATION_GUIDANCE],
+    ["repository_intent", REPO_INTENT_MINING_GUIDANCE],
     ["final_action_policy", args.createPr ? "PR/MR/review creation is an authorized post-approval final action. If implementation and validation are proven and only that action remains, set goal_oracle_satisfied=true and stop_review_loop=true with no blocking findings, and record it as the remaining final action." : "PR/MR/review creation is not enabled; do not require or attempt it during review."],
     ["project_guidance", [
       "Apply AGENTS.md/CLAUDE.md and nearby code, test, script, config, generated-artifact, and CI conventions; specific project guidance overrides general guidance.",
@@ -103490,6 +104068,8 @@ function renderRalphReviewerPrompt(args) {
     ["reviewer_coordination", REVIEWER_INTERCOM_COORDINATION_PROTOCOL],
     ["regression_evidence", REGRESSION_EVIDENCE_CONTRACT],
     ["e2e_verification", E2E_VERIFICATION_GUIDANCE],
+    ["code_quality_verification", CODE_QUALITY_VERIFICATION_GUIDANCE],
+    ["repository_intent", REPO_INTENT_MINING_GUIDANCE],
     ["qa_e2e_video_review", renderE2eQaVideoReviewGuidance(args.qaVideoPath)],
     ["evidence_closure", EVIDENCE_CLOSURE_POLICY],
     [
@@ -103884,6 +104464,8 @@ Read it before implementation or delegation because it is the primary current im
       ["project_setup", WORKER_PREFLIGHT_CONTRACT],
       ["worktree_discipline", WORKTREE_DISCIPLINE_CONTRACT],
       ["qa_e2e_video", renderQaE2eVideoGuidance(qaVideoPath)],
+      ["code_quality_verification", CODE_QUALITY_VERIFICATION_GUIDANCE],
+      ["repository_intent", REPO_INTENT_MINING_GUIDANCE],
       [
         "delegation",
         [
@@ -106172,6 +106754,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));
   }
@@ -109509,6 +110094,7 @@ import { randomUUID as randomUUID16 } from "node:crypto";
 
 // dist/builtin/workflows/src/shared/intercom-group.ts
 import { randomUUID as randomUUID15 } from "node:crypto";
+var DEFAULT_INTERCOM_GROUP = "default";
 function workflowInvocationIntercomGroup(rootRunId) {
   return `workflow:${rootRunId}`;
 }
@@ -109518,6 +110104,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;
@@ -109542,6 +110134,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/src/shared/budget-meter.ts
 var usageFields = ["input", "output", "cacheRead", "cacheWrite", "cost"];
@@ -109796,9 +110393,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 ? randomUUID16() : undefined;
     const resolveAutoGroup = (value) => value.group === true && autoGroup ? { ...value, group: autoGroup } : value;
@@ -111769,7 +112366,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();
@@ -111820,7 +112417,7 @@ function createAdmittedToolExecutionTracker(options = {}) {
         return { accepted: false, error, bindNode() {}, noteCancelled() {} };
       }
       const admission = {
-        admissionOrder: ++nextAdmissionOrder,
+        admissionOrder: ++nextAdmissionOrder2,
         nodeId: undefined,
         failure: undefined,
         cancelled: false,
@@ -113122,6 +113719,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 randomUUID17 } 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 = randomUUID17();
+    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, stageName3) {
+  let resolveReady;
+  let rejectReady;
+  let readyPromise;
+  let drainError;
+  let drainPromise;
+  const pendingReady = () => {
+    if (readyPromise === undefined) {
+      readyPromise = new Promise((resolve35, reject) => {
+        resolveReady = resolve35;
+        rejectReady = reject;
+      });
+    }
+    return readyPromise;
+  };
+  return {
+    routeCapability: workflowPendingStageRouteCapability(activeStore, runId),
+    deliverPending(deliver) {
+      if (drainPromise === undefined) {
+        drainError = undefined;
+        const attempt = deliverPendingStageMessages(activeStore, runId, stageId, stageName3, 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 === stageName3 || activeStore.pendingStageMessagesFor(runId, stageName3).length === 0)) {
+        return;
+      }
+      return drainError === undefined ? pendingReady() : Promise.reject(drainError);
+    }
+  };
+}
+async function deliverPendingStageMessages(activeStore, runId, stageId, stageName3, deliver) {
+  const candidateIds = new Set([
+    ...activeStore.pendingStageMessagesFor(runId, stageId),
+    ...activeStore.pendingStageMessagesFor(runId, stageName3)
+  ].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();
 
@@ -113513,7 +114254,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,
@@ -113522,11 +114263,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,
@@ -114892,7 +115634,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 } : {}
@@ -114909,10 +115651,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);
@@ -115664,6 +116408,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,
@@ -115671,6 +116421,7 @@ function createWorkflowStageFactory(input2) {
       status: shouldReplay ? "completed" : "pending",
       parentIds: Object.freeze(parentIds),
       toolEvents: [],
+      pendingStageDeliveryAvailable,
       ...shouldReplay ? {
         startedAt: Date.now(),
         endedAt: Date.now(),
@@ -115699,11 +116450,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;
@@ -115741,6 +116487,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,
@@ -115866,6 +116615,7 @@ function createWorkflowStageFactory(input2) {
         name,
         parentIds: stageSnapshot.parentIds,
         ...stageReplayFields(stageSnapshot),
+        pendingStageDeliveryAvailable,
         ts: stageSnapshot.startedAt ?? Date.now()
       });
     };
@@ -116228,6 +116978,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,
@@ -116801,8 +117554,8 @@ var runWorkflow = () => {
 };
 
 // dist/builtin/workflows/src/extension/workflow-module-loader.ts
-var WORKFLOWS_MODULE_SPECIFIER = "@bastani/workflows";
-var WORKFLOWS_BUILTIN_MODULE_SPECIFIER = `${WORKFLOWS_MODULE_SPECIFIER}/builtin`;
+var WORKFLOWS_MODULE_SPECIFIER = "@bastani/atomic/workflows";
+var LEGACY_WORKFLOWS_MODULE_SPECIFIER = "@bastani/workflows";
 var TYPEBOX_MODULE_SPECIFIER = "typebox";
 var WORKFLOWS_SDK_MODULE = {
   ...exports_sdk_surface
@@ -116821,19 +117574,27 @@ var WORKFLOWS_BUILTIN_MODULE = {
 var TYPEBOX_MODULE = {
   ...typeboxModule
 };
+function createWorkflowVirtualModules(moduleSpecifier) {
+  const builtinModuleSpecifier = `${moduleSpecifier}/builtin`;
+  return {
+    [moduleSpecifier]: WORKFLOWS_SDK_MODULE,
+    [builtinModuleSpecifier]: WORKFLOWS_BUILTIN_MODULE,
+    [`${builtinModuleSpecifier}/adversarial-verification`]: { default: adversarial_verification_default },
+    [`${builtinModuleSpecifier}/classify-and-act`]: { default: classify_and_act_default },
+    [`${builtinModuleSpecifier}/fan-out-and-synthesize`]: { default: fan_out_and_synthesize_default },
+    [`${builtinModuleSpecifier}/generate-and-filter`]: { default: generate_and_filter_default },
+    [`${builtinModuleSpecifier}/goal`]: { default: goal_default },
+    [`${builtinModuleSpecifier}/loop-until-done`]: { default: loop_until_done_default },
+    [`${builtinModuleSpecifier}/open-claude-design`]: { default: open_claude_design_default },
+    [`${builtinModuleSpecifier}/ralph`]: { default: ralph_default },
+    [`${builtinModuleSpecifier}/tournament`]: { default: tournament_default },
+    [`${builtinModuleSpecifier}/steering-context`]: exports_steering_context
+  };
+}
 var WORKFLOWS_VIRTUAL_MODULES = {
-  [WORKFLOWS_MODULE_SPECIFIER]: WORKFLOWS_SDK_MODULE,
-  [WORKFLOWS_BUILTIN_MODULE_SPECIFIER]: WORKFLOWS_BUILTIN_MODULE,
-  [TYPEBOX_MODULE_SPECIFIER]: TYPEBOX_MODULE,
-  [`${WORKFLOWS_BUILTIN_MODULE_SPECIFIER}/adversarial-verification`]: { default: adversarial_verification_default },
-  [`${WORKFLOWS_BUILTIN_MODULE_SPECIFIER}/classify-and-act`]: { default: classify_and_act_default },
-  [`${WORKFLOWS_BUILTIN_MODULE_SPECIFIER}/fan-out-and-synthesize`]: { default: fan_out_and_synthesize_default },
-  [`${WORKFLOWS_BUILTIN_MODULE_SPECIFIER}/generate-and-filter`]: { default: generate_and_filter_default },
-  [`${WORKFLOWS_BUILTIN_MODULE_SPECIFIER}/goal`]: { default: goal_default },
-  [`${WORKFLOWS_BUILTIN_MODULE_SPECIFIER}/loop-until-done`]: { default: loop_until_done_default },
-  [`${WORKFLOWS_BUILTIN_MODULE_SPECIFIER}/open-claude-design`]: { default: open_claude_design_default },
-  [`${WORKFLOWS_BUILTIN_MODULE_SPECIFIER}/ralph`]: { default: ralph_default },
-  [`${WORKFLOWS_BUILTIN_MODULE_SPECIFIER}/tournament`]: { default: tournament_default }
+  ...createWorkflowVirtualModules(WORKFLOWS_MODULE_SPECIFIER),
+  ...createWorkflowVirtualModules(LEGACY_WORKFLOWS_MODULE_SPECIFIER),
+  [TYPEBOX_MODULE_SPECIFIER]: TYPEBOX_MODULE
 };
 var workflowModuleLoader = createJiti2(import.meta.url, {
   moduleCache: false,
@@ -117478,27 +118239,6 @@ function ensurePostMortemStageHandle(runId, stage, deps) {
   const handle = deps.registry.getOrCreateDetached(runId, stage.id, () => createPostMortemStageHandle(runId, stage, sessionFile, adapters, deps.cwd, deps.defaultSessionDir));
   return { ok: true, handle };
 }
-function acquirePostMortemStageHandle(runId, stage, deps) {
-  if (!TERMINAL_POSTMORTEM_STATUSES.has(stage.status))
-    return { ok: false, reason: "not_terminal" };
-  const existing = deps.registry.peek(runId, stage.id);
-  if (existing !== undefined && existing.isDisposed !== true) {
-    return {
-      ok: true,
-      lease: deps.registry.acquireDetached(runId, stage.id, () => existing)
-    };
-  }
-  if (deps.adapters?.agentSession === undefined)
-    return { ok: false, reason: "no_adapter" };
-  const sessionFile = stage.sessionFile;
-  if (typeof sessionFile !== "string" || sessionFile.length === 0)
-    return { ok: false, reason: "no_session" };
-  if (!isReopenableSessionTranscript(sessionFile))
-    return { ok: false, reason: "invalid_session" };
-  const adapters = deps.adapters;
-  const lease = deps.registry.acquireDetached(runId, stage.id, () => createPostMortemStageHandle(runId, stage, sessionFile, adapters, deps.cwd, deps.defaultSessionDir));
-  return { ok: true, lease };
-}
 function createPostMortemStageHandle(runId, stage, sessionFile, adapters, cwd, defaultSessionDir) {
   const context = createStageContext2({
     runId,
@@ -118228,7 +118968,7 @@ function formatWorkflowHeartbeatNoticeText(details) {
   const workflowName = escapeQuotedText3(details.workflowName);
   const elapsed = formatWorkflowHeartbeatElapsed(details);
   const cadence = formatWorkflowHeartbeatCadence(details.intervalMinutes);
-  return `${WORKFLOW_HEARTBEAT_GLYPH} Workflow "${workflowName}" heartbeat (run ${details.runId}) — still running` + `${elapsed === undefined ? "" : ` after ${elapsed}`}, on a ${cadence} cadence. ` + "This is a periodic alignment check, not a failure. Review whether the run is still on goal, then " + "continue, steer it, stop and replace it, or ask the user. " + `Inspect: /workflow status ${details.runId}`;
+  return `${WORKFLOW_HEARTBEAT_GLYPH} Workflow "${workflowName}" heartbeat (run ${details.runId}) — still running` + `${elapsed === undefined ? "" : ` after ${elapsed}`}, on a ${cadence} cadence. ` + "This is a periodic alignment check. Review whether the run is still on goal. " + "When steering or communication is useful, use Intercom. Consider the expanded workflow topology and match " + "each update's reach to its impact: send a local update to its affected stage; when shared scope or acceptance " + "criteria change, send the same authoritative Intercom update to every relevant live and known unstarted " + "`<runId>:<stageKey>`, including each worker-to-reviewer loop. Intercom delivers immediately to live stages and " + "queues updates for known stages that have not started, delivering them before their first model turn, so workers " + "and reviewers begin with one consistent contract. " + "Use `ask` once the target has a live session that can reply. " + "Use workflow pause, resume, interrupt, or quit for run control. " + "Continue the progressing run when no intervention is needed, or ask the user when a decision is needed. " + `Inspect: /workflow status ${details.runId}`;
 }
 function registerWorkflowHeartbeatRenderer(options) {
   const register = options.registerMessageRenderer;
@@ -119460,6 +120200,241 @@ function createWorkflowExtensionRuntimeState(pi, adapters, resolveCwd = () => pi
   };
 }
 
+// dist/builtin/workflows/src/extension/pending-stage-intercom.ts
+var PENDING_STAGE_ROUTE_EVENT = "atomic:workflow-pending-stage-route";
+var PENDING_STAGE_MESSAGE_EVENT = "atomic:workflow-pending-stage-message";
+var PENDING_STAGE_UNDELIVERABLE_EVENT = "atomic:workflow-pending-stage-undeliverable";
+var PENDING_STAGE_ASK_REFUSAL = "Cannot ask a workflow stage whose session has not initialized. Use send; Atomic will queue the message until the stage session initializes.";
+function registerPendingStageIntercomBridge(pi, activeStore) {
+  let disposed = false;
+  let sweepPromise = Promise.resolve();
+  const notifyUndeliverable = async (entry, reason, notificationId) => {
+    const payload = {
+      handled: false,
+      runId: entry.runId,
+      senderId: entry.from.id,
+      ...entry.senderRegistrationName === undefined ? {} : { senderRegistrationName: entry.senderRegistrationName },
+      ...entry.senderReturnAddress === undefined ? {} : { senderReturnAddress: entry.senderReturnAddress },
+      messageId: entry.message.id,
+      notificationId,
+      reason
+    };
+    pi.events?.emit?.(PENDING_STAGE_UNDELIVERABLE_EVENT, payload);
+    return payload.handled && await payload.completion === true;
+  };
+  const announceRoutes = () => {
+    if (disposed)
+      return;
+    const runs = activeStore.runs();
+    for (const run2 of runs) {
+      const rootRunId = durableRootRunIdForRun(runs, run2.id);
+      if (rootRunId === undefined)
+        continue;
+      pi.events?.emit?.(PENDING_STAGE_ROUTE_EVENT, {
+        runId: run2.id,
+        group: workflowInvocationIntercomGroup(rootRunId),
+        capability: workflowPendingStageRouteCapability(activeStore, run2.id)
+      });
+    }
+    sweepPromise = sweepPromise.then(() => settleUndeliverablePendingStageMessages(activeStore, notifyUndeliverable)).then(() => {
+      return;
+    }).catch((error) => console.warn("atomic-workflows: pending stage delivery sweep failed", error));
+  };
+  const unsubscribeStore = activeStore.subscribeInvalidation(announceRoutes);
+  announceRoutes();
+  const subscription = pi.events?.on?.(PENDING_STAGE_MESSAGE_EVENT, (payload) => {
+    if (disposed || !isPendingStageMessageEvent(payload) || payload.handled)
+      return;
+    const runs = activeStore.runs();
+    const run2 = runs.find((candidate) => candidate.id === payload.runId);
+    if (run2 === undefined)
+      return;
+    const rootRunId = durableRootRunIdForRun(runs, run2.id);
+    if (rootRunId === undefined)
+      return;
+    if (payload.live === true) {
+      if (knownLiveStage(run2, payload.stageKey) === undefined)
+        return;
+      payload.handled = true;
+      payload.completion = validateLiveDelivery(activeStore, payload);
+      return;
+    }
+    const stage = knownUninitializedStage(run2, payload.stageKey);
+    if (stage === undefined)
+      return;
+    payload.handled = true;
+    payload.completion = queueAndPersist(activeStore, payload, workflowInvocationIntercomGroup(rootRunId), stage.pendingStageDeliveryAvailable === true);
+  });
+  const dispose2 = () => {
+    disposed = true;
+    unsubscribeStore();
+    if (typeof subscription === "function")
+      subscription();
+  };
+  pi.on?.("session_shutdown", dispose2);
+  return dispose2;
+}
+function isPendingStageMessageEvent(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  const event = value;
+  return typeof event.handled === "boolean" && (event.live === undefined || typeof event.live === "boolean") && typeof event.runId === "string" && typeof event.stageKey === "string" && typeof event.from?.id === "string" && (event.from.name === undefined || typeof event.from.name === "string") && (event.senderRegistrationName === undefined || typeof event.senderRegistrationName === "string") && (event.senderReturnAddress === undefined || typeof event.senderReturnAddress === "string") && typeof event.message?.id === "string" && typeof event.message.timestamp === "number" && typeof event.message.content?.text === "string";
+}
+function knownLiveStage(run2, stageKey) {
+  const exactIds = run2.stages.filter((stage) => stage.id === stageKey);
+  const candidates = exactIds.length > 0 ? exactIds : run2.stages.filter((stage) => stage.name === stageKey);
+  return candidates.length === 1 ? candidates[0] : undefined;
+}
+async function validateLiveDelivery(activeStore, event) {
+  const result = await activeStore.validateLiveStageMessage({
+    runId: event.runId,
+    stageKey: event.stageKey,
+    from: event.from,
+    message: event.message,
+    queuedAt: new Date().toISOString()
+  });
+  if (result === undefined)
+    return { outcome: "refused", reason: "Session not found" };
+  if (result.outcome === "forward" || result.outcome === "delivered" || result.outcome === "queued")
+    return result;
+  if (result.outcome === "undeliverable") {
+    return { outcome: "refused", reason: result.reason ?? "Pending-stage delivery was refused" };
+  }
+  return {
+    outcome: "refused",
+    reason: `Intercom message ID '${result.messageId}' conflicts with the durable identity for ${event.runId}:${event.stageKey}`,
+    reasonCode: "message_id_conflict"
+  };
+}
+async function queueAndPersist(activeStore, event, runGroup, pendingStageDeliveryAvailable) {
+  if (event.message.expectsReply === true) {
+    return { outcome: "refused", reason: PENDING_STAGE_ASK_REFUSAL };
+  }
+  if (!pendingStageDeliveryAvailable) {
+    return {
+      outcome: "refused",
+      reason: `Workflow stage ${event.runId}:${event.stageKey} cannot receive Intercom messages before startup`
+    };
+  }
+  const request = {
+    runId: event.runId,
+    stageKey: event.stageKey,
+    from: event.from,
+    ...event.senderRegistrationName === undefined ? {} : { senderRegistrationName: event.senderRegistrationName },
+    ...event.senderReturnAddress === undefined ? {} : { senderReturnAddress: event.senderReturnAddress },
+    message: event.message,
+    queuedAt: new Date().toISOString()
+  };
+  const rootBackend = getDurableBackend();
+  const backend = durableBackendForRun(rootBackend, activeStore.runs(), event.runId);
+  if (backend === undefined)
+    return { outcome: "refused", reason: "Session not found" };
+  const result = await activeStore.queueStageMessage(request, event.from.group, runGroup, backend);
+  if (result === undefined)
+    return { outcome: "refused", reason: "Session not found" };
+  if (!result.ok) {
+    if (result.reason === "capacity") {
+      return {
+        outcome: "refused",
+        reason: `Pending stage message queue is full (limit ${result.limit}) for ${result.runId}:${result.stageKey}`
+      };
+    }
+    if (result.reason === "message_id_conflict") {
+      return {
+        outcome: "refused",
+        reason: `Intercom message ID '${result.messageId}' was already queued for ${result.runId}:${result.stageKey} with a different target, sender, or payload`
+      };
+    }
+    return { outcome: "refused", reason: "Target workflow run is in a different intercom group" };
+  }
+  if (result.entry.status === "delivered")
+    return { outcome: "delivered" };
+  if (result.entry.status === "undeliverable") {
+    return {
+      outcome: "refused",
+      reason: result.entry.undeliverableReason ?? "Pending-stage delivery was refused"
+    };
+  }
+  if (result.position === undefined)
+    return { outcome: "refused", reason: "Pending-stage delivery was refused" };
+  return { outcome: "queued", position: result.position };
+}
+function knownUninitializedStage(run2, stageKey) {
+  const exactIds = run2.stages.filter((stage2) => stage2.id === stageKey);
+  const candidates = exactIds.length > 0 ? exactIds : run2.stages.filter((stage2) => stage2.name === stageKey);
+  if (candidates.length !== 1)
+    return;
+  const stage = candidates[0];
+  return (stage.status === "pending" || stage.status === "running") && stage.sessionId === undefined && stage.sessionFile === undefined ? stage : undefined;
+}
+function pendingStageDestination(run2, entry) {
+  if (entry.stageId !== undefined) {
+    const candidates2 = run2.stages.filter((stage) => stage.id === entry.stageId);
+    return candidates2.length === 1 ? candidates2[0] : undefined;
+  }
+  if (entry.stageReplayKey !== undefined) {
+    const candidates2 = run2.stages.filter((stage) => stage.replayKey === entry.stageReplayKey);
+    return candidates2.length === 1 ? candidates2[0] : undefined;
+  }
+  const exactIds = run2.stages.filter((stage) => stage.id === entry.stageKey);
+  const candidates = exactIds.length > 0 ? exactIds : run2.stages.filter((stage) => stage.name === entry.stageKey);
+  return candidates.length === 1 ? candidates[0] : undefined;
+}
+function pendingStageUndeliverableReason(run2, entry) {
+  const stage = pendingStageDestination(run2, entry);
+  if (run2.status === "cancelled") {
+    return `Workflow run ${run2.id} terminated with status cancelled before stage ${entry.stageKey} started`;
+  }
+  if (stage?.status === "skipped") {
+    return `Workflow stage ${entry.stageKey} was skipped${stage.skippedReason ? ` (${stage.skippedReason})` : ""}`;
+  }
+  if (isTerminalRunStatus(run2.status)) {
+    return `Workflow run ${run2.id} terminated with status ${run2.status} before stage ${entry.stageKey} started`;
+  }
+  return;
+}
+function needsUndeliverableSettlement(run2, entry) {
+  if (entry.status === "queued")
+    return pendingStageUndeliverableReason(run2, entry) !== undefined;
+  return entry.status === "undeliverable" && entry.undeliverableNotificationId !== undefined && entry.undeliverableNotifiedAt === undefined && entry.undeliverableReason !== undefined;
+}
+async function settleUndeliverablePendingStageMessages(activeStore, notify2) {
+  const runs = activeStore.runs();
+  if (!runs.some((run2) => run2.pendingStageMessages?.some((entry) => needsUndeliverableSettlement(run2, entry)))) {
+    return 0;
+  }
+  let settled = 0;
+  const rootBackend = getDurableBackend();
+  for (const run2 of runs) {
+    const backend = durableBackendForRun(rootBackend, runs, run2.id);
+    if (backend === undefined) {
+      throw new Error(`atomic-workflows: workflow run ${run2.id} has no durable owner for pending-stage settlement`);
+    }
+    for (const snapshotEntry of run2.pendingStageMessages ?? []) {
+      let entry = snapshotEntry;
+      if (entry.status === "queued") {
+        const reason = pendingStageUndeliverableReason(run2, entry);
+        if (reason === undefined)
+          continue;
+        if (await activeStore.markPendingStageMessageUndeliverable(run2.id, entry.stageKey, entry.id, reason, backend)) {
+          settled += 1;
+        }
+        const currentRun2 = activeStore.runs().find((candidate) => candidate.id === run2.id);
+        const currentEntry = currentRun2?.pendingStageMessages?.find((candidate) => candidate.stageKey === entry.stageKey && candidate.id === entry.id);
+        if (currentEntry === undefined)
+          continue;
+        entry = currentEntry;
+      }
+      if (entry.status !== "undeliverable" || entry.undeliverableNotificationId === undefined || entry.undeliverableNotifiedAt !== undefined || entry.undeliverableReason === undefined)
+        continue;
+      if (!await notify2(entry, entry.undeliverableReason, entry.undeliverableNotificationId))
+        continue;
+      await activeStore.markPendingStageMessageUndeliverableNotified(run2.id, entry.stageKey, entry.id, entry.undeliverableNotificationId, new Date().toISOString(), backend);
+    }
+  }
+  return settled;
+}
+
 // dist/builtin/workflows/src/extension/postmortem-deps.ts
 function resolveStageCwd(runId) {
   try {
@@ -119793,7 +120768,9 @@ function withWorkflowStageSessionOptions(options, meta2, pi) {
   return {
     ...options,
     excludedTools,
-    ...meta2 ? { orchestrationContext: meta2.orchestrationContext ?? makeWorkflowStageOrchestrationContext(meta2, pi) } : {}
+    ...meta2 ? {
+      orchestrationContext: meta2.orchestrationContext ?? options.orchestrationContext ?? makeWorkflowStageOrchestrationContext(meta2, pi)
+    } : {}
   };
 }
 function shouldBindStageUiContext(pi, meta2) {
@@ -119898,10 +120875,8 @@ function buildRuntimeAdapters(pi, options = {}) {
         const sessionOptions = withWorkflowStageSessionOptions(stripWorkflowOnlyOptions2(stageOptions) ?? {}, meta2, pi);
         const result = await createSession(sessionOptions);
         const bindable = result.session;
-        if (shouldBindStageUiContext(pi, meta2) && typeof bindable.bindExtensions === "function") {
-          await bindable.bindExtensions({
-            uiContext: makeStageExtensionUiContext(pi.ui ?? {}, meta2, broker)
-          });
+        if (typeof bindable.bindExtensions === "function") {
+          await bindable.bindExtensions(shouldBindStageUiContext(pi, meta2) ? { uiContext: makeStageExtensionUiContext(pi.ui ?? {}, meta2, broker) } : {});
         }
         return result;
       }
@@ -121995,6 +122970,139 @@ function buildWorkflowStatusListing(snapshots2, filter = "all", now = Date.now()
   };
 }
 
+// dist/builtin/workflows/src/extension/workflow-tool-answer.ts
+function answerResult(runId, stageId, status, message) {
+  return { action: "answer", runId, stageId, status, message };
+}
+function terminalAnswerResult(runId, stageId, workflowStatus) {
+  const message = `Cannot answer a prompt because workflow ${runId} has terminated with status ${workflowStatus}. If work remains, start a new workflow to address it.`;
+  return {
+    action: "answer",
+    runId,
+    stageId,
+    status: "failed",
+    code: "WORKFLOW_TERMINAL",
+    workflowStatus,
+    error: message,
+    message
+  };
+}
+function hasPayloadProperty(args) {
+  return args.text !== undefined || args.response !== undefined || args.message !== undefined;
+}
+function promptPayloadFromArgs(args) {
+  if (args.response !== undefined)
+    return args.response;
+  if (args.text !== undefined)
+    return args.text;
+  return args.message;
+}
+function textPayloadFromArgs(args) {
+  if (args.text !== undefined)
+    return args.text;
+  if (typeof args.response === "string")
+    return args.response;
+  return args.message;
+}
+function brokerAnswerFromArgs(args) {
+  if (args.response !== undefined) {
+    const coerced = coerceStageInputAnswer(args.response);
+    if (hasStageInputAnswerContent(coerced))
+      return coerced;
+  }
+  const text = textPayloadFromArgs(args);
+  return text !== undefined ? { text } : {};
+}
+function answerablePromptIds(stage) {
+  const target = stage.workflowGraphTarget;
+  const ids = [];
+  const brokered = stageUiBroker.peekStagePrompt(target.runId, target.stageId);
+  if (brokered !== undefined)
+    ids.push(brokered.id);
+  if (stage.pendingPrompt !== undefined)
+    ids.push(stage.pendingPrompt.id);
+  if (stage.status === "awaiting_input" && stage.promptFootprint?.kind === "custom")
+    ids.push(stage.promptFootprint.id);
+  return ids;
+}
+function inferPromptStageTarget(runId, promptId) {
+  const pending = expandWorkflowGraph(readGraphStoreSnapshot(store), runId).stages.filter((stage) => {
+    const ids = answerablePromptIds(stage);
+    return promptId === undefined ? ids.length > 0 : ids.includes(promptId);
+  });
+  const only = pending[0];
+  if (pending.length === 1 && only !== undefined) {
+    return { ok: true, runId: only.workflowGraphTarget.runId, stageId: only.workflowGraphTarget.stageId };
+  }
+  if (pending.length === 0) {
+    return promptId === undefined ? { ok: true, runId } : { ok: false, message: `No pending prompt ${promptId} in run ${runId}.` };
+  }
+  return {
+    ok: false,
+    message: `${pending.length} prompts pending; pass stageId: ${pending.map(expandedStageLabel).join(", ")}`
+  };
+}
+async function workflowAnswerAction(args) {
+  const target = resolveToolRunTarget(args, "No active run with a pending prompt.");
+  if (target.kind === "all")
+    return answerResult("--all", "", "noop", "Answer requires a single run.");
+  if (target.kind === "malformed" || target.kind === "not_found") {
+    return answerResult(target.target, "", "noop", target.message);
+  }
+  const runs = store.runs();
+  const runById = new Map(runs.map((run2) => [run2.id, run2]));
+  const rootRunId = reciprocalWorkflowRootRunId(runById, target.runId) ?? target.runId;
+  const rootRun = runById.get(rootRunId);
+  if (rootRun !== undefined && isTerminalRunStatus(rootRun.status)) {
+    return terminalAnswerResult(rootRun.id, args.stageId?.trim() ?? "", rootRun.status);
+  }
+  const requested = resolveToolStageTarget(target.runId, args.stageId);
+  const stage = requested.ok && requested.stageId === undefined ? inferPromptStageTarget(target.runId, args.promptId) : requested;
+  if (!stage.ok || stage.stageId === undefined) {
+    return answerResult(target.runId, "", "noop", stage.ok ? "Stage id or name is required." : stage.message);
+  }
+  const stageRunId = stage.runId ?? target.runId;
+  const snapshot2 = store.runs().find((run2) => run2.id === stageRunId)?.stages.find((item) => item.id === stage.stageId);
+  const brokerPrompt = stageUiBroker.peekStagePrompt(stageRunId, stage.stageId);
+  if (brokerPrompt !== undefined && (args.promptId === undefined || args.promptId === brokerPrompt.id)) {
+    if (!hasPayloadProperty(args))
+      return answerResult(stageRunId, stage.stageId, "noop", "Answer requires text, response, or message.");
+    const ok2 = stageUiBroker.answerStagePrompt(stageRunId, stage.stageId, brokerAnswerFromArgs(args), {
+      answerSource: "workflow_tool"
+    });
+    return answerResult(stageRunId, stage.stageId, ok2 ? "ok" : "noop", ok2 ? `Answered input request ${brokerPrompt.id}.` : `No matching pending input request ${brokerPrompt.id}.`);
+  }
+  const customPrompt = snapshot2?.status === "awaiting_input" && snapshot2.promptFootprint?.kind === "custom" ? snapshot2.promptFootprint : undefined;
+  if (customPrompt !== undefined && (args.promptId === undefined || args.promptId === customPrompt.id)) {
+    return answerResult(stageRunId, stage.stageId, "noop", `Custom UI prompt ${customPrompt.id} requires the interactive workflow graph; arbitrary ctx.ui.custom<T> results cannot be answered through workflow answer.`);
+  }
+  const promptId = args.promptId ?? snapshot2?.pendingPrompt?.id;
+  if (promptId === undefined) {
+    return answerResult(stageRunId, stage.stageId, "noop", "No pending prompt to answer.");
+  }
+  if (!hasPayloadProperty(args))
+    return answerResult(stageRunId, stage.stageId, "noop", "Answer requires text, response, or message.");
+  if (stageUiBroker.wasStagePromptResolved(stageRunId, stage.stageId, promptId)) {
+    return answerResult(stageRunId, stage.stageId, "ok", `Input request ${promptId} was already answered.`);
+  }
+  const rawPayload = promptPayloadFromArgs(args);
+  const pendingPrompt = snapshot2?.pendingPrompt;
+  const primitivePrompt = pendingPrompt?.id === promptId && isPrimitivePrompt(pendingPrompt) ? pendingPrompt : undefined;
+  if (primitivePrompt !== undefined) {
+    const coerced = coercePrimitivePromptAnswer(primitivePrompt, rawPayload);
+    if (!coerced.ok)
+      return answerResult(stageRunId, stage.stageId, "noop", primitivePromptAnswerRejection(promptId, primitivePrompt));
+    const ok2 = store.resolveStagePendingPrompt(stageRunId, stage.stageId, promptId, coerced.value, {
+      answerSource: "workflow_tool"
+    });
+    return answerResult(stageRunId, stage.stageId, ok2 ? "ok" : "noop", ok2 ? `Answered prompt ${promptId}.` : `No matching pending prompt ${promptId}.`);
+  }
+  const ok = store.resolveStagePendingPrompt(stageRunId, stage.stageId, promptId, rawPayload, {
+    answerSource: "workflow_tool"
+  });
+  return answerResult(stageRunId, stage.stageId, ok ? "ok" : "noop", ok ? `Answered prompt ${promptId}.` : `No matching pending prompt ${promptId}.`);
+}
+
 // dist/builtin/workflows/src/extension/workflow-tool-content.ts
 function stringifyWorkflowToolResult(result) {
   return JSON.stringify(result, null, 2);
@@ -122003,7 +123111,7 @@ function compactWorkflowToolMessage(result) {
   if (result.action === "reload") {
     return `${result.action}: ${result.status} — ${result.message}`;
   }
-  const target = [result.runId, result.action === "send" ? result.stageId : undefined].filter((part) => part !== undefined && part.length > 0).join("/");
+  const target = [result.runId, result.action === "answer" ? result.stageId : undefined].filter((part) => part !== undefined && part.length > 0).join("/");
   return `${result.action}:${target ? ` ${target}` : ""} ${result.status} — ${result.message}`;
 }
 var STATUS_MESSAGE_CHAR_LIMIT = 120;
@@ -122079,7 +123187,7 @@ function renderStatusToolContent(result) {
     for (const entry of run2.awaitingInput)
       lines.push(statusAwaitingInputLine(entry));
   });
-  lines.push("hint: status with runId returns full run detail; pause/resume/interrupt/quit/send accept the same runId (send also takes stageId/promptId).");
+  lines.push("hint: status with runId returns full run detail; workflow answer answers pending prompts using runId/stageId/promptId; workflow resume controls paused runs; pause/interrupt/quit also accept runId. Ordinary Intercom handles free-form workflow-stage communication at <runId>:<stageKey>: live delivery is immediate, known unstarted stages queue before their first model turn. Use Intercom ask once a reply-capable live session exists.");
   return lines.join(`
 `);
 }
@@ -122207,7 +123315,7 @@ function renderWorkflowToolContent(result, args) {
       return renderStagesToolContent(result);
     case "stage":
       return renderStageToolContent(result);
-    case "send":
+    case "answer":
     case "pause":
     case "reload":
     case "interrupt":
@@ -122982,284 +124090,6 @@ function workflowTranscriptResult(args, source) {
   });
 }
 
-// dist/builtin/workflows/src/extension/workflow-tool-send.ts
-function hasPayloadProperty(args) {
-  return args.text !== undefined || args.response !== undefined || args.message !== undefined;
-}
-function promptPayloadFromArgs(args) {
-  if (args.response !== undefined)
-    return args.response;
-  if (args.text !== undefined)
-    return args.text;
-  return args.message;
-}
-function textPayloadFromArgs(args) {
-  if (args.text !== undefined)
-    return args.text;
-  if (typeof args.response === "string")
-    return args.response;
-  if (args.message !== undefined)
-    return args.message;
-  return;
-}
-function brokerAnswerFromArgs(args) {
-  if (args.response !== undefined) {
-    const coerced = coerceStageInputAnswer(args.response);
-    if (hasStageInputAnswerContent(coerced))
-      return coerced;
-  }
-  const text = textPayloadFromArgs(args);
-  return text !== undefined ? { text } : {};
-}
-function answersPendingPrompt(delivery, promptId) {
-  return delivery === "answer" || delivery === "auto" || promptId !== undefined;
-}
-function answerablePromptIds(stage) {
-  const target = stage.workflowGraphTarget;
-  const ids = [];
-  const brokered = stageUiBroker.peekStagePrompt(target.runId, target.stageId);
-  if (brokered !== undefined)
-    ids.push(brokered.id);
-  if (stage.pendingPrompt !== undefined)
-    ids.push(stage.pendingPrompt.id);
-  if (stage.status === "awaiting_input" && stage.promptFootprint?.kind === "custom") {
-    ids.push(stage.promptFootprint.id);
-  }
-  return ids;
-}
-function inferPromptStageTarget(runId, delivery, promptId) {
-  if (!answersPendingPrompt(delivery, promptId))
-    return { ok: true, runId };
-  const pending = expandWorkflowGraph(readGraphStoreSnapshot(store), runId).stages.filter((stage) => {
-    const ids = answerablePromptIds(stage);
-    return promptId === undefined ? ids.length > 0 : ids.includes(promptId);
-  });
-  const only = pending[0];
-  if (pending.length === 1 && only !== undefined) {
-    return { ok: true, runId: only.workflowGraphTarget.runId, stageId: only.workflowGraphTarget.stageId };
-  }
-  if (pending.length === 0) {
-    return promptId === undefined ? { ok: true, runId } : { ok: false, message: `No pending prompt ${promptId} in run ${runId}.` };
-  }
-  return {
-    ok: false,
-    message: `${pending.length} prompts pending; pass stageId: ${pending.map(expandedStageLabel).join(", ")}`
-  };
-}
-function workflowSendResult(runId, stageId, delivery, status, message) {
-  return { action: "send", runId, stageId, delivery, status, message };
-}
-function terminalWorkflowSendResult(runId, stageId, workflowStatus) {
-  const message = `Cannot send a message because workflow ${runId} has terminated with status ${workflowStatus}. If work remains, start a new workflow to address it. Complete it inline only when the remaining task is small, deterministic, and low risk.`;
-  return {
-    action: "send",
-    runId,
-    stageId,
-    delivery: "rejected",
-    status: "failed",
-    code: "WORKFLOW_TERMINAL",
-    workflowStatus,
-    error: message,
-    message
-  };
-}
-
-class WorkflowSendAdmissionError extends Error {
-  result;
-  constructor(result) {
-    super(result.message);
-    this.result = result;
-  }
-}
-function terminalWorkflowSendResultForRoot(rootRunId, stageId) {
-  const rootRun = store.runs().find((run2) => run2.id === rootRunId);
-  return rootRun !== undefined && isTerminalRunStatus(rootRun.status) ? terminalWorkflowSendResult(rootRun.id, stageId, rootRun.status) : undefined;
-}
-async function deliverStageUserMessage(handle, text, deliverAs, beforeDelivery) {
-  if (handle.sendUserMessage === undefined) {
-    throw new Error("atomic-workflows: stage handle does not support admission-aware message delivery");
-  }
-  return handle.sendUserMessage(text, { deliverAs }, beforeDelivery);
-}
-function deliveryMessage(delivery) {
-  if (delivery === "prompt")
-    return "Prompt started for stage.";
-  if (delivery === "steer")
-    return "Steered live stage.";
-  if (delivery === "followUp")
-    return "Follow-up queued for stage.";
-  return "Message handled by stage extension.";
-}
-async function workflowSendAction(args, deps = {}) {
-  const target = resolveToolRunTarget(args, "No active run to message.");
-  const requestedDelivery = args.delivery ?? "auto";
-  if (target.kind === "all") {
-    return workflowSendResult("--all", "", requestedDelivery, "noop", "Send requires a single run.");
-  }
-  if (target.kind === "malformed" || target.kind === "not_found") {
-    return workflowSendResult(target.target, "", requestedDelivery, "noop", target.message);
-  }
-  const runs = store.runs();
-  const runById = new Map(runs.map((run3) => [run3.id, run3]));
-  const rootRunId = reciprocalWorkflowRootRunId(runById, target.runId) ?? target.runId;
-  const rootRun = runById.get(rootRunId);
-  if (rootRun !== undefined && isTerminalRunStatus(rootRun.status)) {
-    return terminalWorkflowSendResult(rootRun.id, args.stageId?.trim() ?? "", rootRun.status);
-  }
-  const requested = resolveToolStageTarget(target.runId, args.stageId);
-  const stage = requested.ok && requested.stageId === undefined ? inferPromptStageTarget(target.runId, requestedDelivery, args.promptId) : requested;
-  if (!stage.ok || stage.stageId === undefined) {
-    return workflowSendResult(target.runId, "", requestedDelivery, "noop", stage.ok ? "Stage id or name is required." : stage.message);
-  }
-  const resolvedStageId = stage.stageId;
-  const stageRunId = stage.runId ?? target.runId;
-  const run2 = store.runs().find((r) => r.id === stageRunId);
-  const snapshot2 = run2?.stages.find((s) => s.id === stage.stageId);
-  const brokerPrompt = stageUiBroker.peekStagePrompt(stageRunId, stage.stageId);
-  const targetsBrokerPrompt = brokerPrompt !== undefined && (args.promptId === undefined || args.promptId === brokerPrompt.id) && (requestedDelivery === "answer" || args.promptId !== undefined || requestedDelivery === "auto");
-  if (targetsBrokerPrompt && brokerPrompt !== undefined) {
-    if (!hasPayloadProperty(args)) {
-      return workflowSendResult(stageRunId, stage.stageId, "answer", "noop", "Send requires text, response, or message.");
-    }
-    const ok = stageUiBroker.answerStagePrompt(stageRunId, stage.stageId, brokerAnswerFromArgs(args), {
-      answerSource: "workflow_tool"
-    });
-    return workflowSendResult(stageRunId, stage.stageId, "answer", ok ? "ok" : "noop", ok ? `Answered input request ${brokerPrompt.id}.` : `No matching pending input request ${brokerPrompt.id}.`);
-  }
-  const customPrompt = snapshot2?.status === "awaiting_input" && snapshot2.promptFootprint?.kind === "custom" ? snapshot2.promptFootprint : undefined;
-  const targetsCustomPrompt = customPrompt !== undefined && (args.promptId === undefined || args.promptId === customPrompt.id) && (requestedDelivery === "answer" || args.promptId !== undefined || requestedDelivery === "auto");
-  if (targetsCustomPrompt && customPrompt !== undefined) {
-    return workflowSendResult(stageRunId, stage.stageId, "answer", "noop", `Custom UI prompt ${customPrompt.id} requires the interactive workflow graph; arbitrary ctx.ui.custom<T> results cannot be answered through workflow send.`);
-  }
-  const targetsPrompt = requestedDelivery === "answer" || args.promptId !== undefined || requestedDelivery === "auto" && snapshot2?.pendingPrompt !== undefined;
-  if (targetsPrompt) {
-    const promptId = args.promptId ?? snapshot2?.pendingPrompt?.id;
-    if (promptId === undefined) {
-      return workflowSendResult(stageRunId, stage.stageId, "answer", "noop", "No pending prompt to answer.");
-    }
-    if (!hasPayloadProperty(args)) {
-      return workflowSendResult(stageRunId, stage.stageId, "answer", "noop", "Send requires text, response, or message.");
-    }
-    if (stageUiBroker.wasStagePromptResolved(stageRunId, stage.stageId, promptId)) {
-      return workflowSendResult(stageRunId, stage.stageId, "answer", "ok", `Input request ${promptId} was already answered.`);
-    }
-    const rawPayload = promptPayloadFromArgs(args);
-    const pendingPrompt = snapshot2?.pendingPrompt;
-    const primitivePrompt = pendingPrompt?.id === promptId && isPrimitivePrompt(pendingPrompt) ? pendingPrompt : undefined;
-    if (primitivePrompt !== undefined) {
-      const coercedPayload = coercePrimitivePromptAnswer(primitivePrompt, rawPayload);
-      if (!coercedPayload.ok) {
-        return workflowSendResult(stageRunId, stage.stageId, "answer", "noop", primitivePromptAnswerRejection(promptId, primitivePrompt));
-      }
-      const ok2 = store.resolveStagePendingPrompt(stageRunId, stage.stageId, promptId, coercedPayload.value, {
-        answerSource: "workflow_tool"
-      });
-      return workflowSendResult(stageRunId, stage.stageId, "answer", ok2 ? "ok" : "noop", ok2 ? `Answered prompt ${promptId}.` : `No matching pending prompt ${promptId}.`);
-    }
-    const ok = store.resolveStagePendingPrompt(stageRunId, stage.stageId, promptId, rawPayload, {
-      answerSource: "workflow_tool"
-    });
-    return workflowSendResult(stageRunId, stage.stageId, "answer", ok ? "ok" : "noop", ok ? `Answered prompt ${promptId}.` : `No matching pending prompt ${promptId}.`);
-  }
-  const text = textPayloadFromArgs(args);
-  if (text === undefined) {
-    return workflowSendResult(stageRunId, stage.stageId, requestedDelivery, "noop", "Send requires text, response, or message.");
-  }
-  let lease;
-  let handle;
-  const existingHandle = stageControlRegistry.peek(stageRunId, stage.stageId);
-  if (existingHandle !== undefined) {
-    lease = stageControlRegistry.acquireDetached(stageRunId, stage.stageId, () => existingHandle);
-    handle = lease.handle;
-  } else if (deps.resolvePostMortemDeps !== undefined && snapshot2 !== undefined) {
-    const acquired = acquirePostMortemStageHandle(stageRunId, snapshot2, deps.resolvePostMortemDeps(stageRunId));
-    if (acquired.ok) {
-      lease = acquired.lease;
-      handle = lease.handle;
-    }
-  }
-  if (handle === undefined) {
-    return workflowSendResult(stageRunId, stage.stageId, requestedDelivery, "noop", "No live handle for stage.");
-  }
-  let admitted = false;
-  const admitDelivery = () => {
-    const terminal = terminalWorkflowSendResultForRoot(rootRunId, args.stageId?.trim() ?? resolvedStageId);
-    if (terminal !== undefined)
-      throw new WorkflowSendAdmissionError(terminal);
-    if (lease !== undefined && !lease.commit()) {
-      throw new WorkflowSendAdmissionError(workflowSendResult(stageRunId, resolvedStageId, requestedDelivery, "noop", "Stage handle changed before message admission; retry against the current live stage."));
-    }
-    admitted = true;
-  };
-  const terminalPending = Promise.withResolvers();
-  const unsubscribeTerminal = subscribeStoreInvalidation(store, () => {
-    if (admitted)
-      return;
-    const terminal = terminalWorkflowSendResultForRoot(rootRunId, args.stageId?.trim() ?? resolvedStageId);
-    if (terminal !== undefined)
-      terminalPending.reject(new WorkflowSendAdmissionError(terminal));
-  });
-  const awaitAdmission = (operation) => Promise.race([operation, terminalPending.promise]);
-  try {
-    const isTerminalPostMortemStage = handle.status === "completed";
-    if (requestedDelivery === "resume" && handle.status !== "paused" && !isTerminalPostMortemStage) {
-      return workflowSendResult(stageRunId, stage.stageId, "resume", "noop", "Stage is not paused; no resume message was delivered.");
-    }
-    if (handle.status === "paused" && requestedDelivery !== "resume" && requestedDelivery !== "auto") {
-      return workflowSendResult(stageRunId, stage.stageId, requestedDelivery, "noop", "Stage is paused; resume it before sending a new message.");
-    }
-    const resumesStage = requestedDelivery === "resume" || requestedDelivery === "auto" && handle.status === "paused";
-    if (!resumesStage && handle.sendUserMessage === undefined) {
-      return workflowSendResult(stageRunId, stage.stageId, requestedDelivery, "noop", "Stage handle does not support admission-aware message delivery.");
-    }
-    if (resumesStage) {
-      if (isTerminalPostMortemStage) {
-        return workflowSendResult(stageRunId, stage.stageId, "resume", "noop", 'Cannot resume a terminal post-mortem stage; use delivery "followUp" or "prompt" to continue its retained conversation.');
-      }
-      const resumedDelivery = await awaitAdmission(handle.resume(text, admitDelivery));
-      if (resumedDelivery !== undefined && resumedDelivery !== "prompt") {
-        return workflowSendResult(stageRunId, stage.stageId, resumedDelivery, "ok", deliveryMessage(resumedDelivery));
-      }
-      if (resumedDelivery === "prompt") {
-        return workflowSendResult(stageRunId, stage.stageId, "prompt", "ok", "Resumed stage and started prompt.");
-      }
-      const hasResumeMessage = text.trim().length > 0;
-      return workflowSendResult(stageRunId, stage.stageId, "resume", "ok", hasResumeMessage ? "Resumed interrupted stage with message." : "Resumed stage.");
-    }
-    if (requestedDelivery === "steer") {
-      if (isTerminalPostMortemStage) {
-        return workflowSendResult(stageRunId, stage.stageId, "steer", "noop", 'Cannot steer a terminal post-mortem stage; use delivery "followUp" or "prompt" to continue its retained conversation.');
-      }
-      const delivery2 = await awaitAdmission(deliverStageUserMessage(handle, text, "steer", admitDelivery));
-      return workflowSendResult(stageRunId, stage.stageId, delivery2, "ok", deliveryMessage(delivery2));
-    }
-    if (requestedDelivery === "auto" && handle.isStreaming && !isTerminalPostMortemStage) {
-      const delivery2 = await awaitAdmission(deliverStageUserMessage(handle, text, "steer", admitDelivery));
-      return workflowSendResult(stageRunId, stage.stageId, delivery2, "ok", deliveryMessage(delivery2));
-    }
-    if (requestedDelivery === "prompt") {
-      const delivery2 = await awaitAdmission(deliverStageUserMessage(handle, text, undefined, admitDelivery));
-      const message = delivery2 === "prompt" ? "Prompt sent to stage." : deliveryMessage(delivery2);
-      return workflowSendResult(stageRunId, stage.stageId, delivery2, "ok", message);
-    }
-    const delivery = await awaitAdmission(deliverStageUserMessage(handle, text, "followUp", admitDelivery));
-    return workflowSendResult(stageRunId, stage.stageId, delivery, "ok", deliveryMessage(delivery));
-  } catch (error) {
-    if (error instanceof WorkflowSendAdmissionError)
-      return error.result;
-    throw error;
-  } finally {
-    unsubscribeTerminal();
-    if (!admitted) {
-      try {
-        await lease?.release();
-      } catch (error) {
-        console.warn("atomic-workflows: provisional workflow-send handle cleanup failed", error);
-      }
-    }
-  }
-}
-
 // dist/builtin/workflows/src/extension/workflow-tool.ts
 async function resolveDurableInspectionSource(args, runtime) {
   const target = args.runId?.trim();
@@ -123287,7 +124117,7 @@ function durableInspectionError(action, runId, message) {
     truncated: false
   };
 }
-function makeExecuteWorkflowTool(runtime, reloadWorkflowResources, ensureWorkflowResourcesLoaded = () => {}, sendDeps = {}) {
+function makeExecuteWorkflowTool(runtime, reloadWorkflowResources, ensureWorkflowResourcesLoaded = () => {}) {
   return async function executeWorkflowTool(args, ctx, signal, onRunAccepted) {
     const action = args.action ?? "run";
     const runId = args.runId ?? "";
@@ -123376,8 +124206,8 @@ function makeExecuteWorkflowTool(runtime, reloadWorkflowResources, ensureWorkflo
           return workflowStageResult(args, source);
         return workflowTranscriptResult(args, source);
       }
-      case "send":
-        return awaitRequest(workflowSendAction(args, sendDeps));
+      case "answer":
+        return awaitRequest(workflowAnswerAction(args));
       case "pause":
         return awaitRequest(workflowPauseAction(args));
       case "reload":
@@ -123438,8 +124268,8 @@ function renderCall(args, opts = {}) {
     case "transcript":
       line = name === undefined ? "workflow: read stage transcript" : `workflow: read stage transcript in ${quoted(name)}`;
       break;
-    case "send":
-      line = name === undefined ? "workflow: send to stage" : `workflow: send to stage in ${quoted(name)}`;
+    case "answer":
+      line = name === undefined ? "workflow: answer prompt" : `workflow: answer prompt in ${quoted(name)}`;
       break;
     case "pause":
       line = name === undefined ? "workflow: pause run" : `workflow: pause run ${quoted(name)}`;
@@ -123631,9 +124461,9 @@ function renderResult(result, opts) {
       const suffix = r.truncated ? " (truncated)" : "";
       return renderNotice("WORKFLOW TRANSCRIPT", `${r.runId}/${r.stageId} ${r.source}: ${text}${suffix}`, opts, themed);
     }
-    case "send": {
+    case "answer": {
       const r = result;
-      return renderNotice("WORKFLOW SEND", `${r.runId}/${r.stageId} ${r.delivery}: ${r.message}`, opts, themed);
+      return renderNotice("WORKFLOW ANSWER", `${r.runId}/${r.stageId}: ${r.message}`, opts, themed);
     }
     case "pause": {
       const r = result;
@@ -123676,13 +124506,14 @@ function renderResult(result, opts) {
 }
 
 // dist/builtin/workflows/src/extension/workflow-prompts.ts
-var WORKFLOW_TOOL_DESCRIPTION = "Run named builtin, project, user, or package workflows; custom definitions may import reusable project/package workflows or builtin definitions from @bastani/workflows/builtin and nest them with ctx.workflow(...), including deeper composition within the configured maxDepth; " + "when workflow execution fits but another shape would better achieve the task, author a custom TypeScript workflow({...}) inline with normal coding tools, reload it, and run it; after successfully creating and reloading a newly authored custom workflow, report the folder containing its generated code as 'Custom workflow created. You can inspect its code at: <workflow-folder-path>'; do this only for newly created custom workflows, never builtin or pre-existing workflows; " + "discover with list/get/inputs/models, list session runs with status (no runId; statusFilter narrows the list), inspect status/stages/stage details, " + "send prompt answers or steering only while the root workflow is nonterminal, pause/resume/interrupt/quit runs, and reload workflow resources. " + "Treat a blocked run as continuable by default: resume resumable blocks, answer pending prompts, steer past the obstacle, or start a follow-up workflow past a terminal block, and escalate to the user only when the blocked result is so ambiguous that human input or steering must settle it; when ask_user_question or human input is unavailable, continue fully autonomously on the interpretation best supported by the objective and repository evidence, and record the assumption. " + "For action 'run' and 'resume', budget accepts per-field duration, token, cost, and warning overrides; fields resolve over the workflow declaration and config, and 0 disables a field. " + "Pass budget only when the user asked for a limit; otherwise omit it entirely and inherit the declaration and config rather than inventing a cap. " + "For primitive prompt answers, use booleans or the documented confirm labels, exact case-insensitive select labels or 1-based indexes, and text strings for input/editor; an invalid answer remains pending and returns guidance instead of choosing a default. " + "For large stage handoffs, write context to files/artifacts, pass paths via reads, and prompt downstream agents to 'Read the file at <path>...' instead of injecting large previous text. " + "Wrap critical parts of run inputs and steering messages in <keepContext>...</keepContext> so compaction preserves them verbatim in the stages that inherit them; tag role constraints, prohibitions, must-hold criteria, and identifiers, not background or bulk reference material. " + "For transcripts, prefer status/stages/stage to get sessionFile/transcriptPath, " + "quote the exact path without rewriting separators (Windows backslashes are valid), " + "then search it with rg/grep and read small ranges; transcript is path-only by default when sessionFile/transcriptPath exists, explicit tail/limit returns bounded previews, and missing transcript paths fall back to a small preview. " + "Use action 'models' to inspect models in the configured catalog; the result is a configured-auth snapshot showing what's present in the registry with configured authentication, not proof of credentials, entitlements, OAuth freshness, or live provider access. " + "When authoring a workflow that should dynamically select a model, first call workflow({ action: 'models' }) to inspect the configured catalog, then select from the returned provider/id entries considering the isCurrent marker and available thinking levels.";
+var WORKFLOW_TOOL_DESCRIPTION = "Run named builtin, project, user, or package workflows; custom definitions may import reusable project/package workflows or builtin definitions from @bastani/atomic/workflows/builtin and nest them with ctx.workflow(...), including deeper composition within the configured maxDepth; " + "when workflow execution fits but another shape would better achieve the task, author a custom TypeScript workflow({...}) inline with normal coding tools, reload it, and run it; after successfully creating and reloading a newly authored custom workflow, report the folder containing its generated code as 'Custom workflow created. You can inspect its code at: <workflow-folder-path>'; do this only for newly created custom workflows, never builtin or pre-existing workflows; " + "discover with list/get/inputs/models, list session runs with status (no runId; statusFilter narrows the list), inspect status/stages/stage details, " + "answer pending prompts only while the root workflow is nonterminal, pause/resume/interrupt/quit runs, and reload workflow resources. " + "When steering or communication is useful, use Intercom; address a workflow stage as `<runId>:<stageKey>`. Live delivery is immediate; a known stage that has not started is queued and receives the message before its first model turn. Use `ask` only for a reply-capable live session. " + "Treat a blocked run as continuable by default: resume resumable blocks, answer pending prompts, steer past the obstacle, or start a follow-up workflow past a terminal block, and escalate to the user only when the blocked result is so ambiguous that human input or steering must settle it; when ask_user_question or human input is unavailable, continue fully autonomously on the interpretation best supported by the objective and repository evidence, and record the assumption. " + "For action 'run' and 'resume', budget accepts per-field duration, token, cost, and warning overrides; fields resolve over the workflow declaration and config, and 0 disables a field. " + "Pass budget only when the user asked for a limit; otherwise omit it entirely and inherit the declaration and config rather than inventing a cap. " + "For primitive prompt answers, use booleans or the documented confirm labels, exact case-insensitive select labels or 1-based indexes, and text strings for input/editor; an invalid answer remains pending and returns guidance instead of choosing a default. " + "For large stage handoffs, write context to files/artifacts, pass paths via reads, and prompt downstream agents to 'Read the file at <path>...' instead of injecting large previous text. " + "Wrap critical parts of run inputs and steering messages in <keepContext>...</keepContext> so compaction preserves them verbatim in the stages that inherit them; tag role constraints, prohibitions, must-hold criteria, and identifiers, not background or bulk reference material. " + "For transcripts, prefer status/stages/stage to get sessionFile/transcriptPath, " + "quote the exact path without rewriting separators (Windows backslashes are valid), " + "then search it with rg/grep and read small ranges; transcript is path-only by default when sessionFile/transcriptPath exists, explicit tail/limit returns bounded previews, and missing transcript paths fall back to a small preview. " + "Use action 'models' to inspect models in the configured catalog; the result is a configured-auth snapshot showing what's present in the registry with configured authentication, not proof of credentials, entitlements, OAuth freshness, or live provider access. " + "When authoring a workflow that should dynamically select a model, first call workflow({ action: 'models' }) to inspect the configured catalog, then select from the returned provider/id entries considering the isCurrent marker and available thinking levels.";
 var DEFAULT_PROMPT_GUIDANCE = [
   `**Workflows**: Treat workflows as the default execution path for any non-trivial task and for any request that has inherent structure plus an objective you can make verifiable. Use the \`workflow\` tool for existing named workflows; when the task needs a graph that is not installed, author a custom TypeScript \`workflow({...})\` inline with normal coding tools, reload workflow resources, and run it.
   - Workflow fit check: prefer a workflow for implementation, build, debug/diagnosis, bug-fix, migration, new-feature, scoped multi-file, or docs/code changes with validation; and whenever there are multiple steps, dependencies, handoffs, uncertainty, review/validation needs, long-running work, measurable done criteria, or an outcome that needs evidence.
   - Treat loop or stop-condition wording as a strong workflow signal, especially "do X until Y", "repeat until", "iterate until", "review/fix until passing", "run checks and fix until green", "keep going until done", or any prompt that names an approval gate or evidence requirement.
   - Do not force-fit an installed workflow. When another graph better matches the task, write a task-specific TypeScript workflow inline. Rich custom workflows may use deterministic branching, dynamic fan-out, child workflows, artifacts, structured outputs, human-in-the-loop prompts, gates, retries, and explicit stop conditions.
   - Before launching any workflow for a non-trivial task, perform a short workflow-architecture pass. Derive implementation lifecycle needs, whole-codebase research needs, independent slices, competing strategies, exact API/type/build contracts, schema or generated-artifact contracts, state transitions/lifecycle behavior, deterministic stop conditions, and required evidence. Enumerate implementation slices in this same pass, not a second planning ritual; give each slice its own objective, acceptance criteria, and gates, and require each to leave a buildable, testable repository state before the next slice. Use a compact internal coverage matrix: \`requirement/risk | required evidence | workflow/stage that produces it | gap\`. Add the topology row \`acyclic topology | node/edge sketch for branches and loops | architecture pass | unresolved back-edge\`. Unresolved material rows or back-edges must change the graph before launch.
+  - In that same pass, for coding tasks, infer repository intent from repo-level behavior before freezing objectives and acceptance criteria: mine git history (including \`git log --show-signature\`), merged PRs, issues, commits, and review comments for unwritten conventions — commit signing, message style and issue linking, changelog discipline, PR size and review norms — weighing the requesting user's own activity highest, so authored workflow contracts capture norms no doc states. For non-coding tasks, mine the analogous available context sources (issue trackers, long-form docs, chat/comment threads, prior artifacts) the same way. Inferred conventions fill contract gaps; they never override the stated objective or explicit repository docs.
   - In that architecture pass, sketch each branch, loop, and nested workflow boundary. Identify which stages repeat, require distinct tracked work for every iteration, name the current frontier before each repeat, reject self-edges and ancestor edges, compose nested workflows through \`ctx.workflow(...)\` boundaries rather than recursive \`run\` invocation, and preserve stable per-iteration identity and call order for resume/replay.
   - Compare candidate workflows by guarantees, not broad objectives: run one named workflow only when it covers the lifecycle and produces evidence for every material requirement/risk. A generic implementation workflow may cover the lifecycle without covering exact API/type/build contracts, schemas/generated artifacts, state transitions, or domain-specific gates. Do not treat "has reviewers" as proof that a task-specific risk is covered.
   - Use these routing signals without adding decorative stages: broad repository uncertainty → Fan-out-and-synthesize with repository-focused branches; independent slices → Fan-out-and-synthesize; plausible-but-wrong contract risk → Adversarial verification or a task-specific verification stage; competing architectures or implementations → Generate-and-filter or Tournament; an explicit repeat-until condition → Loop until done; implementation lifecycle → a task-specific worker/reviewer loop; exact API/build/schema requirements → dedicated deterministic gates.
@@ -123707,16 +124538,16 @@ var DEFAULT_PROMPT_GUIDANCE = [
   `**Workflow discovery and lifecycle**:
   - For unfamiliar named workflows, discover with \`action: "list"\`, inspect with \`action: "get"\` or \`action: "inputs"\`, and run with \`action: "run"\`, \`workflow\`, and validated \`inputs\`; do not invent workflow names or input keys.
   - Do not pass a \`budget\` unless the user asked for a limit. Budget fields are overrides, not required inputs: omitting \`budget\` inherits the workflow declaration and config, which is the intended default, and assuming no budget is always the correct default. A cap you invented truncates an otherwise healthy run at a duration, token, or cost boundary the user never chose, and the resulting failure reads as a workflow problem rather than as your override. When the user does state a limit, pass only the fields they named, leave every other field inherited, and use \`0\` to disable a field they asked you to remove.
-  - Heartbeat cadence is 15 minutes by default. Assume that interval and do not configure, shorten, or lengthen it unless the user explicitly asks for a different cadence. A heartbeat is a periodic alignment check rather than a failure: re-read the objective, judge whether the run is still on goal, then continue, steer, replace, or ask. Do not treat it as a prompt to add a budget, poll in a loop, or intervene in a run that is progressing.
+  - Heartbeat cadence is 15 minutes by default. Keep that interval unless the user explicitly asks for a different cadence. A heartbeat is a periodic alignment check: re-read the objective, judge whether the run is still on goal, and continue a progressing run when no intervention is needed. Use workflow pause, resume, interrupt, or quit when run control is useful, and ask the user when a decision is needed.
   - Wrap critical parts of the \`inputs\` you pass — objective, prompt, acceptance criteria — in \`<keepContext>\` / \`</keepContext>\`. Tagged text survives compaction verbatim regardless of the compression ratio, and stages inherit it because workflows inject your inputs into their prompts. A long stage is compacted repeatedly, and compaction ranks lines individually: a verbose restated objective outlives the one line that bounds it, so a stage can end up executing a coherent but unbounded version of what you asked for. Decide this per launch rather than tagging everything — tag role constraints, prohibitions, must-hold criteria, and identifiers such as a target branch, worktree path, or issue number; leave background, quoted issue text, and reference material untagged and pass bulk through files and \`reads\`. Protected lines count against the keep target rather than raising it, so an over-tagged input makes the evidence stages need compress harder.
-  - Tag steering the same way. A \`send\` amendment is authoritative and stages must carry it forward, but it arrives late in an already-long session and is exactly one short message competing with the whole transcript; \`<keepContext>\` around the requirement keeps it from being compacted away before the stage acts on it.
-  - In interactive chat, named workflow launches run in the background. Run \`/workflow connect <run>\` to see agents working and chat with and steer each stage. Inspection and control calls (\`status\`, \`stages\`, \`stage\`, \`transcript\`, \`send\`, \`pause\`, \`resume\`, \`interrupt\`, \`quit\`) remain available while work runs.
-  - \`workflow send\` is nonterminal-only: once the authoritative root run has completed, failed, skipped, been cancelled or killed, or ended terminal-blocked, start a new workflow if tracked work remains. Proceed inline only when the remaining task is small, deterministic, and low risk. Use explicit \`/workflow attach <run> <stage>\` for user-driven post-mortem chat; it does not resume or modify workflow execution.
+  - Tag steering the same way. An Intercom \`send\` amendment is authoritative and stages must carry it forward, but it arrives late in an already-long session and is exactly one short message competing with the whole transcript; \`<keepContext>\` around the requirement keeps it from being compacted away before the stage acts on it.
+  - In interactive chat, named workflow launches run in the background. Run \`/workflow connect <run>\` to see agents working and chat with and steer each stage. Inspection and control calls (\`status\`, \`stages\`, \`stage\`, \`transcript\`, \`answer\`, \`pause\`, \`resume\`, \`interrupt\`, \`quit\`) remain available while work runs.
+  - \`workflow answer\` handles a pending human-input prompt. Send free-form updates through Intercom to \`<runId>:<stageKey>\`; Atomic delivers immediately to live stages and queues messages for known stages that have not started, delivering them before their first model turn. Use \`ask\` once the target has a live session that can reply. Use explicit \`/workflow attach <run> <stage>\` for user-driven post-mortem chat.
   - A blocked run is a changed condition, not a stop order. On a blocked status or a WORKFLOW BLOCKED lifecycle notice, keep the work moving by default: resume a resumable block, answer the pending prompt, steer the stage past the obstacle, or start a follow-up workflow that carries the remaining tracked work past a terminal block — continue inline only if the remaining work is minimal. Stop for user input only when the task is so ambiguous that competing interpretations lead to materially different outcomes and judgment cannot infer intent from the stated objective and repository evidence; then ask one grouped question or wait for steering.
   - A budget-exceeded stop (the resumable \`budget_exceeded\` blocked rail) is the exception: the exhausted budget is a boundary someone chose, so do not raise it silently. Summarize progress and the estimated next steps, ask the user whether to proceed — prefer the \`ask_user_question\` tool when it is available — and resume with a raised \`budget\` only after approval.
   - When human input is unavailable — \`ask_user_question\` is not among your tools, the session is headless, or nobody answers — do not stall on a question. Choose the interpretation best supported by the stated objective and repository evidence — mine git history, commits, PRs, issues, and the user's own comments to infer how they would decide — record the assumption and rationale in the result or an artifact, and continue fully autonomously on best judgment.
   - Natural-language instructions to create or use a worktree do not enable runner isolation. A named workflow must declare and implement any worktree and feature-branch inputs it supports; inspect its inputs and pass a distinct path and branch for each concurrent item. Reusable \`baseBranch\` binding creates a missing target as a detached checkout from that base or reuses an existing same-repository worktree as-is; neither case checks out a separate feature-branch input.
-  - Once you have started the selected single run or every run in the selected bounded wave, end the current turn and wait for user input or lifecycle notices. Do not use sleep/status polling loops: key start, finish, and failure events arrive automatically. Use targeted \`status\`/\`stages\`/\`stage\` checks only when the user asks or the next step needs them, and use \`send\`/\`pause\`/\`resume\`/\`interrupt\`/\`quit\` only to answer, steer, or honor control requests.
+  - Once you have started the selected single run or every run in the selected bounded wave, end the current turn and wait for user input or lifecycle notices. Do not use sleep/status polling loops: key start, finish, and failure events arrive automatically. Use targeted \`status\`/\`stages\`/\`stage\` checks only when the user asks or the next step needs them, and use Intercom \`send\`/\`ask\` for stage communication or \`answer\`/\`pause\`/\`resume\`/\`interrupt\`/\`quit\` for workflow prompts and control.
   - For transcripts, avoid whole-file reads. Get \`sessionFile\`/\`transcriptPath\` from \`stages\` or \`stage\`, preserve the exact path and platform separators, search with \`rg\`/\`grep\`, and read small relevant ranges; use explicit \`tail\` or \`limit\` only for a bounded preview.`,
   `**Workflow authoring and handoffs**:
   - When a user asks to create or edit a workflow, clarify only unresolved requirements that materially affect its purpose, inputs, stages, handoffs, validation, success criteria, or starter pattern. Read the workflow docs/examples, implement the TypeScript definition with normal coding tools, reload it, and run representative test inputs before presenting it. Use the create-spec skill when it adds value; it is not mandatory when context is already sufficient.
@@ -123778,26 +124609,26 @@ var WorkflowParametersSchema = Type36.Object({
     Type36.Literal("stages"),
     Type36.Literal("stage"),
     Type36.Literal("transcript"),
-    Type36.Literal("send"),
+    Type36.Literal("answer"),
     Type36.Literal("pause"),
     Type36.Literal("interrupt"),
     Type36.Literal("quit"),
     Type36.Literal("resume"),
     Type36.Literal("reload")
   ], {
-    description: "Workflow action: run/list/get/inputs/models/status, inspect stage metadata, send messages or prompt answers, pause/resume/interrupt/quit runs, inspect the configured model catalog, or reload workflow resources. 'status' without runId lists every workflow run in the current session with concise per-run summaries (status, timing, active stages, awaiting-input prompts); filter the listing with statusFilter. 'status' with runId returns one run's full detail. For transcript inspection, prefer status/stages/stage first to get sessionFile/transcriptPath, quote the exact path without rewriting separators (Windows backslashes are valid), then search it with rg/grep and read small ranges; transcript is path-only by default when sessionFile/transcriptPath exists, explicit tail/limit returns bounded previews, and missing transcript paths fall back to a small preview."
+    description: "Workflow action: run/list/get/inputs/models/status, inspect stage metadata, answer pending prompts, pause/resume/interrupt/quit runs, inspect the configured model catalog, or reload workflow resources. 'status' without runId lists every workflow run in the current session with concise per-run summaries (status, timing, active stages, awaiting-input prompts); filter the listing with statusFilter. 'status' with runId returns one run's full detail. For transcript inspection, prefer status/stages/stage first to get sessionFile/transcriptPath, quote the exact path without rewriting separators (Windows backslashes are valid), then search it with rg/grep and read small ranges; transcript is path-only by default when sessionFile/transcriptPath exists, explicit tail/limit returns bounded previews, and missing transcript paths fall back to a small preview."
   })),
   runId: Type36.Optional(Type36.String({
-    description: "Full 36-character run UUID for status/stages/stage/transcript/send/pause/resume/interrupt/quit. Prefixes are not accepted; pass the id exactly as displayed. Omit runId with action 'status' to list all session runs and their statuses. Use '--all' or all:true for supported bulk run-control actions."
+    description: "Full 36-character run UUID for status/stages/stage/transcript/answer/pause/resume/interrupt/quit. Prefixes are not accepted; pass the id exactly as displayed. Omit runId with action 'status' to list all session runs and their statuses. Use '--all' or all:true for supported bulk run-control actions."
   })),
   all: Type36.Optional(Type36.Boolean({
     description: "Apply supported run-control actions (pause/interrupt/quit) to all in-flight runs instead of one run; cannot be combined with stageId."
   })),
   stageId: Type36.Optional(Type36.String({
-    description: "Exact stage id or exact stage name for stage-scoped inspection, transcript, send, pause, or resume. Prefixes and partial names are not accepted. A nested stage id is the full 'runId:stageId' composite. For interrupt and quit it may also name an in-flight ctx.tool node by its exact tool:<argsHash> id or tool name, which aborts that single call."
+    description: "Exact stage id or exact stage name for stage-scoped inspection, transcript, answer, pause, or resume. Prefixes and partial names are not accepted. A nested stage id is the full 'runId:stageId' composite. For interrupt and quit it may also name an in-flight ctx.tool node by its exact tool:<argsHash> id or tool name, which aborts that single call."
   })),
   message: Type36.Optional(Type36.String({
-    description: "Message payload for send/follow-up/prompt/steer/resume, or optional text forwarded when resuming paused work."
+    description: "Prompt answer text for answer, or optional text forwarded when resuming paused work."
   })),
   statusFilter: Type36.Optional(Type36.Union([
     Type36.Literal("pending"),
@@ -123829,21 +124660,11 @@ var WorkflowParametersSchema = Type36.Object({
     description: "Transcript-only: include captured tool output entries when building inlined snapshot previews; this does not bypass the path-only default. Prefer rg/grep on the exact quoted sessionFile/transcriptPath for large outputs. Live session transcripts may not expose tool output."
   })),
   text: Type36.Optional(Type36.String({
-    description: "Text to send to a stage for prompt answers, steering, follow-ups, or resume messages."
+    description: "Text for a pending prompt answer."
   })),
   response: Type36.Optional(WorkflowResponseSchema),
-  delivery: Type36.Optional(Type36.Union([
-    Type36.Literal("auto"),
-    Type36.Literal("answer"),
-    Type36.Literal("prompt"),
-    Type36.Literal("steer"),
-    Type36.Literal("followUp"),
-    Type36.Literal("resume")
-  ], {
-    description: "Delivery mode for the send action: auto answers pending prompts first, then resumes paused stages, steers streaming stages, or queues a follow-up."
-  })),
   promptId: Type36.Optional(Type36.String({
-    description: "Pending prompt identifier to answer when using the send action."
+    description: "Pending prompt identifier for the answer action."
   })),
   reason: Type36.Optional(Type36.String({
     description: "Human-readable reason for the reload action, echoed in the reload result."
@@ -123855,7 +124676,7 @@ var WORKFLOW_TOOL_REQUEST_TIMEOUT_MS = 120000;
 var MUTATING_WORKFLOW_ACTIONS = new Set([
   "reload",
   "run",
-  "send",
+  "answer",
   "pause",
   "resume",
   "interrupt",
@@ -123976,10 +124797,11 @@ function factory(pi) {
   const postMortemHandleResolver = createPostMortemHandleResolver(postMortemResolverDeps);
   const overlay = buildWorkflowOverlay(pi, postMortemHandleResolver);
   registerCompletedStageIntercomAskRouter(pi, postMortemHandleResolver);
+  registerPendingStageIntercomBridge(pi, store);
   const workflowCommands = new Map;
   const storeWidgetRef = { current: null };
   const intercomControlRef = { current: null };
-  const executeWorkflowTool = makeExecuteWorkflowTool((ctx) => runtimeState.runtimeForContext(ctx), runtimeState.reloadWorkflowResources, runtimeState.ensureWorkflowResourcesLoaded, { resolvePostMortemDeps: (runId) => postMortemDepsForRun(runId, postMortemResolverDeps) });
+  const executeWorkflowTool = makeExecuteWorkflowTool((ctx) => runtimeState.runtimeForContext(ctx), runtimeState.reloadWorkflowResources, runtimeState.ensureWorkflowResourcesLoaded);
   const executeWorkflowToolWithAutoAttach = async (args, ctx, signal, onRunAccepted) => {
     const result = await executeWorkflowTool(args, ctx, signal, onRunAccepted);
     if (workflowPolicyFromContext(ctx).mode === "interactive" && typeof args.workflow === "string" && result.action === "run" && result.status === "running" && result.runId.length > 0 && runtimeState.runtimeProxy.registry.get(args.workflow)?.autoAttach === true) {