@bastani/atomic 0.9.18-alpha.5 → 0.9.18-alpha.7

package/dist/builtin/workflows/src/index.js

@@ -219,6 +219,7 @@ class GraphFrontierTracker {
   nodes = new Map;
   onSpawn(stageId, stageName) {
     const parents = Array.from(this.frontier);
+    this.assertAcyclicParents(stageId, parents);
     this.stageParents.set(stageId, parents);
     this.nodes.set(stageId, {
       id: stageId,
@@ -232,6 +233,7 @@ class GraphFrontierTracker {
   }
   replaceParents(stageId, parentIds) {
     const parents = Array.from(parentIds);
+    this.assertAcyclicParents(stageId, parents);
     this.stageParents.set(stageId, parents);
     const node = this.nodes.get(stageId);
     if (node !== undefined) {
@@ -254,6 +256,19 @@ class GraphFrontierTracker {
   getParents(stageId) {
     return this.stageParents.get(stageId) ?? [];
   }
+  assertAcyclicParents(nodeId, parentIds) {
+    const pending = [...parentIds];
+    const visited = new Set;
+    while (pending.length > 0) {
+      const parentId = pending.pop();
+      if (parentId === nodeId)
+        throw new Error(`atomic-workflows: graph cycle at node ${nodeId}`);
+      if (visited.has(parentId))
+        continue;
+      visited.add(parentId);
+      pending.push(...this.stageParents.get(parentId) ?? []);
+    }
+  }
   reset() {
     this.frontier.clear();
     this.stageParents.clear();
@@ -993,6 +1008,96 @@ function queueStageMessage(messages, input, senderGroup, runGroup, stageIdentity
     deduplicated: false
   };
 }
+function queueStickyStageMessage(messages, input, senderGroup, runGroup) {
+  if (normalizeDeliveryGroup(senderGroup) !== normalizeDeliveryGroup(runGroup)) {
+    return { ok: false, reason: "group_mismatch", runId: input.runId, stageKey: input.targetPath };
+  }
+  const messageId = input.message.id;
+  const existing = messages.find((entry2) => entry2.runId === input.runId && entry2.id === messageId);
+  if (existing !== undefined) {
+    if (pendingStageMessageSignature(existing) !== pendingStageMessageSignature(input)) {
+      return {
+        ok: false,
+        reason: "message_id_conflict",
+        runId: input.runId,
+        stageKey: input.targetPath,
+        messageId
+      };
+    }
+    const queuedForTarget = queuedStickyCount(messages, input.runId, input.targetPath);
+    return {
+      ok: true,
+      messages,
+      entry: existing,
+      ...existing.status === "queued" ? { position: queuedForTarget } : {},
+      deduplicated: true
+    };
+  }
+  if (queuedStickyCount(messages, input.runId, input.targetPath) >= PENDING_STAGE_MESSAGE_LIMIT) {
+    return {
+      ok: false,
+      reason: "capacity",
+      limit: PENDING_STAGE_MESSAGE_LIMIT,
+      runId: input.runId,
+      stageKey: input.targetPath
+    };
+  }
+  const entry = {
+    ...input,
+    id: messageId,
+    stageKey: input.targetPath,
+    sticky: true,
+    deliveries: [],
+    deliveryCount: 0,
+    admissionOrder: nextAdmissionOrder(messages, input.runId),
+    status: "queued"
+  };
+  return {
+    ok: true,
+    messages: [...messages, entry],
+    entry,
+    position: queuedStickyCount(messages, input.runId, input.targetPath) + 1,
+    deduplicated: false
+  };
+}
+function queuedStickyCount(messages, runId, targetPath) {
+  return messages.filter((entry) => entry.runId === runId && entry.sticky === true && entry.targetPath === targetPath && entry.status === "queued").length;
+}
+function recordPendingStageMessageDeliveries(messages, runId, messageId, records, deliveredAt) {
+  const index = messages.findIndex((entry2) => entry2.runId === runId && entry2.id === messageId && entry2.sticky === true && entry2.status === "queued");
+  if (index < 0)
+    return messages;
+  const entry = messages[index];
+  const recorded = new Set((entry.deliveries ?? []).map((delivery) => `${delivery.runId}\x00${delivery.stageId}`));
+  const additions = [];
+  for (const record of records) {
+    const key = `${record.runId}\x00${record.stageId}`;
+    if (recorded.has(key))
+      continue;
+    recorded.add(key);
+    additions.push({
+      runId: record.runId,
+      stageId: record.stageId,
+      ...record.stageName === undefined ? {} : { stageName: record.stageName },
+      deliveredAt
+    });
+  }
+  if (additions.length === 0)
+    return messages;
+  const deliveries = [...entry.deliveries ?? [], ...additions];
+  const next = { ...entry, deliveries, deliveryCount: deliveries.length };
+  const result = [...messages];
+  result[index] = next;
+  return result;
+}
+function settleStickyPendingStageMessageDelivered(messages, runId, messageId, settledAt) {
+  const index = messages.findIndex((entry) => entry.runId === runId && entry.id === messageId && entry.sticky === true && entry.status === "queued" && (entry.deliveryCount ?? 0) > 0);
+  if (index < 0)
+    return messages;
+  const next = [...messages];
+  next[index] = { ...next[index], status: "delivered", deliveredAt: settledAt };
+  return next;
+}
 function pendingStageMessagesFor(messages, runId, stageKey, stageIdentity) {
   return messages.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);
 }
@@ -1012,7 +1117,7 @@ function markPendingStageMessageUndeliverable(messages, runId, stageKey, message
   }));
 }
 function markPendingStageMessageUndeliverableNotified(messages, runId, stageKey, messageId, notificationId, notifiedAt) {
-  const index = messages.findIndex((entry) => matchesPendingStage(entry, runId, stageKey) && entry.id === messageId && entry.status === "undeliverable" && entry.undeliverableNotificationId === notificationId && entry.undeliverableNotifiedAt === undefined);
+  const index = messages.findIndex((entry) => (entry.sticky === true ? entry.runId === runId : matchesPendingStage(entry, runId, stageKey)) && entry.id === messageId && entry.status === "undeliverable" && entry.undeliverableNotificationId === notificationId && entry.undeliverableNotifiedAt === undefined);
   if (index < 0)
     return messages;
   const next = [...messages];
@@ -1028,14 +1133,21 @@ function pendingStageUndeliverableNotificationId(entry) {
   ].join(":");
 }
 function updateQueuedPendingStageMessage(messages, runId, stageKey, messageId, stageIdentity, update) {
-  const index = messages.findIndex((entry) => matchesPendingStage(entry, runId, stageKey, stageIdentity) && entry.id === messageId && entry.status === "queued");
+  const index = messages.findIndex((entry) => queuedEntryMatches(entry, runId, stageKey, messageId, stageIdentity));
   if (index < 0)
     return messages;
   const next = [...messages];
   next[index] = update(next[index]);
   return next;
 }
+function queuedEntryMatches(entry, runId, stageKey, messageId, stageIdentity) {
+  if (entry.runId !== runId || entry.id !== messageId || entry.status !== "queued")
+    return false;
+  return entry.sticky === true || matchesPendingStage(entry, runId, stageKey, stageIdentity);
+}
 function matchesPendingStage(entry, runId, stageKey, stageIdentity) {
+  if (entry.sticky === true)
+    return false;
   if (entry.runId !== runId)
     return false;
   if (stageIdentity === undefined)
@@ -1753,6 +1865,50 @@ function createPendingStageDeliveryStoreMethods(context) {
         context.bumpAndNotify();
         return true;
       });
+    },
+    async queueStickyStageMessage(input, senderGroup, runGroup, backend) {
+      return await serialize(input.runId, async () => {
+        const run = context.findRun(input.runId);
+        if (run === undefined)
+          return;
+        const result = queueStickyStageMessage(run.pendingStageMessages ?? [], input, senderGroup, runGroup);
+        if (result.ok && !result.deduplicated) {
+          await persistTransition(backend, input.runId, result.messages);
+          run.pendingStageMessages = [...result.messages];
+          context.bumpAndNotify();
+        }
+        return result;
+      });
+    },
+    async recordPendingStageMessageDeliveries(runId, messageId, records, deliveredAt, backend) {
+      return await serialize(runId, async () => {
+        const run = context.findRun(runId);
+        if (run === undefined)
+          return false;
+        const current = run.pendingStageMessages ?? [];
+        const next = recordPendingStageMessageDeliveries(current, runId, messageId, records, deliveredAt);
+        if (next === current)
+          return false;
+        await persistTransition(backend, runId, next);
+        run.pendingStageMessages = [...next];
+        context.bumpAndNotify();
+        return true;
+      });
+    },
+    async settleStickyPendingStageMessageDelivered(runId, messageId, settledAt, backend) {
+      return await serialize(runId, async () => {
+        const run = context.findRun(runId);
+        if (run === undefined)
+          return false;
+        const current = run.pendingStageMessages ?? [];
+        const next = settleStickyPendingStageMessageDelivered(current, runId, messageId, settledAt);
+        if (next === current)
+          return false;
+        await persistTransition(backend, runId, next);
+        run.pendingStageMessages = [...next];
+        context.bumpAndNotify();
+        return true;
+      });
     }
   };
 }
@@ -4472,7 +4628,6 @@ function durableStageCheckpointMetadata(stage, run, sourceOrder) {
     ...stage.sessionFile !== undefined ? { sessionFile: stage.sessionFile } : {},
     ...stage.durationMs !== undefined ? { durationMs: stage.durationMs } : {},
     ...stage.model !== undefined ? { model: stage.model } : {},
-    ...stage.fastMode !== undefined ? { fastMode: stage.fastMode } : {},
     ...stage.attemptedModels !== undefined ? { attemptedModels: [...stage.attemptedModels] } : {},
     ...stage.modelAttempts !== undefined ? { modelAttempts: [...stage.modelAttempts] } : {},
     ...stage.structured !== undefined ? { structured: stage.structured } : {},
@@ -4484,6 +4639,57 @@ function durableStageCheckpointMetadata(stage, run, sourceOrder) {
 // dist/builtin/workflows/src/durable/tool-primitive.ts
 import { runCallback } from "@bastani/atomic";
 
+// dist/builtin/workflows/src/engine/workflow-tool-abort.ts
+class WorkflowToolAbortError extends Error {
+  runId;
+  nodeId;
+  toolName;
+  scope;
+  constructor(input) {
+    super(`atomic-workflows: ctx.tool ${input.toolName} aborted by ${input.scope === "quit" ? "workflow quit" : "node abort"}`);
+    this.name = "AbortError";
+    this.runId = input.runId;
+    this.nodeId = input.nodeId;
+    this.toolName = input.toolName;
+    this.scope = input.scope;
+  }
+}
+function isWorkflowToolAbortError(value) {
+  return value instanceof WorkflowToolAbortError;
+}
+var WORKFLOW_GRACEFUL_QUIT_EXIT_REASON = "quit";
+
+class WorkflowGracefulQuitError extends Error {
+  runId;
+  constructor(runId, detail) {
+    super(`atomic-workflows: ${detail} suspended by workflow quit`);
+    this.name = "AbortError";
+    this.runId = runId;
+  }
+}
+function isGracefulQuitSignal(value) {
+  if (value instanceof WorkflowGracefulQuitError)
+    return true;
+  return isWorkflowToolAbortError(value) && value.scope === "quit";
+}
+function findWorkflowGracefulQuit(value) {
+  let current = value;
+  for (let depth = 0;depth < 8; depth++) {
+    if (isGracefulQuitSignal(current))
+      return current;
+    if (typeof current !== "object" || current === null)
+      return;
+    try {
+      if (!("cause" in current))
+        return;
+      current = current.cause;
+    } catch {
+      return;
+    }
+  }
+  return;
+}
+
 // dist/builtin/workflows/src/runs/shared/retry.ts
 import { nextRetryDecision } from "@bastani/atomic";
 function abortReason(signal) {
@@ -4519,7 +4725,7 @@ function sleepOrAbort(ms, signal) {
   });
 }
 // dist/builtin/workflows/src/durable/tool-failure-checkpoint.ts
-async function recordThrowingToolFailure(input, node, identity, error, attempts) {
+async function recordThrowingToolFailure(input, node, identity, error, attempts, cancelled = false) {
   const message = workflowToolFailure(error, attempts, false).error.message;
   const failedAt = Date.now();
   await input.backend.recordAdditiveCheckpointBestEffort({
@@ -4532,6 +4738,7 @@ async function recordThrowingToolFailure(input, node, identity, error, attempts)
     argsHash: identity.argsHash,
     output: null,
     throwingFailureError: message,
+    ...cancelled ? { cancelled: true } : {},
     completedAt: failedAt,
     topology: {
       version: DURABLE_TOOL_TOPOLOGY_VERSION,
@@ -4837,7 +5044,7 @@ async function executeLiveToolInvocation(live) {
     const cancellation = timeoutFailure ? undefined : invocationCancellation(input, toolSignal);
     if (cancellation !== undefined) {
       control.noteCancelled();
-      if (returnFailure) {
+      if (returnFailure || isWorkflowToolAbortError(cancellation) && cancellation.scope === "node") {
         await recordCancelledToolInspection(live, startedAt, cancellation, attempts);
       }
       const endedAt = Date.now();
@@ -4939,7 +5146,7 @@ async function recordCancelledToolInspection(live, startedAt, cancellation, atte
       argsHash: live.argsHash,
       ordinal: live.ordinal,
       startedAt
-    }, cancellation, attempts);
+    }, cancellation, attempts, true);
   } catch {}
 }
 function invocationCancellation(input, signal) {
@@ -5346,7 +5553,6 @@ function completeTaskResult(name, base, checkpoint) {
     ...base.sessionFile !== undefined || checkpoint.sessionFile !== undefined ? { sessionFile: base.sessionFile ?? checkpoint.sessionFile } : {},
     ...base.artifacts !== undefined || checkpoint.artifacts !== undefined ? { artifacts: [...base.artifacts ?? checkpoint.artifacts ?? []] } : {},
     ...base.model !== undefined || checkpoint.model !== undefined ? { model: base.model ?? checkpoint.model } : {},
-    ...base.fastMode !== undefined || checkpoint.fastMode !== undefined ? { fastMode: base.fastMode ?? checkpoint.fastMode } : {},
     ...base.attemptedModels !== undefined || checkpoint.attemptedModels !== undefined ? { attemptedModels: [...base.attemptedModels ?? checkpoint.attemptedModels ?? []] } : {},
     ...base.modelAttempts !== undefined || checkpoint.modelAttempts !== undefined ? { modelAttempts: [...base.modelAttempts ?? checkpoint.modelAttempts ?? []] } : {},
     ...base.warnings !== undefined || checkpoint.warnings !== undefined ? { warnings: [...base.warnings ?? checkpoint.warnings ?? []] } : {}
@@ -5447,7 +5653,6 @@ function taskCheckpointMetadata(result) {
     ...result.sessionId !== undefined ? { sessionId: result.sessionId } : {},
     ...result.sessionFile !== undefined ? { sessionFile: result.sessionFile } : {},
     ...result.model !== undefined ? { model: result.model } : {},
-    ...result.fastMode !== undefined ? { fastMode: result.fastMode } : {},
     ...result.attemptedModels !== undefined ? { attemptedModels: [...result.attemptedModels] } : {},
     ...result.modelAttempts !== undefined ? { modelAttempts: [...result.modelAttempts] } : {},
     ...result.structured !== undefined ? { structured: result.structured } : {},
@@ -5477,7 +5682,6 @@ function mergeCheckpointHydrationMetadata(replayValueCheckpoint, checkpoints) {
     ...replayValueCheckpoint.sessionId === undefined ? metadataValue(checkpoints, "sessionId") : {},
     ...replayValueCheckpoint.sessionFile === undefined ? metadataValue(checkpoints, "sessionFile") : {},
     ...replayValueCheckpoint.model === undefined ? metadataValue(checkpoints, "model") : {},
-    ...replayValueCheckpoint.fastMode === undefined ? metadataValue(checkpoints, "fastMode") : {},
     ...replayValueCheckpoint.attemptedModels === undefined ? metadataValue(checkpoints, "attemptedModels") : {},
     ...replayValueCheckpoint.modelAttempts === undefined ? metadataValue(checkpoints, "modelAttempts") : {},
     ...replayValueCheckpoint.structured === undefined ? metadataValue(checkpoints, "structured") : {},
@@ -5567,7 +5771,6 @@ function recordCachedStageIntoStore(store2, runId, name, replayKey, output, comp
     ...checkpoint?.sessionId !== undefined ? { sessionId: checkpoint.sessionId } : {},
     ...checkpoint?.sessionFile !== undefined ? { sessionFile: checkpoint.sessionFile } : {},
     ...checkpoint?.model !== undefined ? { model: checkpoint.model } : {},
-    ...checkpoint?.fastMode !== undefined ? { fastMode: checkpoint.fastMode } : {},
     ...checkpoint?.attemptedModels !== undefined ? { attemptedModels: checkpoint.attemptedModels } : {},
     ...checkpoint?.modelAttempts !== undefined ? { modelAttempts: checkpoint.modelAttempts } : {},
     ...checkpoint?.structured !== undefined ? { structured: checkpoint.structured } : {},
@@ -5670,6 +5873,49 @@ function hasInvocationData(checkpoints, replayKey) {
   return checkpoints.some((checkpoint) => checkpoint.kind === "stage" ? checkpoint.replayKey === replayKey || checkpoint.replayKey.startsWith(prefix) : checkpoint.checkpointId.startsWith(prefix));
 }
 
+// dist/builtin/workflows/src/durable/backend-process-owner.ts
+var DURABLE_BACKEND_PROCESS_OWNER_KEY = Symbol.for("atomic-workflows/durable-backend-process-owner@1");
+function emptyOwner() {
+  return {
+    version: 1,
+    injectedBackend: undefined,
+    initializedBackend: undefined,
+    initializing: undefined,
+    warningSink: undefined,
+    warningReported: false
+  };
+}
+function ownerBag() {
+  return globalThis;
+}
+function getDurableBackendProcessOwner() {
+  const bag = ownerBag();
+  const existing = bag[DURABLE_BACKEND_PROCESS_OWNER_KEY];
+  if (existing !== undefined && existing.version === 1)
+    return existing;
+  const created = emptyOwner();
+  bag[DURABLE_BACKEND_PROCESS_OWNER_KEY] = created;
+  return created;
+}
+
+// dist/builtin/workflows/src/shared/possible-stages.ts
+var BUILTIN_BARREL_SPECIFIERS = new Set([
+  "@bastani/atomic/workflows/builtin",
+  "@bastani/workflows/builtin"
+]);
+var TRACKED_NODE_METHODS = new Set(["stage", "task", "chain", "parallel", "workflow", "tool"]);
+function coercePossibleStages(value) {
+  if (!Array.isArray(value))
+    return;
+  const stages = [];
+  for (const entry of value) {
+    if (typeof entry !== "string")
+      return;
+    stages.push(entry);
+  }
+  return stages;
+}
+
 // dist/builtin/workflows/src/shared/workflow-failures-contract.ts
 var WORKFLOW_AUTH_FAILURE_MESSAGE = "You must be logged in to run workflows. Run /login and try again.";
 var WORKFLOW_MISSING_API_KEY_FAILURE_MESSAGE = "A required model provider API key is missing. Configure the provider credentials and resume the workflow.";
@@ -6223,7 +6469,7 @@ function classifyWorkflowFailure(error) {
 }
 // dist/builtin/workflows/src/durable/dbos-process-owner.ts
 var DBOS_PROCESS_OWNER_KEY = Symbol.for("atomic-workflows/dbos-process-owner@1");
-function emptyOwner() {
+function emptyOwner2() {
   return {
     version: 1,
     state: "uninitialized",
@@ -6235,15 +6481,15 @@ function emptyOwner() {
     wrappers: undefined
   };
 }
-function ownerBag() {
+function ownerBag2() {
   return globalThis;
 }
 function getDbosProcessOwner() {
-  const bag = ownerBag();
+  const bag = ownerBag2();
   const existing = bag[DBOS_PROCESS_OWNER_KEY];
   if (existing !== undefined && existing.version === 1)
     return existing;
-  const created = emptyOwner();
+  const created = emptyOwner2();
   bag[DBOS_PROCESS_OWNER_KEY] = created;
   return created;
 }
@@ -6290,14 +6536,13 @@ function dbosLifecycleState() {
 }
 
 // dist/builtin/workflows/src/durable/factory.ts
-var injectedBackend;
-var initializedBackend;
 function isMemoizedBackendUsable(backend) {
   return !backend.persistent || dbosLifecycleState() === "ready";
 }
 function getDurableBackend() {
-  const memoized = initializedBackend !== undefined && isMemoizedBackendUsable(initializedBackend) ? initializedBackend : undefined;
-  const backend = injectedBackend ?? memoized ?? getReadyDbosBackendSync();
+  const owner2 = getDurableBackendProcessOwner();
+  const memoized = owner2.initializedBackend !== undefined && isMemoizedBackendUsable(owner2.initializedBackend) ? owner2.initializedBackend : undefined;
+  const backend = owner2.injectedBackend ?? memoized ?? getReadyDbosBackendSync();
   if (backend === undefined)
     throw new DbosNotReadyError;
   return backend;
@@ -6638,7 +6883,7 @@ function stripOnePrefix(value, prefix) {
 
 // dist/builtin/workflows/src/runs/foreground/executor-direct-helpers.ts
 import { isAbsolute as isAbsolute7, join as join8, resolve as resolve8 } from "node:path";
-import { CONFIG_DIR_NAME, isCodexFastModeCandidateModelId } from "@bastani/atomic";
+import { CONFIG_DIR_NAME } from "@bastani/atomic";
 
 // dist/builtin/workflows/src/shared/workflow-artifacts.ts
 import { mkdir, readdir, rm, stat } from "node:fs/promises";
@@ -6809,261 +7054,60 @@ async function ensureWorkflowArtifactRunDirectory(runId) {
   return directory;
 }
 
-// dist/builtin/workflows/src/runs/shared/model-fallback-candidates.ts
-function makeCandidate(id, value, level) {
+// dist/builtin/workflows/src/runs/shared/worktree-git.ts
+import * as fs3 from "node:fs";
+import * as path3 from "node:path";
+
+// dist/builtin/workflows/src/runs/shared/worktree-generation.ts
+import * as fs from "node:fs";
+import * as path from "node:path";
+function sameFileIdentity(left, right) {
+  return left.dev === right.dev && left.ino === right.ino;
+}
+function openMainCheckoutAnchor(gitDir) {
+  let disposed = false;
   return {
-    id,
-    value,
-    ...level !== undefined ? { reasoningLevel: level } : {}
+    assertCurrent() {
+      if (disposed)
+        throw new Error(`cached .git identity anchor is already disposed: ${gitDir}`);
+      if (!fs.lstatSync(gitDir).isDirectory()) {
+        throw new Error(`cached main-checkout .git directory is no longer current: ${gitDir}`);
+      }
+    },
+    dispose() {
+      disposed = true;
+    }
   };
 }
-var WORKFLOW_THINKING_LEVELS = [
-  "off",
-  "minimal",
-  "low",
-  "medium",
-  "high",
-  "xhigh",
-  "max"
-];
-var WORKFLOW_THINKING_LEVEL_SET = new Set(WORKFLOW_THINKING_LEVELS);
-function splitReasoningSuffix(model) {
-  const index = model.lastIndexOf(":");
-  if (index < 0)
-    return { baseModel: model };
-  const suffix = model.slice(index + 1);
-  if (WORKFLOW_THINKING_LEVEL_SET.has(suffix)) {
-    return { baseModel: model.slice(0, index), level: suffix };
-  }
-  return { baseModel: model };
-}
-function candidateKey(candidate) {
-  return `${candidate.id}::${candidate.reasoningLevel ?? ""}`;
-}
-
-class WorkflowModelValidationError extends Error {
-  failures;
-  constructor(failures) {
-    super(formatModelValidationError(failures));
-    this.name = "WorkflowModelValidationError";
-    this.failures = failures;
-  }
-}
-function formatModelValidationError(failures) {
-  const lines = ["workflows: model validation failed before starting workflow.", "Unavailable or ambiguous models:"];
-  for (const failure2 of failures) {
-    lines.push(`- ${failure2.input} (${failure2.reason})`);
-  }
-  return lines.join(`
-`);
-}
-function isModelObject(value) {
-  return typeof value !== "string";
-}
-function workflowModelId(value) {
-  if (value === undefined)
-    return;
-  if (typeof value === "string") {
-    const trimmed = value.trim();
-    return trimmed.length === 0 ? undefined : trimmed;
-  }
-  return `${String(value.provider)}/${value.id}`;
-}
-function normalizeInfo(info) {
-  const fullId = info.fullId.trim().length > 0 ? info.fullId : `${info.provider}/${info.id}`;
-  return { ...info, fullId };
-}
-function uniqueByFullId(models) {
-  const seen = new Set;
-  const result = [];
-  for (const info of models.map(normalizeInfo)) {
-    if (seen.has(info.fullId))
-      continue;
-    seen.add(info.fullId);
-    result.push(info);
-  }
-  return result;
-}
-function resolveStringModel(rawInput, availableModels, preferredProvider) {
-  const input = rawInput.trim();
-  if (!input)
-    return { input: rawInput, reason: "empty model id" };
-  const { baseModel, level } = splitReasoningSuffix(input);
-  const candidate = (id, value) => makeCandidate(id, value, level);
-  if (availableModels === undefined) {
-    return candidate(baseModel, baseModel);
-  }
-  const models = uniqueByFullId(availableModels);
-  const explicit = models.find((model) => model.fullId === baseModel);
-  if (explicit !== undefined) {
-    return candidate(explicit.fullId, explicit.model ?? explicit.fullId);
-  }
-  if (baseModel.includes("/")) {
-    return candidate(baseModel, baseModel);
-  }
-  const byBareId = models.filter((model) => model.id === baseModel);
-  if (byBareId.length === 0) {
-    return { input, reason: "not available" };
-  }
-  if (byBareId.length === 1) {
-    const only = byBareId[0];
-    return candidate(only.fullId, only.model ?? only.fullId);
-  }
-  const preferred = preferredProvider === undefined ? undefined : byBareId.find((model) => model.provider === preferredProvider);
-  if (preferred !== undefined) {
-    return candidate(preferred.fullId, preferred.model ?? preferred.fullId);
-  }
-  return {
-    input,
-    reason: `ambiguous: ${byBareId.map((model) => model.fullId).join(", ")}; specify provider/model`
-  };
-}
-function resolveModelValue(value, availableModels, preferredProvider) {
-  if (isModelObject(value)) {
-    return { id: workflowModelId(value), value };
-  }
-  return resolveStringModel(value, availableModels, preferredProvider);
-}
-function isFailure(value) {
-  return "reason" in value;
-}
-function buildModelCandidates(input) {
-  const rawValues = [];
-  if (input.primaryModel !== undefined)
-    rawValues.push(input.primaryModel);
-  for (const [index, fallback] of (input.fallbackModels ?? []).entries()) {
-    const trimmedFallback = fallback.trim();
-    const split = splitReasoningSuffix(trimmedFallback);
-    const compatLevel = input.fallbackThinkingLevels?.[index];
-    if (split.level === undefined && compatLevel !== undefined) {
-      if (!WORKFLOW_THINKING_LEVEL_SET.has(compatLevel)) {
-        throw new WorkflowModelValidationError([
-          {
-            input: trimmedFallback,
-            reason: `invalid fallbackThinkingLevels[${index}] "${compatLevel}"; expected one of ${WORKFLOW_THINKING_LEVELS.join(", ")}`
-          }
-        ]);
-      }
-      rawValues.push(`${trimmedFallback}:${compatLevel}`);
-    } else {
-      rawValues.push(trimmedFallback);
-    }
-  }
-  if (input.currentModel !== undefined)
-    rawValues.push(input.currentModel);
-  const failures = [];
-  const seen = new Set;
-  const candidates = [];
-  for (const value of rawValues) {
-    const resolved = resolveModelValue(value, input.availableModels, input.preferredProvider);
-    if (isFailure(resolved)) {
-      failures.push(resolved);
-      continue;
-    }
-    const key2 = candidateKey(resolved);
-    if (seen.has(key2))
-      continue;
-    seen.add(key2);
-    candidates.push(resolved);
-  }
-  if (failures.length > 0)
-    throw new WorkflowModelValidationError(failures);
-  return candidates;
-}
-function catalogUnavailableWarning() {
-  return "workflows: model catalog unavailable; using the current selected model for fallback validation.";
-}
-async function buildModelCandidatesFromCatalog(input) {
-  const hasExplicitModel = input.primaryModel !== undefined || (input.fallbackModels?.length ?? 0) > 0;
-  if (!hasExplicitModel)
-    return [];
-  if (input.catalog === undefined) {
-    return buildModelCandidates({
-      primaryModel: input.primaryModel,
-      fallbackModels: input.fallbackModels,
-      fallbackThinkingLevels: input.fallbackThinkingLevels
-    });
-  }
-  try {
-    const availableModels = await input.catalog.listModels();
-    return buildModelCandidates({
-      primaryModel: input.primaryModel,
-      fallbackModels: input.fallbackModels,
-      fallbackThinkingLevels: input.fallbackThinkingLevels,
-      currentModel: input.catalog.currentModel,
-      availableModels,
-      preferredProvider: input.catalog.preferredProvider
-    });
-  } catch (err) {
-    if (input.catalog.currentModel === undefined) {
-      throw err;
-    }
-    input.catalog.recordWarning?.(catalogUnavailableWarning());
-    return buildModelCandidates({ currentModel: input.catalog.currentModel });
-  }
-}
-// dist/builtin/workflows/src/runs/shared/model-fallback-failures.ts
-import {
-  errorMessage as errorMessage2,
-  isRetryableModelFailure,
-  isRetryableSameModelFailure,
-  modelFailureMessage,
-  normalizeModelFailureSignal
-} from "@bastani/atomic";
-// dist/builtin/workflows/src/runs/shared/worktree-git.ts
-import * as fs3 from "node:fs";
-import * as path3 from "node:path";
-
-// dist/builtin/workflows/src/runs/shared/worktree-generation.ts
-import * as fs from "node:fs";
-import * as path from "node:path";
-function sameFileIdentity(left, right) {
-  return left.dev === right.dev && left.ino === right.ino;
-}
-function openMainCheckoutAnchor(gitDir) {
-  let disposed = false;
-  return {
-    assertCurrent() {
-      if (disposed)
-        throw new Error(`cached .git identity anchor is already disposed: ${gitDir}`);
-      if (!fs.lstatSync(gitDir).isDirectory()) {
-        throw new Error(`cached main-checkout .git directory is no longer current: ${gitDir}`);
-      }
-    },
-    dispose() {
-      disposed = true;
-    }
-  };
-}
-function openGitWorktreeGenerationAnchor(worktreeRoot) {
-  const gitFile = path.join(worktreeRoot, ".git");
-  if (fs.lstatSync(gitFile).isDirectory())
-    return openMainCheckoutAnchor(gitFile);
-  const descriptor = fs.openSync(gitFile, "r");
-  let disposed = false;
-  const anchor = {
-    assertCurrent() {
-      if (disposed)
-        throw new Error(`cached .git identity anchor is already disposed: ${gitFile}`);
-      const held = fs.fstatSync(descriptor, { bigint: true });
-      const current = fs.lstatSync(gitFile, { bigint: true });
-      if (!current.isFile() || !sameFileIdentity(held, current)) {
-        throw new Error(`cached .git identity anchor no longer matches the selected checkout: ${gitFile}`);
-      }
-    },
-    dispose() {
-      if (disposed)
-        return;
-      disposed = true;
-      fs.closeSync(descriptor);
-    }
-  };
-  try {
-    anchor.assertCurrent();
-    return anchor;
-  } catch (error) {
-    anchor.dispose();
-    throw error;
+function openGitWorktreeGenerationAnchor(worktreeRoot) {
+  const gitFile = path.join(worktreeRoot, ".git");
+  if (fs.lstatSync(gitFile).isDirectory())
+    return openMainCheckoutAnchor(gitFile);
+  const descriptor = fs.openSync(gitFile, "r");
+  let disposed = false;
+  const anchor = {
+    assertCurrent() {
+      if (disposed)
+        throw new Error(`cached .git identity anchor is already disposed: ${gitFile}`);
+      const held = fs.fstatSync(descriptor, { bigint: true });
+      const current = fs.lstatSync(gitFile, { bigint: true });
+      if (!current.isFile() || !sameFileIdentity(held, current)) {
+        throw new Error(`cached .git identity anchor no longer matches the selected checkout: ${gitFile}`);
+      }
+    },
+    dispose() {
+      if (disposed)
+        return;
+      disposed = true;
+      fs.closeSync(descriptor);
+    }
+  };
+  try {
+    anchor.assertCurrent();
+    return anchor;
+  } catch (error) {
+    anchor.dispose();
+    throw error;
   }
 }
 
@@ -8561,24 +8605,6 @@ function cleanupPreparedWorktrees(prepared) {
   if (prepared.setup !== undefined)
     cleanupWorktrees(prepared.setup);
 }
-async function hasExplicitFastModeCandidate(input) {
-  const rawCandidate = isCodexFastModeCandidate(input.model) || Array.isArray(input.fallbackModels) && input.fallbackModels.some((candidate) => isCodexFastModeCandidate(candidate));
-  if (rawCandidate)
-    return true;
-  try {
-    const candidates = await buildModelCandidatesFromCatalog({
-      primaryModel: input.model,
-      fallbackModels: input.fallbackModels,
-      catalog: input.models
-    });
-    return candidates.some((candidate) => isCodexFastModeCandidate(candidate.id));
-  } catch {
-    return false;
-  }
-}
-function isCodexFastModeCandidate(model) {
-  return isCodexFastModeCandidateModelId(workflowModelId(model));
-}
 
 // dist/builtin/workflows/src/shared/persistence-session-entries.ts
 function appendRunStart(api, payload) {
@@ -8925,24 +8951,24 @@ function stageReplayFields(stage) {
   };
 }
 function finalizeKilled(runId, runSnapshot, activeStore, persistence, onRunEnd) {
-  const errorMessage3 = "workflow killed";
+  const errorMessage2 = "workflow killed";
   const metadata = {
     failureKind: "cancelled",
     failureCode: "cancelled",
     failureRecoverability: "non_recoverable",
     failureDisposition: "terminal_killed",
-    failureMessage: errorMessage3,
+    failureMessage: errorMessage2,
     resumable: false
   };
-  const recorded = activeStore.recordRunEnd(runId, "killed", undefined, errorMessage3, metadata);
+  const recorded = activeStore.recordRunEnd(runId, "killed", undefined, errorMessage2, metadata);
   appendRunEndWhenRecorded(persistence, recorded, {
     runId,
     status: "killed",
-    error: errorMessage3,
+    error: errorMessage2,
     ...metadata,
     ts: Date.now()
   });
-  return reconcileTerminalRunResult(runId, runSnapshot, activeStore, { status: "killed", error: errorMessage3 }, onRunEnd);
+  return reconcileTerminalRunResult(runId, runSnapshot, activeStore, { status: "killed", error: errorMessage2 }, onRunEnd);
 }
 function finalizeKilledByFailure(runId, runSnapshot, activeStore, persistence, onRunEnd, metadata) {
   const recorded = activeStore.recordRunEnd(runId, "killed", undefined, metadata.errorMessage, metadata);
@@ -9216,7 +9242,7 @@ function createContinuationReplayIndex(continuation, sourceToContinuationNodeIds
       markPromptAnswerReplayed: () => {}
     };
   }
-  if (continuation.resumeFromStageId === undefined) {
+  if (continuation.resumeFromStageId === undefined && continuation.resumeFromToolNodeId === undefined) {
     if (continuation.source.stages.length > 0)
       throw new Error(`atomic-workflows: insufficient_state: continuation has no resume stage in source run ${continuation.source.id}`);
     return {
@@ -9228,9 +9254,9 @@ function createContinuationReplayIndex(continuation, sourceToContinuationNodeIds
       markPromptAnswerReplayed: () => {}
     };
   }
-  const resumeStage = continuation.source.stages.find((stage) => stage.id === continuation.resumeFromStageId);
-  if (resumeStage === undefined) {
-    throw new Error(`atomic-workflows: insufficient_state: resume stage ${continuation.resumeFromStageId} was not found in source run ${continuation.source.id}`);
+  const resumeNode = continuation.resumeFromToolNodeId === undefined ? continuation.source.stages.find((stage) => stage.id === continuation.resumeFromStageId) : continuation.source.toolNodes?.find((node) => node.id === continuation.resumeFromToolNodeId);
+  if (resumeNode === undefined) {
+    throw new Error(`atomic-workflows: insufficient_state: resume frontier ${continuation.resumeFromStageId ?? continuation.resumeFromToolNodeId} was not found in source run ${continuation.source.id}`);
   }
   const stagesByReplayIdentity = new Map;
   const stagesByDisplayName = new Map;
@@ -9662,6 +9688,8 @@ function createRunFinalizers(input) {
     }
     let outputs;
     try {
+      if (signal.status === "completed")
+        input.assertSuccessfulCompletion();
       outputs = normalizeWorkflowExitOutput(input.def.name, signal.outputSnapshot);
       assertWorkflowExitOutputs(input.def.name, outputs, input.def.outputs);
     } catch (err) {
@@ -10728,14 +10756,19 @@ function createParallelPrimitive(input) {
 function createTaskPrimitive(runtime) {
   return async (name, options, stageFailFastScope) => {
     runtime.exit.throwIfWorkflowExitSelected();
-    const runTaskOnce = async (taskOptions) => {
+    const runTaskOnce = async (taskOptions, prepareLiveOptions) => {
       runtime.exit.throwIfWorkflowExitSelected();
-      const resolvedTaskOptions = stageOptionsWithGitWorktree(stageOptionsWithInputDefaults(taskOptions, runtime.inputRuntimeDefaults), runtime.workflowInvocationCwd, runtime.gitWorktreeSetupCache) ?? taskOptions;
+      let resolvedTaskOptions = stageOptionsWithInputDefaults(taskOptions, runtime.inputRuntimeDefaults) ?? taskOptions;
       const stageOptions = taskStageOptions(resolvedTaskOptions);
       const stageHandle = runtime.spawnStage(name, {
         kind: "agent",
         ...stageOptions !== undefined ? { options: stageOptions } : {},
-        ...stageFailFastScope !== undefined ? { failFastScope: stageFailFastScope } : {}
+        ...stageFailFastScope !== undefined ? { failFastScope: stageFailFastScope } : {},
+        prepareLiveOptions: () => {
+          const preparedOptions = prepareLiveOptions?.() ?? taskOptions;
+          resolvedTaskOptions = stageOptionsWithGitWorktree(stageOptionsWithInputDefaults(preparedOptions, runtime.inputRuntimeDefaults), runtime.workflowInvocationCwd, runtime.gitWorktreeSetupCache) ?? preparedOptions;
+          return taskStageOptions(resolvedTaskOptions);
+        }
       });
       const stage = stageHandle.context;
       const promptText = resolvedTaskOptions.resumeFromSessionFile !== undefined ? RESUME_CONTINUATION_PROMPT : applyTaskContext(`${taskReadInstruction(resolvedTaskOptions)}${taskPrompt(resolvedTaskOptions)}`, taskPrevious(resolvedTaskOptions));
@@ -10758,7 +10791,6 @@ function createTaskPrimitive(runtime) {
         ...sessionId !== undefined ? { sessionId } : {},
         ...stage.sessionFile !== undefined ? { sessionFile: stage.sessionFile } : {},
         ...stageMeta.model !== undefined ? { model: stageMeta.model } : {},
-        ...stageMeta.fastMode === true ? { fastMode: stageMeta.fastMode } : {},
         ...stageMeta.attemptedModels !== undefined ? { attemptedModels: stageMeta.attemptedModels } : {},
         ...stageMeta.modelAttempts !== undefined ? { modelAttempts: stageMeta.modelAttempts } : {},
         ...stageMeta.warnings !== undefined ? { warnings: stageMeta.warnings } : {}
@@ -10766,22 +10798,25 @@ function createTaskPrimitive(runtime) {
     };
     if (options.worktree !== true)
       return runTaskOnce(options);
-    const prepared = prepareTaskWorktrees([{ ...options, name }], { ...options, worktree: true }, `${runtime.runId}-${name}-${crypto.randomUUID()}`, name, runtime.workflowInvocationCwd, runtime.worktreeSymlinkDirectories);
-    const preparedTask = prepared.tasks[0];
+    let prepared;
     let collected;
     const collect = () => {
-      collected ??= collectWorktreeDiffs(prepared, options.artifacts !== false).artifacts;
+      collected ??= prepared === undefined ? [] : collectWorktreeDiffs(prepared, options.artifacts !== false).artifacts;
       return collected;
     };
-    const replayKey = preparedTask.durableReplayKey;
-    if (replayKey !== undefined)
-      runtime.registerTerminalArtifactCollector(replayKey, collect);
     try {
-      const result = await runTaskOnce(preparedTask);
+      const result = await runTaskOnce(options, () => {
+        prepared = prepareTaskWorktrees([{ ...options, name }], { ...options, worktree: true }, `${runtime.runId}-${name}-${crypto.randomUUID()}`, name, runtime.workflowInvocationCwd, runtime.worktreeSymlinkDirectories);
+        const preparedTask = prepared.tasks[0];
+        if (preparedTask.durableReplayKey !== undefined)
+          runtime.registerTerminalArtifactCollector(preparedTask.durableReplayKey, collect);
+        return preparedTask;
+      });
       const artifacts = collect();
       return artifacts.length === 0 ? result : { ...result, artifacts: [...result.artifacts ?? [], ...artifacts] };
     } finally {
-      cleanupPreparedWorktrees(prepared);
+      if (prepared !== undefined)
+        cleanupPreparedWorktrees(prepared);
     }
   };
 }
@@ -10993,57 +11028,6 @@ function buildExitGatedUiContext(input) {
   };
 }
 
-// dist/builtin/workflows/src/engine/workflow-tool-abort.ts
-class WorkflowToolAbortError extends Error {
-  runId;
-  nodeId;
-  toolName;
-  scope;
-  constructor(input) {
-    super(`atomic-workflows: ctx.tool ${input.toolName} aborted by ${input.scope === "quit" ? "workflow quit" : "node abort"}`);
-    this.name = "AbortError";
-    this.runId = input.runId;
-    this.nodeId = input.nodeId;
-    this.toolName = input.toolName;
-    this.scope = input.scope;
-  }
-}
-function isWorkflowToolAbortError(value) {
-  return value instanceof WorkflowToolAbortError;
-}
-var WORKFLOW_GRACEFUL_QUIT_EXIT_REASON = "quit";
-
-class WorkflowGracefulQuitError extends Error {
-  runId;
-  constructor(runId, detail) {
-    super(`atomic-workflows: ${detail} suspended by workflow quit`);
-    this.name = "AbortError";
-    this.runId = runId;
-  }
-}
-function isGracefulQuitSignal(value) {
-  if (value instanceof WorkflowGracefulQuitError)
-    return true;
-  return isWorkflowToolAbortError(value) && value.scope === "quit";
-}
-function findWorkflowGracefulQuit(value) {
-  let current = value;
-  for (let depth = 0;depth < 8; depth++) {
-    if (isGracefulQuitSignal(current))
-      return current;
-    if (typeof current !== "object" || current === null)
-      return;
-    try {
-      if (!("cause" in current))
-        return;
-      current = current.cause;
-    } catch {
-      return;
-    }
-  }
-  return;
-}
-
 // dist/builtin/workflows/src/engine/primitives/workflow.ts
 function createChildWorkflowRunner(input) {
   return async (child, ...args) => {
@@ -11078,6 +11062,7 @@ function createChildWorkflowRunner(input) {
         await durableInvocation?.recordTerminal("completed", boundary.replayedChild);
         return boundary.replayedChild;
       }
+      runtime.assertLiveWorkAllowed?.();
       const childInputs = resolveAndValidateInputs(child.inputs, options.inputs ?? {}, `child workflow "${childName}" (${child.name})`);
       runtime.exit.throwIfWorkflowExitSelected();
       childRunId = durableInvocation?.identity.childRunId ?? crypto.randomUUID();
@@ -11186,7 +11171,8 @@ function durableRootRegistrationForRun(args) {
     status: "running",
     rootWorkflowId: args.runId,
     resumable: true,
-    ...args.hasPersistence ? { sessionFile: undefined } : {}
+    ...args.hasPersistence ? { sessionFile: undefined } : {},
+    ...args.possibleStages !== undefined ? { possibleStages: args.possibleStages } : {}
   };
 }
 async function admitDurableRootRun(args) {
@@ -11630,7 +11616,6 @@ function mergeStageDraft(existing, checkpoint, sequence) {
     ...valueOrExisting("endedAt", checkpoint, existing),
     ...valueOrExisting("durationMs", checkpoint, existing),
     ...valueOrExisting("model", checkpoint, existing),
-    ...valueOrExisting("fastMode", checkpoint, existing),
     ...valueOrExisting("attemptedModels", checkpoint, existing),
     ...valueOrExisting("modelAttempts", checkpoint, existing),
     ...checkpoint.topology !== undefined ? { topology: checkpoint.topology } : existing?.topology !== undefined ? { topology: existing.topology } : {}
@@ -11765,9 +11750,9 @@ function completedToolNodes(checkpoints, runId, rootRunId, sourceIds, firstSeque
         argsHash: checkpoint.argsHash,
         ordinal: topology?.ordinal ?? index + 1,
         parentIds: Object.freeze([...topology?.parentIds ?? []].map((parentId) => sourceIds.get(parentId) ?? parentId)),
-        replayed: true,
+        ...checkpoint.throwingFailureError === undefined ? { replayed: true } : {},
         ...topology === undefined ? { topologyState: "unavailable" } : {},
-        status: failed ? "failed" : "cached",
+        status: checkpoint.cancelled === true ? "cancelled" : failed ? "failed" : "cached",
         executionOrder: topology?.order ?? firstSequenceByHash.get(checkpoint.argsHash),
         ...topology?.startedAt !== undefined ? { startedAt: topology.startedAt } : {},
         endedAt: topology?.endedAt ?? checkpoint.completedAt,
@@ -12027,7 +12012,6 @@ function stageSnapshotFromDraft(draft, id, parentIds) {
     ...draft.sessionId !== undefined ? { sessionId: draft.sessionId } : {},
     ...draft.sessionFile !== undefined ? { sessionFile: draft.sessionFile } : {},
     ...draft.model !== undefined ? { model: draft.model } : {},
-    ...draft.fastMode !== undefined ? { fastMode: draft.fastMode } : {},
     ...draft.attemptedModels !== undefined ? { attemptedModels: draft.attemptedModels } : {},
     ...draft.modelAttempts !== undefined ? { modelAttempts: draft.modelAttempts } : {}
   };
@@ -12548,6 +12532,7 @@ function createAdmittedToolExecutionTracker(options = {}) {
   const inFlight = new Set;
   const admissions = [];
   const failures = [];
+  const cancellations = [];
   let nextAdmissionOrder2 = 0;
   let state = "OPEN";
   let closing;
@@ -12609,8 +12594,10 @@ function createAdmittedToolExecutionTracker(options = {}) {
       const observed = execution.then(() => {
         return;
       }, (error) => {
-        if (admission.cancelled)
+        if (admission.cancelled) {
+          cancellations.push({ admissionOrder: admission.admissionOrder, error, nodeId: admission.nodeId });
           return;
+        }
         recordFailure(admission, error, admission.nodeId);
         reportDrainFailure();
       });
@@ -12657,7 +12644,7 @@ function createAdmittedToolExecutionTracker(options = {}) {
       return failures[0];
     },
     uniqueFailureFor(error) {
-      const matching = failures.filter((failure2) => Object.is(failure2.error, error));
+      const matching = [...failures, ...cancellations].filter((failure2) => Object.is(failure2.error, error));
       return matching.length === 1 ? matching[0] : undefined;
     }
   };
@@ -12668,10 +12655,20 @@ function createToolNodeLifecycle(input) {
   const { store: store2, tracker, run: run2, sourceToContinuationNodeIds } = input;
   const ownsCurrentRun = () => store2.runs().some((candidate) => candidate === run2);
   const replayedToolNodeIds = new Set;
+  let pendingFrontier = input.resumeToolNode;
   return {
+    assertFrontierConsumed: () => {
+      if (pendingFrontier !== undefined) {
+        throw new Error(`${REPLAY_TOPOLOGY_MISMATCH_MESSAGE} for unfinished tool ${pendingFrontier.id}: pending frontier was not consumed`);
+      }
+    },
     onNodeStart: (node) => {
+      const frontier = node.replayed === true ? undefined : pendingFrontier;
+      if (frontier !== undefined && (node.id !== frontier.id || node.argsHash !== frontier.argsHash || node.ordinal !== frontier.ordinal)) {
+        throw new Error(`${REPLAY_TOPOLOGY_MISMATCH_MESSAGE} for unfinished tool ${frontier.id}`);
+      }
       const inferredParents = tracker.onSpawn(node.id, node.name);
-      const sourceParents = node.replayed === true && node.topologyState !== "unavailable" ? node.parentIds : undefined;
+      const sourceParents = frontier?.parentIds ?? (node.replayed === true && node.topologyState !== "unavailable" ? node.parentIds : undefined);
       const restored = sourceParents?.map((sourceId) => sourceToContinuationNodeIds.get(sourceId));
       const translated = restored?.every((id) => id !== undefined) ? restored : undefined;
       if (run2.resumedFromRunId !== undefined && sourceParents !== undefined && translated === undefined) {
@@ -12688,6 +12685,8 @@ function createToolNodeLifecycle(input) {
         replayedToolNodeIds.add(node.id);
       if (ownsCurrentRun())
         store2.recordToolNodeStart(run2.id, node);
+      if (frontier !== undefined)
+        pendingFrontier = undefined;
     },
     onNodeRunning: (nodeId, startedAt) => {
       if (ownsCurrentRun())
@@ -12779,7 +12778,13 @@ function createTrackedToolPrimitive(input) {
       return;
     abandonInFlightAsCancelled(input.controller.signal.reason);
   }, { once: true });
-  return { tool, admittedTools, abandonInFlightAsCancelled, observedQuitCancellation: () => observedQuit };
+  return {
+    tool,
+    admittedTools,
+    assertFrontierConsumed: lifecycle.assertFrontierConsumed,
+    abandonInFlightAsCancelled,
+    observedQuitCancellation: () => observedQuit
+  };
 }
 
 // dist/builtin/workflows/src/runs/foreground/executor-child-boundary.ts
@@ -13154,11 +13159,7 @@ function createTrackedStageCaller(input) {
         const now = Date.now();
         const hasNoExplicitModelConfig = input.options?.model === undefined && input.options?.fallbackModels === undefined;
         const promptAdapterHandlesInitialPrompt = input.adapters.prompt !== undefined;
-        if (callOptions.eagerSession && !promptAdapterHandlesInitialPrompt && (hasNoExplicitModelConfig || await hasExplicitFastModeCandidate({
-          model: input.options?.model,
-          fallbackModels: input.options?.fallbackModels,
-          models: runtime.opts.models
-        }))) {
+        if (callOptions.eagerSession && !promptAdapterHandlesInitialPrompt && hasNoExplicitModelConfig) {
           try {
             await runtime.innerCtx.__ensureSession();
           } catch (err) {
@@ -13930,7 +13931,6 @@ function createReplayStageContext(input) {
     __pendingMessageCount: () => 0,
     __modelFallbackMeta: () => ({
       ...replaySource.model !== undefined ? { model: replaySource.model } : {},
-      ...replaySource.fastMode === true ? { fastMode: replaySource.fastMode } : {},
       ...replaySource.attemptedModels !== undefined ? { attemptedModels: replaySource.attemptedModels } : {},
       ...replaySource.modelAttempts !== undefined ? { modelAttempts: replaySource.modelAttempts } : {}
     }),
@@ -13988,13 +13988,140 @@ function workflowPendingStageRouteCapability(store2, runId) {
   return capability;
 }
 
+// dist/builtin/workflows/src/shared/workflow-stage-path-matching.ts
+function matchStagePathSegments(patternSegments, candidateSegments) {
+  return matchSegmentsFrom(patternSegments, 0, candidateSegments, 0);
+}
+function matchSegmentsFrom(pattern, patternIndex, candidate, candidateIndex) {
+  let p = patternIndex;
+  let c = candidateIndex;
+  while (p < pattern.length) {
+    const segment = pattern[p];
+    if (segment === "**") {
+      for (let skip = c;skip <= candidate.length; skip += 1) {
+        if (matchSegmentsFrom(pattern, p + 1, candidate, skip))
+          return true;
+      }
+      return false;
+    }
+    if (c >= candidate.length)
+      return false;
+    if (!matchSegmentGlob(segment, candidate[c]))
+      return false;
+    p += 1;
+    c += 1;
+  }
+  return c === candidate.length;
+}
+function matchSegmentGlob(pattern, value) {
+  if (!pattern.includes("*"))
+    return pattern === value;
+  let p = 0;
+  let v = 0;
+  let star = -1;
+  let mark = -1;
+  while (v < value.length) {
+    if (p < pattern.length && pattern[p] === "*") {
+      star = p;
+      mark = v;
+      p += 1;
+      continue;
+    }
+    if (p < pattern.length && pattern[p] === value[v]) {
+      p += 1;
+      v += 1;
+      continue;
+    }
+    if (star >= 0) {
+      p = star + 1;
+      mark += 1;
+      v = mark;
+      continue;
+    }
+    return false;
+  }
+  while (p < pattern.length && pattern[p] === "*")
+    p += 1;
+  return p === pattern.length;
+}
+
+// dist/builtin/workflows/src/shared/workflow-stage-target.ts
+var WORKFLOW_RUN_ID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+var WORKFLOW_TARGET_PREFIX = "workflow:";
+function parseWorkflowStageTarget(target) {
+  if (!target.startsWith(WORKFLOW_TARGET_PREFIX))
+    return;
+  const slash = target.indexOf("/", WORKFLOW_TARGET_PREFIX.length);
+  if (slash < 0)
+    return;
+  const rootRunId = target.slice(WORKFLOW_TARGET_PREFIX.length, slash);
+  if (!WORKFLOW_RUN_ID_PATTERN.test(rootRunId))
+    return;
+  const segments = target.slice(slash + 1).split("/");
+  if (segments.length === 0 || segments.some((segment) => segment.length === 0))
+    return;
+  const kind = segments.includes("**") ? "deep-pattern" : segments.some((segment) => segment.includes("*")) ? "pattern" : "path";
+  return { rootRunId, segments, kind };
+}
+
+// dist/builtin/workflows/src/shared/pending-stage-status.ts
+function workflowBoundaryHops(runs, runId) {
+  const runById = new Map(runs.map((run2) => [run2.id, run2]));
+  const hops = [];
+  let current = runById.get(runId);
+  while (current !== undefined && current.parentRunId !== undefined) {
+    const parent = runById.get(current.parentRunId);
+    const boundary = parent?.stages.find((stage) => stage.id === current?.parentStageId);
+    if (parent === undefined || boundary === undefined)
+      return;
+    hops.unshift({ name: boundary.name, runId: current.id });
+    current = parent;
+  }
+  return current === undefined ? undefined : hops;
+}
+function workflowStagePathVariants(hops, stageSegments) {
+  let prefixes = [[]];
+  for (const hop of hops) {
+    prefixes = prefixes.flatMap((prefix) => {
+      const withName = [...prefix, hop.name];
+      return hop.runId === hop.name ? [withName] : [withName, [...prefix, hop.runId]];
+    });
+  }
+  return prefixes.flatMap((prefix) => stageSegments.map((stage) => [...prefix, stage]));
+}
+function stageMatchesPathPattern(patternSegments, hops, stageSegments) {
+  return workflowStagePathVariants(hops, stageSegments).some((candidate) => matchStagePathSegments(patternSegments, candidate));
+}
+
 // dist/builtin/workflows/src/runs/foreground/pending-stage-delivery.ts
 var pendingDeliveryClaims = new WeakMap;
+
+class WorkflowPendingStageDeliveryFailedError extends Error {
+  code = "pending_stage_delivery_failed";
+  runId;
+  stageId;
+  stageName;
+  reason;
+  constructor(runId, stageId, stageName, reason) {
+    super(`atomic-workflows: stage "${stageName}" (${stageId}) did not start because its queued Intercom instructions could not be delivered: ${reason.message}`);
+    this.name = "WorkflowPendingStageDeliveryFailedError";
+    this.runId = runId;
+    this.stageId = stageId;
+    this.stageName = stageName;
+    this.reason = reason;
+  }
+}
+function isWorkflowPendingStageDeliveryFailure(error) {
+  if (error instanceof WorkflowPendingStageDeliveryFailedError)
+    return true;
+  return error?.code === "pending_stage_delivery_failed";
+}
 function createWorkflowPendingStageDelivery(activeStore, runId, stageId, stageName) {
   let resolveReady;
   let rejectReady;
   let readyPromise;
   let drainError;
+  let terminalError;
   let drainPromise;
   const pendingReady = () => {
     if (readyPromise === undefined) {
@@ -14008,48 +14135,84 @@ function createWorkflowPendingStageDelivery(activeStore, runId, stageId, stageNa
   return {
     routeCapability: workflowPendingStageRouteCapability(activeStore, runId),
     deliverPending(deliver) {
-      if (drainPromise === undefined) {
-        drainError = undefined;
-        const attempt = deliverPendingStageMessages(activeStore, runId, stageId, stageName, deliver);
-        const drain = attempt.then(() => resolveReady?.(), (error) => {
-          drainError = error;
-          rejectReady?.(error);
-          readyPromise = undefined;
-          resolveReady = undefined;
-          rejectReady = undefined;
-          if (drainPromise === drain)
-            drainPromise = undefined;
-          throw error;
-        });
-        drainPromise = drain;
-      }
+      if (drainPromise !== undefined)
+        return drainPromise;
+      if (terminalError !== undefined)
+        return Promise.resolve();
+      drainError = undefined;
+      const attempt = deliverPendingStageMessages(activeStore, runId, stageId, stageName, deliver);
+      const drain = attempt.then(() => resolveReady?.(), (error) => {
+        drainError = error;
+        rejectReady?.(error);
+        readyPromise = undefined;
+        resolveReady = undefined;
+        rejectReady = undefined;
+        if (drainPromise === drain)
+          drainPromise = undefined;
+        throw error;
+      });
+      drainPromise = drain;
       return drainPromise;
     },
     ready() {
-      if (activeStore.pendingStageMessagesFor(runId, stageId).length === 0 && (stageId === stageName || activeStore.pendingStageMessagesFor(runId, stageName).length === 0)) {
+      if (activeStore.pendingStageMessagesFor(runId, stageId).length === 0 && (stageId === stageName || activeStore.pendingStageMessagesFor(runId, stageName).length === 0) && stickyPendingStageEntriesForStage(activeStore, runId, stageId, stageName).length === 0) {
         return;
       }
+      if (terminalError !== undefined)
+        return Promise.reject(terminalError);
       return drainError === undefined ? pendingReady() : Promise.reject(drainError);
+    },
+    fail(reason) {
+      if (terminalError !== undefined)
+        return;
+      terminalError = new WorkflowPendingStageDeliveryFailedError(runId, stageId, stageName, reason);
+      if (readyPromise === undefined)
+        return;
+      readyPromise.catch(() => {});
+      rejectReady?.(terminalError);
     }
   };
 }
 async function deliverPendingStageMessages(activeStore, runId, stageId, stageName, deliver) {
+  const stickyEntries = stickyPendingStageEntriesForStage(activeStore, runId, stageId, stageName);
   const candidateIds = new Set([
     ...activeStore.pendingStageMessagesFor(runId, stageId),
-    ...activeStore.pendingStageMessagesFor(runId, stageName)
+    ...activeStore.pendingStageMessagesFor(runId, stageName),
+    ...stickyEntries
   ].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 runs = activeStore.runs();
+  const entries = [
+    ...(runs.find((run2) => run2.id === runId)?.pendingStageMessages ?? []).map((entry, index) => ({ entry, index })).filter(({ entry }) => candidateIds.has(entry.id) && entry.sticky !== true),
+    ...stickyEntries.map((entry) => ({ entry, index: Number.MAX_SAFE_INTEGER }))
+  ].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);
+  const backend = durableBackendForRun(rootBackend, 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);
+    const claimOwner = entry.sticky === true ? `${entry.runId}\x00${runId}:${stageId}` : entry.runId;
+    const releaseClaim = claimPendingDelivery(activeStore, claimOwner, entry.stageKey, entry.id);
     if (releaseClaim === undefined)
       continue;
     try {
       await deliver(toPendingStageSender(entry), entry.message);
+      if (entry.sticky === true) {
+        const entryBackend = durableBackendForRun(rootBackend, activeStore.runs(), entry.runId);
+        if (entryBackend === undefined) {
+          throw new Error(`atomic-workflows: workflow run ${entry.runId} has no durable owner for sticky pending-stage delivery`);
+        }
+        if (!await activeStore.recordPendingStageMessageDeliveries(entry.runId, entry.id, [
+          {
+            runId,
+            stageId,
+            ...stageName === stageId ? {} : { stageName }
+          }
+        ], new Date().toISOString(), entryBackend)) {
+          throw new Error(`atomic-workflows: pending-stage message ${entry.id} changed during delivery`);
+        }
+        continue;
+      }
       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`);
       }
@@ -14058,6 +14221,29 @@ async function deliverPendingStageMessages(activeStore, runId, stageId, stageNam
     }
   }
 }
+function stickyPendingStageEntriesForStage(activeStore, runId, stageId, stageName) {
+  const runs = activeStore.runs();
+  const rootRunId = durableRootRunIdForRun(runs, runId);
+  if (rootRunId === undefined)
+    return [];
+  const rootRun = runs.find((run2) => run2.id === rootRunId);
+  if (rootRun === undefined)
+    return [];
+  const hops = workflowBoundaryHops(runs, runId);
+  if (hops === undefined)
+    return [];
+  return (rootRun.pendingStageMessages ?? []).filter((entry) => {
+    if (entry.sticky !== true || entry.status !== "queued")
+      return false;
+    const parsed = entry.targetPath === undefined ? undefined : parseWorkflowStageTarget(entry.targetPath);
+    if (parsed === undefined || parsed.rootRunId !== rootRunId)
+      return false;
+    if ((entry.deliveries ?? []).some((delivery) => delivery.runId === runId && delivery.stageId === stageId)) {
+      return false;
+    }
+    return stageMatchesPathPattern(parsed.segments, hops, [stageId, stageName]);
+  });
+}
 function claimPendingDelivery(store2, runId, stageKey, messageId) {
   let claims = pendingDeliveryClaims.get(store2);
   if (claims === undefined) {
@@ -14090,10 +14276,210 @@ import { createStructuredOutputCapture, runCallback as runCallback2 } from "@bas
 
 // dist/builtin/workflows/src/runs/foreground/stage-runner-controller.ts
 import {
-  convertToLlm,
-  shouldApplyCodexFastModeForScope
+  convertToLlm
 } from "@bastani/atomic";
 
+// dist/builtin/workflows/src/runs/shared/model-fallback-candidates.ts
+function makeCandidate(id, value, level) {
+  return {
+    id,
+    value,
+    ...level !== undefined ? { reasoningLevel: level } : {}
+  };
+}
+var WORKFLOW_THINKING_LEVELS = [
+  "off",
+  "minimal",
+  "low",
+  "medium",
+  "high",
+  "xhigh",
+  "max"
+];
+var WORKFLOW_THINKING_LEVEL_SET = new Set(WORKFLOW_THINKING_LEVELS);
+function splitReasoningSuffix(model) {
+  const index = model.lastIndexOf(":");
+  if (index < 0)
+    return { baseModel: model };
+  const suffix = model.slice(index + 1);
+  if (WORKFLOW_THINKING_LEVEL_SET.has(suffix)) {
+    return { baseModel: model.slice(0, index), level: suffix };
+  }
+  return { baseModel: model };
+}
+function candidateKey(candidate) {
+  return `${candidate.id}::${candidate.reasoningLevel ?? ""}`;
+}
+
+class WorkflowModelValidationError extends Error {
+  failures;
+  constructor(failures) {
+    super(formatModelValidationError(failures));
+    this.name = "WorkflowModelValidationError";
+    this.failures = failures;
+  }
+}
+function formatModelValidationError(failures) {
+  const lines = ["workflows: model validation failed before starting workflow.", "Unavailable or ambiguous models:"];
+  for (const failure2 of failures) {
+    lines.push(`- ${failure2.input} (${failure2.reason})`);
+  }
+  return lines.join(`
+`);
+}
+function isModelObject(value) {
+  return typeof value !== "string";
+}
+function workflowModelId(value) {
+  if (value === undefined)
+    return;
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    return trimmed.length === 0 ? undefined : trimmed;
+  }
+  return `${String(value.provider)}/${value.id}`;
+}
+function normalizeInfo(info) {
+  const fullId = info.fullId.trim().length > 0 ? info.fullId : `${info.provider}/${info.id}`;
+  return { ...info, fullId };
+}
+function uniqueByFullId(models) {
+  const seen = new Set;
+  const result = [];
+  for (const info of models.map(normalizeInfo)) {
+    if (seen.has(info.fullId))
+      continue;
+    seen.add(info.fullId);
+    result.push(info);
+  }
+  return result;
+}
+function resolveStringModel(rawInput, availableModels, preferredProvider) {
+  const input = rawInput.trim();
+  if (!input)
+    return { input: rawInput, reason: "empty model id" };
+  const { baseModel, level } = splitReasoningSuffix(input);
+  const candidate = (id, value) => makeCandidate(id, value, level);
+  if (availableModels === undefined) {
+    return candidate(baseModel, baseModel);
+  }
+  const models = uniqueByFullId(availableModels);
+  const explicit = models.find((model) => model.fullId === baseModel);
+  if (explicit !== undefined) {
+    return candidate(explicit.fullId, explicit.model ?? explicit.fullId);
+  }
+  if (baseModel.includes("/")) {
+    return candidate(baseModel, baseModel);
+  }
+  const byBareId = models.filter((model) => model.id === baseModel);
+  if (byBareId.length === 0) {
+    return { input, reason: "not available" };
+  }
+  if (byBareId.length === 1) {
+    const only = byBareId[0];
+    return candidate(only.fullId, only.model ?? only.fullId);
+  }
+  const preferred = preferredProvider === undefined ? undefined : byBareId.find((model) => model.provider === preferredProvider);
+  if (preferred !== undefined) {
+    return candidate(preferred.fullId, preferred.model ?? preferred.fullId);
+  }
+  return {
+    input,
+    reason: `ambiguous: ${byBareId.map((model) => model.fullId).join(", ")}; specify provider/model`
+  };
+}
+function resolveModelValue(value, availableModels, preferredProvider) {
+  if (isModelObject(value)) {
+    return { id: workflowModelId(value), value };
+  }
+  return resolveStringModel(value, availableModels, preferredProvider);
+}
+function isFailure(value) {
+  return "reason" in value;
+}
+function buildModelCandidates(input) {
+  const rawValues = [];
+  if (input.primaryModel !== undefined)
+    rawValues.push(input.primaryModel);
+  for (const [index, fallback] of (input.fallbackModels ?? []).entries()) {
+    const trimmedFallback = fallback.trim();
+    const split = splitReasoningSuffix(trimmedFallback);
+    const compatLevel = input.fallbackThinkingLevels?.[index];
+    if (split.level === undefined && compatLevel !== undefined) {
+      if (!WORKFLOW_THINKING_LEVEL_SET.has(compatLevel)) {
+        throw new WorkflowModelValidationError([
+          {
+            input: trimmedFallback,
+            reason: `invalid fallbackThinkingLevels[${index}] "${compatLevel}"; expected one of ${WORKFLOW_THINKING_LEVELS.join(", ")}`
+          }
+        ]);
+      }
+      rawValues.push(`${trimmedFallback}:${compatLevel}`);
+    } else {
+      rawValues.push(trimmedFallback);
+    }
+  }
+  if (input.currentModel !== undefined)
+    rawValues.push(input.currentModel);
+  const failures = [];
+  const seen = new Set;
+  const candidates = [];
+  for (const value of rawValues) {
+    const resolved = resolveModelValue(value, input.availableModels, input.preferredProvider);
+    if (isFailure(resolved)) {
+      failures.push(resolved);
+      continue;
+    }
+    const key2 = candidateKey(resolved);
+    if (seen.has(key2))
+      continue;
+    seen.add(key2);
+    candidates.push(resolved);
+  }
+  if (failures.length > 0)
+    throw new WorkflowModelValidationError(failures);
+  return candidates;
+}
+function catalogUnavailableWarning() {
+  return "workflows: model catalog unavailable; using the current selected model for fallback validation.";
+}
+async function buildModelCandidatesFromCatalog(input) {
+  const hasExplicitModel = input.primaryModel !== undefined || (input.fallbackModels?.length ?? 0) > 0;
+  if (!hasExplicitModel)
+    return [];
+  if (input.catalog === undefined) {
+    return buildModelCandidates({
+      primaryModel: input.primaryModel,
+      fallbackModels: input.fallbackModels,
+      fallbackThinkingLevels: input.fallbackThinkingLevels
+    });
+  }
+  try {
+    const availableModels = await input.catalog.listModels();
+    return buildModelCandidates({
+      primaryModel: input.primaryModel,
+      fallbackModels: input.fallbackModels,
+      fallbackThinkingLevels: input.fallbackThinkingLevels,
+      currentModel: input.catalog.currentModel,
+      availableModels,
+      preferredProvider: input.catalog.preferredProvider
+    });
+  } catch (err) {
+    if (input.catalog.currentModel === undefined) {
+      throw err;
+    }
+    input.catalog.recordWarning?.(catalogUnavailableWarning());
+    return buildModelCandidates({ currentModel: input.catalog.currentModel });
+  }
+}
+// dist/builtin/workflows/src/runs/shared/model-fallback-failures.ts
+import {
+  errorMessage as errorMessage2,
+  isRetryableModelFailure,
+  isRetryableSameModelFailure,
+  modelFailureMessage,
+  normalizeModelFailureSignal
+} from "@bastani/atomic";
 // dist/builtin/workflows/src/runs/foreground/stage-delivery-activity.ts
 class StageDeliveryActivity {
   listeners = new Set;
@@ -14356,6 +14742,15 @@ function lastAssistantTextFromMessages(messages) {
   }
   return;
 }
+function structuredOutputTurnDetail(messages, startIndex) {
+  for (let index = messages.length - 1;index >= Math.max(startIndex, 0); index -= 1) {
+    const message = messages[index];
+    if (message?.role !== "assistant")
+      continue;
+    return extractMessageText(message).trim().length > 0 ? "The model produced assistant text but never called structured_output" : "The model produced an assistant message with empty text";
+  }
+  return "The model produced no assistant message after the prompt";
+}
 function assistantArtifactTextForToolCall(messages, toolCallId2) {
   for (let index = messages.length - 1;index >= 0; index -= 1) {
     const message = messages[index];
@@ -15077,7 +15472,7 @@ function retrySettingsManagerFromError(error) {
   if (manager === null || typeof manager !== "object")
     return;
   const candidate = manager;
-  return typeof candidate.getCodexFastModeSettings === "function" ? candidate : undefined;
+  return typeof candidate.getRetrySettings === "function" ? candidate : undefined;
 }
 function retryableAgentSession(activeSession) {
   const session = asAgentSession(activeSession);
@@ -15126,6 +15521,7 @@ class StageSessionController {
   };
   terminatingToolCallIds = new Set;
   latestStructuredOutputToolErrorValue;
+  structuredOutputCycleAttemptMark;
   unsubscribeTerminateWatcher;
   unresolvedContextOverflowMessage;
   generationSealed = false;
@@ -15175,12 +15571,48 @@ class StageSessionController {
   get currentPromptStartIndex() {
     return this.lastPromptStartIndex;
   }
-  get latestStructuredOutputToolError() {
-    return this.latestStructuredOutputToolErrorValue;
-  }
   resetStructuredOutputToolError() {
     this.latestStructuredOutputToolErrorValue = undefined;
   }
+  beginStructuredOutputCandidateCycle() {
+    this.structuredOutputCycleAttemptMark = this.modelAttempts.length;
+  }
+  structuredOutputFailureReason() {
+    const toolError = this.latestStructuredOutputToolErrorValue;
+    if (toolError !== undefined)
+      return toolError;
+    const messages = this.session?.messages;
+    if (messages === undefined)
+      return STRUCTURED_OUTPUT_MISSING_ERROR;
+    return `${STRUCTURED_OUTPUT_MISSING_ERROR} ${structuredOutputTurnDetail(messages, this.lastPromptStartIndex ?? 0)}`;
+  }
+  async failCandidateForStructuredOutputExhaustion(error) {
+    const mark = this.structuredOutputCycleAttemptMark ?? 0;
+    this.structuredOutputCycleAttemptMark = undefined;
+    for (let attemptIndex = mark;attemptIndex < this.modelAttempts.length; attemptIndex += 1) {
+      const attempt = this.modelAttempts[attemptIndex];
+      if (attempt === undefined || !attempt.success)
+        continue;
+      this.modelAttempts[attemptIndex] = { ...attempt, success: false, error };
+    }
+    const candidates = this.hasExplicitModelFallbackConfig ? await this.modelCandidates() : [];
+    const index = this.activeCandidateIndex ?? 0;
+    const candidate = candidates[index];
+    const nextCandidate = candidates[index + 1];
+    if (this.opts.signal?.aborted || candidate === undefined || nextCandidate === undefined) {
+      this.modelWarnings.push(...this.pendingFallbackWarnings);
+      this.pendingFallbackWarnings.length = 0;
+      this.notifyModelFallbackMetaChange();
+      return false;
+    }
+    this.pendingFallbackWarnings.push(`[fallback] ${candidateLabel(candidate)} failed: ${error}. Retrying with ${candidateLabel(nextCandidate)}.`);
+    this.modelWarnings.push(...this.pendingFallbackWarnings);
+    this.pendingFallbackWarnings.length = 0;
+    await this.disposeCurrentSession();
+    this.activeCandidateIndex = index + 1;
+    this.notifyModelFallbackMetaChange();
+    return true;
+  }
   requireSession(property) {
     if (!this.session)
       unavailableSync(property);
@@ -15359,10 +15791,8 @@ class StageSessionController {
   currentModelFallbackMeta() {
     const attemptedModels = this.modelAttempts.map((attempt) => attempt.model);
     const model = this.selectedModel ?? workflowModelId(this.session?.model);
-    const fastMode = this.isWorkflowFastModeEnabled();
     return {
       ...model !== undefined ? { model } : {},
-      ...fastMode !== undefined ? { fastMode } : {},
       ...attemptedModels.length > 0 ? { attemptedModels } : {},
       ...this.modelAttempts.length > 0 ? { modelAttempts: [...this.modelAttempts] } : {},
       ...this.modelWarnings.length > 0 ? { warnings: [...this.modelWarnings] } : {}
@@ -15810,7 +16240,7 @@ class StageSessionController {
         const errorSettingsManager = retrySettingsManagerFromError(error);
         if (errorSettingsManager !== undefined)
           this.sessionSettingsManager = errorSettingsManager;
-        const decision = nextRetryDecision(this.retrySettings(), retryAttempt, isRetryableSameModelFailure(error));
+        const decision = isWorkflowPendingStageDeliveryFailure(error) ? undefined : nextRetryDecision(this.retrySettings(), retryAttempt, isRetryableSameModelFailure(error));
         if (decision === undefined || this.disposed || this.opts.signal?.aborted === true || this.capturedStructuredOutputForAttempt()) {
           throw error;
         }
@@ -15879,8 +16309,16 @@ class StageSessionController {
     const session = attachCreatedStageSession(created, this.disposed, this.opts.stageName, (result) => this.attachSession(result));
     const attachedSession = session instanceof Promise ? await session : session;
     const pendingStageDeliveryReady = this.sharedOrchestrationContext?.pendingStageDelivery?.ready();
-    if (pendingStageDeliveryReady !== undefined)
-      await pendingStageDeliveryReady;
+    if (pendingStageDeliveryReady !== undefined) {
+      try {
+        await pendingStageDeliveryReady;
+      } catch (error) {
+        if (this.session === attachedSession)
+          this.session = undefined;
+        await disposeStageSession(attachedSession).catch(() => {});
+        throw error;
+      }
+    }
     await this.opts.onSessionReady?.();
     return attachedSession;
   }
@@ -15894,12 +16332,12 @@ class StageSessionController {
       result.session.sealWorkflowStageGeneration?.();
     this.replacement.adopt(result.session);
     this.session = result.session;
+    this.sessionSettingsManager = result.settingsManager ?? result.session.settingsManager;
     if (this.sharedModelRuntime === undefined) {
       const withRegistry = result.session;
       if (withRegistry.modelRuntime !== undefined)
         this.sharedModelRuntime = withRegistry.modelRuntime;
     }
-    this.sessionSettingsManager = result.settingsManager ?? result.session.settingsManager;
     if (this.pendingThinkingLevel !== undefined)
       result.session.setThinkingLevel(this.pendingThinkingLevel);
     for (const listener of this.pendingListeners) {
@@ -16003,6 +16441,7 @@ class StageSessionController {
         });
         this.pendingFallbackWarnings.length = 0;
         this.resumeCurrentSession = true;
+        this.notifySuccessfulModelFallbackMeta();
         return true;
       }
       throw new WorkflowPromptModelFailure(terminalFailure);
@@ -16016,6 +16455,7 @@ class StageSessionController {
         });
         this.pendingFallbackWarnings.length = 0;
         this.resumeCurrentSession = true;
+        this.notifySuccessfulModelFallbackMeta();
         return true;
       }
       const message = errorMessage2(err);
@@ -16047,7 +16487,8 @@ class StageSessionController {
   }
   async handleCandidateFailure(err, candidate, candidates, index) {
     const message = errorMessage2(err);
-    if (this.capturedStructuredOutputForAttempt() && isRetryableModelFailure(err)) {
+    const terminalStageDelivery = isWorkflowPendingStageDeliveryFailure(err);
+    if (!terminalStageDelivery && this.capturedStructuredOutputForAttempt() && isRetryableModelFailure(err)) {
       this.recordSuccessfulAttempt(candidate);
       return "handled";
     }
@@ -16059,7 +16500,7 @@ class StageSessionController {
       ...usage === undefined ? {} : { usage },
       error: message
     });
-    if (this.opts.signal?.aborted || !isRetryableModelFailure(err) || index === candidates.length - 1) {
+    if (this.opts.signal?.aborted || terminalStageDelivery || !isRetryableModelFailure(err) || index === candidates.length - 1) {
       this.modelWarnings.push(...this.pendingFallbackWarnings);
       this.pendingFallbackWarnings.length = 0;
       this.notifyModelFallbackMetaChange();
@@ -16083,18 +16524,19 @@ class StageSessionController {
     });
     this.pendingFallbackWarnings.length = 0;
     this.resumeCurrentSession = true;
+    this.notifySuccessfulModelFallbackMeta();
   }
   notifyModelFallbackMetaChange() {
     this.opts.onModelFallbackMetaChange?.(this.currentModelFallbackMeta());
   }
+  notifySuccessfulModelFallbackMeta() {
+    if (this.disposed)
+      return;
+    this.notifyModelFallbackMetaChange();
+  }
   applyCandidateThinking(candidate) {
     this.pendingThinkingLevel = candidate === undefined ? this.effectiveStageOptions?.thinkingLevel : effectiveCandidateReasoning(candidate, this.effectiveStageOptions?.thinkingLevel);
   }
-  isWorkflowFastModeEnabled() {
-    const model = this.session?.model;
-    const settingsManager = this.sessionSettingsManager ?? this.effectiveStageOptions?.settingsManager;
-    return model === undefined || settingsManager === undefined ? undefined : shouldApplyCodexFastModeForScope(model, settingsManager.getCodexFastModeSettings(), "workflow");
-  }
   throwUnresolvedContextOverflowIfPresent() {
     const message = this.unresolvedContextOverflowMessage;
     this.unresolvedContextOverflowMessage = undefined;
@@ -16371,20 +16813,27 @@ function createStageContext2(opts) {
         return lastAssistantText;
       }
       if (structuredOutputCapture) {
-        let nextPrompt = promptText;
-        let correctiveAttempts = 0;
         let structuredOutputError = STRUCTURED_OUTPUT_MISSING_ERROR;
         while (!structuredOutputCapture.called) {
-          controller.resetStructuredOutputToolError();
-          await controller.promptWithFallback(nextPrompt, sdkOptions);
+          let nextPrompt = promptText;
+          let correctiveAttempts = 0;
+          controller.beginStructuredOutputCandidateCycle();
+          while (!structuredOutputCapture.called) {
+            controller.resetStructuredOutputToolError();
+            await controller.promptWithFallback(nextPrompt, sdkOptions);
+            if (structuredOutputCapture.called)
+              break;
+            structuredOutputError = controller.structuredOutputFailureReason();
+            if (correctiveAttempts >= STRUCTURED_OUTPUT_MAX_CORRECTIVE_PROMPTS)
+              break;
+            correctiveAttempts += 1;
+            nextPrompt = formatStructuredOutputCorrectionPrompt(structuredOutputError, correctiveAttempts, hasOutputArtifact);
+          }
           if (structuredOutputCapture.called)
             break;
-          structuredOutputError = controller.latestStructuredOutputToolError ?? STRUCTURED_OUTPUT_MISSING_ERROR;
-          if (correctiveAttempts >= STRUCTURED_OUTPUT_MAX_CORRECTIVE_PROMPTS) {
+          if (!await controller.failCandidateForStructuredOutputExhaustion(structuredOutputError)) {
             throw new Error(structuredOutputError);
           }
-          correctiveAttempts += 1;
-          nextPrompt = formatStructuredOutputCorrectionPrompt(structuredOutputError, correctiveAttempts, hasOutputArtifact);
         }
         const sessionMessages = controller.currentSession?.messages;
         const executionSnapshot = structuredOutputExecutionCapture?.snapshot;
@@ -16610,9 +17059,9 @@ function createStageSessionHeartbeat(checkpoint, intervalMs = STAGE_SESSION_HEAR
 
 // dist/builtin/workflows/src/runs/foreground/executor-stage-factory.ts
 function createWorkflowStageFactory(input) {
-  return (name, options, stageFailFastScope) => {
+  return (name, options, stageFailFastScope, prepareLiveOptions) => {
     input.exit.throwIfWorkflowExitSelected();
-    options = stageOptionsWithGitWorktree(stageOptionsWithInputDefaults(options, input.inputRuntimeDefaults), input.workflowInvocationCwd, input.gitWorktreeSetupCache);
+    options = stageOptionsWithInputDefaults(options, input.inputRuntimeDefaults);
     const stageId = options?.durableStageId ?? crypto.randomUUID();
     const provisionalParentIds = input.tracker.onSpawn(stageId, name);
     const scopedParentIds = options?.durableParentIds ?? (input.opts.continuation === undefined ? stageFailFastScope?.parentIds : undefined);
@@ -16634,6 +17083,10 @@ function createWorkflowStageFactory(input) {
     const replaySource = replayDecision.kind === "replay" ? replayDecision.source : undefined;
     const executeReplaySource = replayDecision.kind === "execute" ? replayDecision.source : undefined;
     const shouldReplay = replaySource !== undefined;
+    if (!shouldReplay) {
+      input.assertLiveWorkAllowed?.();
+      options = stageOptionsWithGitWorktree(prepareLiveOptions?.() ?? options, input.workflowInvocationCwd, input.gitWorktreeSetupCache);
+    }
     const replayStageOptions = executeReplaySource?.sessionFile === undefined ? options : {
       ...options ?? {},
       context: options?.context ?? "fork",
@@ -16682,12 +17135,6 @@ function createWorkflowStageFactory(input) {
     const applyModelFallbackMeta = (meta2) => {
       if (meta2.model !== undefined)
         stageSnapshot.model = meta2.model;
-      if (meta2.fastMode !== undefined) {
-        if (meta2.fastMode)
-          stageSnapshot.fastMode = true;
-        else
-          delete stageSnapshot.fastMode;
-      }
       if (meta2.attemptedModels !== undefined)
         stageSnapshot.attemptedModels = meta2.attemptedModels;
       if (meta2.modelAttempts !== undefined)
@@ -17011,6 +17458,7 @@ class EngineRuntime {
   rootBudget;
   gitWorktreeSetupCache;
   worktreeSymlinkDirectories;
+  assertLiveWorkAllowed;
   terminalArtifactCollectors = new Map;
   spawnAgentStage;
   spawnWorkflowBoundary;
@@ -17031,6 +17479,7 @@ class EngineRuntime {
     this.rootBudget = input.rootBudget;
     this.gitWorktreeSetupCache = input.gitWorktreeSetupCache;
     this.worktreeSymlinkDirectories = input.worktreeSymlinkDirectories;
+    this.assertLiveWorkAllowed = input.assertLiveWorkAllowed;
     this.spawnAgentStage = createWorkflowStageFactory({
       runId: input.runId,
       workflowIntercomGroup: this.workflowIntercomGroup,
@@ -17049,6 +17498,7 @@ class EngineRuntime {
       budget: input.budget,
       exit: input.exit,
       classifyExecutorFailure: input.classifyExecutorFailure,
+      assertLiveWorkAllowed: input.assertLiveWorkAllowed,
       createMcpScope: (stageId, options) => this.createMcpScope(stageId, options),
       takeTerminalArtifacts: (replayKey) => this.takeTerminalArtifacts(replayKey)
     });
@@ -17071,7 +17521,10 @@ class EngineRuntime {
         boundary: this.spawnWorkflowBoundary(name, opts.replayKey, opts.identity)
       };
     }
-    return { kind: "agent", context: this.spawnAgentStage(name, opts.options, opts.failFastScope) };
+    return {
+      kind: "agent",
+      context: this.spawnAgentStage(name, opts.options, opts.failFastScope, opts.prepareLiveOptions)
+    };
   }
   registerTerminalArtifactCollector(replayKey, collect) {
     this.terminalArtifactCollectors.set(replayKey, collect);
@@ -17201,6 +17654,9 @@ async function run(def, inputs, opts = {}) {
   const continuedBudgetState = opts.continuation?.source.budgetState ?? priorRun?.budgetState ?? (durableAccounting === undefined ? undefined : { accounting: durableAccounting });
   const sameBudget = budgetSnapshot !== undefined && continuedBudget?.warnAtPercent === budgetSnapshot.warnAtPercent && ["maxDurationMs", "maxTokens", "maxCost"].every((field2) => (continuedBudget?.[field2] ?? 0) === (budgetSnapshot[field2] ?? 0));
   const continuationBudgetState = continuedBudgetState === undefined || !sameBudget && continuedBudgetState.accounting === undefined ? undefined : sameBudget ? continuedBudgetState : { accounting: continuedBudgetState.accounting };
+  const continuationSourceRunId = opts.continuation?.source.id;
+  const persistedPossibleStages = coercePossibleStages(opts.possibleStages) ?? (continuationSourceRunId !== undefined ? coercePossibleStages(rootBackend.getWorkflow(continuationSourceRunId)?.possibleStages) : undefined);
+  const runPossibleStages = persistedPossibleStages ?? coercePossibleStages(rootBackend.getWorkflow(runId)?.possibleStages) ?? [];
   const runSnapshot = {
     id: runId,
     name: def.name,
@@ -17211,6 +17667,7 @@ async function run(def, inputs, opts = {}) {
     pendingStageMessages: [
       ...pendingStageMessagesForDurableRun(rootBackend, runId, opts.parentRun?.rootRunId ?? runId)
     ],
+    ...opts.parentRun === undefined ? { possibleStages: runPossibleStages } : {},
     startedAt: Date.now(),
     ...opts.parentRun !== undefined ? {
       parentRunId: opts.parentRun.runId,
@@ -17324,7 +17781,8 @@ async function run(def, inputs, opts = {}) {
     activeStore,
     opts,
     classifyExecutorFailure,
-    drainWorkflowExitCleanups: exit.drainWorkflowExitCleanups
+    drainWorkflowExitCleanups: exit.drainWorkflowExitCleanups,
+    assertSuccessfulCompletion: () => assertFrontierConsumed()
   });
   const checkpointIdGenerator = createCheckpointIdGenerator();
   const stageReplayKeyGenerator = createStageReplayKeyGenerator(runId);
@@ -17421,6 +17879,7 @@ async function run(def, inputs, opts = {}) {
     worktreeSymlinkDirectories: opts.config?.worktree?.symlinkDirectories,
     exit,
     classifyExecutorFailure,
+    assertLiveWorkAllowed: () => assertFrontierConsumed(),
     rootBudget,
     budget
   });
@@ -17460,9 +17919,10 @@ async function run(def, inputs, opts = {}) {
     createdAt: runSnapshot.startedAt,
     hasPersistence: opts.persistence !== undefined,
     isChildRun: opts.parentRun !== undefined,
-    continuationSourceId: opts.continuation?.source.id
+    continuationSourceId: opts.continuation?.source.id,
+    ...persistedPossibleStages === undefined ? {} : { possibleStages: persistedPossibleStages }
   });
-  const { tool, admittedTools, abandonInFlightAsCancelled, observedQuitCancellation } = createTrackedToolPrimitive({
+  const { tool, admittedTools, assertFrontierConsumed, abandonInFlightAsCancelled, observedQuitCancellation } = createTrackedToolPrimitive({
     workflowId: runId,
     ...opts.continuation === undefined ? {} : { checkpointSourceWorkflowId: opts.continuation.source.id },
     backend: durableBackend,
@@ -17473,6 +17933,7 @@ async function run(def, inputs, opts = {}) {
     tracker,
     run: runSnapshot,
     sourceToContinuationNodeIds,
+    resumeToolNode: opts.continuation?.source.toolNodes?.find((node) => node.id === opts.continuation?.resumeFromToolNodeId),
     toolControls,
     toolAdmission,
     budget
@@ -17656,6 +18117,8 @@ async function run(def, inputs, opts = {}) {
     assertWorkflowCreatedExecution(runSnapshot);
     await durableBackend.flush(runId);
     const returned = classifyReturnedRunStatus(result, runSnapshot);
+    if (returned.status === "completed")
+      assertFrontierConsumed();
     const recorded = activeStore.recordRunEnd(runId, returned.status, result, returned.error, returned.metadata);
     appendRunEndWhenRecorded(opts.persistence, recorded, {
       runId,
@@ -17717,7 +18180,7 @@ async function run(def, inputs, opts = {}) {
       stages: runSnapshot.stages,
       classifyFailure: classifyExecutorFailure
     }), runSnapshot.stages.length));
-    const failedToolNodeId = selectedMetadata2.failedStageId === undefined && selectedMetadata2.failureKind !== "cancelled" && selectedMetadata2.failureDisposition !== "terminal_killed" ? catchTerminalEvent?.kind === "failure" && Object.is(catchTerminalEvent.error, err) ? catchTerminalEvent.nodeId ?? observedAdmittedToolFailure?.nodeId : observedAdmittedToolFailure?.nodeId : undefined;
+    const failedToolNodeId = selectedMetadata2.failedStageId === undefined && selectedMetadata2.failureDisposition !== "terminal_killed" ? catchTerminalEvent?.kind === "failure" && Object.is(catchTerminalEvent.error, err) ? catchTerminalEvent.nodeId ?? observedAdmittedToolFailure?.nodeId : observedAdmittedToolFailure?.nodeId : undefined;
     const metadata = failedToolNodeId === undefined ? selectedMetadata2 : { ...selectedMetadata2, failedToolNodeId };
     if (metadata.failureDisposition === "terminal_killed") {
       for (const failedStageId of metadata.failedStageIds)