@bastani/atomic 0.9.12 → 0.9.13-alpha.1

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

@@ -36157,6 +36157,10 @@ function topLevelWorkflowRuns(runs) {
 function nonNegative(ms) {
   return Math.max(0, ms);
 }
+function nextControlTimestamp(requestedAt, previousAt) {
+  const candidate = requestedAt ?? Date.now();
+  return previousAt === undefined || candidate > previousAt ? candidate : previousAt + 1;
+}
 function rebasedStageStartedAt(accumulatedDurationMs, resumedAt) {
   return resumedAt - nonNegative(accumulatedDurationMs ?? 0);
 }
@@ -36333,38 +36337,65 @@ function createRunStoreMethods(context) {
       if (TERMINAL_STATUSES.has(run.status))
         return false;
       const wasPaused = run.status === "paused";
-      const enteringQuit = metadata?.exitReason === "quit" && run.exitReason !== "quit";
       if (!wasPaused) {
         run.status = "paused";
-        run.pausedAt = pausedAt ?? Date.now();
+        run.pausedAt = nextControlTimestamp(pausedAt, run.resumedAt);
         run.resumedAt = undefined;
+        delete run.pauseActor;
+        delete run.resumeActor;
+        delete run.resumeSource;
       }
       if (metadata?.resumable !== undefined)
         run.resumable = metadata.resumable;
       if (metadata?.exitReason !== undefined)
         run.exitReason = metadata.exitReason;
-      if (enteringQuit)
-        run.quitAt = Date.now();
+      if (metadata?.exitReason === "quit" && run.quitAt === undefined)
+        run.quitAt = nextControlTimestamp(undefined, run.pausedAt);
+      if (metadata?.actor !== undefined)
+        run.pauseActor = metadata.actor;
       if (wasPaused && metadata === undefined)
         return false;
       context.bumpAndNotify();
       return true;
     },
-    recordRunResumed(runId, resumedAt) {
+    recordRunResumed(runId, resumedAt, metadata) {
       const run = context.findRun(runId);
       if (!run)
         return false;
       if (TERMINAL_STATUSES.has(run.status))
         return false;
-      if (run.status !== "paused")
+      const claimsRunControl = metadata?.source === "run_control";
+      if (run.status !== "paused") {
+        if (!claimsRunControl || run.status !== "running" || run.resumedAt === undefined)
+          return false;
+        if (run.resumeSource === "run_control" && run.resumeActor === metadata?.actor)
+          return false;
+        run.resumeSource = "run_control";
+        if (metadata?.actor === undefined)
+          delete run.resumeActor;
+        else
+          run.resumeActor = metadata.actor;
+        context.bumpAndNotify();
         return false;
-      const resumedTs = resumedAt ?? Date.now();
+      }
+      const resumedTs = nextControlTimestamp(resumedAt, run.pausedAt);
       run.status = "running";
       run.pausedDurationMs = accumulatePausedDurationMs(run.pausedDurationMs, run.pausedAt, resumedTs);
       run.resumedAt = resumedTs;
       run.pausedAt = undefined;
       delete run.quitAt;
       delete run.exitReason;
+      delete run.pauseActor;
+      if (metadata === undefined) {
+        delete run.resumeActor;
+        delete run.resumeSource;
+      } else {
+        run.resumeSource = metadata.source;
+        if (metadata.actor === undefined)
+          delete run.resumeActor;
+        else
+          run.resumeActor = metadata.actor;
+      }
       context.bumpAndNotify();
       return true;
     },
@@ -36717,7 +36748,7 @@ function createStageStoreMethods(context) {
       context.bumpAndNotify();
       return true;
     },
-    recordStagePaused(runId, stageId, pausedAt) {
+    recordStagePaused(runId, stageId, pausedAt, metadata) {
       const run = context.findRun(runId);
       if (!run)
         return false;
@@ -36726,16 +36757,28 @@ function createStageStoreMethods(context) {
       const stage = context.findStage(run, stageId);
       if (!stage)
         return false;
-      if (cannotPause(stage.status))
+      if (cannotPause(stage.status)) {
+        if (stage.status !== "paused" || metadata?.actor === undefined)
+          return false;
+        if (stage.pauseActor === metadata.actor)
+          return false;
+        stage.pauseActor = metadata.actor;
+        context.bumpAndNotify();
         return false;
+      }
       stage.status = "paused";
-      stage.pausedAt = pausedAt ?? Date.now();
+      stage.pausedAt = nextControlTimestamp(pausedAt, stage.resumedAt);
       stage.resumedAt = undefined;
       delete stage.awaitingInputSince;
+      delete stage.resumeActor;
+      if (metadata?.actor === undefined)
+        delete stage.pauseActor;
+      else
+        stage.pauseActor = metadata.actor;
       context.bumpAndNotify();
       return true;
     },
-    recordStageResumed(runId, stageId, resumedAt) {
+    recordStageResumed(runId, stageId, resumedAt, metadata) {
       const run = context.findRun(runId);
       if (!run)
         return false;
@@ -36744,9 +36787,17 @@ function createStageStoreMethods(context) {
       const stage = context.findStage(run, stageId);
       if (!stage)
         return false;
-      if (stage.status !== "paused" && stage.status !== "blocked")
+      if (stage.status !== "paused" && stage.status !== "blocked") {
+        if (stage.status !== "running" || stage.resumedAt === undefined || metadata?.actor === undefined) {
+          return false;
+        }
+        if (stage.resumeActor === metadata.actor)
+          return false;
+        stage.resumeActor = metadata.actor;
+        context.bumpAndNotify();
         return false;
-      const resumedTs = resumedAt ?? Date.now();
+      }
+      const resumedTs = nextControlTimestamp(resumedAt, stage.pausedAt);
       stage.status = "running";
       if (stage.startedAt !== undefined) {
         stage.pausedDurationMs = accumulatePausedDurationMs(stage.pausedDurationMs, stage.pausedAt, resumedTs);
@@ -36755,6 +36806,11 @@ function createStageStoreMethods(context) {
       stage.pausedAt = undefined;
       delete stage.blockedByStageId;
       delete stage.awaitingInputSince;
+      delete stage.pauseActor;
+      if (metadata?.actor === undefined)
+        delete stage.resumeActor;
+      else
+        stage.resumeActor = metadata.actor;
       context.bumpAndNotify();
       return true;
     }
@@ -37724,6 +37780,51 @@ function stringResultField(result, key) {
   return typeof value2 === "string" && value2.trim().length > 0 ? value2.trim() : undefined;
 }
 
+// dist/builtin/workflows/src/shared/run-indicator-status.ts
+var TERMINAL_OR_BLOCKED = new Set(["completed", "failed", "killed", "cancelled", "skipped", "blocked"]);
+function runIndicatorStatus(run, allRuns = [run]) {
+  const status = effectiveRunStatus(run);
+  if (TERMINAL_OR_BLOCKED.has(status))
+    return status;
+  if (runHasPendingInput(run))
+    return "awaiting_input";
+  const runsById = new Map(allRuns.map((candidate) => [candidate.id, candidate]));
+  for (const candidate of allRuns) {
+    if (candidate.id === run.id || !runBelongsTo(candidate, run, runsById))
+      continue;
+    const candidateStatus = effectiveRunStatus(candidate);
+    if (!TERMINAL_OR_BLOCKED.has(candidateStatus) && runHasPendingInput(candidate))
+      return "awaiting_input";
+  }
+  return status;
+}
+function resolveRunIndicatorStatuses(runs, allRuns) {
+  const statuses = {};
+  for (const run of runs)
+    statuses[run.id] = runIndicatorStatus(run, allRuns);
+  return statuses;
+}
+function runHasPendingInput(run) {
+  if (run.pendingPrompt !== undefined)
+    return true;
+  return run.stages.some((stage) => stage.status === "awaiting_input" || stage.awaitingInputSince !== undefined || stage.pendingPrompt !== undefined || stage.inputRequest !== undefined);
+}
+function runBelongsTo(candidate, ancestor, runsById) {
+  if (candidate.rootRunId === ancestor.id)
+    return true;
+  const visited = new Set;
+  let current = candidate;
+  while (current !== undefined && current.parentRunId !== undefined) {
+    if (current.parentRunId === ancestor.id)
+      return true;
+    if (visited.has(current.id))
+      return false;
+    visited.add(current.id);
+    current = runsById.get(current.parentRunId);
+  }
+  return false;
+}
+
 // dist/builtin/workflows/src/tui/status-list.ts
 var STAGE_LABEL_BUDGET = 24;
 function isQuitRun(run) {
@@ -37744,7 +37845,7 @@ function renderStatusList(runs, opts = {}) {
     for (let i = 0;i < sorted.length; i++) {
       if (i > 0)
         body.push("");
-      body.push(...renderRunEntry(sorted[i], now, cardWidth, opts.theme));
+      body.push(...renderRunEntry(sorted[i], now, cardWidth, opts.theme, opts.allRuns ?? runs, opts.indicatorStatuses));
     }
   }
   if (opts.showDetailHint !== false && sorted.length > 0) {
@@ -37759,11 +37860,12 @@ function renderStatusList(runs, opts = {}) {
     width
   });
 }
-function renderRunEntry(run, now, width, theme) {
+function renderRunEntry(run, now, width, theme, allRuns, indicatorStatuses) {
   const bodyWidth = effectiveWidth2(width);
   const interior = Math.max(8, bodyWidth - 4);
-  const glyph = statusIconForRun(run);
-  const glyphFg = theme ? hexToAnsi(runAccent(run, theme)) : "";
+  const indicatorStatus = indicatorStatuses?.[run.id] ?? runIndicatorStatus(run, allRuns);
+  const glyph = statusIconForRun(run, indicatorStatus);
+  const glyphFg = theme ? hexToAnsi(runAccent(run, theme, indicatorStatus)) : "";
   const accent = theme ? hexToAnsi(theme.accent) : "";
   const text = theme ? hexToAnsi(theme.text) : "";
   const muted = theme ? hexToAnsi(theme.textMuted) : "";
@@ -37799,31 +37901,12 @@ function renderRunEntry(run, now, width, theme) {
   const metaLine = `   ${modeSeg}    ${strip}${" ".repeat(gap)}${metaSeg} `;
   return [...identityRows, identity, metaLine];
 }
-function runAccent(run, theme) {
+function runAccent(run, theme, indicatorStatus) {
   if (!theme)
     return "#000000";
   if (isQuitRun(run))
     return theme.warning;
-  switch (effectiveRunStatus(run)) {
-    case "completed":
-      return theme.success;
-    case "running":
-      return theme.warning;
-    case "paused":
-      return theme.warning;
-    case "skipped":
-      return theme.dim;
-    case "cancelled":
-      return theme.dim;
-    case "blocked":
-      return theme.dim;
-    case "failed":
-      return theme.error;
-    case "killed":
-      return theme.error;
-    default:
-      return theme.dim;
-  }
+  return statusColor(indicatorStatus, theme);
 }
 function runTrailing(run, theme) {
   if (isQuitRun(run))
@@ -38074,28 +38157,10 @@ function emptyStateLine(theme) {
     return "  no workflow runs in current session";
   return `  ${hexToAnsi(theme.dim)}no workflow runs in current session${RESET}`;
 }
-function statusIconForRun(run) {
+function statusIconForRun(run, indicatorStatus) {
   if (isQuitRun(run))
-    return "○";
-  switch (effectiveRunStatus(run)) {
-    case "completed":
-      return "✓";
-    case "skipped":
-    case "cancelled":
-      return "⊘";
-    case "blocked":
-      return "↑";
-    case "running":
-      return "●";
-    case "paused":
-      return "❚❚";
-    case "failed":
-      return "✗";
-    case "killed":
-      return "⊘";
-    default:
-      return "○";
-  }
+    return statusIcon("pending");
+  return statusIcon(indicatorStatus);
 }
 
 // dist/builtin/workflows/src/tui/workflow-list.ts
@@ -38235,7 +38300,12 @@ function renderChatSurfacePlainText(payload, options = {}) {
 `);
     }
     case "status": {
-      const rendered = renderStatusList(payload.runs, { width, now, ...themed });
+      const rendered = renderStatusList(payload.runs, {
+        width,
+        now,
+        ...themed,
+        indicatorStatuses: payload.indicatorStatuses
+      });
       if (payload.runs.length === 0)
         return rendered;
       return [
@@ -38325,7 +38395,12 @@ function renderPayload(payload, theme, width, now) {
         width
       });
     case "status":
-      return renderStatusList(payload.runs, { theme, width, now });
+      return renderStatusList(payload.runs, {
+        theme,
+        width,
+        now,
+        indicatorStatuses: payload.indicatorStatuses
+      });
     case "list":
       return renderWorkflowList(payload.entries, { theme, width });
     case "detail":
@@ -46389,13 +46464,8 @@ function quitExpiryTimestamp(run) {
 function recentlyQuit(run, now) {
   return isQuitRun2(run) && now - quitExpiryTimestamp(run) <= RECENT_ENDED_WINDOW_MS;
 }
-function runAwaitsInput(run) {
-  return run.endedAt === undefined && (run.pendingPrompt !== undefined || run.stages.some((s) => s.status === "awaiting_input"));
-}
 function subtreeAwaitsInput(root, allRuns) {
-  if (runAwaitsInput(root))
-    return true;
-  return allRuns.some((run) => run.rootRunId === root.id && runAwaitsInput(run));
+  return runIndicatorStatus(root, allRuns) === "awaiting_input";
 }
 function countRuns(runs, allRuns = runs) {
   const counts = { active: 0, paused: 0, quit: 0, done: 0, blocked: 0, failed: 0, awaiting: 0 };
@@ -46413,7 +46483,7 @@ function countRuns(runs, allRuns = runs) {
       counts.done++;
     else if (status === "failed" || status === "killed")
       counts.failed++;
-    if (r.endedAt === undefined && subtreeAwaitsInput(r, allRuns))
+    if (r.endedAt === undefined && !isQuitRun2(r) && subtreeAwaitsInput(r, allRuns))
       counts.awaiting++;
   }
   return counts;
@@ -46445,32 +46515,17 @@ function selectDisplayRuns(snap, now) {
   const sort = (xs) => [...xs].sort((a, b) => (b.startedAt ?? 0) - (a.startedAt ?? 0));
   return [...sort(active), ...sort(recent)];
 }
-function statusGlyph(run) {
+function statusGlyph(run, allRuns) {
   if (isQuitRun2(run))
-    return "○";
-  switch (effectiveRunStatus(run)) {
-    case "running":
-      return "●";
-    case "paused":
-      return "❚❚";
-    case "completed":
-      return "✓";
-    case "skipped":
-    case "cancelled":
-      return "⊘";
-    case "blocked":
-      return "↑";
-    case "failed":
-      return "✗";
-    case "killed":
-      return "⊘";
-    default:
-      return "○";
-  }
+    return statusIcon("pending");
+  return statusIcon(runIndicatorStatus(run, allRuns));
 }
-function statusFg(run, theme) {
+function statusFg(run, theme, allRuns) {
   if (isQuitRun2(run))
     return theme.warning;
+  const indicatorStatus = runIndicatorStatus(run, allRuns);
+  if (indicatorStatus === "awaiting_input")
+    return statusColor(indicatorStatus, theme);
   switch (effectiveRunStatus(run)) {
     case "running":
     case "paused":
@@ -46568,25 +46623,25 @@ function formatTitleBadges(badges, theme, themed) {
   const fallbackFg = hexToAnsi(theme.border);
   return badges.map((b) => `${b.fg ? hexToAnsi(b.fg) : fallbackFg}${b.text}${RESET}${fallbackFg}`).join("  ");
 }
-function themedRunLines(run, now, theme) {
+function themedRunLines(run, now, theme, allRuns) {
   const meta = metaLine(run, now);
   const metaColor = effectiveRunStatus(run) === "running" ? theme.textMuted : theme.dim;
   return renderRunIdentityRows({
     runId: run.id,
     name: run.name,
     meta,
-    glyph: statusGlyph(run),
-    glyphColor: statusFg(run, theme),
+    glyph: statusGlyph(run, allRuns),
+    glyphColor: statusFg(run, theme, allRuns),
     metaColor,
     theme
   });
 }
-function plainRunLines(run, now) {
+function plainRunLines(run, now, allRuns) {
   return renderRunIdentityRows({
     runId: run.id,
     name: run.name,
     meta: metaLine(run, now),
-    glyph: statusGlyph(run)
+    glyph: statusGlyph(run, allRuns)
   });
 }
 function themedCollapsed(counts, theme) {
@@ -46635,7 +46690,7 @@ function buildThemedWidgetLines(snap, piTheme, width = 120, now = Date.now()) {
   const body = [];
   for (let i = 0;i < display.length; i++) {
     const run = display[i];
-    const runLines = themed ? themedRunLines(run, now, graphTheme) : plainRunLines(run, now);
+    const runLines = themed ? themedRunLines(run, now, graphTheme, snap.runs) : plainRunLines(run, now, snap.runs);
     body.push(...runLines);
     if (i < display.length - 1)
       body.push("");
@@ -46659,6 +46714,13 @@ var STALE_CONTEXT = "This extension ctx is stale";
 function isStale(err) {
   return err instanceof Error && err.message.includes(STALE_CONTEXT);
 }
+function liveWidgetSnapshot(storeInstance) {
+  return {
+    runs: storeInstance.runs(),
+    notices: storeInstance.notices(),
+    version: 0
+  };
+}
 function installStoreWidget(pi, storeInstance, timers = defaultTimerApi) {
   const ui = pi.ui;
   if (!ui?.setWidget)
@@ -46672,7 +46734,7 @@ function installStoreWidget(pi, storeInstance, timers = defaultTimerApi) {
     key: WIDGET_KEY,
     placement: "belowEditor",
     timers,
-    getSnapshot: () => readGraphStoreSnapshot(storeInstance),
+    getSnapshot: () => liveWidgetSnapshot(storeInstance),
     subscribe: (listener) => subscribeStoreInvalidation(storeInstance, listener),
     getPreviewLines: (snap, now) => buildThemedWidgetLines(snap, undefined, 120, now),
     render: (snap, { theme, width, now }) => buildThemedWidgetLines(snap, theme, width, now),
@@ -47745,6 +47807,7 @@ class InMemoryDurableBackend {
       createdAt: handle.createdAt,
       status: handle.status,
       ...handle.invocationCwd !== undefined ? { invocationCwd: handle.invocationCwd } : existing?.handle.invocationCwd !== undefined ? { invocationCwd: existing.handle.invocationCwd } : {},
+      ...handle.origin !== undefined ? { origin: handle.origin } : existing?.handle.origin !== undefined ? { origin: existing.handle.origin } : {},
       ...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 } : {},
@@ -47959,6 +48022,7 @@ class InMemoryDurableBackend {
       ...h.resumable !== undefined ? { resumable: h.resumable } : {},
       ...workflowFailureFields(h),
       ...h.invocationCwd !== undefined ? { invocationCwd: h.invocationCwd } : {},
+      ...h.origin !== undefined ? { origin: h.origin } : {},
       ...h.workflowCwd !== undefined ? { workflowCwd: h.workflowCwd } : {},
       ...h.repositoryRoot !== undefined ? { repositoryRoot: h.repositoryRoot } : {},
       ...h.gitWorktreeRoot !== undefined ? { gitWorktreeRoot: h.gitWorktreeRoot } : {},
@@ -48026,6 +48090,7 @@ function toResumableEntry(handle) {
     ...handle.resumable !== undefined ? { resumable: handle.resumable } : {},
     ...workflowFailureFields(handle),
     ...handle.invocationCwd !== undefined ? { invocationCwd: handle.invocationCwd } : {},
+    ...handle.origin !== undefined ? { origin: handle.origin } : {},
     ...handle.workflowCwd !== undefined ? { workflowCwd: handle.workflowCwd } : {},
     ...handle.repositoryRoot !== undefined ? { repositoryRoot: handle.repositoryRoot } : {},
     ...handle.gitWorktreeRoot !== undefined ? { gitWorktreeRoot: handle.gitWorktreeRoot } : {},
@@ -49235,6 +49300,7 @@ function encodeMetadata(metadata) {
       ...metadata.failureRecoverability !== undefined ? { failureRecoverability: metadata.failureRecoverability } : {},
       ...metadata.failureDisposition !== undefined ? { failureDisposition: metadata.failureDisposition } : {},
       ...metadata.failedToolNodeId !== undefined ? { failedToolNodeId: metadata.failedToolNodeId } : {},
+      ...metadata.origin !== undefined ? { origin: metadata.origin } : {},
       ...metadata.invocationCwd !== undefined ? { invocationCwd: metadata.invocationCwd } : {},
       ...metadata.workflowCwd !== undefined ? { workflowCwd: metadata.workflowCwd } : {},
       ...metadata.repositoryRoot !== undefined ? { repositoryRoot: metadata.repositoryRoot } : {},
@@ -49280,7 +49346,14 @@ function parseDurableWorkflowMetadata(value2, workflowId) {
   const metadata = value2;
   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.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;
-  return metadata;
+  const { origin, ...metadataWithoutOrigin } = metadata;
+  return {
+    ...metadataWithoutOrigin,
+    ...isWorkflowActor(origin) ? { origin } : {}
+  };
+}
+function isWorkflowActor(value2) {
+  return value2 === "user" || value2 === "agent";
 }
 function isDurableWorkflowStatus(value2) {
   return value2 === "running" || value2 === "paused" || value2 === "completed" || value2 === "failed" || value2 === "cancelled" || value2 === "blocked";
@@ -51041,7 +51114,7 @@ async function quitRun(runId, opts) {
     return { ok: false, runId, reason: "already_ended" };
   const suspendedByAbort = toolHandles.length > 0;
   const publish = (resumable) => {
-    publishLocalQuit(activeStore, runId, pausedRunIds, resumable);
+    publishLocalQuit(activeStore, runId, pausedRunIds, resumable, opts?.actor);
     if (abandonedTools.length > 0)
       jobs.detach(runId, jobs.get(runId));
   };
@@ -51062,10 +51135,17 @@ async function quitRun(runId, opts) {
   publish(true);
   return { ok: true, runId, paused, cancelledTools, abandonedTools };
 }
-function publishLocalQuit(activeStore, runId, pausedRunIds, resumable) {
-  for (const pausedRunId of pausedRunIds)
+function publishLocalQuit(activeStore, runId, pausedRunIds, resumable, actor) {
+  for (const pausedRunId of pausedRunIds) {
+    if (pausedRunId === runId)
+      continue;
     activeStore.recordRunPaused(pausedRunId);
-  activeStore.recordRunPaused(runId, undefined, { exitReason: "quit", resumable });
+  }
+  activeStore.recordRunPaused(runId, undefined, {
+    exitReason: "quit",
+    resumable,
+    ...actor === undefined ? {} : { actor }
+  });
 }
 function unrecordedDurableQuitMessage(error) {
   const detail = error instanceof Error ? error.message : String(error);
@@ -51148,7 +51228,8 @@ async function quitAllRuns(opts) {
     store: activeStore,
     stageControlRegistry: opts?.stageControlRegistry,
     toolControlRegistry: opts?.toolControlRegistry,
-    jobs: opts?.jobs
+    jobs: opts?.jobs,
+    ...opts?.actor === undefined ? {} : { actor: opts.actor }
   }));
   const settled = await Promise.allSettled(attempts);
   return settled.map((result, index) => {
@@ -51202,6 +51283,7 @@ function appendRunStart(api, payload) {
     ...payload.parentStageId !== undefined ? { parentStageId: payload.parentStageId } : {},
     ...payload.rootRunId !== undefined ? { rootRunId: payload.rootRunId } : {},
     ...payload.resumedFromRunId !== undefined ? { resumedFromRunId: payload.resumedFromRunId } : {},
+    ...payload.origin !== undefined ? { origin: payload.origin } : {},
     ...payload.resumeFromStageId !== undefined ? { resumeFromStageId: payload.resumeFromStageId } : {},
     ...payload.accumulatedDurationMs !== undefined ? { accumulatedDurationMs: payload.accumulatedDurationMs } : {},
     ts: payload.ts
@@ -51405,7 +51487,7 @@ async function settleResumeAcknowledgements(store2, targets, message) {
       failures.push(qualified);
   });
   for (const controlRunId of resumedRunIds)
-    store2.recordRunResumed(controlRunId);
+    store2.recordRunResumed(controlRunId, undefined, { source: "acknowledgement" });
   return { resumed, acknowledged, failures, lateFailures };
 }
 async function waitForResumeReconciliation(acknowledged) {
@@ -51526,9 +51608,17 @@ async function resumeRun(runId, opts) {
     const currentRun2 = activeStore.runs().find((candidate) => candidate.id === runId);
     const hasPausedDescendant = workflowHasPausedStages(activeStore, runId);
     if (acknowledgements.acknowledged > 0 || handles.length === 0 && acknowledgements.failures.length === 0 && !hasPausedDescendant && currentRun2?.status === "paused") {
-      activeStore.recordRunResumed(runId);
-      if (aggregateRootRunId !== runId)
-        activeStore.recordRunResumed(aggregateRootRunId);
+      const attributeStage = opts?.stageId !== undefined && (hasPausedDescendant || currentRun2?.resumedAt === undefined);
+      activeStore.recordRunResumed(runId, undefined, {
+        source: "run_control",
+        ...opts?.actor === undefined || attributeStage ? {} : { actor: opts.actor }
+      });
+      if (aggregateRootRunId !== runId) {
+        activeStore.recordRunResumed(aggregateRootRunId, undefined, { source: "run_control" });
+      }
+      if (attributeStage && opts?.actor !== undefined && opts.stageId !== undefined) {
+        activeStore.recordStageResumed(runId, opts.stageId, undefined, { actor: opts.actor });
+      }
     }
     const reconciledRoot = activeStore.runs().find((candidate) => candidate.id === runId);
     if (acknowledgements.failures.length > 0) {
@@ -51603,6 +51693,7 @@ async function pauseRun(runId, opts) {
   const activeStore = opts?.store ?? store;
   const registry = opts?.stageControlRegistry ?? stageControlRegistry;
   const run = activeStore.runs().find((candidate) => candidate.id === runId);
+  const actorMetadata = opts?.actor === undefined ? undefined : { actor: opts.actor };
   if (!run)
     return { ok: false, runId, reason: "not_found" };
   if (run.endedAt !== undefined)
@@ -51621,7 +51712,9 @@ async function pauseRun(runId, opts) {
     const paused2 = stage === undefined ? [] : [structuredClone(stage)];
     const stillActive = currentRun2?.stages.some((candidate) => candidate.id !== opts.stageId && (candidate.status === "running" || candidate.status === "pending")) ?? false;
     if (!stillActive)
-      activeStore.recordRunPaused(runId);
+      activeStore.recordRunPaused(runId, undefined, actorMetadata);
+    else if (actorMetadata !== undefined)
+      activeStore.recordStagePaused(runId, opts.stageId, undefined, actorMetadata);
     return { ok: true, runId, paused: paused2 };
   }
   const controlRunIds = expandedControlRunIds(activeStore, runId);
@@ -51639,15 +51732,22 @@ async function pauseRun(runId, opts) {
     if (stage !== undefined)
       paused.push(structuredClone(stage));
   }
-  for (const pausedRunId of pausedRunIds)
+  for (const pausedRunId of pausedRunIds) {
+    if (pausedRunId === runId)
+      continue;
     activeStore.recordRunPaused(pausedRunId);
-  activeStore.recordRunPaused(runId);
+  }
+  activeStore.recordRunPaused(runId, undefined, actorMetadata);
   return { ok: true, runId, paused };
 }
 async function pauseAllRuns(opts) {
   const activeStore = opts?.store ?? store;
   const inFlight = topLevelWorkflowRuns(activeStore.runs()).filter((run) => run.endedAt === undefined);
-  return Promise.all(inFlight.map((run) => pauseRun(run.id, { store: activeStore, stageControlRegistry: opts?.stageControlRegistry })));
+  return Promise.all(inFlight.map((run) => pauseRun(run.id, {
+    store: activeStore,
+    stageControlRegistry: opts?.stageControlRegistry,
+    ...opts?.actor === undefined ? {} : { actor: opts.actor }
+  })));
 }
 async function interruptRun(runId, opts) {
   return pauseRun(runId, opts);
@@ -51995,10 +52095,14 @@ function createLifecycleNoticeDelivery(options) {
 var LIFECYCLE_NOTICE_CUSTOM_TYPE = "workflows:lifecycle-notice";
 var LIFECYCLE_NOTICE_SNIPPET_LIMIT = 240;
 var WORKFLOW_LIFECYCLE_NOTICE_KINDS = [
+  "started",
   "completed",
   "failed",
   "blocked",
-  "awaiting_input"
+  "awaiting_input",
+  "paused",
+  "quit",
+  "resumed"
 ];
 var rendererRegisteredHosts4 = new WeakSet;
 function createWorkflowLifecycleNotificationState() {
@@ -52032,6 +52136,12 @@ function seedWorkflowLifecycleNotificationState(state2, snapshot) {
         state2.deliveredTerminalRuns.add(key2);
       }
     }
+    for (const occurrence of controlOccurrences(run)) {
+      const controlKey = controlOccurrenceKey(run, occurrence);
+      if (!state2.pendingTerminalRuns.has(controlKey) && !state2.retryableTerminalRuns.has(controlKey)) {
+        state2.deliveredTerminalRuns.add(controlKey);
+      }
+    }
     if (run.pendingPrompt !== undefined) {
       state2.deliveredInputPrompts.add(runAwaitingInputKey(run.id, run.pendingPrompt));
     }
@@ -52102,6 +52212,22 @@ function installWorkflowLifecycleNotifications(options) {
     }
     delivery.deliver(key2, makeTerminalNotice(run, kind));
   };
+  const emitControlNoticesOnce = (run) => {
+    for (const occurrence of controlOccurrences(run)) {
+      if (!notifyOn.has(occurrence.kind))
+        continue;
+      const key2 = controlOccurrenceKey(run, occurrence);
+      if (state2.deliveredTerminalRuns.has(key2) || state2.pendingTerminalRuns.has(key2) || state2.retryableTerminalRuns.has(key2))
+        continue;
+      if (state2.suppressionDepth > 0) {
+        state2.deliveredTerminalRuns.add(key2);
+        state2.retryableTerminalRuns.delete(key2);
+        state2.retryableTerminalNotices.delete(key2);
+        continue;
+      }
+      delivery.deliver(key2, makeControlNotice(run, occurrence));
+    }
+  };
   const emitStageAwaitingInputNoticeOnce = (run, stage) => {
     if (stage.status !== "awaiting_input")
       return;
@@ -52125,6 +52251,7 @@ function installWorkflowLifecycleNotifications(options) {
       emitTerminalNoticeOnce(run, "completed");
       emitTerminalNoticeOnce(run, "failed");
       emitTerminalNoticeOnce(run, "blocked");
+      emitControlNoticesOnce(run);
       if (!notifyOn.has("awaiting_input"))
         continue;
       emitRunAwaitingInputNoticeOnce(run);
@@ -52163,20 +52290,41 @@ function registerLifecycleNoticeRenderer(options) {
 }
 function formatWorkflowLifecycleNoticeText(details) {
   const workflowName = escapeQuotedText2(details.workflowName);
+  const origin = details.origin === undefined ? "" : details.origin === "agent" ? ", which you started" : ", which the user started";
+  const actor = details.actor === "agent" ? "You" : "The user";
+  if (details.kind === "started") {
+    return `▶ ${actor} started workflow "${workflowName}" (run ${details.runId}). It is running in the background; you will be notified when it completes.`;
+  }
   if (details.kind === "completed") {
-    return `✓ Workflow "${workflowName}" completed (run ${details.runId}). Inspect: /workflow status ${details.runId}`;
+    return `✓ Workflow "${workflowName}" completed (run ${details.runId})${origin}. Inspect: /workflow status ${details.runId}`;
   }
   if (details.kind === "failed") {
     const stage2 = details.stageName ?? details.failedStageId ?? details.stageId;
     const tool = lifecycleToolOrigin(details);
-    const originText = stage2 ? `, stage ${stage2}` : tool !== undefined ? `, tool ${tool}` : "";
+    const failureSite = stage2 ? `, stage ${stage2}` : tool !== undefined ? `, tool ${tool}` : "";
     const errorText = details.error ? `: ${details.error}` : "";
-    return `✗ Workflow "${workflowName}" failed (run ${details.runId}${originText})${errorText}. Inspect: /workflow status ${details.runId}`;
+    return `✗ Workflow "${workflowName}" failed (run ${details.runId}${failureSite})${origin}${errorText}. Inspect: /workflow status ${details.runId}`;
   }
   if (details.kind === "blocked") {
     const errorText = details.error ? `: ${details.error}` : "";
     const stateText = details.active === true ? "is blocked" : "ended blocked";
-    return `! Workflow "${workflowName}" ${stateText} (run ${details.runId})${errorText}. Inspect: /workflow status ${details.runId}`;
+    return `! Workflow "${workflowName}" ${stateText} (run ${details.runId})${origin}${errorText}. Inspect: /workflow status ${details.runId}`;
+  }
+  if (details.kind === "paused" || details.kind === "quit") {
+    const stopStage = details.stageName ?? details.stageId;
+    const stageText = stopStage ? `${origin === "" ? "" : ","} at stage ${stopStage}` : "";
+    const scopeText = details.scope === "stage" ? "stage of workflow" : "workflow";
+    const verb = details.kind === "paused" ? "paused" : "quit";
+    const noun = details.kind === "paused" ? "pause" : "stop";
+    const glyph = details.kind === "paused" ? "⏸" : "⏹";
+    return `${glyph} ${actor} ${verb} the ${scopeText} "${workflowName}" (run ${details.runId})${origin}${stageText}. This ${noun} was deliberate and user-requested; do not resume it or take over the work unless asked. Resume: /workflow resume ${details.runId}`;
+  }
+  if (details.kind === "resumed") {
+    const resumedStage = details.stageName ?? details.stageId;
+    const stageText = resumedStage ? `${origin === "" ? "" : ","} at stage ${resumedStage}` : "";
+    const scopeText = details.scope === "stage" ? "stage of workflow" : "workflow";
+    const continues = details.continuedFromRunId === undefined ? "" : `, continuing run ${details.continuedFromRunId}`;
+    return `▶ ${actor} resumed the ${scopeText} "${workflowName}" (run ${details.runId}${continues})${origin}${stageText}. It is running again in the background.`;
   }
   const prompt = details.promptMessage ? ` Prompt: ${details.promptMessage}` : "";
   if (details.scope === "run") {
@@ -52205,9 +52353,31 @@ function makeTerminalNotice(run, kind) {
     ...failedToolNodeId !== undefined ? { toolNodeId: failedToolNodeId } : {},
     ...failedTool !== undefined ? { toolName: failedTool.name } : {},
     ...run.durationMs !== undefined ? { durationMs: run.durationMs } : {},
+    ...run.origin !== undefined ? { origin: run.origin } : {},
     createdAt: lifecycleOccurrenceAt(run, kind) ?? Date.now()
   };
 }
+function makeControlNotice(run, occurrence) {
+  const stage = occurrence.stage ?? restingStage(run);
+  const elapsedMs = run.durationMs ?? (occurrence.at >= run.startedAt ? occurrence.at - run.startedAt : undefined);
+  return {
+    kind: occurrence.kind,
+    scope: occurrence.scope,
+    runId: run.id,
+    workflowName: run.name,
+    status: occurrence.stage !== undefined ? occurrence.stage.status : run.status,
+    ...stage !== undefined ? { stageId: stage.id, stageName: stage.name } : {},
+    ...elapsedMs !== undefined ? { durationMs: elapsedMs } : {},
+    ...occurrence.kind === "quit" && run.resumable !== undefined ? { resumable: run.resumable } : {},
+    ...occurrence.actor !== undefined ? { actor: occurrence.actor } : {},
+    ...occurrence.kind !== "started" && run.origin !== undefined ? { origin: run.origin } : {},
+    ...occurrence.kind === "resumed" && run.resumedFromRunId !== undefined ? { continuedFromRunId: run.resumedFromRunId } : {},
+    createdAt: occurrence.at
+  };
+}
+function restingStage(run) {
+  return run.stages.find((stage) => stage.status === "paused") ?? run.stages.find((stage) => stage.status === "running");
+}
 function warnLifecycleSendFailure(error) {
   if (process.env.ATOMIC_WORKFLOW_DEBUG !== "1")
     return;
@@ -52255,6 +52425,54 @@ function terminalRunKey(kind, run) {
   const occurrence = kind === "blocked" ? run.blockedAt ?? lifecycleOccurrenceAt(run, kind) : "";
   return occurrence === undefined ? `${kind}:${run.id}` : `${kind}:${run.id}:${occurrence}`;
 }
+function controlOccurrences(run) {
+  const occurrences = [];
+  const resumedRun = run.resumeSource === "run_control" || run.resumedFromRunId !== undefined;
+  const userResumed = run.resumeSource === "run_control" && run.resumeActor === "user";
+  const continuation = userResumed && run.resumedAt === undefined;
+  if (run.origin === "user" && !resumedRun) {
+    occurrences.push({ kind: "started", scope: "run", at: run.startedAt, actor: "user" });
+  }
+  if (userResumed && run.status === "running") {
+    occurrences.push({
+      kind: "resumed",
+      scope: "run",
+      at: continuation ? run.startedAt : run.resumedAt ?? run.startedAt,
+      actor: "user"
+    });
+  }
+  if (run.endedAt === undefined && run.status === "paused" && run.pauseActor === "user") {
+    if (run.exitReason === "quit") {
+      const quitAt = run.quitAt ?? run.pausedAt;
+      if (quitAt !== undefined)
+        occurrences.push({ kind: "quit", scope: "run", at: quitAt, actor: "user" });
+    } else if (run.pausedAt !== undefined) {
+      occurrences.push({ kind: "paused", scope: "run", at: run.pausedAt, actor: "user" });
+    }
+  }
+  const runScoped = new Set(occurrences.map((occurrence) => occurrence.kind));
+  if (run.endedAt !== undefined)
+    return occurrences;
+  for (const stage of run.stages) {
+    if (stage.status === "paused" && stage.pauseActor === "user" && stage.pausedAt !== undefined) {
+      if (!runScoped.has("paused") && !runScoped.has("quit")) {
+        occurrences.push({ kind: "paused", scope: "stage", at: stage.pausedAt, actor: "user", stage });
+      }
+    }
+    if (stage.status === "running" && stage.resumeActor === "user" && stage.resumedAt !== undefined) {
+      if (!runScoped.has("resumed")) {
+        occurrences.push({ kind: "resumed", scope: "stage", at: stage.resumedAt, actor: "user", stage });
+      }
+    }
+  }
+  return occurrences;
+}
+function controlOccurrenceKey(run, occurrence) {
+  if (occurrence.scope === "stage" && occurrence.stage !== undefined) {
+    return `${occurrence.kind}:${run.id}:stage:${occurrence.stage.id}:${occurrence.at}`;
+  }
+  return `${occurrence.kind}:${run.id}:${occurrence.at}`;
+}
 function awaitingInputKey(runId, stage) {
   const promptId = stage.pendingPrompt?.id ?? stage.inputRequest?.id;
   if (promptId)
@@ -52283,12 +52501,12 @@ function makeNoticeComponent2(details, theme) {
   };
 }
 function renderLifecycleNoticeCard(details, opts) {
-  const tone = details.kind === "failed" ? "error" : details.kind === "awaiting_input" || details.kind === "blocked" ? "warning" : "success";
-  const title = details.kind === "failed" ? "WORKFLOW FAILED" : details.kind === "awaiting_input" ? "WORKFLOW INPUT" : details.kind === "blocked" ? "WORKFLOW BLOCKED" : "WORKFLOW COMPLETE";
-  const glyph = details.kind === "failed" ? "✗" : details.kind === "awaiting_input" ? "？" : details.kind === "blocked" ? "!" : "✓";
+  const tone = lifecycleNoticeTone(details.kind);
+  const title = lifecycleNoticeTitle(details.kind);
+  const glyph = lifecycleNoticeGlyph(details.kind);
   const stage = details.stageName ?? details.failedStageId ?? details.stageId;
   const tool = stage === undefined ? lifecycleToolOrigin(details) : undefined;
-  const headline = details.kind === "failed" ? `Workflow "${details.workflowName}" failed` : details.kind === "awaiting_input" ? `Workflow "${details.workflowName}" needs input` : details.kind === "blocked" ? `Workflow "${details.workflowName}" ${details.active === true ? "is blocked" : "ended blocked"}` : `Workflow "${details.workflowName}" completed`;
+  const headline = lifecycleNoticeHeadline(details);
   return renderWorkflowNoticeCard({
     title,
     glyph,
@@ -52297,20 +52515,108 @@ function renderLifecycleNoticeCard(details, opts) {
     fields: [
       { label: "workflow", value: details.workflowName },
       { label: "run", value: details.runId },
+      { label: "continues", value: details.continuedFromRunId },
       { label: "stage", value: stage },
       { label: "tool", value: tool },
+      { label: "actor", value: details.actor, tone: "muted" },
+      { label: "launched", value: details.origin, tone: "muted" },
       { label: "prompt", value: details.promptMessage, tone: "muted" },
       { label: "error", value: details.error, tone: "error" },
+      { label: "resumable", value: resumableFieldValue(details), tone: "muted" },
       { label: "duration", value: formatDurationMs(details.durationMs), tone: "muted" }
     ],
-    hints: [
-      details.kind === "awaiting_input" ? `/workflow connect ${details.runId}` : `/workflow status ${details.runId}`
-    ],
+    hints: [lifecycleNoticeHint(details)],
     fallbackText: opts.fallbackText,
     width: opts.width,
     ...opts.theme ? { theme: opts.theme } : {}
   });
 }
+function lifecycleNoticeTone(kind) {
+  switch (kind) {
+    case "failed":
+      return "error";
+    case "blocked":
+    case "awaiting_input":
+    case "paused":
+    case "quit":
+      return "warning";
+    default:
+      return "success";
+  }
+}
+function lifecycleNoticeTitle(kind) {
+  switch (kind) {
+    case "started":
+      return "WORKFLOW STARTED";
+    case "failed":
+      return "WORKFLOW FAILED";
+    case "awaiting_input":
+      return "WORKFLOW INPUT";
+    case "blocked":
+      return "WORKFLOW BLOCKED";
+    case "paused":
+      return "WORKFLOW PAUSED";
+    case "quit":
+      return "WORKFLOW QUIT";
+    case "resumed":
+      return "WORKFLOW RESUMED";
+    default:
+      return "WORKFLOW COMPLETE";
+  }
+}
+function lifecycleNoticeGlyph(kind) {
+  switch (kind) {
+    case "failed":
+      return "✗";
+    case "awaiting_input":
+      return "？";
+    case "blocked":
+      return "!";
+    case "paused":
+      return "⏸";
+    case "quit":
+      return "⏹";
+    case "started":
+    case "resumed":
+      return "▶";
+    default:
+      return "✓";
+  }
+}
+function lifecycleNoticeHeadline(details) {
+  const name = details.workflowName;
+  const scope = details.scope === "stage" ? "Stage of workflow" : "Workflow";
+  switch (details.kind) {
+    case "started":
+      return `Workflow "${name}" started`;
+    case "failed":
+      return `Workflow "${name}" failed`;
+    case "awaiting_input":
+      return `Workflow "${name}" needs input`;
+    case "blocked":
+      return `Workflow "${name}" ${details.active === true ? "is blocked" : "ended blocked"}`;
+    case "paused":
+      return `${scope} "${name}" paused`;
+    case "quit":
+      return `Workflow "${name}" quit`;
+    case "resumed":
+      return `${scope} "${name}" resumed`;
+    default:
+      return `Workflow "${name}" completed`;
+  }
+}
+function lifecycleNoticeHint(details) {
+  if (details.kind === "awaiting_input")
+    return `/workflow connect ${details.runId}`;
+  if (details.kind === "paused" || details.kind === "quit")
+    return `/workflow resume ${details.runId}`;
+  return `/workflow status ${details.runId}`;
+}
+function resumableFieldValue(details) {
+  if (details.resumable === undefined)
+    return;
+  return details.resumable ? "yes" : "no";
+}
 function formatDurationMs(durationMs) {
   if (durationMs === undefined)
     return;
@@ -52686,6 +52992,11 @@ import { CONFIG_DIR_NAME, CONFIG_DIR_NAMES, getAgentDir, getAgentDirs, getProjec
 
 // dist/builtin/workflows/src/extension/config-file-loader.ts
 var WORKFLOW_LIFECYCLE_NOTICE_KIND_SET = new Set(WORKFLOW_LIFECYCLE_NOTICE_KINDS);
+var WORKFLOW_LIFECYCLE_NOTICE_KIND_LIST = (() => {
+  const quoted = WORKFLOW_LIFECYCLE_NOTICE_KINDS.map((kind) => JSON.stringify(kind));
+  const last = quoted[quoted.length - 1] ?? "";
+  return quoted.length <= 1 ? last : `${quoted.slice(0, -1).join(", ")}, or ${last}`;
+})();
 async function tryReadFile(filePath) {
   const { readFile } = await import("node:fs/promises");
   try {
@@ -52741,7 +53052,7 @@ function validateConfig(value2) {
       }
       for (const item of notifyOn) {
         if (!isWorkflowLifecycleNoticeKind(item)) {
-          return `"workflowNotifications.notifyOn" entries must be "completed", "failed", "blocked", or "awaiting_input", got ${JSON.stringify(item)}`;
+          return `"workflowNotifications.notifyOn" entries must be ${WORKFLOW_LIFECYCLE_NOTICE_KIND_LIST}, got ${JSON.stringify(item)}`;
         }
       }
     }
@@ -52852,7 +53163,7 @@ var WORKFLOW_CONFIG_DEFAULTS = {
   resumeInFlight: "ask",
   workflowNotifications: {
     enabled: true,
-    notifyOn: ["completed", "failed", "blocked", "awaiting_input"]
+    notifyOn: ["started", "completed", "failed", "blocked", "awaiting_input", "paused", "quit", "resumed"]
   },
   worktree: {
     symlinkDirectories: ["node_modules"]
@@ -59478,6 +59789,40 @@ function durableStageCheckpointMetadata(stage, run, sourceOrder) {
 // dist/builtin/workflows/src/durable/tool-primitive.ts
 import { runCallback } from "@bastani/atomic";
 
+// dist/builtin/workflows/src/runs/shared/retry.ts
+import { nextRetryDecision } from "@bastani/atomic";
+function abortReason(signal) {
+  const reason = signal?.reason;
+  if (reason instanceof Error || reason instanceof DOMException || typeof reason === "string")
+    return reason;
+  return new Error("atomic-workflows: workflow cancelled");
+}
+function sleepOrAbort(ms, signal) {
+  if (signal?.aborted)
+    return Promise.reject(abortReason(signal));
+  return new Promise((resolve4, reject) => {
+    let settled = false;
+    const cleanup = () => signal?.removeEventListener("abort", onAbort);
+    const finish = () => {
+      if (settled)
+        return;
+      settled = true;
+      cleanup();
+      resolve4();
+    };
+    const fail = (error) => {
+      if (settled)
+        return;
+      settled = true;
+      clearTimeout(timer);
+      cleanup();
+      reject(error);
+    };
+    const timer = setTimeout(finish, Math.max(0, ms));
+    const onAbort = () => fail(abortReason(signal));
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
 // dist/builtin/workflows/src/durable/tool-failure-checkpoint.ts
 async function recordThrowingToolFailure(input, node, identity, error, attempts) {
   const message = workflowToolFailure(error, attempts, false).error.message;
@@ -59905,32 +60250,6 @@ async function executeWithRetries(fn, options, throwIfCancelled, signal) {
   }
   throw lastError ?? new Error("ctx.tool: retries exhausted");
 }
-function sleepOrAbort(ms, signal) {
-  if (signal?.aborted)
-    return Promise.reject(signal.reason instanceof Error ? signal.reason : new Error("atomic-workflows: workflow cancelled"));
-  return new Promise((resolve4, reject) => {
-    let settled = false;
-    const cleanup = () => signal?.removeEventListener("abort", onAbort);
-    const finish = () => {
-      if (settled)
-        return;
-      settled = true;
-      cleanup();
-      resolve4();
-    };
-    const fail = (err) => {
-      if (settled)
-        return;
-      settled = true;
-      clearTimeout(timer);
-      cleanup();
-      reject(err);
-    };
-    const timer = setTimeout(finish, ms);
-    const onAbort = () => fail(signal?.reason instanceof Error ? signal.reason : new Error("atomic-workflows: workflow cancelled"));
-    signal?.addEventListener("abort", onAbort, { once: true });
-  });
-}
 function createCheckpointIdGenerator() {
   let counter = 0;
   return () => `cp-${++counter}`;
@@ -60753,455 +61072,13 @@ async function buildModelCandidatesFromCatalog(input) {
   }
 }
 // dist/builtin/workflows/src/runs/shared/model-fallback-failures.ts
-var RETRYABLE_MODEL_FAILURE_PATTERNS = [
-  /rate\s*limit/i,
-  /too\s*many\s*requests/i,
-  /\b429\b/,
-  /quota/i,
-  /usage[\s_-]*limit/i,
-  /billing/i,
-  /credit/i,
-  /auth(?:entication|orization)?/i,
-  /unauthori[sz]ed/i,
-  /\b40[13]\b/,
-  /api\s*key/i,
-  /token\s*expired/i,
-  /forbidden/i,
-  /invalid\s*key/i,
-  /model.*(?:unavailable|disabled|not\s*found|unknown)/i,
-  /(?:unavailable|disabled|not\s*found|unknown).*model/i,
-  /overloaded/i,
-  /temporarily\s*unavailable/i,
-  /service\s*unavailable/i,
-  /network/i,
-  /fetch/i,
-  /socket/i,
-  /connection\s*refused/i,
-  /upstream/i,
-  /timeout/i,
-  /timed\s*out/i,
-  /\b50[0-4]\b/
-];
-var NON_RETRYABLE_FAILURE_PATTERNS = [
-  /command failed/i,
-  /tests? failed/i,
-  /shell/i,
-  /missing file/i,
-  /no such file/i,
-  /cancel/i,
-  /abort/i,
-  /interrupted/i
-];
-var CANCELLED_FAILURE_PATTERNS = [/cancel/i, /abort/i, /interrupted/i];
-var FALLBACKABLE_FAILURE_KINDS = new Set([
-  "auth_on_candidate_provider",
-  "rate_limit",
-  "provider_unavailable",
-  "network_timeout",
-  "transport_error",
-  "model_unavailable",
-  "request_incompatible"
-]);
-function asRecord2(value2) {
-  return value2 !== null && typeof value2 === "object" ? value2 : undefined;
-}
-function field2(value2, key2) {
-  return asRecord2(value2)?.[key2];
-}
-function stringField3(value2, key2) {
-  const raw = field2(value2, key2);
-  return typeof raw === "string" && raw.trim().length > 0 ? raw : undefined;
-}
-function errorName2(value2) {
-  return value2 instanceof Error ? value2.name : stringField3(value2, "name");
-}
-function directMessageFrom(value2) {
-  return stringField3(value2, "errorMessage") ?? stringField3(value2, "message") ?? stringField3(value2, "statusText");
-}
-function integerFrom2(value2) {
-  if (typeof value2 === "number" && Number.isInteger(value2))
-    return value2;
-  if (typeof value2 !== "string" || value2.trim().length === 0)
-    return;
-  const parsed = Number(value2.trim());
-  return Number.isInteger(parsed) ? parsed : undefined;
-}
-function statusFrom(value2) {
-  return integerFrom2(field2(value2, "status")) ?? integerFrom2(field2(value2, "statusCode")) ?? integerFrom2(field2(value2, "httpStatus"));
-}
-function codeFrom(value2) {
-  const rawCode = field2(value2, "code");
-  return typeof rawCode === "string" || typeof rawCode === "number" ? rawCode : undefined;
-}
-function stopReasonFrom(value2) {
-  return stringField3(value2, "stopReason");
-}
-function finishReasonFrom(value2) {
-  return stringField3(value2, "finish_reason") ?? stringField3(value2, "finishReason");
-}
-function causeOf2(value2) {
-  return value2 instanceof Error ? value2.cause : field2(value2, "cause");
-}
-function diagnosticErrors2(value2) {
-  const diagnostics = field2(value2, "diagnostics");
-  if (!Array.isArray(diagnostics))
-    return [];
-  const errors = [];
-  for (const diagnostic of diagnostics) {
-    const diagnosticError = field2(diagnostic, "error");
-    errors.push(diagnosticError ?? diagnostic);
-  }
-  return errors;
-}
-function normalizeCode2(value2) {
-  if (value2 === undefined)
-    return;
-  const normalized = String(value2).trim().toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
-  return normalized.length > 0 ? normalized : undefined;
-}
-function kindFromStatus(status) {
-  switch (status) {
-    case 400:
-    case 413:
-    case 422:
-      return "request_incompatible";
-    case 401:
-    case 403:
-      return "auth_on_candidate_provider";
-    case 408:
-      return "network_timeout";
-    case 404:
-      return "model_unavailable";
-    case 429:
-      return "rate_limit";
-    default:
-      if (status !== undefined && status >= 500 && status <= 599)
-        return "provider_unavailable";
-      return;
-  }
-}
-function refusalKindFromCode(code) {
-  const normalizedCode = normalizeCode2(code);
-  if (normalizedCode === undefined)
-    return;
-  if (normalizedCode.includes("content_filter") || normalizedCode.includes("contentfilter"))
-    return "task_failure";
-  if (normalizedCode.includes("safety") || normalizedCode.includes("policy"))
-    return "task_failure";
-  switch (normalizedCode) {
-    case "blocked":
-    case "blocked_by_provider":
-    case "blocked_by_safety":
-    case "blocked_by_policy":
-    case "provider_refusal":
-    case "refusal":
-    case "tool_refusal":
-    case "tool_call_refusal":
-    case "tool_use_refusal":
-      return "task_failure";
-    default:
-      return;
-  }
-}
-var REQUEST_INCOMPATIBLE_CODES = new Set([
-  "invalid_request",
-  "invalid_request_error",
-  "bad_request",
-  "context_length_exceeded",
-  "request_too_large",
-  "too_large",
-  "request_entity_too_large",
-  "max_tokens",
-  "max_context_length",
-  "context_window_exceeded"
-]);
-function requestIncompatibleKindFromCode(code) {
-  const normalizedCode = normalizeCode2(code);
-  return normalizedCode !== undefined && REQUEST_INCOMPATIBLE_CODES.has(normalizedCode) ? "request_incompatible" : undefined;
-}
-function kindFromCode(code) {
-  const normalizedCode = normalizeCode2(code);
-  if (normalizedCode === undefined)
-    return;
-  const refusalKind = refusalKindFromCode(code);
-  if (refusalKind !== undefined)
-    return refusalKind;
-  const httpStatusKind = kindFromStatus(integerFrom2(code));
-  if (httpStatusKind !== undefined)
-    return httpStatusKind;
-  const requestIncompatibleKind = requestIncompatibleKindFromCode(code);
-  if (requestIncompatibleKind !== undefined)
-    return requestIncompatibleKind;
-  switch (normalizedCode) {
-    case "auth":
-    case "auth_required":
-    case "authentication_required":
-    case "unauthorized":
-    case "forbidden":
-    case "invalid_api_key":
-    case "missing_api_key":
-    case "invalid_key":
-      return "auth_on_candidate_provider";
-    case "etimedout":
-    case "econnreset":
-    case "econnrefused":
-    case "enotfound":
-    case "eai_again":
-    case "fetch_failed":
-    case "network_error":
-    case "timeout":
-    case "timeout_error":
-    case "und_err_connect_timeout":
-      return "network_timeout";
-    case "rate_limit":
-    case "rate_limit_exceeded":
-    case "too_many_requests":
-    case "quota_exceeded":
-    case "insufficient_quota":
-    case "usage_limit":
-    case "usage_limit_reached":
-    case "usage_limit_exceeded":
-      return "rate_limit";
-    case "aborterror":
-    case "aborted":
-    case "cancelled":
-    case "canceled":
-      return "cancelled";
-    case "model_not_found":
-    case "model_unavailable":
-    case "model_disabled":
-    case "unknown_model":
-      return "model_unavailable";
-    case "provider_error":
-    case "api_error":
-    case "service_unavailable":
-    case "temporarily_unavailable":
-    case "overloaded":
-      return "provider_unavailable";
-    default:
-      return;
-  }
-}
-var REQUEST_INCOMPATIBLE_FAILURE_PATTERNS = [
-  /\bcontext[_\s-]?length(?:[_\s-]?exceeded)?\b/i,
-  /\bcontext[_\s-]?window(?:[_\s-]?exceeded)?\b/i,
-  /\bmax[_\s-]?context\b/i,
-  /\bmax[_\s-]?tokens?\b/i,
-  /\brequest(?:[_\s-]?entity)?[_\s-]?too[_\s-]?large\b/i,
-  /\btoo[_\s-]?large\b/i,
-  /\b(?:unsupported|unknown|invalid)\s+(?:tool|parameter|function)\b/i,
-  /\b(?:tool|parameter|function)\s+(?:not\s+(?:supported|found|allowed)|unknown|invalid)\b/i,
-  /\binvalid[_\s-]?request(?:[_\s-]?error)?\b/i,
-  /\bbad[_\s-]?request\b/i
-];
-var PROVIDER_REFUSAL_FAILURE_PATTERNS = [
-  /\bfinish[_\s-]?reason\b[^\n]*\bcontent[_\s-]?filter\b/i,
-  /\bcontent[_\s-]?filter(?:ed|ing)?\b/i,
-  /\b(?:safety|policy)\b[^\n]*\b(?:refus(?:e|al|ed|es|ing)?|block(?:ed|ing)?|filter(?:ed|ing)?|violat(?:e|ion|ed|ing)?|disallow(?:ed|ing)?|reject(?:ed|ion|ing)?)\b/i,
-  /\b(?:refus(?:e|al|ed|es|ing)?|block(?:ed|ing)?|filter(?:ed|ing)?|violat(?:e|ion|ed|ing)?|disallow(?:ed|ing)?|reject(?:ed|ion|ing)?)\b[^\n]*\b(?:safety|policy)\b/i,
-  /\btool[_\s-]?(?:call|use)?[_\s-]?refus(?:e|al|ed|es|ing)?\b/i,
-  /\btool(?:\s+call|\s+use)?\b[^\n]*\brefus(?:e|al|ed|es|ing)?\b/i,
-  /\brefus(?:e|al|ed|es|ing)?\b[^\n]*\btool(?:\s+call|\s+use)?\b/i,
-  /\bprovider[_\s-]?refus(?:e|al|ed|es|ing)?\b/i,
-  /\bprovider\b[^\n]*\brefus(?:e|al|ed|es|ing)?\b[^\n]*\b(?:prompt|request|content|policy|safety)\b/i
-];
-var TRANSPORT_OUTAGE_FAILURE_PATTERNS = [/^connection\s+error\.?$/i, /^fetch\s+failed\.?$/i];
-function transportOutageKindFromMessage(message) {
-  return TRANSPORT_OUTAGE_FAILURE_PATTERNS.some((pattern) => pattern.test(message.trim())) ? "transport_error" : undefined;
-}
-function refusalKindFromMessage(message) {
-  if (CANCELLED_FAILURE_PATTERNS.some((pattern) => pattern.test(message)))
-    return "cancelled";
-  if (NON_RETRYABLE_FAILURE_PATTERNS.some((pattern) => pattern.test(message)))
-    return "task_failure";
-  if (PROVIDER_REFUSAL_FAILURE_PATTERNS.some((pattern) => pattern.test(message)))
-    return "task_failure";
-  return;
-}
-function fallbackKindFromMessage(message, name) {
-  const refusalKind = refusalKindFromMessage(message);
-  if (refusalKind !== undefined)
-    return refusalKind;
-  const transportOutageKind = transportOutageKindFromMessage(message);
-  if (transportOutageKind !== undefined)
-    return transportOutageKind;
-  if (REQUEST_INCOMPATIBLE_FAILURE_PATTERNS.some((pattern) => pattern.test(message)))
-    return "request_incompatible";
-  const nameKind = kindFromCode(name);
-  if (nameKind !== undefined)
-    return nameKind;
-  if (!RETRYABLE_MODEL_FAILURE_PATTERNS.some((pattern) => pattern.test(message)))
-    return;
-  if (/rate\s*limit|too\s*many\s*requests|\b429\b|quota|usage[\s_-]*limit|billing|credit/i.test(message))
-    return "rate_limit";
-  if (/auth|unauthori[sz]ed|\b40[13]\b|api\s*key|token\s*expired|forbidden|invalid\s*key/i.test(message))
-    return "auth_on_candidate_provider";
-  if (/model.*(?:unavailable|disabled|not\s*found|unknown)|(?:unavailable|disabled|not\s*found|unknown).*model/i.test(message))
-    return "model_unavailable";
-  if (/network|fetch|socket|connection\s*refused|timeout|timed\s*out/i.test(message))
-    return "network_timeout";
-  return "provider_unavailable";
-}
-function signalSource(value2, fallback) {
-  if (fallback !== undefined)
-    return fallback;
-  if (stopReasonFrom(value2) !== undefined || diagnosticErrors2(value2).length > 0)
-    return "assistant_message";
-  if (value2 instanceof Error)
-    return "throw";
-  return "structured";
-}
-function makeSignal(kind, value2, source) {
-  const status = statusFrom(value2);
-  const code = codeFrom(value2);
-  const name = errorName2(value2);
-  const stopReason = stopReasonFrom(value2);
-  return {
-    kind,
-    message: errorMessage3(value2),
-    source: signalSource(value2, source),
-    ...stopReason !== undefined ? { stopReason } : {},
-    ...status !== undefined ? { status } : {},
-    ...code !== undefined ? { code } : {},
-    ...name !== undefined ? { name } : {}
-  };
-}
-function fallbackSignalFromDirectMessage(value2, source) {
-  const message = directMessageFrom(value2);
-  if (message === undefined)
-    return;
-  const kind = fallbackKindFromMessage(message, errorName2(value2));
-  return kind === undefined ? undefined : makeSignal(kind, value2, source);
-}
-function fallbackSignalFromMessage(value2, source) {
-  const message = errorMessage3(value2);
-  if (!message.trim())
-    return;
-  const kind = fallbackKindFromMessage(message, errorName2(value2));
-  return kind === undefined ? undefined : makeSignal(kind, value2, source);
-}
-function classifyAssistantRefusalSignal(value2, source) {
-  const codeRefusalKind = refusalKindFromCode(codeFrom(value2)) ?? refusalKindFromCode(errorName2(value2)) ?? refusalKindFromCode(finishReasonFrom(value2));
-  if (codeRefusalKind !== undefined)
-    return makeSignal(codeRefusalKind, value2, source);
-  const messageRefusalKind = refusalKindFromMessage(directMessageFrom(value2) ?? "");
-  return messageRefusalKind === undefined ? undefined : makeSignal(messageRefusalKind, value2, source);
-}
-function isRefusalSignal(signal) {
-  return signal.kind === "cancelled" || signal.kind === "task_failure";
-}
-function structuredSignal2(value2, seen, source) {
-  if (value2 === undefined || value2 === null || seen.has(value2))
-    return;
-  if (typeof value2 === "object")
-    seen.add(value2);
-  const stopReason = stopReasonFrom(value2)?.toLowerCase();
-  if (stopReason === "aborted")
-    return makeSignal("cancelled", value2, source);
-  const directRefusalSignal = classifyAssistantRefusalSignal(value2, source);
-  if (directRefusalSignal !== undefined)
-    return directRefusalSignal;
-  const codeKind = kindFromCode(codeFrom(value2));
-  const nameKind = kindFromCode(errorName2(value2));
-  if (codeKind === "cancelled" || nameKind === "cancelled")
-    return makeSignal("cancelled", value2, source);
-  let firstNestedFallbackSignal;
-  const nestedSeen = new Set(seen);
-  for (const diagnosticError of diagnosticErrors2(value2)) {
-    const diagnosticSignal = structuredSignal2(diagnosticError, nestedSeen, "diagnostic") ?? fallbackSignalFromMessage(diagnosticError, "diagnostic");
-    if (diagnosticSignal === undefined)
-      continue;
-    if (isRefusalSignal(diagnosticSignal))
-      return diagnosticSignal;
-    firstNestedFallbackSignal ??= diagnosticSignal;
-  }
-  const cause = causeOf2(value2);
-  const causeSignal = structuredSignal2(cause, nestedSeen, source) ?? fallbackSignalFromMessage(cause, source);
-  if (causeSignal !== undefined) {
-    if (isRefusalSignal(causeSignal))
-      return causeSignal;
-    firstNestedFallbackSignal ??= causeSignal;
-  }
-  const directMessageSignal = fallbackSignalFromDirectMessage(value2, source);
-  if (directMessageSignal !== undefined)
-    return directMessageSignal;
-  const statusKind = kindFromStatus(statusFrom(value2));
-  if (statusKind !== undefined)
-    return makeSignal(statusKind, value2, source);
-  if (codeKind !== undefined)
-    return makeSignal(codeKind, value2, source);
-  if (nameKind !== undefined)
-    return makeSignal(nameKind, value2, source);
-  if (firstNestedFallbackSignal !== undefined)
-    return firstNestedFallbackSignal;
-  if (stopReason === "error")
-    return makeSignal("provider_unavailable", value2, source);
-  return;
-}
-function messageFromUnknown(value2, seen) {
-  if (value2 === undefined || value2 === null || seen.has(value2))
-    return;
-  if (typeof value2 === "string")
-    return value2.trim().length > 0 ? value2 : undefined;
-  if (typeof value2 === "number" || typeof value2 === "boolean" || typeof value2 === "bigint")
-    return String(value2);
-  if (typeof value2 === "symbol" || typeof value2 === "function")
-    return;
-  seen.add(value2);
-  if (value2 instanceof Error && value2.message.trim().length > 0)
-    return value2.message;
-  const directMessage = directMessageFrom(value2);
-  if (directMessage !== undefined)
-    return directMessage;
-  for (const diagnosticError of diagnosticErrors2(value2)) {
-    const diagnosticMessage = messageFromUnknown(diagnosticError, seen);
-    if (diagnosticMessage !== undefined)
-      return diagnosticMessage;
-  }
-  const causeMessage = messageFromUnknown(causeOf2(value2), seen);
-  if (causeMessage !== undefined)
-    return causeMessage;
-  const stopReason = stopReasonFrom(value2);
-  if (stopReason !== undefined)
-    return `Assistant message ended with stopReason:${stopReason}`;
-  const finishReason = finishReasonFrom(value2);
-  if (finishReason !== undefined)
-    return `Model request finished with finish_reason:${finishReason}`;
-  const status = statusFrom(value2);
-  if (status !== undefined)
-    return `Model request failed with status ${status}`;
-  const code = codeFrom(value2);
-  if (code !== undefined)
-    return `Model request failed with code ${String(code)}`;
-  return;
-}
-function errorMessage3(error) {
-  const structuredMessage = messageFromUnknown(error, new Set);
-  if (structuredMessage !== undefined)
-    return structuredMessage;
-  const rendered = String(error);
-  return rendered === "[object Object]" ? "Model request failed" : rendered;
-}
-function normalizeModelFailureSignal(error) {
-  const structured2 = structuredSignal2(error, new Set);
-  if (structured2 !== undefined)
-    return structured2;
-  const message = errorMessage3(error);
-  const name = errorName2(error);
-  const fallbackKind = message.trim().length > 0 ? fallbackKindFromMessage(message, name) : undefined;
-  return {
-    kind: fallbackKind ?? "unknown",
-    message,
-    source: "string_fallback",
-    ...name !== undefined ? { name } : {}
-  };
-}
-function isRetryableModelFailure(error) {
-  if (error === undefined)
-    return false;
-  const signal = normalizeModelFailureSignal(error);
-  return FALLBACKABLE_FAILURE_KINDS.has(signal.kind);
-}
+import {
+  errorMessage as errorMessage3,
+  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";
@@ -62541,7 +62418,7 @@ function truncateTaskOutput(text, maxOutput) {
 [workflow output truncated; limits: ${limits.bytes} bytes, ${limits.lines} lines]`;
 }
 function withoutUndefinedProperties(value2) {
-  return Object.fromEntries(Object.entries(value2).filter(([, field3]) => field3 !== undefined));
+  return Object.fromEntries(Object.entries(value2).filter(([, field2]) => field2 !== undefined));
 }
 function sharedTaskDefaultsFromOptions(options) {
   const {
@@ -62680,11 +62557,12 @@ function setupWorkflowInputGitWorktree(inputDefaults, workflowInvocationCwd, cac
 function workflowCwdWithInputWorktree(inputDefaults, workflowInvocationCwd, cache) {
   return setupWorkflowInputGitWorktree(inputDefaults, workflowInvocationCwd, cache)?.cwd ?? workflowInvocationCwd;
 }
-function workflowInvocationMetadata(inputDefaults, workflowInvocationCwd, cache) {
+function workflowInvocationMetadata(inputDefaults, workflowInvocationCwd, cache, origin) {
   const setup = setupWorkflowInputGitWorktree(inputDefaults, workflowInvocationCwd, cache);
   return {
     invocationCwd: workflowInvocationCwd,
-    ...setup !== undefined ? { workflowCwd: setup.cwd, repositoryRoot: setup.repositoryRoot, gitWorktreeRoot: setup.worktreeRoot } : {}
+    ...setup !== undefined ? { workflowCwd: setup.cwd, repositoryRoot: setup.repositoryRoot, gitWorktreeRoot: setup.worktreeRoot } : {},
+    ...origin !== undefined ? { origin } : {}
   };
 }
 function resolvedTaskCwd(cwd, workflowInvocationCwd) {
@@ -63409,7 +63287,7 @@ function buildPromptNodeUiAdapter(input) {
       },
       async resume() {
         input.activeStore.recordStageResumed(input.runId, stageId);
-        input.activeStore.recordRunResumed(input.runId);
+        input.activeStore.recordRunResumed(input.runId, undefined, { source: "prompt_answer" });
         const currentPauseGate = pauseGate;
         pauseGate = undefined;
         currentPauseGate?.resolve();
@@ -63643,8 +63521,8 @@ function createRunFinalizers(input) {
       ...signal.reason !== undefined ? { exitReason: signal.reason } : {}
     }, input.opts.onRunEnd);
   };
-  const finalizeParentWorkflowExitCancellation = async (abortReason) => {
-    const parentReason = abortReason.workflowExitReason;
+  const finalizeParentWorkflowExitCancellation = async (abortReason2) => {
+    const parentReason = abortReason2.workflowExitReason;
     await input.drainWorkflowExitCleanups(parentReason);
     const exitReason = parentWorkflowExitRunReason(parentReason);
     const metadata = { resumable: false, exited: true, exitReason };
@@ -65043,6 +64921,7 @@ async function resumeDurableWorkflow(workflowId, deps, catalog) {
   const resumeRunOpts = {
     ...deps.baseRunOpts,
     ...handle.invocationCwd !== undefined ? { cwd: handle.invocationCwd } : {},
+    ...handle.origin !== undefined ? { origin: handle.origin } : {},
     runId: resolved.workflowId,
     durableBackend: backend
   };
@@ -66858,7 +66737,7 @@ function createStageControlHandle(runtime) {
         if (changed) {
           runtime.scheduler.releaseStageBarrier(runtime.stageId);
           await runtime.scheduler.cascadeResumeFrom(runtime.stageId);
-          runtime.activeStore.recordRunResumed(runtime.runId);
+          runtime.activeStore.recordRunResumed(runtime.runId, undefined, { source: "stage_control" });
         }
         if (wakeReleasedIdleStageChat)
           runtime.state.wakeWaitingForStageChatTurn?.();
@@ -67028,6 +66907,7 @@ import { createStructuredOutputCapture, runCallback as runCallback2 } from "@bas
 
 // dist/builtin/workflows/src/runs/foreground/stage-runner-controller.ts
 import {
+  convertToLlm,
   shouldApplyCodexFastModeForScope
 } from "@bastani/atomic";
 
@@ -67915,6 +67795,54 @@ function terminatingToolCallId(event) {
 }
 
 // dist/builtin/workflows/src/runs/foreground/stage-runner-controller.ts
+function isSessionCreationPauseResult(value2) {
+  return "kind" in value2 && value2.kind === "paused";
+}
+
+class StageSessionCreationCancelled extends Error {
+  constructor() {
+    super("atomic-workflows: stage session creation was cancelled while paused");
+    this.name = "StageSessionCreationCancelled";
+  }
+}
+function stageUserMessageText(message) {
+  if (message.role !== "user")
+    return;
+  if (typeof message.content === "string")
+    return message.content;
+  return message.content.filter((part) => part.type === "text").map((part) => part.text).join("");
+}
+function retrySettingsManagerFromError(error) {
+  if (error === null || typeof error !== "object")
+    return;
+  const manager = error.settingsManager;
+  if (manager === null || typeof manager !== "object")
+    return;
+  const candidate = manager;
+  return typeof candidate.getCodexFastModeSettings === "function" ? candidate : undefined;
+}
+function retryableAgentSession(activeSession) {
+  const session = asAgentSession(activeSession);
+  if (session === undefined)
+    return;
+  const candidate = session;
+  return typeof candidate._runAgentContinue === "function" ? session : undefined;
+}
+function canContinueFromTranscript(activeSession) {
+  const converted = convertToLlm([...activeSession.messages]);
+  const last = converted[converted.length - 1];
+  return last !== undefined && (last.role === "user" || last.role === "toolResult");
+}
+
+class ThrownErrorRetryPaused extends Error {
+  resume;
+  constructor(resume) {
+    super("atomic-workflows: thrown-error retry paused");
+    this.resume = resume;
+    this.name = "ThrownErrorRetryPaused";
+  }
+}
+
 class StageSessionController {
   opts;
   meta;
@@ -67922,6 +67850,10 @@ class StageSessionController {
   structuredOutputCapture;
   session;
   activeCreation;
+  ownedCreationPromise;
+  abortGeneration = 0;
+  abortReason;
+  abortReasonGeneration = 0;
   sessionPromise;
   reattachSessionFile;
   lastPromptStartIndex;
@@ -67947,7 +67879,10 @@ class StageSessionController {
   pendingFallbackWarnings = [];
   modelCatalog;
   sessionSettingsManager;
+  thrownErrorRetryStates = new Set;
+  creationPauseObservers = new Set;
   replacement = new StageSessionReplacement;
+  pendingCreationResumeMessage;
   messageAdmission = new StageMessageAdmission;
   deliveryActivity = new StageDeliveryActivity;
   constructor(opts, meta2, effectiveStageOptions, structuredOutputCapture) {
@@ -68005,8 +67940,20 @@ class StageSessionController {
       throw new Error(`atomic-workflows: stage "${this.opts.stageName}" session has been disposed`);
     if (this.session !== undefined)
       return this.session;
-    if (!this.sessionPromise)
-      this.sessionPromise = this.createInitialSession(consumer);
+    if (!this.sessionPromise) {
+      const pending = this.createInitialSession(consumer);
+      this.sessionPromise = pending;
+      this.ownedCreationPromise = pending;
+      const release = () => {
+        if (this.ownedCreationPromise === pending)
+          this.ownedCreationPromise = undefined;
+      };
+      pending.then(release, () => {
+        release();
+        if (this.sessionPromise === pending)
+          this.sessionPromise = undefined;
+      });
+    }
     return this.sessionPromise;
   }
   async ensureSessionFromFile(sessionFile, consumer = "prompt") {
@@ -68025,7 +67972,15 @@ class StageSessionController {
       }
       preparation?.beforePreparation?.();
       const sessionFile = preparation?.sessionFile;
-      const deliver = async (activity) => sendStageUserMessage(sessionFile === undefined ? await this.ensureSession("prompt") : await this.ensureSessionFromFile(sessionFile, "prompt"), content, options, beforeDelivery, release, this.messageAdmission, activity);
+      const deliver = async (activity) => {
+        const activeSession = sessionFile === undefined ? await this.ensureSession("prompt") : await this.ensureSessionFromFile(sessionFile, "prompt");
+        const pausedDelivery2 = this.pauseControl.deferRunnerOwnedDelivery(() => sendStageUserMessage(activeSession, content, options, beforeDelivery, release, this.messageAdmission, activity));
+        if (pausedDelivery2 !== undefined) {
+          release();
+          return pausedDelivery2;
+        }
+        return sendStageUserMessage(activeSession, content, options, beforeDelivery, release, this.messageAdmission, activity);
+      };
       if (this.session === undefined || sessionFile !== undefined)
         return this.deliveryActivity.runWithLease(() => deliver());
       return deliver(this.deliveryActivity);
@@ -68047,25 +68002,61 @@ class StageSessionController {
   }
   async promptWithFallback(text, sdkOptions, consumer = "prompt") {
     if (!this.hasExplicitModelFallbackConfig) {
-      await this.promptWithPauseResume(await this.ensureSession(consumer), text, sdkOptions);
+      try {
+        const activeSession = await this.ensureSession(consumer);
+        const resumedText2 = this.pendingCreationResumeMessage;
+        this.pendingCreationResumeMessage = undefined;
+        await this.promptWithThrownErrorRetry(activeSession, resumedText2 ?? text, sdkOptions);
+      } catch (error) {
+        if (error instanceof StageSessionCreationCancelled)
+          return;
+        throw error;
+      }
       return;
     }
     const candidates = await this.modelCandidates();
     if (candidates.length === 0) {
-      await this.promptWithPauseResume(await this.ensureSession(consumer), text, sdkOptions);
+      try {
+        const activeSession = await this.ensureSession(consumer);
+        const resumedText2 = this.pendingCreationResumeMessage;
+        this.pendingCreationResumeMessage = undefined;
+        await this.promptWithThrownErrorRetry(activeSession, resumedText2 ?? text, sdkOptions);
+      } catch (error) {
+        if (error instanceof StageSessionCreationCancelled)
+          return;
+        throw error;
+      }
       return;
     }
-    if (await this.tryResumeCurrentSession(text, sdkOptions, candidates))
+    if (this.session === undefined && this.sessionPromise !== undefined) {
+      try {
+        await this.sessionPromise;
+      } catch (error) {
+        if (error instanceof StageSessionCreationCancelled)
+          return;
+      }
+    }
+    const resumedText = this.pendingCreationResumeMessage;
+    this.pendingCreationResumeMessage = undefined;
+    let promptText = resumedText ?? text;
+    if (await this.tryResumeCurrentSession(promptText, sdkOptions, candidates))
       return;
     let index = this.activeCandidateIndex ?? 0;
     while (index < candidates.length) {
       const candidate = candidates[index];
-      const activeSession = this.session && this.activeCandidateIndex === index ? this.session : await this.createSession(candidate, consumer);
-      this.activeCandidateIndex = index;
-      this.selectedModel = candidate.id;
-      this.notifyModelFallbackMetaChange();
       try {
-        const { terminalScanStartIndex } = await this.promptWithPauseResume(activeSession, text, sdkOptions);
+        const created = this.session && this.activeCandidateIndex === index ? this.session : await this.createSessionWithThrownErrorRetry(candidate, consumer);
+        if (isSessionCreationPauseResult(created)) {
+          if (created.resumeMessage === undefined)
+            return;
+          promptText = created.resumeMessage;
+          continue;
+        }
+        const activeSession = created;
+        this.activeCandidateIndex = index;
+        this.selectedModel = candidate.id;
+        this.notifyModelFallbackMetaChange();
+        const { terminalScanStartIndex } = await this.promptWithThrownErrorRetry(activeSession, promptText, sdkOptions);
         const terminalFailure = latestTerminalAssistantFailureSince(activeSession.messages, terminalScanStartIndex);
         if (terminalFailure !== undefined) {
           if (this.capturedStructuredOutputForAttempt()) {
@@ -68100,6 +68091,9 @@ class StageSessionController {
   }
   async disposeAll() {
     this.disposed = true;
+    const reason = new Error(`atomic-workflows: stage "${this.opts.stageName}" session has been disposed`);
+    this.markAbort(reason);
+    this.pauseControl.reject(reason);
     for (const unsubscribe of this.listenerUnsubscribes.values())
       unsubscribe();
     this.listenerUnsubscribes.clear();
@@ -68112,8 +68106,25 @@ class StageSessionController {
     await this.replacement.dispose();
     await disposeStageSession(this.session);
   }
+  async abort() {
+    const reason = new DOMException("stage aborted", "AbortError");
+    this.markAbort(reason);
+    this.pauseControl.reject(reason);
+    await this.session?.abort();
+  }
   requestPause() {
-    return this.pauseControl.requestPause();
+    const pause = this.pauseControl.requestPause();
+    const resume = this.pauseControl.currentResume();
+    if (resume !== undefined) {
+      this.pauseThrownErrorRetries(resume);
+      for (const observer of this.creationPauseObservers) {
+        if (observer.pauseResume !== undefined)
+          continue;
+        observer.pauseResume = resume;
+        this.latchCreationResume(resume);
+      }
+    }
+    return pause;
   }
   resume(message, beforeResolve, beforeRelease) {
     return this.pauseControl.resume(message, beforeResolve, beforeRelease);
@@ -68134,21 +68145,224 @@ class StageSessionController {
     const { signal } = this.opts;
     if (!signal)
       return;
-    const abortReason = () => {
+    const abortReason2 = () => {
       const reason = signal.reason;
       if (reason instanceof Error || reason instanceof DOMException || typeof reason === "string")
         return reason;
       return new DOMException("workflow killed", "AbortError");
     };
     const onAbort = () => {
+      const reason = abortReason2();
+      this.markAbort(reason);
       this.session?.abort().catch(() => {});
-      this.pauseControl.reject(abortReason());
+      this.pauseControl.reject(reason);
     };
     if (signal.aborted)
       onAbort();
     else
       signal.addEventListener("abort", onAbort, { once: true });
   }
+  markAbort(reason) {
+    this.abortGeneration += 1;
+    this.abortReason = reason;
+    this.abortReasonGeneration = this.abortGeneration;
+    this.abortThrownErrorRetries(reason);
+  }
+  pauseThrownErrorRetries(resume) {
+    for (const state2 of this.thrownErrorRetryStates) {
+      if (state2.pauseResume !== undefined)
+        continue;
+      state2.pauseResume = resume;
+      state2.controller.abort(new ThrownErrorRetryPaused(resume));
+    }
+  }
+  abortThrownErrorRetries(reason) {
+    for (const state2 of this.thrownErrorRetryStates)
+      state2.controller.abort(reason);
+    this.thrownErrorRetryStates.clear();
+  }
+  retrySettings() {
+    const managers = [
+      this.sessionSettingsManager,
+      this.session?.settingsManager,
+      this.effectiveStageOptions?.settingsManager
+    ];
+    for (const manager of managers) {
+      if (manager === undefined || typeof manager.getRetrySettings !== "function")
+        continue;
+      return manager.getRetrySettings();
+    }
+    return;
+  }
+  restoreSessionMessages(session, snapshot, promptText, keepPrompt) {
+    const snapshotMessages = new Set(snapshot);
+    const admitted = session.messages.filter((message) => !snapshotMessages.has(message));
+    const failedAssistantIndex = admitted.findLastIndex((message) => message.role === "assistant" && message.stopReason === "error");
+    const promptUser = admitted.slice(0, failedAssistantIndex < 0 ? admitted.length : failedAssistantIndex).findLast((message) => message.role === "user" && stageUserMessageText(message) === promptText);
+    const retainedMessages = admitted.filter((message) => {
+      if (message === promptUser)
+        return keepPrompt;
+      if (message.role === "assistant")
+        return message.stopReason !== "error";
+      return ["user", "toolResult", "custom", "bashExecution", "branchSummary"].includes(message.role);
+    });
+    session.messages.splice(0, session.messages.length, ...snapshot, ...retainedMessages);
+    return keepPrompt ? promptUser : undefined;
+  }
+  dropRetainedPrompt(session, retained) {
+    if (retained === undefined)
+      return;
+    const index = session.messages.indexOf(retained);
+    if (index >= 0)
+      session.messages.splice(index, 1);
+  }
+  async sleepForThrownErrorRetry(delayMs, state2) {
+    this.thrownErrorRetryStates.add(state2);
+    const currentResume = this.pauseControl.currentResume();
+    if (currentResume !== undefined) {
+      state2.pauseResume = currentResume;
+      state2.controller.abort(new ThrownErrorRetryPaused(currentResume));
+    }
+    try {
+      await sleepOrAbort(delayMs, state2.controller.signal);
+    } finally {
+      this.thrownErrorRetryStates.delete(state2);
+    }
+  }
+  async continueWithPauseResume(continuationSession) {
+    const settlePause = async (resume) => {
+      const resumed = await resume;
+      await resumed.runnerOwnedDeliverySettlement;
+      return { kind: "paused", ...resumed.message === undefined ? {} : { message: resumed.message } };
+    };
+    const pauseBeforeContinue = this.pauseControl.currentResume();
+    if (pauseBeforeContinue !== undefined)
+      return settlePause(pauseBeforeContinue);
+    const state2 = { controller: new AbortController };
+    this.thrownErrorRetryStates.add(state2);
+    try {
+      await continuationSession._runAgentContinue();
+    } catch (error) {
+      const resume = state2.pauseResume ?? this.pauseControl.currentResume();
+      if (resume === undefined)
+        throw error;
+      return settlePause(resume);
+    } finally {
+      this.thrownErrorRetryStates.delete(state2);
+    }
+    const pauseAfterContinue = state2.pauseResume ?? this.pauseControl.currentResume();
+    if (pauseAfterContinue !== undefined)
+      return settlePause(pauseAfterContinue);
+    return { kind: "continued" };
+  }
+  async promptWithThrownErrorRetry(activeSession, text, sdkOptions) {
+    let retryAttempt = 0;
+    let nextText = text;
+    let retryAdmittedPrompt = false;
+    let retainedPrompt;
+    let terminalScanStartIndex;
+    while (true) {
+      const messagesBeforeAttempt = [...activeSession.messages];
+      try {
+        if (retryAdmittedPrompt) {
+          const continuationSession = retryableAgentSession(activeSession);
+          if (continuationSession !== undefined) {
+            const outcome = await this.continueWithPauseResume(continuationSession);
+            if (outcome.kind === "continued") {
+              return {
+                terminalScanStartIndex: terminalScanStartIndex ?? this.lastPromptStartIndex ?? messagesBeforeAttempt.length
+              };
+            }
+            this.dropRetainedPrompt(activeSession, retainedPrompt);
+            retainedPrompt = undefined;
+            retryAdmittedPrompt = false;
+            retryAttempt = 0;
+            terminalScanStartIndex = undefined;
+            if (outcome.message === undefined) {
+              return { terminalScanStartIndex: activeSession.messages.length };
+            }
+            nextText = outcome.message;
+            continue;
+          }
+          this.dropRetainedPrompt(activeSession, retainedPrompt);
+          retainedPrompt = undefined;
+          retryAdmittedPrompt = false;
+        }
+        const result = await this.promptWithPauseResume(activeSession, nextText, sdkOptions);
+        return {
+          terminalScanStartIndex: terminalScanStartIndex ?? result.terminalScanStartIndex
+        };
+      } catch (error) {
+        const errorSettingsManager = retrySettingsManagerFromError(error);
+        if (errorSettingsManager !== undefined)
+          this.sessionSettingsManager = errorSettingsManager;
+        const retryableFailure = isRetryableModelFailure(error);
+        const sameCandidateRetryable = isRetryableSameModelFailure(error) && !isUnresolvedContextOverflowFailure(error);
+        const decision = nextRetryDecision(this.retrySettings(), retryAttempt, sameCandidateRetryable);
+        const continuationSession = retryableAgentSession(activeSession);
+        const admittedMessages = activeSession.messages.length > messagesBeforeAttempt.length;
+        const willRetry = decision !== undefined && !this.disposed && this.opts.signal?.aborted !== true && !this.capturedStructuredOutputForAttempt();
+        const willContinue = continuationSession !== undefined && admittedMessages;
+        if (retryableFailure && willRetry) {
+          retainedPrompt = this.restoreSessionMessages(activeSession, messagesBeforeAttempt, nextText, willContinue) ?? retainedPrompt;
+        }
+        if (!willRetry)
+          throw error;
+        terminalScanStartIndex ??= this.lastPromptStartIndex ?? messagesBeforeAttempt.length;
+        retryAttempt = decision.attempt;
+        const state2 = { controller: new AbortController };
+        let pauseResume;
+        try {
+          await this.sleepForThrownErrorRetry(decision.delayMs, state2);
+        } catch (sleepError) {
+          if (sleepError instanceof ThrownErrorRetryPaused)
+            pauseResume = sleepError.resume;
+          else {
+            if (this.opts.signal?.aborted)
+              throw this.workflowAbortReason();
+            if (this.disposed)
+              throw new Error(`atomic-workflows: stage "${this.opts.stageName}" session has been disposed`);
+            throw sleepError;
+          }
+        }
+        if (pauseResume !== undefined) {
+          const resumed = await pauseResume;
+          retryAttempt = 0;
+          retryAdmittedPrompt = false;
+          terminalScanStartIndex = undefined;
+          this.dropRetainedPrompt(activeSession, retainedPrompt);
+          retainedPrompt = undefined;
+          if (resumed.message === undefined) {
+            return { terminalScanStartIndex: activeSession.messages.length };
+          }
+          nextText = resumed.message;
+          continue;
+        }
+        if (this.disposed)
+          throw new Error(`atomic-workflows: stage "${this.opts.stageName}" session has been disposed`);
+        if (this.opts.signal?.aborted)
+          throw this.workflowAbortReason();
+        retryAdmittedPrompt = willContinue && canContinueFromTranscript(activeSession);
+        if (!retryAdmittedPrompt) {
+          this.dropRetainedPrompt(activeSession, retainedPrompt);
+          retainedPrompt = undefined;
+        }
+      }
+    }
+  }
+  workflowAbortReason() {
+    const reason = this.opts.signal?.reason;
+    if (reason instanceof Error || reason instanceof DOMException || typeof reason === "string")
+      return reason;
+    return new DOMException("workflow killed", "AbortError");
+  }
+  staleCreationReason(startGeneration) {
+    if (this.opts.signal?.aborted)
+      return this.workflowAbortReason();
+    if (this.abortReasonGeneration > startGeneration && this.abortReason !== undefined)
+      return this.abortReason;
+    return new DOMException("stage aborted", "AbortError");
+  }
   modelCandidates() {
     if (!this.candidatesPromise) {
       this.candidatesPromise = buildModelCandidatesFromCatalog({
@@ -68161,12 +68375,14 @@ class StageSessionController {
     return this.candidatesPromise;
   }
   async createInitialSession(consumer) {
-    if (!this.hasExplicitModelFallbackConfig)
-      return this.createSession(undefined, consumer);
+    if (!this.hasExplicitModelFallbackConfig) {
+      return this.createSessionObservingPause(undefined, consumer).catch((error) => this.createInitialSessionWithRetry(undefined, consumer, { error }));
+    }
     const candidates = await this.modelCandidates();
     const first = candidates[0];
-    if (first === undefined)
-      return this.createSession(undefined, consumer);
+    if (first === undefined) {
+      return this.createSessionObservingPause(undefined, consumer).catch((error) => this.createInitialSessionWithRetry(undefined, consumer, { error }));
+    }
     if (this.reattachSessionFile !== undefined) {
       const resumed = await this.createSession(undefined, consumer, { restoreSavedModel: true });
       const restoredId = workflowModelId(resumed.model);
@@ -68178,7 +68394,119 @@ class StageSessionController {
     }
     this.activeCandidateIndex = 0;
     this.selectedModel = first.id;
-    return this.createSession(first, consumer);
+    return this.createSessionObservingPause(first, consumer).catch((error) => this.createInitialSessionCandidateWalk(candidates, consumer, 0, { error }));
+  }
+  async createInitialSessionCandidateWalk(candidates, consumer, startIndex, initialFailure) {
+    let index = startIndex;
+    let pendingFailure = initialFailure;
+    let lastError = initialFailure?.error;
+    while (index < candidates.length) {
+      const candidate = candidates[index];
+      this.activeCandidateIndex = index;
+      this.selectedModel = candidate.id;
+      try {
+        const created = await this.createSessionWithThrownErrorRetry(candidate, consumer, pendingFailure);
+        pendingFailure = undefined;
+        if (!isSessionCreationPauseResult(created)) {
+          this.notifyModelFallbackMetaChange();
+          return created;
+        }
+        if (created.resumeMessage === undefined) {
+          this.pendingCreationResumeMessage = undefined;
+          this.sessionPromise = undefined;
+          throw new StageSessionCreationCancelled;
+        }
+        this.pendingCreationResumeMessage = created.resumeMessage;
+      } catch (error) {
+        if (error instanceof StageSessionCreationCancelled)
+          throw error;
+        pendingFailure = undefined;
+        lastError = error;
+        if (await this.handleCandidateFailure(error, candidate, candidates, index) !== "retry")
+          throw error;
+        index += 1;
+      }
+    }
+    throw lastError ?? new Error(`atomic-workflows: stage "${this.opts.stageName}" has no usable model candidate`);
+  }
+  async createInitialSessionWithRetry(candidate, consumer, initialFailure) {
+    let pendingFailure = initialFailure;
+    while (true) {
+      const created = await this.createSessionWithThrownErrorRetry(candidate, consumer, pendingFailure);
+      pendingFailure = undefined;
+      if (!isSessionCreationPauseResult(created))
+        return created;
+      if (created.resumeMessage === undefined) {
+        this.pendingCreationResumeMessage = undefined;
+        this.sessionPromise = undefined;
+        throw new StageSessionCreationCancelled;
+      }
+      this.pendingCreationResumeMessage = created.resumeMessage;
+    }
+  }
+  latchCreationResume(resume) {
+    resume.then(async (resolved) => {
+      await resolved.runnerOwnedDeliverySettlement;
+      if (resolved.message !== undefined)
+        this.pendingCreationResumeMessage = resolved.message;
+    }).catch(() => {});
+  }
+  createSessionObservingPause(candidate, consumer) {
+    const activePause = this.pauseControl.currentResume();
+    const observer = { pauseResume: activePause };
+    if (activePause !== undefined)
+      this.latchCreationResume(activePause);
+    this.creationPauseObservers.add(observer);
+    const creation = this.createSession(candidate, consumer);
+    const settle = () => {
+      this.creationPauseObservers.delete(observer);
+    };
+    creation.then(settle, settle);
+    return creation;
+  }
+  async createSessionWithThrownErrorRetry(candidate, consumer, initialFailure) {
+    let retryAttempt = 0;
+    let pendingFailure = initialFailure;
+    while (true) {
+      try {
+        if (pendingFailure !== undefined) {
+          const failure3 = pendingFailure;
+          pendingFailure = undefined;
+          throw failure3.error;
+        }
+        return await this.createSessionObservingPause(candidate, consumer);
+      } catch (error) {
+        const errorSettingsManager = retrySettingsManagerFromError(error);
+        if (errorSettingsManager !== undefined)
+          this.sessionSettingsManager = errorSettingsManager;
+        const decision = nextRetryDecision(this.retrySettings(), retryAttempt, isRetryableSameModelFailure(error));
+        if (decision === undefined || this.disposed || this.opts.signal?.aborted === true || this.capturedStructuredOutputForAttempt()) {
+          throw error;
+        }
+        retryAttempt = decision.attempt;
+        const state2 = { controller: new AbortController };
+        try {
+          await this.sleepForThrownErrorRetry(decision.delayMs, state2);
+        } catch (sleepError) {
+          if (sleepError instanceof ThrownErrorRetryPaused) {
+            const resumed = await sleepError.resume;
+            return {
+              kind: "paused",
+              ...resumed.message === undefined ? {} : { resumeMessage: resumed.message }
+            };
+          }
+          if (this.opts.signal?.aborted)
+            throw this.workflowAbortReason();
+          if (this.disposed)
+            throw new Error(`atomic-workflows: stage "${this.opts.stageName}" session has been disposed`);
+          throw sleepError;
+        }
+        if (this.disposed)
+          throw new Error(`atomic-workflows: stage "${this.opts.stageName}" session has been disposed`);
+        if (this.opts.signal?.aborted)
+          throw this.workflowAbortReason();
+      }
+    }
   }
   createSession(candidate, consumer, resumeOptions) {
     const creation = this.createSessionAttempt(candidate, consumer, resumeOptions);
@@ -68190,6 +68518,7 @@ class StageSessionController {
     return creation;
   }
   async createSessionAttempt(candidate, consumer, resumeOptions) {
+    const startGeneration = this.abortGeneration;
     this.applyCandidateThinking(candidate);
     const stageOptions = buildStageSessionOptions({
       effectiveStageOptions: this.effectiveStageOptions,
@@ -68198,11 +68527,24 @@ class StageSessionController {
       reattachSessionFile: this.reattachSessionFile,
       sharedModelRuntime: this.sharedModelRuntime
     });
-    const created = this.opts.adapters.agentSession ? await this.opts.adapters.agentSession.create(stripWorkflowOnlyOptions(stageOptions, this.opts.defaultSessionDir, this.meta), {
-      ...this.meta,
-      stageOptions,
-      ...this.sharedOrchestrationContext !== undefined ? { orchestrationContext: this.sharedOrchestrationContext } : {}
-    }) : missingAdapter(consumer);
+    let created;
+    try {
+      created = this.opts.adapters.agentSession ? await this.opts.adapters.agentSession.create(stripWorkflowOnlyOptions(stageOptions, this.opts.defaultSessionDir, this.meta), {
+        ...this.meta,
+        stageOptions,
+        ...this.sharedOrchestrationContext !== undefined ? { orchestrationContext: this.sharedOrchestrationContext } : {}
+      }) : missingAdapter(consumer);
+    } catch (error) {
+      if (this.disposed || this.opts.signal?.aborted === true || this.abortGeneration !== startGeneration)
+        throw this.disposed ? new Error(`atomic-workflows: stage "${this.opts.stageName}" session has been disposed`) : this.staleCreationReason(startGeneration);
+      throw error;
+    }
+    if (this.disposed || this.opts.signal?.aborted === true || this.abortGeneration !== startGeneration) {
+      await disposeStageSession(normalizeSessionCreateResult(created).session).catch(() => {});
+      if (this.disposed)
+        throw new Error(`atomic-workflows: stage "${this.opts.stageName}" session has been disposed`);
+      throw this.staleCreationReason(startGeneration);
+    }
     return attachCreatedStageSession(created, this.disposed, this.opts.stageName, (result) => this.attachSession(result));
   }
   attachSession(created) {
@@ -68242,11 +68584,13 @@ class StageSessionController {
     return result.session;
   }
   async disposeCurrentSession() {
+    this.abortThrownErrorRetries(new Error(`atomic-workflows: stage "${this.opts.stageName}" session was replaced`));
     const current = this.session;
     this.messageAdmission.reset();
     this.replacement.retire(current);
     this.session = undefined;
-    this.sessionPromise = undefined;
+    if (this.sessionPromise !== this.ownedCreationPromise)
+      this.sessionPromise = undefined;
     this.sessionSettingsManager = undefined;
     this.resumeCurrentSession = false;
     for (const unsubscribe of this.listenerUnsubscribes.values())
@@ -68310,7 +68654,7 @@ class StageSessionController {
     const resumedLabel = this.selectedModel ?? workflowModelId(resumedSession.model) ?? candidates[0].id;
     this.notifyModelFallbackMetaChange();
     try {
-      const { terminalScanStartIndex } = await this.promptWithPauseResume(resumedSession, text, sdkOptions);
+      const { terminalScanStartIndex } = await this.promptWithThrownErrorRetry(resumedSession, text, sdkOptions);
       const terminalFailure = latestTerminalAssistantFailureSince(resumedSession.messages, terminalScanStartIndex);
       if (terminalFailure === undefined || this.capturedStructuredOutputForAttempt()) {
         this.modelAttempts.push({ model: resumedLabel, success: true });
@@ -68765,7 +69109,7 @@ function createStageContext2(opts) {
       controller.currentSession?.abortCompaction();
     },
     async abort() {
-      await controller.currentSession?.abort();
+      await controller.abort();
     },
     async __dispose() {
       await controller.disposeAll();
@@ -69314,6 +69658,7 @@ async function run(def, inputs, opts = {}) {
   const rootBackend = opts.durableRootBackend ?? backendView;
   const durableBackend = opts.durableScope !== undefined ? new ScopedDurableBackend(backendView, opts.durableScope) : backendView;
   const inheritedElapsedMs = opts.parentRun === undefined ? inheritedRunElapsedMs({ backend: durableBackend, runId, continuationSource: opts.continuation?.source }) : undefined;
+  const continuationOrigin = opts.continuation !== undefined ? opts.continuation.source.origin : opts.origin;
   const runSnapshot = {
     id: runId,
     name: def.name,
@@ -69331,6 +69676,8 @@ async function run(def, inputs, opts = {}) {
       resumedFromRunId: opts.continuation.source.id,
       resumeFromStageId: opts.continuation.resumeFromStageId
     } : {},
+    ...continuationOrigin !== undefined ? { origin: continuationOrigin } : {},
+    ...opts.resumeActor !== undefined ? { resumeActor: opts.resumeActor, resumeSource: "run_control" } : {},
     ...inheritedElapsedMs !== undefined ? { accumulatedDurationMs: inheritedElapsedMs } : {}
   };
   const classifiedFailures = new Map;
@@ -69361,6 +69708,7 @@ async function run(def, inputs, opts = {}) {
       ...runSnapshot.parentStageId !== undefined ? { parentStageId: runSnapshot.parentStageId } : {},
       ...runSnapshot.rootRunId !== undefined ? { rootRunId: runSnapshot.rootRunId } : {},
       ...runSnapshot.resumedFromRunId !== undefined ? { resumedFromRunId: runSnapshot.resumedFromRunId } : {},
+      ...runSnapshot.origin !== undefined ? { origin: runSnapshot.origin } : {},
       ...runSnapshot.resumeFromStageId !== undefined ? { resumeFromStageId: runSnapshot.resumeFromStageId } : {},
       ...runSnapshot.accumulatedDurationMs !== undefined ? { accumulatedDurationMs: runSnapshot.accumulatedDurationMs } : {},
       ts: runSnapshot.startedAt
@@ -69664,7 +70012,7 @@ async function run(def, inputs, opts = {}) {
       isChildRun: opts.parentRun !== undefined,
       registration: durableRootRegistration === undefined ? undefined : {
         ...durableRootRegistration,
-        ...workflowInvocationMetadata(inputRuntimeDefaults, workflowInvocationCwd, gitWorktreeSetupCache)
+        ...workflowInvocationMetadata(inputRuntimeDefaults, workflowInvocationCwd, gitWorktreeSetupCache, runSnapshot.origin)
       }
     });
     if (opts.deferWorkflowStart === true)
@@ -69989,21 +70337,21 @@ function validateConfig2(config) {
     return "config must be an object";
   }
   const c = config;
-  for (const field3 of ["projectWorkflows", "globalWorkflows"]) {
-    const val = c[field3];
+  for (const field2 of ["projectWorkflows", "globalWorkflows"]) {
+    const val = c[field2];
     if (val !== undefined) {
       if (Array.isArray(val)) {
         for (const entry of val) {
           if (typeof entry !== "string")
-            return `config.${field3} entries must be strings`;
+            return `config.${field2} entries must be strings`;
         }
       } else if (typeof val === "object" && val !== null) {
         for (const [key2, entry] of Object.entries(val)) {
           if (typeof entry !== "string")
-            return `config.${field3}["${key2}"] must be a string path`;
+            return `config.${field2}["${key2}"] must be a string path`;
         }
       } else {
-        return `config.${field3} must be a string array or a Record<string, string> map`;
+        return `config.${field2} must be a string array or a Record<string, string> map`;
       }
     }
   }
@@ -70261,6 +70609,7 @@ async function dispatch(args, opts) {
           executionMode: policy.mode,
           cwd: opts.cwd,
           defaultSessionDir: opts.defaultSessionDir,
+          ...opts.origin === undefined ? {} : { origin: opts.origin },
           runId
         });
       } catch (error) {
@@ -70606,7 +70955,10 @@ function createDurableResumeRuntime(deps) {
         await backend.hydrateWorkflow(resolved.workflowId);
       const adapterDeps = {
         registry: deps.registry,
-        baseRunOpts: deps.baseRunOpts(options?.policy),
+        baseRunOpts: {
+          ...deps.baseRunOpts(options?.policy),
+          ...options?.actor === undefined ? {} : { resumeActor: options.actor }
+        },
         durableBackend: backend,
         resolveDefinition: async (name, cwd) => (await discoverWorkflows({ cwd: cwd ?? deps.runtimeCwd })).registry.get(name),
         ...deps.jobs !== undefined ? { jobs: deps.jobs } : {}
@@ -70791,6 +71143,7 @@ function createExtensionRuntime(opts = {}) {
     const launchContinuation = () => launchDetachedUntilStartup(def, sourceInputs, {
       ...runOptions(options?.policy),
       continuation: { source, resumeFromStageId: resolvedStage.stageId },
+      ...options?.actor === undefined ? {} : { resumeActor: options.actor },
       ...jobs !== undefined ? { jobs } : {}
     });
     if (isActiveBlockedResumable) {
@@ -70907,6 +71260,7 @@ function createExtensionRuntime(opts = {}) {
         config,
         models,
         policy: options?.policy,
+        ...options?.origin === undefined ? {} : { origin: options.origin },
         cwd: runtimeCwd,
         ...defaultSessionDir !== undefined ? { defaultSessionDir } : {}
       });
@@ -71567,6 +71921,12 @@ function renderRunSummary(payload) {
 
 // dist/builtin/workflows/src/extension/atomic-stage-session.ts
 import { basename as basename5 } from "node:path";
+var WORKFLOW_STAGE_SUBAGENT_POLICY = {
+  managementActions: "full",
+  fanoutAuthorized: false,
+  inheritProjectContext: true,
+  inheritSkills: true
+};
 function resolveSessionCwd(options) {
   return options?.cwd ?? options?.sessionManager?.getCwd() ?? process.cwd();
 }
@@ -71579,6 +71939,7 @@ async function prepareAtomicStageSessionOptions(options, sdk, prepareOptions = {
   const hasAgentDirOverride = atomicOptions?.agentDir !== undefined;
   const agentDir = atomicOptions?.agentDir ?? sdk.getAgentDir();
   const settingsManager = atomicOptions?.settingsManager ?? sdk.SettingsManager.create(cwd, agentDir, inheritanceSnapshot?.projectTrusted === undefined ? undefined : { projectTrusted: inheritanceSnapshot.projectTrusted });
+  prepareOptions.onSettingsManager?.(settingsManager);
   const inheritedBuiltinPackagePaths = inheritanceSnapshot?.builtinPackagePaths;
   const builtinPackagePaths = inheritedBuiltinPackagePaths === undefined ? sdk.getBuiltinPackagePaths?.() ?? [] : [...inheritedBuiltinPackagePaths];
   const resourceLoader = new sdk.DefaultResourceLoader({
@@ -71594,7 +71955,8 @@ async function prepareAtomicStageSessionOptions(options, sdk, prepareOptions = {
     cwd,
     ...hasAgentDirOverride ? { agentDir } : {},
     settingsManager,
-    resourceLoader
+    resourceLoader,
+    subagentPolicy: WORKFLOW_STAGE_SUBAGENT_POLICY
   };
 }
 function clonePackageSource(source) {
@@ -71623,54 +71985,67 @@ function stageBuiltinPackagePaths(paths) {
     return basename5(packageSourcePath(cloned)) === "workflows" ? disablePackageExtensions(cloned) : cloned;
   });
 }
-var SUBAGENT_CHILD_EXTENSION_ENV_KEYS = [
-  "ATOMIC_SUBAGENT_CHILD",
-  "ATOMIC_SUBAGENT_FANOUT_CHILD",
-  "PI_SUBAGENT_CHILD",
-  "PI_SUBAGENT_FANOUT_CHILD"
-];
 var workflowStageResourceReloadQueue = Promise.resolve();
 async function reloadWorkflowStageResources(resourceLoader) {
-  const queuedReload = workflowStageResourceReloadQueue.then(() => reloadWorkflowStageResourcesWithEnvIsolation(resourceLoader));
+  const queuedReload = workflowStageResourceReloadQueue.then(() => resourceLoader.reload());
   workflowStageResourceReloadQueue = queuedReload.catch(() => {
     return;
   });
   return queuedReload;
 }
-async function reloadWorkflowStageResourcesWithEnvIsolation(resourceLoader) {
-  const previousValues = new Map;
-  for (const key2 of SUBAGENT_CHILD_EXTENSION_ENV_KEYS) {
-    previousValues.set(key2, process.env[key2]);
-    delete process.env[key2];
-  }
-  try {
-    await resourceLoader.reload();
-  } finally {
-    for (const key2 of SUBAGENT_CHILD_EXTENSION_ENV_KEYS) {
-      const previousValue = previousValues.get(key2);
-      if (previousValue === undefined)
-        delete process.env[key2];
-      else
-        process.env[key2] = previousValue;
-    }
-  }
-}
 
 // dist/builtin/workflows/src/extension/wiring.ts
 var LATE_STAGE_MESSAGE_EVENT2 = "atomic:workflow-stage-late-message";
 function isTestContext() {
   return process.env.NODE_TEST_CONTEXT !== undefined || false;
 }
+function attachSettingsManager(error, settingsManager) {
+  if (error !== null && (typeof error === "object" || typeof error === "function")) {
+    try {
+      if (Object.isExtensible(error)) {
+        Object.defineProperty(error, "settingsManager", {
+          configurable: true,
+          enumerable: false,
+          value: settingsManager,
+          writable: false
+        });
+        return error;
+      }
+    } catch {}
+  }
+  const wrapped = new Error(error instanceof Error ? error.message : String(error), { cause: error });
+  Object.defineProperty(wrapped, "settingsManager", {
+    configurable: true,
+    enumerable: false,
+    value: settingsManager,
+    writable: false
+  });
+  return wrapped;
+}
 async function createPiSdkAgentSession(options, prepareOptions) {
   const sdk = await import("@bastani/atomic");
-  const sessionOptions = await prepareAtomicStageSessionOptions(options, sdk, prepareOptions);
-  const result = await sdk.createAgentSession(sessionOptions);
-  const resultSettingsManager = result.session.settingsManager;
-  const settingsManager = sessionOptions?.settingsManager ?? resultSettingsManager;
-  return {
-    session: result.session,
-    ...settingsManager?.getCodexFastModeSettings !== undefined ? { settingsManager } : {}
-  };
+  let settingsManager;
+  try {
+    const sessionOptions = await prepareAtomicStageSessionOptions(options, sdk, {
+      ...prepareOptions,
+      onSettingsManager: (manager) => {
+        settingsManager = manager;
+        prepareOptions?.onSettingsManager?.(manager);
+      }
+    });
+    settingsManager = sessionOptions?.settingsManager ?? settingsManager;
+    const result = await sdk.createAgentSession(sessionOptions);
+    const resultSettingsManager = result.session.settingsManager;
+    settingsManager = sessionOptions?.settingsManager ?? resultSettingsManager ?? settingsManager;
+    return {
+      session: result.session,
+      ...settingsManager?.getCodexFastModeSettings !== undefined ? { settingsManager } : {}
+    };
+  } catch (error) {
+    if (settingsManager !== undefined)
+      throw attachSettingsManager(error, settingsManager);
+    throw error;
+  }
 }
 async function createTestAgentSession(_options) {
   let lastAssistantText;
@@ -71965,23 +72340,23 @@ function renderPretty(name, inputs, theme, width) {
     width: boxWidth
   });
 }
-function renderInputRows(field3, theme) {
-  const tagLabel = field3.required ? "required" : "optional";
-  const heading = theme ? ` ${paint(field3.name, theme.text, { bold: true })}  ${paint(field3.type, theme.dim)}  ·  ${paint(tagLabel, field3.required ? theme.warning : theme.dim)} ` : ` ${field3.name}  ${field3.type}  ·  ${tagLabel} `;
+function renderInputRows(field2, theme) {
+  const tagLabel = field2.required ? "required" : "optional";
+  const heading = theme ? ` ${paint(field2.name, theme.text, { bold: true })}  ${paint(field2.type, theme.dim)}  ·  ${paint(tagLabel, field2.required ? theme.warning : theme.dim)} ` : ` ${field2.name}  ${field2.type}  ·  ${tagLabel} `;
   const lines = [heading];
-  if (field3.description) {
-    lines.push(`   ${theme ? paint(field3.description, theme.textMuted) : field3.description} `);
+  if (field2.description) {
+    lines.push(`   ${theme ? paint(field2.description, theme.textMuted) : field2.description} `);
   }
-  if (field3.choices && field3.choices.length > 0) {
-    const values = field3.choices.join("  ·  ");
+  if (field2.choices && field2.choices.length > 0) {
+    const values = field2.choices.join("  ·  ");
     lines.push(`   ${theme ? paint("values: ", theme.dim) + paint(values, theme.text) : `values: ${values}`} `);
   }
-  if (field3.default !== undefined) {
-    const value2 = JSON.stringify(field3.default);
+  if (field2.default !== undefined) {
+    const value2 = JSON.stringify(field2.default);
     lines.push(`   ${theme ? paint("default: ", theme.dim) + paint(value2, theme.text) : `default: ${value2}`} `);
   }
-  if (field3.placeholder) {
-    lines.push(`   ${theme ? paint("placeholder: ", theme.dim) + paint(field3.placeholder, theme.textMuted) : `placeholder: ${field3.placeholder}`} `);
+  if (field2.placeholder) {
+    lines.push(`   ${theme ? paint("placeholder: ", theme.dim) + paint(field2.placeholder, theme.textMuted) : `placeholder: ${field2.placeholder}`} `);
   }
   return lines;
 }
@@ -72006,14 +72381,14 @@ function supportedType(type) {
       return "string";
   }
 }
-function initialValue(field3, prefilled) {
-  if (prefilled[field3.name] !== undefined)
-    return String(prefilled[field3.name]);
-  if (field3.default !== undefined)
-    return String(field3.default);
-  if (field3.type === "select" && field3.choices && field3.choices.length > 0)
-    return field3.choices[0];
-  if (field3.type === "boolean")
+function initialValue(field2, prefilled) {
+  if (prefilled[field2.name] !== undefined)
+    return String(prefilled[field2.name]);
+  if (field2.default !== undefined)
+    return String(field2.default);
+  if (field2.type === "select" && field2.choices && field2.choices.length > 0)
+    return field2.choices[0];
+  if (field2.type === "boolean")
     return "false";
   return "";
 }
@@ -72022,14 +72397,14 @@ async function openHostInputsForm(ui, options) {
   if (typeof open !== "function")
     return { kind: "unsupported" };
   const prefilled = options.prefilled ?? {};
-  const fields = options.fields.map((field3) => ({
-    name: field3.name,
-    type: supportedType(field3.type),
-    initialValue: initialValue(field3, prefilled),
-    ...field3.description !== undefined ? { description: field3.description } : {},
-    ...field3.required !== undefined ? { required: field3.required } : {},
-    ...field3.choices !== undefined ? { choices: [...field3.choices] } : {},
-    ...field3.placeholder !== undefined ? { placeholder: field3.placeholder } : {}
+  const fields = options.fields.map((field2) => ({
+    name: field2.name,
+    type: supportedType(field2.type),
+    initialValue: initialValue(field2, prefilled),
+    ...field2.description !== undefined ? { description: field2.description } : {},
+    ...field2.required !== undefined ? { required: field2.required } : {},
+    ...field2.choices !== undefined ? { choices: [...field2.choices] } : {},
+    ...field2.placeholder !== undefined ? { placeholder: field2.placeholder } : {}
   }));
   try {
     const raw = await open.call(ui, {
@@ -72140,6 +72515,9 @@ function openInputsPicker(ui, opts) {
 // dist/builtin/workflows/src/tui/session-picker.ts
 import { keyText as keyText2 } from "@bastani/atomic";
 var ESCAPE_CODE = 27;
+function isQuitRun3(run2) {
+  return run2.endedAt === undefined && run2.status === "paused" && run2.exitReason === "quit";
+}
 var DOUBLE_ESCAPE_SEQUENCE = String.fromCharCode(ESCAPE_CODE, ESCAPE_CODE);
 function createSessionPickerState() {
   return { query: "", selectedIndex: 0, includeAll: true, filterFocused: false };
@@ -72280,12 +72658,13 @@ function stageProgress(run2) {
   const done = run2.stages.filter((s) => s.status === "completed" || s.status === "failed").length;
   return `${done}/${total} stages`;
 }
-function renderRunRow(row, isSelected, inner, theme, now) {
+function renderRunRow(row, isSelected, inner, theme, now, allRuns) {
   const border = hexToAnsi(theme.border);
   const panelBg = hexBg(theme.bg);
   const run2 = row.run;
-  const icon = statusIcon(run2.status);
-  const iconColor = hexToAnsi(statusColor(run2.status, theme));
+  const indicatorStatus = isQuitRun3(run2) ? run2.status : runIndicatorStatus(run2, allRuns);
+  const icon = statusIcon(indicatorStatus);
+  const iconColor = hexToAnsi(statusColor(indicatorStatus, theme));
   const dim = hexToAnsi(theme.dim);
   const text = hexToAnsi(theme.text);
   const muted = hexToAnsi(theme.textMuted);
@@ -72339,6 +72718,7 @@ function renderSessionPicker(opts) {
   const start = Math.max(0, Math.min(sel - Math.floor(VIEWPORT / 2), rows.length - VIEWPORT));
   const visible = rows.slice(Math.max(0, start), Math.max(0, start) + VIEWPORT);
   let prevBucket = null;
+  const allRuns = opts.allRuns ?? rows.map(({ run: run2 }) => run2);
   for (let i = 0;i < visible.length; i++) {
     const row = visible[i];
     if (row.bucket !== prevBucket) {
@@ -72346,7 +72726,7 @@ function renderSessionPicker(opts) {
       prevBucket = row.bucket;
     }
     const absIndex = Math.max(0, start) + i;
-    lines.push(...renderRunRow(row, absIndex === sel, inner, theme, now));
+    lines.push(...renderRunRow(row, absIndex === sel, inner, theme, now, allRuns));
   }
   lines.push(renderBlankRow(inner, theme));
   lines.push(renderBottomBorder(width, theme));
@@ -72686,7 +73066,7 @@ function renderSessionList(runs, opts) {
       toolNodes: graph.tools.map((tool) => structuredClone(tool))
     };
   });
-  return renderStatusList(filtered, { theme: opts.theme, now });
+  return renderStatusList(filtered, { theme: opts.theme, now, allRuns: runs });
 }
 
 // dist/builtin/workflows/src/tui/session-overlays.ts
@@ -72707,6 +73087,7 @@ function openSessionPicker(ui, store2, theme, intent = "connect") {
     const state2 = createSessionPickerState();
     let settled = false;
     let unsubscribe = null;
+    let pickerRevision = 0;
     const resumeCandidateCache = createSessionPickerResumeCandidateCache();
     const factory = (tui, _theme, _keys, done) => {
       const finish = (result) => {
@@ -72719,15 +73100,18 @@ function openSessionPicker(ui, store2, theme, intent = "connect") {
         resolve14(result);
       };
       const selectRows = () => {
-        const snapshot = readGraphStoreSnapshot(store2);
-        const resumeCandidateLookup = intent === "resume" ? resumeCandidateCache({ ...snapshot, runs: store2.runs() }) : undefined;
-        return selectRunsForPicker(snapshot.runs, state2.query, state2.includeAll, Date.now(), intent, resumeCandidateLookup);
+        const liveRuns = store2.runs();
+        const resumeCandidateLookup = intent === "resume" ? resumeCandidateCache({ runs: liveRuns, notices: store2.notices(), version: pickerRevision }) : undefined;
+        return selectRunsForPicker(liveRuns, state2.query, state2.includeAll, Date.now(), intent, resumeCandidateLookup);
       };
-      unsubscribe = subscribeStoreInvalidation(store2, () => tui.requestRender?.());
+      unsubscribe = subscribeStoreInvalidation(store2, () => {
+        pickerRevision++;
+        tui.requestRender?.();
+      });
       return {
         render: (width) => {
           const rows = selectRows();
-          return renderSessionPicker({ width, theme, rows, state: state2 });
+          return renderSessionPicker({ width, theme, rows, state: state2, allRuns: store2.runs() });
         },
         handleInput: (data) => {
           const rows = selectRows();
@@ -73056,7 +73440,7 @@ async function handleDurableResume(target, ctx, reporter, deps, preparedCatalog)
       fail(completedAttempt.message);
       return true;
     }
-    const result = await runtime.resumeDurableWorkflow(target, { policy });
+    const result = await runtime.resumeDurableWorkflow(target, { policy, actor: "user" });
     fail(allOpenable.length === 0 ? result.message : `${result.message}
 
 ${formatResumableWorkflowList(allOpenable)}`);
@@ -73125,7 +73509,10 @@ function isExplicitResumeCandidate(run2) {
   return isWorkflowRunResumable(workflowRunResumeCandidate(run2)) || run2.endedAt === undefined && run2.status === "running";
 }
 async function resumeDurableTarget(workflowId, ctx, reporter, deps, runtime) {
-  const result = await runtime.resumeDurableWorkflow(workflowId, { policy: workflowPolicyFromContext(ctx) });
+  const result = await runtime.resumeDurableWorkflow(workflowId, {
+    policy: workflowPolicyFromContext(ctx),
+    actor: "user"
+  });
   if (!result.ok)
     reporter.error(result.message);
   else {
@@ -73300,7 +73687,7 @@ ${renderSessionList(store.runs(), { theme, includeAll: true })}`);
           return true;
         }
       }
-      const results = action === "quit" ? await quitAllRuns() : await interruptAllRuns();
+      const results = action === "quit" ? await quitAllRuns({ actor: "user" }) : await interruptAllRuns();
       const successes = results.filter((result) => result.ok);
       const changed = successes.length;
       const failures = results.filter((result) => !result.ok);
@@ -73334,7 +73721,7 @@ ${renderSessionList(store.runs(), { theme, includeAll: true })}`);
         return true;
       }
       try {
-        const result = await quitRun(resolved.runId);
+        const result = await quitRun(resolved.runId, { actor: "user" });
         if (result.ok)
           print(`Run ${result.runId} quit and can be resumed with /workflow resume.`);
         else if (result.reason === "already_ended")
@@ -73427,11 +73814,11 @@ Picker requires an interactive UI surface. Pass a runId: /workflow attach <id> [
           const isResumableContinuation2 = run3 !== undefined && !isPaused3 && run3.exitReason !== "quit" && isWorkflowRunResumable(workflowRunResumeCandidate(run3));
           if (isResumableContinuation2) {
             await ensureWorkflowResourcesVisible();
-            const continuation = await deps.runtimeForContext(ctx).resumeFailedRun(resolved.runId, undefined, { policy });
+            const continuation = await deps.runtimeForContext(ctx).resumeFailedRun(resolved.runId, undefined, { policy, actor: "user" });
             continuation.ok ? print(continuation.message) : fail(continuation.message);
           } else {
             try {
-              const result2 = await resumeRun(resolved.runId, {});
+              const result2 = await resumeRun(resolved.runId, { actor: "user" });
               if (result2.ok && !isPaused3 && result2.mode === "snapshot" && run3?.exitReason === "quit") {
                 return await handleDurableResume(resolved.runId, ctx, reporter, deps);
               }
@@ -73541,7 +73928,7 @@ Picker requires an interactive UI surface. Pass a runId: /workflow attach <id> [
     const stageRunId = resolvedStage.runId ?? runId;
     if (action === "pause") {
       try {
-        const result2 = await pauseRun(stageRunId, { stageId });
+        const result2 = await pauseRun(stageRunId, { stageId, actor: "user" });
         if (!result2.ok) {
           fail(result2.reason === "not_found" ? `Run not found: ${stageRunId}` : result2.reason === "already_ended" ? `Run ${stageRunId} already ended.` : result2.reason === "no_active_stages" ? `No pausable stages on run ${stageRunId}.` : `Stage not found: ${stageTarget ?? "(unknown)"}`);
           return true;
@@ -73566,7 +73953,7 @@ Picker requires an interactive UI surface. Pass a runId: /workflow attach <id> [
     }
     if (isResumableContinuation) {
       await ensureWorkflowResourcesVisible();
-      const continuation = await deps.runtimeForContext(ctx).resumeFailedRun(stageRunId, stageId, { policy });
+      const continuation = await deps.runtimeForContext(ctx).resumeFailedRun(stageRunId, stageId, { policy, actor: "user" });
       continuation.ok ? print(continuation.message) : fail(continuation.message);
       return true;
     }
@@ -73575,7 +73962,7 @@ Picker requires an interactive UI surface. Pass a runId: /workflow attach <id> [
     }
     let result;
     try {
-      result = await resumeRun(stageRunId, { stageId, message });
+      result = await resumeRun(stageRunId, { stageId, message, actor: "user" });
     } catch (error) {
       fail(`Failed to resume run ${stageRunId}: ${error instanceof Error ? error.message : String(error)}`);
       return true;
@@ -73699,8 +74086,14 @@ Available: ${formatAvailableWorkflowNames(deps.runtimeProxy.registry.names())}`)
       emitChatSurface(pi, { kind: "detail", detail: inspected.detail });
       return;
     }
-    const rows = selectRunsForPicker(store.runs(), "", true, Date.now());
-    emitChatSurface(pi, { kind: "status", runs: rows.map((r) => r.run) });
+    const capturedRuns = store.graphSnapshot().runs;
+    const rows = selectRunsForPicker(capturedRuns, "", true, Date.now());
+    const visibleRuns = rows.map((r) => r.run);
+    emitChatSurface(pi, {
+      kind: "status",
+      runs: visibleRuns,
+      indicatorStatuses: resolveRunIndicatorStatuses(visibleRuns, capturedRuns)
+    });
     return;
   }
   if (subcommand === "reload") {
@@ -73775,7 +74168,7 @@ Available: ${formatAvailableWorkflowNames(deps.runtimeProxy.registry.names())}`)
     }
   }
   await ensureWorkflowResourcesVisible();
-  const result = await deps.runWithLifecycleSuppressedForPolicy(policy, () => deps.runtimeForContext(ctx).dispatch({ workflow: workflowName, inputs: mergedInputs, action: "run" }, { policy }));
+  const result = await deps.runWithLifecycleSuppressedForPolicy(policy, () => deps.runtimeForContext(ctx).dispatch({ workflow: workflowName, inputs: mergedInputs, action: "run" }, { policy, origin: "user" }));
   if (result.action !== "run" || !("runId" in result))
     return;
   const runResult = result;
@@ -73806,6 +74199,13 @@ Available: ${formatAvailableWorkflowNames(deps.runtimeProxy.registry.names())}`)
 import { getSupportedThinkingLevels } from "@earendil-works/pi-ai/compat";
 
 // dist/builtin/workflows/src/extension/workflow-status-summary.ts
+var workflowStatusRenderRuns = new WeakMap;
+function setWorkflowStatusRenderRuns(result, runs) {
+  workflowStatusRenderRuns.set(result, runs);
+}
+function getWorkflowStatusRenderRuns(result) {
+  return workflowStatusRenderRuns.get(result);
+}
 function stageIsActive(stage) {
   return stage.status === "running" || stage.status === "awaiting_input";
 }
@@ -73949,7 +74349,17 @@ function statusAwaitingInputLine(entry) {
   const message = entry.message !== undefined ? ` — "${truncateStatusText(entry.message)}"` : "";
   return `    awaiting input: ${target}${prompt}${message}`;
 }
+function statusRunIcon(run2, snapshot, allRuns) {
+  if (snapshot === undefined)
+    return statusIcon(run2.status);
+  const indicatorStatus = runIndicatorStatus(snapshot, allRuns);
+  if (snapshot.endedAt === undefined && snapshot.status === "paused" && snapshot.exitReason === "quit") {
+    return statusIcon("pending");
+  }
+  return statusIcon(indicatorStatus);
+}
 function renderStatusToolContent(result) {
+  const allRuns = getWorkflowStatusRenderRuns(result) ?? result.snapshots;
   const lines = ["action: status", `filter: ${result.filter}`];
   if (result.runs.length === 0) {
     lines.push(result.filter === "all" ? "runs: none" : `runs: none (statusFilter: ${result.filter})`);
@@ -73962,6 +74372,7 @@ function renderStatusToolContent(result) {
     const hint = statusRunHint(run2);
     const summaryLine = [
       `[${index + 1}]`,
+      statusRunIcon(run2, result.snapshots[index], allRuns),
       run2.runId,
       run2.name,
       run2.status,
@@ -74196,7 +74607,7 @@ async function workflowPauseAction(args) {
       return { action, runId: "--all", status: "noop", message: allStageConflictMessage("pause") };
     }
     try {
-      const results = await pauseAllRuns();
+      const results = await pauseAllRuns({ actor: "agent" });
       const paused = results.filter((result) => result.ok).length;
       return {
         action,
@@ -74226,7 +74637,7 @@ async function workflowPauseAction(args) {
     return { action, runId: target.runId, status: "noop", message: stage.message };
   const stageRunId = stage.runId ?? target.runId;
   try {
-    const result = await pauseRun(stageRunId, { stageId: stage.stageId });
+    const result = await pauseRun(stageRunId, { stageId: stage.stageId, actor: "agent" });
     return result.ok ? {
       action,
       runId: result.runId,
@@ -74315,7 +74726,7 @@ async function workflowQuitAction(args) {
     if (args.stageId !== undefined && args.stageId.length > 0) {
       return { action, runId: "--all", status: "noop", message: allStageConflictMessage("quit") };
     }
-    const results = await quitAllRuns();
+    const results = await quitAllRuns({ actor: "agent" });
     const successes = results.filter((result) => result.ok);
     const quitCount = successes.length;
     const failures = results.filter((result) => !result.ok);
@@ -74335,7 +74746,7 @@ async function workflowQuitAction(args) {
   if (controlNode.kind === "tool")
     return quitToolNodeAction(controlNode.runId, controlNode.nodeId, action);
   try {
-    const result = await quitRun(target.runId);
+    const result = await quitRun(target.runId, { actor: "agent" });
     if (result.ok) {
       return {
         action,
@@ -74417,7 +74828,7 @@ async function resumeDurableShadow(runId, deps) {
   } catch (error) {
     warning = formatWorkflowResourceLoadWarning(error);
   }
-  const resumed = await runtime.resumeDurableWorkflow(runId, { policy: deps.policy });
+  const resumed = await runtime.resumeDurableWorkflow(runId, { policy: deps.policy, actor: "agent" });
   const message = warning === undefined ? resumed.message : `${warning}
 
 ${resumed.message}`;
@@ -74430,7 +74841,7 @@ ${resumed.message}`;
 }
 async function resumePreparedDurableTarget(runId, deps) {
   try {
-    const resumed = await deps.getRuntime().resumeDurableWorkflow(runId, { policy: deps.policy });
+    const resumed = await deps.getRuntime().resumeDurableWorkflow(runId, { policy: deps.policy, actor: "agent" });
     return {
       action: "resume",
       runId: resumed.ok ? resumed.runId : runId,
@@ -74538,7 +74949,7 @@ async function workflowResumeAction(args, deps) {
     } catch (error) {
       warning = formatWorkflowResourceLoadWarning(error);
     }
-    const continuation = await deps.getRuntime().resumeFailedRun(stageRunId, stage.stageId, { policy: deps.policy });
+    const continuation = await deps.getRuntime().resumeFailedRun(stageRunId, stage.stageId, { policy: deps.policy, actor: "agent" });
     const message = warning === undefined ? continuation.message : `${warning}
 
 ${continuation.message}`;
@@ -74550,7 +74961,7 @@ ${continuation.message}`;
     };
   }
   try {
-    const result = await resumeRun(stageRunId, { stageId: stage.stageId, message: args.message });
+    const result = await resumeRun(stageRunId, { stageId: stage.stageId, message: args.message, actor: "agent" });
     if (result.ok) {
       const runLevelResumed = hadPausedRunState && !hadPausedStageState && stage.stageId === undefined && result.snapshot.status === "running";
       const noPausedProgress = isPaused2 && result.resumed.length === 0 && result.message === undefined && !runLevelResumed;
@@ -75131,7 +75542,7 @@ function makeExecuteWorkflowTool(runtime, reloadWorkflowResources, ensureWorkflo
       }
       case "run": {
         await ensureWorkflowResourcesVisible();
-        return getRuntime().dispatch(args, { policy });
+        return getRuntime().dispatch(args, { policy, origin: "agent" });
       }
       case "status": {
         const target = args.runId;
@@ -75143,16 +75554,18 @@ function makeExecuteWorkflowTool(runtime, reloadWorkflowResources, ensureWorkflo
           if (resolved.kind === "not_found") {
             return { action: "statusDetail", runId: target, error: `run not found: ${target}` };
           }
-          const result = inspectRun(resolved.runId);
-          return result.ok ? { action: "statusDetail", runId: result.runId, detail: result.detail } : { action: "statusDetail", runId: target, error: `run not found: ${target}` };
+          const result2 = inspectRun(resolved.runId);
+          return result2.ok ? { action: "statusDetail", runId: result2.runId, detail: result2.detail } : { action: "statusDetail", runId: target, error: `run not found: ${target}` };
         }
         const listing = buildWorkflowStatusListing(topLevelExpandedSnapshots(), args.statusFilter ?? "all");
-        return {
+        const result = {
           action: "status",
           filter: listing.filter,
           runs: listing.runs,
           snapshots: listing.snapshots
         };
+        setWorkflowStatusRenderRuns(result, store.graphSnapshot().runs);
+        return result;
       }
       case "stages":
         return workflowStagesResult(args);
@@ -75319,7 +75732,8 @@ function renderResult(result, opts) {
       return renderStatusList(r.snapshots, {
         theme: themed ? deriveGraphTheme({}) : undefined,
         width: opts?.width,
-        now: opts?.now
+        now: opts?.now,
+        allRuns: opts?.allRuns ?? getWorkflowStatusRenderRuns(r) ?? r.snapshots
       });
     }
     case "statusDetail": {