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

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

@@ -69012,9 +69012,9 @@ function renderDetailHintRows(detail, width, theme) {
 }
 function formatTime(ms) {
   const d = new Date(ms);
-  const hh = String(d.getUTCHours()).padStart(2, "0");
-  const mm = String(d.getUTCMinutes()).padStart(2, "0");
-  const ss = String(d.getUTCSeconds()).padStart(2, "0");
+  const hh = String(d.getHours()).padStart(2, "0");
+  const mm = String(d.getMinutes()).padStart(2, "0");
+  const ss = String(d.getSeconds()).padStart(2, "0");
   return `${hh}:${mm}:${ss}`;
 }
 
@@ -72599,7 +72599,7 @@ class GraphCanvas {
 
 // dist/builtin/workflows/src/tui/layout.ts
 var NODE_W = 24;
-var NODE_H = 6;
+var NODE_H = 5;
 function computeLayout(stages, opts = {}) {
   const colGap = opts.colGap ?? 4;
   const rowGap = opts.rowGap ?? 3;
@@ -72682,17 +72682,255 @@ function computeLayout(stages, opts = {}) {
       rowIndex.set(ids[i], i);
     }
   }
+  const heights = new Map(stages.map((stage) => [stage.id, opts.nodeHeight?.(stage) ?? NODE_H]));
+  const verticalOffsets = new Map;
+  const horizontalOffsets = new Map;
+  let depthY = 0;
+  for (const depth of [...colGroups.keys()].sort((a, b) => a - b)) {
+    const ids = colGroups.get(depth);
+    verticalOffsets.set(depth, depthY);
+    let siblingY = 0;
+    let tallest = 0;
+    for (const id of ids) {
+      const height = heights.get(id);
+      horizontalOffsets.set(id, siblingY);
+      siblingY += height + rowGap;
+      tallest = Math.max(tallest, height);
+    }
+    depthY += tallest + rowGap;
+  }
   const nodes = [];
   for (const s of stages) {
     const col = colMap.get(s.id) ?? 0;
     const row = rowIndex.get(s.id) ?? 0;
     const x = orientation === "vertical" ? row * (NODE_W + colGap) + (centreShift.get(col) ?? 0) : col * (NODE_W + colGap);
-    const y = orientation === "vertical" ? col * (NODE_H + rowGap) : row * (NODE_H + rowGap);
-    nodes.push({ stage: s, col, row, x, y });
+    const y = orientation === "vertical" ? verticalOffsets.get(col) : horizontalOffsets.get(s.id);
+    nodes.push({ stage: s, col, row, x, y, ...opts.nodeHeight ? { height: heights.get(s.id) } : {} });
   }
   return nodes;
 }
 
+// dist/builtin/workflows/src/tui/node-card.ts
+import { stripTerminalSequences } from "@earendil-works/pi-tui";
+function pulseT(phase) {
+  return (Math.sin(phase * Math.PI * 2 - Math.PI / 2) + 1) / 2;
+}
+function queuedBadgeCount(count) {
+  if (typeof count !== "number" || !Number.isFinite(count))
+    return 0;
+  return Math.max(0, Math.trunc(count));
+}
+function queuedBadgeText(count) {
+  return `✉ ${count} queued`;
+}
+function pickBorder(status, focused, phase, theme) {
+  switch (status) {
+    case "running":
+      if (focused)
+        return theme.warning;
+      return lerpColor(theme.borderDim, theme.warning, pulseT(phase));
+    case "paused":
+      return theme.warning;
+    case "awaiting_input":
+      if (focused)
+        return theme.info;
+      return lerpColor(theme.borderDim, theme.info, pulseT(phase));
+    case "completed":
+      return theme.success;
+    case "failed":
+      return theme.error;
+    case "blocked":
+      return theme.dim;
+    case "skipped":
+      return theme.dim;
+    default:
+      return focused ? theme.borderActive : theme.borderDim;
+  }
+}
+function durationColor(status, theme) {
+  switch (status) {
+    case "running":
+      return theme.warning;
+    case "paused":
+      return theme.warning;
+    case "awaiting_input":
+      return theme.info;
+    case "completed":
+      return theme.success;
+    case "failed":
+      return theme.error;
+    default:
+      return theme.dim;
+  }
+}
+function blockedBadgeText(stage, stages, width) {
+  const base = "↑ blocked";
+  const blockedBy = stage.blockedByStageId;
+  if (!blockedBy)
+    return base;
+  const upstream = stages?.find((s) => s.id === blockedBy)?.name ?? blockedBy;
+  const withUpstream = `${base} by ${upstream}`;
+  if (visibleWidth(withUpstream) <= width)
+    return withUpstream;
+  return base;
+}
+function durationText(stage) {
+  const elapsed = elapsedStageMs(stage);
+  return elapsed === undefined ? "—" : fmtDuration(elapsed);
+}
+function metaText(stage) {
+  return stage.topologyState === "unavailable" ? "topology unavailable" : "";
+}
+function modelText(stage, innerWidth) {
+  const model = stage.model;
+  if (model === undefined || model === "")
+    return "";
+  const slash = model.lastIndexOf("/");
+  const short = slash >= 0 ? model.slice(slash + 1) : model;
+  const level = stage.thinkingLevel;
+  const showLevel = level !== undefined && level !== "" && level !== "off";
+  const suffix = showLevel ? ` · ${level}` : "";
+  const full = `${short}${suffix}`;
+  if (visibleWidth(full) <= innerWidth)
+    return full;
+  const modelSuffix = short.endsWith("-fast") ? "-fast" : "";
+  const name = modelSuffix ? short.slice(0, -modelSuffix.length) : short;
+  const room = Math.max(1, innerWidth - visibleWidth(modelSuffix + suffix));
+  return `${truncateToWidth2(name, room, "…")}${modelSuffix}${suffix}`;
+}
+function workflowChildRunRows(stage, width) {
+  const child = stage.workflowChild ?? stage.workflowChildRun;
+  if (child === undefined)
+    return [];
+  return wrapIdentifierLines(child.runId, Math.max(1, width), "run ", "").map((row) => `${row.prefix}${row.chunk}`);
+}
+function workflowChildMetaText(stage) {
+  const completed = stage.workflowChild;
+  if (completed !== undefined) {
+    const outputCount = completed.outputCount ?? Object.keys(completed.outputs).length;
+    return outputCount === 1 ? "1 out" : `${outputCount} outs`;
+  }
+  if (stage.workflowChildRun !== undefined)
+    return "live";
+  return;
+}
+function joinCompactStatusMeta(status, meta, width) {
+  const candidates = [`${status} · ${meta}`, `${status} ·${meta}`, `${status}· ${meta}`, `${status}·${meta}`];
+  return candidates.find((candidate) => visibleWidth(candidate) <= width) ?? status;
+}
+function nodeCardHeight(stage, opts = {}) {
+  const queuedRows = queuedBadgeCount(opts.queuedMessageCount) > 0 ? 1 : 0;
+  const modelRows = stage.model !== undefined && stage.model !== "" ? 1 : 0;
+  let bodyRows;
+  if (stage.status === "awaiting_input") {
+    bodyRows = 2 + modelRows + queuedRows;
+  } else if (stage.workflowChild !== undefined || stage.workflowChildRun !== undefined) {
+    const innerWidth = Math.max(2, (opts.width ?? NODE_W) - 2);
+    bodyRows = workflowChildRunRows(stage, innerWidth).length + 1 + queuedRows;
+  } else {
+    bodyRows = 2 + modelRows + (metaText(stage) ? 1 : 0) + queuedRows;
+  }
+  return Math.max(NODE_H, bodyRows + 2);
+}
+function statusLabel(status) {
+  switch (status) {
+    case "awaiting_input":
+      return "awaiting input";
+    case "completed":
+      return "complete";
+    default:
+      return status.replace(/_/g, " ");
+  }
+}
+function truncate(s, maxWidth) {
+  if (maxWidth <= 0)
+    return "";
+  if (visibleWidth(s) <= maxWidth)
+    return s;
+  return truncateToWidth2(s, maxWidth, "…");
+}
+function centreColored(content, width, fg, bg, opts = {}) {
+  const safe = truncate(content, width);
+  const safeWidth = visibleWidth(safe);
+  const pad = Math.max(0, width - safeWidth);
+  const left = Math.max(0, Math.floor(pad / 2));
+  const right = Math.max(0, pad - left);
+  const bold = opts.bold ? BOLD : "";
+  return `${bg}${" ".repeat(left)}` + `${hexToAnsi(fg)}${bold}${safe}${RESET}` + `${bg}${" ".repeat(right)}`;
+}
+function buildTitleSlot(name, innerWidth, focused, theme, cardBg, compact = false) {
+  const maxName = Math.max(2, compact ? innerWidth - 1 : innerWidth - 4);
+  const safeName = stripTerminalSequences(truncate(name, maxName));
+  if (focused) {
+    const tabText = compact ? safeName : ` ${safeName} `;
+    const styled = `${paint(tabText, theme.surface, {
+      bg: theme.accent,
+      bold: true
+    })}${cardBg}`;
+    return { slot: styled, visibleWidth: visibleWidth(tabText) };
+  }
+  const titleRaw = compact ? safeName : ` ${safeName} `;
+  const styled = `${BOLD}${titleRaw}${RESET}${cardBg}`;
+  return { slot: styled, visibleWidth: visibleWidth(titleRaw) };
+}
+function renderNodeCard(stage, opts) {
+  const width = opts.width ?? NODE_W;
+  const height = opts.height ?? nodeCardHeight(stage, opts);
+  const focused = opts.focused ?? false;
+  const phase = opts.pulsePhase ?? 0;
+  const theme = opts.theme;
+  const borderHex = pickBorder(stage.status, focused, phase, theme);
+  const bc = hexToAnsi(borderHex);
+  const bg = DEFAULT_BG;
+  const innerWidth = Math.max(2, width - 2);
+  const child = stage.workflowChild ?? stage.workflowChildRun;
+  const { slot: titleSlot, visibleWidth: titleVisibleWidth } = buildTitleSlot(child === undefined ? stage.name : `↳ ${child.workflow}`, innerWidth, focused, theme, bg, child !== undefined);
+  const titleStart = Math.max(1, Math.floor((innerWidth - titleVisibleWidth) / 2));
+  const titleEnd = titleStart + titleVisibleWidth;
+  const topMiddle = `${bc}${"─".repeat(titleStart)}` + `${titleSlot}${bc}` + `${"─".repeat(Math.max(0, innerWidth - titleEnd))}`;
+  const top = `${bg}${bc}╭${topMiddle}╮${RESET}`;
+  const bottom = `${bg}${bc}╰${"─".repeat(innerWidth)}╯${RESET}`;
+  const bodyText = stage.nodeKind === "tool" ? "durable tool" : stage.status === "blocked" ? blockedBadgeText(stage, opts.stages, innerWidth) : durationText(stage);
+  const bodyHex = durationColor(stage.status, theme);
+  const statusText = `${statusIcon(stage.status)} ${stage.toolStatus ?? statusLabel(stage.status)}`;
+  const queuedCount = queuedBadgeCount(opts.queuedMessageCount);
+  const statusLine = `${bg}${bc}│${RESET}` + centreColored(statusText, innerWidth, bodyHex, bg, {
+    bold: stage.status === "running" || stage.status === "awaiting_input"
+  }) + `${bg}${bc}│${RESET}`;
+  const durLine = `${bg}${bc}│${RESET}` + centreColored(bodyText, innerWidth, bodyHex, bg, {
+    bold: stage.status === "blocked"
+  }) + `${bg}${bc}│${RESET}`;
+  const contentRows = Math.max(0, height - 2);
+  const metaLine = `${bg}${bc}│${RESET}${centreColored(metaText(stage), innerWidth, theme.dim, bg)}${bg}${bc}│${RESET}`;
+  const model = modelText(stage, innerWidth);
+  const modelLine = `${bg}${bc}│${RESET}${centreColored(model, innerWidth, theme.textMuted, bg)}${bg}${bc}│${RESET}`;
+  const childRunLines = workflowChildRunRows(stage, innerWidth).map((row) => `${bg}${bc}│${RESET}${centreColored(row, innerWidth, theme.dim, bg)}${bg}${bc}│${RESET}`);
+  const childMeta = workflowChildMetaText(stage);
+  const childSummary = childMeta === undefined ? undefined : joinCompactStatusMeta(statusText, childMeta, innerWidth);
+  const childSummaryLine = childSummary === undefined ? undefined : `${bg}${bc}│${RESET}` + centreColored(childSummary, innerWidth, bodyHex, bg, {
+    bold: stage.status === "running" || stage.status === "awaiting_input"
+  }) + `${bg}${bc}│${RESET}`;
+  const queuedLines = queuedCount > 0 ? [
+    `${bg}${bc}│${RESET}` + centreColored(queuedBadgeText(queuedCount), innerWidth, theme.info, bg, { bold: true }) + `${bg}${bc}│${RESET}`
+  ] : [];
+  const modelLines = model === "" ? [] : [modelLine];
+  const interior = stage.status === "awaiting_input" ? [
+    ...modelLines,
+    statusLine,
+    ...model === "" && queuedCount === 0 ? [
+      `${bg}${bc}│${RESET}` + centreColored("waiting for response", innerWidth, theme.info, bg) + `${bg}${bc}│${RESET}`
+    ] : [],
+    ...queuedLines,
+    `${bg}${bc}│${RESET}` + centreColored("↵ enter to respond", innerWidth, theme.dim, bg) + `${bg}${bc}│${RESET}`
+  ] : childSummaryLine === undefined ? [durLine, ...modelLines, statusLine, ...metaText(stage) ? [metaLine] : [], ...queuedLines] : [...childRunLines, childSummaryLine, ...queuedLines];
+  while (interior.length < contentRows) {
+    interior.push(`${bg}${bc}│${RESET}${bg}${" ".repeat(innerWidth)}${bg}${bc}│${RESET}`);
+  }
+  if (interior.length > contentRows)
+    interior.length = contentRows;
+  return [top, ...interior, bottom];
+}
+
 // dist/builtin/workflows/src/tui/prompt-card-select.ts
 import { SelectList, truncateToWidth as truncateToWidth3 } from "@earendil-works/pi-tui";
 function createPromptSelectList(state, theme, maxVisible = 5) {
@@ -73558,9 +73796,25 @@ class GraphViewState {
   _needsAnimationTick() {
     return this.promptState !== null || this.hasAnimatingStages;
   }
+  _nodeHeight(stage) {
+    const baseHeight = nodeCardHeight(stage);
+    if (!this.getStageQueuedMessageCount || nodeCardHeight(stage, { queuedMessageCount: 1 }) === baseHeight) {
+      return baseHeight;
+    }
+    return nodeCardHeight(stage, { queuedMessageCount: this._stageQueuedMessageCount(stage) });
+  }
+  _refreshQueuedNodeHeights() {
+    if (!this.getStageQueuedMessageCount)
+      return;
+    if (!this.cachedLayout.some((node) => (node.height ?? NODE_H) !== this._nodeHeight(node.stage)))
+      return;
+    this.lastBuiltSnapshotVersion = null;
+    this._rebuildLayout();
+  }
   _rebuildLayout() {
     const version = this.currentSnapshot?.version ?? null;
     if (version !== null && version === this.lastBuiltSnapshotVersion) {
+      this._refreshQueuedNodeHeights();
       return;
     }
     const run = this._getCurrentRun();
@@ -73587,6 +73841,8 @@ class GraphViewState {
       const next = graphStages[index];
       if (!next || node.stage.id !== next.id || node.stage.nodeKind !== next.nodeKind)
         return false;
+      if ((node.height ?? NODE_H) !== this._nodeHeight(next))
+        return false;
       if (node.stage.parentIds.length !== next.parentIds.length)
         return false;
       return node.stage.parentIds.every((parentId, parentIndex) => parentId === next.parentIds[parentIndex]);
@@ -73602,7 +73858,10 @@ class GraphViewState {
       this.lastBuiltSnapshotVersion = version;
       return;
     }
-    const nextLayout = computeLayout(graphStages, { orientation: "vertical" });
+    const nextLayout = computeLayout(graphStages, {
+      orientation: "vertical",
+      nodeHeight: (stage) => this._nodeHeight(stage)
+    });
     this.cachedLayout = nextLayout;
     this.cachedDisplayStages = nextLayout.map((node) => node.stage);
     this.cachedRenderGeometry = this._buildRenderGeometry(nextLayout);
@@ -73621,13 +73880,15 @@ class GraphViewState {
     for (let index = 0;index < layout.length; index++) {
       const node = layout[index];
       canvasWidth = Math.max(canvasWidth, node.x + NODE_W);
-      totalRows = Math.max(totalRows, node.y + NODE_H);
+      const bottom = node.y + (node.height ?? NODE_H);
+      totalRows = Math.max(totalRows, bottom);
       nodeByStageId.set(node.stage.id, node);
       const band = bandsByTop.get(node.y);
-      if (band)
+      if (band) {
         band.nodeIndices.push(index);
-      else
-        bandsByTop.set(node.y, { top: node.y, bottom: node.y + NODE_H, nodeIndices: [index] });
+        band.bottom = Math.max(band.bottom, bottom);
+      } else
+        bandsByTop.set(node.y, { top: node.y, bottom, nodeIndices: [index] });
     }
     const edges = [];
     for (const node of layout) {
@@ -73640,9 +73901,10 @@ class GraphViewState {
         edges.push({
           parentX: parent.x,
           parentY: parent.y,
+          parentHeight: parent.height ?? NODE_H,
           childX: node.x,
           childY: node.y,
-          top: parent.y + NODE_H,
+          top: parent.y + (parent.height ?? NODE_H),
           bottom: node.y,
           left: Math.min(parentCol, childCol),
           right: Math.max(parentCol, childCol) + 1
@@ -73978,10 +74240,10 @@ class GraphViewRenderHelpers extends GraphViewState {
     }
     this._clampGraphHorizontalScroll(totalCols, viewportCols);
   }
-  _plotEdge(canvas, px, py, cx, cy, color) {
+  _plotEdge(canvas, px, py, cx, cy, color, parentHeight = NODE_H) {
     const parentCol = px + Math.floor(NODE_W / 2);
     const childCol = cx + Math.floor(NODE_W / 2);
-    const parentExitRow = py + NODE_H;
+    const parentExitRow = py + parentHeight;
     const childEntryRow = cy - 1;
     if (childEntryRow < parentExitRow)
       return;
@@ -74040,214 +74302,6 @@ class GraphViewRenderHelpers extends GraphViewState {
   }
 }
 
-// dist/builtin/workflows/src/tui/node-card.ts
-import { stripTerminalSequences } from "@earendil-works/pi-tui";
-function pulseT(phase) {
-  return (Math.sin(phase * Math.PI * 2 - Math.PI / 2) + 1) / 2;
-}
-function queuedBadgeCount(count) {
-  if (typeof count !== "number" || !Number.isFinite(count))
-    return 0;
-  return Math.max(0, Math.trunc(count));
-}
-function queuedBadgeText(count) {
-  return `✉ ${count} queued`;
-}
-function pickBorder(status, focused, phase, theme) {
-  switch (status) {
-    case "running":
-      if (focused)
-        return theme.warning;
-      return lerpColor(theme.borderDim, theme.warning, pulseT(phase));
-    case "paused":
-      return theme.warning;
-    case "awaiting_input":
-      if (focused)
-        return theme.info;
-      return lerpColor(theme.borderDim, theme.info, pulseT(phase));
-    case "completed":
-      return theme.success;
-    case "failed":
-      return theme.error;
-    case "blocked":
-      return theme.dim;
-    case "skipped":
-      return theme.dim;
-    default:
-      return focused ? theme.borderActive : theme.borderDim;
-  }
-}
-function durationColor(status, theme) {
-  switch (status) {
-    case "running":
-      return theme.warning;
-    case "paused":
-      return theme.warning;
-    case "awaiting_input":
-      return theme.info;
-    case "completed":
-      return theme.success;
-    case "failed":
-      return theme.error;
-    default:
-      return theme.dim;
-  }
-}
-function blockedBadgeText(stage, stages, width) {
-  const base = "↑ blocked";
-  const blockedBy = stage.blockedByStageId;
-  if (!blockedBy)
-    return base;
-  const upstream = stages?.find((s) => s.id === blockedBy)?.name ?? blockedBy;
-  const withUpstream = `${base} by ${upstream}`;
-  if (visibleWidth(withUpstream) <= width)
-    return withUpstream;
-  return base;
-}
-function durationText(stage) {
-  const elapsed = elapsedStageMs(stage);
-  return elapsed === undefined ? "—" : fmtDuration(elapsed);
-}
-function metaText(stage) {
-  if (stage.topologyState === "unavailable")
-    return "topology unavailable";
-  const deps = stage.parentIds.length;
-  const dependencyText = deps === 0 ? "root" : deps === 1 ? "1 dep" : `${deps} deps`;
-  return dependencyText;
-}
-function modelText(stage, innerWidth) {
-  const model = stage.model;
-  if (model === undefined || model === "")
-    return "—";
-  const slash = model.lastIndexOf("/");
-  const short = slash >= 0 ? model.slice(slash + 1) : model;
-  const level = stage.thinkingLevel;
-  const showLevel = level !== undefined && level !== "" && level !== "off";
-  const suffix = showLevel ? ` · ${level}` : "";
-  const full = `${short}${suffix}`;
-  if (visibleWidth(full) <= innerWidth)
-    return full;
-  const modelSuffix = short.endsWith("-fast") ? "-fast" : "";
-  const name = modelSuffix ? short.slice(0, -modelSuffix.length) : short;
-  const room = Math.max(1, innerWidth - visibleWidth(modelSuffix + suffix));
-  return `${truncateToWidth2(name, room, "…")}${modelSuffix}${suffix}`;
-}
-function workflowChildRunRows(stage, width) {
-  const child = stage.workflowChild ?? stage.workflowChildRun;
-  if (child === undefined)
-    return [];
-  return wrapIdentifierLines(child.runId, Math.max(1, width), "run ", "").map((row) => `${row.prefix}${row.chunk}`);
-}
-function workflowChildMetaText(stage) {
-  const completed = stage.workflowChild;
-  if (completed !== undefined) {
-    const outputCount = completed.outputCount ?? Object.keys(completed.outputs).length;
-    return outputCount === 1 ? "1 out" : `${outputCount} outs`;
-  }
-  if (stage.workflowChildRun !== undefined)
-    return "live";
-  return;
-}
-function joinCompactStatusMeta(status, meta, width) {
-  const candidates = [`${status} · ${meta}`, `${status} ·${meta}`, `${status}· ${meta}`, `${status}·${meta}`];
-  return candidates.find((candidate) => visibleWidth(candidate) <= width) ?? meta;
-}
-function statusLabel(status) {
-  switch (status) {
-    case "awaiting_input":
-      return "awaiting input";
-    case "completed":
-      return "complete";
-    default:
-      return status.replace(/_/g, " ");
-  }
-}
-function truncate(s, maxWidth) {
-  if (maxWidth <= 0)
-    return "";
-  if (visibleWidth(s) <= maxWidth)
-    return s;
-  return truncateToWidth2(s, maxWidth, "…");
-}
-function centreColored(content, width, fg, bg, opts = {}) {
-  const safe = truncate(content, width);
-  const safeWidth = visibleWidth(safe);
-  const pad = Math.max(0, width - safeWidth);
-  const left = Math.max(0, Math.floor(pad / 2));
-  const right = Math.max(0, pad - left);
-  const bold = opts.bold ? BOLD : "";
-  return `${bg}${" ".repeat(left)}` + `${hexToAnsi(fg)}${bold}${safe}${RESET}` + `${bg}${" ".repeat(right)}`;
-}
-function buildTitleSlot(name, innerWidth, focused, theme, cardBg, compact = false) {
-  const maxName = Math.max(2, compact ? innerWidth - 1 : innerWidth - 4);
-  const safeName = stripTerminalSequences(truncate(name, maxName));
-  if (focused) {
-    const tabText = compact ? safeName : ` ${safeName} `;
-    const styled = `${paint(tabText, theme.surface, {
-      bg: theme.accent,
-      bold: true
-    })}${cardBg}`;
-    return { slot: styled, visibleWidth: visibleWidth(tabText) };
-  }
-  const titleRaw = compact ? safeName : ` ${safeName} `;
-  const styled = `${BOLD}${titleRaw}${RESET}${cardBg}`;
-  return { slot: styled, visibleWidth: visibleWidth(titleRaw) };
-}
-function renderNodeCard(stage, opts) {
-  const width = opts.width ?? NODE_W;
-  const height = opts.height ?? NODE_H;
-  const focused = opts.focused ?? false;
-  const phase = opts.pulsePhase ?? 0;
-  const theme = opts.theme;
-  const borderHex = pickBorder(stage.status, focused, phase, theme);
-  const bc = hexToAnsi(borderHex);
-  const bg = DEFAULT_BG;
-  const innerWidth = Math.max(2, width - 2);
-  const child = stage.workflowChild ?? stage.workflowChildRun;
-  const { slot: titleSlot, visibleWidth: titleVisibleWidth } = buildTitleSlot(child === undefined ? stage.name : `↳ ${child.workflow}`, innerWidth, focused, theme, bg, child !== undefined);
-  const titleStart = Math.max(1, Math.floor((innerWidth - titleVisibleWidth) / 2));
-  const titleEnd = titleStart + titleVisibleWidth;
-  const topMiddle = `${bc}${"─".repeat(titleStart)}` + `${titleSlot}${bc}` + `${"─".repeat(Math.max(0, innerWidth - titleEnd))}`;
-  const top = `${bg}${bc}╭${topMiddle}╮${RESET}`;
-  const bottom = `${bg}${bc}╰${"─".repeat(innerWidth)}╯${RESET}`;
-  const bodyText = stage.nodeKind === "tool" ? "durable tool" : stage.status === "blocked" ? blockedBadgeText(stage, opts.stages, innerWidth) : durationText(stage);
-  const bodyHex = durationColor(stage.status, theme);
-  const statusText = `${statusIcon(stage.status)} ${stage.toolStatus ?? statusLabel(stage.status)}`;
-  const statusLine = `${bg}${bc}│${RESET}` + centreColored(statusText, innerWidth, bodyHex, bg, {
-    bold: stage.status === "running" || stage.status === "awaiting_input"
-  }) + `${bg}${bc}│${RESET}`;
-  const durLine = `${bg}${bc}│${RESET}` + centreColored(bodyText, innerWidth, bodyHex, bg, {
-    bold: stage.status === "blocked"
-  }) + `${bg}${bc}│${RESET}`;
-  const contentRows = Math.max(0, height - 2);
-  const metaLine = `${bg}${bc}│${RESET}${centreColored(metaText(stage), innerWidth, theme.dim, bg)}${bg}${bc}│${RESET}`;
-  const modelLine = `${bg}${bc}│${RESET}${centreColored(modelText(stage, innerWidth), innerWidth, theme.textMuted, bg)}${bg}${bc}│${RESET}`;
-  const childRunLines = workflowChildRunRows(stage, innerWidth).map((row) => `${bg}${bc}│${RESET}${centreColored(row, innerWidth, theme.dim, bg)}${bg}${bc}│${RESET}`);
-  const queuedCount = queuedBadgeCount(opts.queuedMessageCount);
-  const childMeta = workflowChildMetaText(stage);
-  const childSummary = childMeta === undefined ? undefined : joinCompactStatusMeta(statusText, queuedCount > 0 ? queuedBadgeText(queuedCount) : childMeta, innerWidth);
-  const childSummaryLine = childSummary === undefined ? undefined : `${bg}${bc}│${RESET}` + centreColored(childSummary, innerWidth, bodyHex, bg, {
-    bold: stage.status === "running" || stage.status === "awaiting_input"
-  }) + `${bg}${bc}│${RESET}`;
-  const interior = stage.status === "awaiting_input" ? [
-    statusLine,
-    `${bg}${bc}│${RESET}` + centreColored("waiting for response", innerWidth, theme.info, bg) + `${bg}${bc}│${RESET}`,
-    `${bg}${bc}│${RESET}` + centreColored("↵ enter to respond", innerWidth, theme.dim, bg) + `${bg}${bc}│${RESET}`,
-    modelLine
-  ] : childSummaryLine === undefined ? [durLine, statusLine, modelLine, metaLine] : [...childRunLines, childSummaryLine];
-  const preferredBadgeRow = stage.status === "awaiting_input" ? 1 : childSummaryLine === undefined ? interior.length - 1 : -1;
-  while (interior.length < contentRows) {
-    interior.push(`${bg}${bc}│${RESET}${bg}${" ".repeat(innerWidth)}${bg}${bc}│${RESET}`);
-  }
-  if (interior.length > contentRows)
-    interior.length = contentRows;
-  if (queuedCount > 0 && interior.length > 0 && preferredBadgeRow >= 0) {
-    const badgeRow = preferredBadgeRow < interior.length ? preferredBadgeRow : interior.length - 1;
-    interior[badgeRow] = `${bg}${bc}│${RESET}` + centreColored(queuedBadgeText(queuedCount), innerWidth, theme.info, bg, { bold: true }) + `${bg}${bc}│${RESET}`;
-  }
-  return [top, ...interior, bottom];
-}
-
 // dist/builtin/workflows/src/tui/graph-view-graph-render.ts
 class GraphViewGraphRenderer extends GraphViewRenderHelpers {
   _renderGraph(width, viewportTop, viewportRows, renderRun) {
@@ -74292,7 +74346,7 @@ class GraphViewGraphRenderer extends GraphViewRenderHelpers {
       if (edge.bottom <= safeTop || edge.top >= viewportBottom || edge.right <= viewportLeft || edge.left >= viewportRight) {
         continue;
       }
-      this._plotEdge(edgeCanvas, edge.parentX, edge.parentY, edge.childX, edge.childY, edgeColor);
+      this._plotEdge(edgeCanvas, edge.parentX, edge.parentY, edge.childX, edge.childY, edgeColor, edge.parentHeight);
     }
     const edgeLines = edgeCanvas.toLines();
     const placements = new Map;
@@ -74306,7 +74360,7 @@ class GraphViewGraphRenderer extends GraphViewRenderHelpers {
           continue;
         const cardLines = renderNodeCard(node.stage, {
           width: NODE_W,
-          height: NODE_H,
+          height: node.height ?? NODE_H,
           focused: ni === this.focusedIndex,
           pulsePhase,
           theme: this.graphTheme,
@@ -74363,7 +74417,7 @@ class GraphViewGraphRenderer extends GraphViewRenderHelpers {
       for (const index of band.nodeIndices) {
         const node = this.cachedLayout[index];
         const top = graphStartRow + node.y - viewportTop;
-        const bottom = top + NODE_H;
+        const bottom = top + (node.height ?? NODE_H);
         const left = viewport.leftMargin + node.x - this.graphScrollColOffset;
         const right = left + NODE_W;
         const clippedTop = Math.max(visibleTop, top);
@@ -75071,6 +75125,7 @@ class GraphViewRenderer extends GraphViewGraphRenderer {
   render(width) {
     if (this.mode === "widget")
       return this._renderWidget(width);
+    this._refreshQueuedNodeHeights();
     return this._renderOverlay(width);
   }
   dispose() {
@@ -75183,8 +75238,8 @@ class GraphViewRenderer extends GraphViewGraphRenderer {
         let next = scrollView.scrollTop;
         if (node.y < next)
           next = node.y;
-        else if (node.y + NODE_H > next + viewportRows)
-          next = node.y + NODE_H - viewportRows;
+        else if (node.y + (node.height ?? NODE_H) > next + viewportRows)
+          next = node.y + (node.height ?? NODE_H) - viewportRows;
         scrollView.scrollTo(next);
         const graphInner = Math.max(1, width - 4);
         const leftMargin = Math.max(2, this.cachedRenderGeometry.canvasWidth <= graphInner ? Math.floor((graphInner - this.cachedRenderGeometry.canvasWidth) / 2) : 2);
@@ -76420,6 +76475,7 @@ class StageUiBroker {
     };
   }
   requestCustomUi(runId, stageId, factory, options, signal) {
+    signal = options?.signal ? signal ? AbortSignal.any([signal, options.signal]) : options.signal : signal;
     if (signal?.aborted) {
       return Promise.reject(signal.reason ?? new Error("atomic-workflows: stage UI request aborted"));
     }
@@ -82123,6 +82179,108 @@ function collectDefinitionName(tokens, localValues, workflowNames) {
   }
   return;
 }
+function discoveryField(object) {
+  if (object?.[0]?.value !== "{" || object.at(-1)?.value !== "}")
+    return;
+  let value2;
+  for (const field of arrayElements(object)) {
+    let key = field;
+    while (["get", "set", "async", "*"].includes(key[0]?.value ?? ""))
+      key = key.slice(1);
+    if (key[0]?.value === "[" || key !== field && key[0]?.value === "possibleStageNames")
+      return;
+    if (field[0]?.value === ".") {
+      if (value2 !== undefined)
+        return;
+      continue;
+    }
+    if (field[0]?.value !== "possibleStageNames")
+      continue;
+    if (value2 !== undefined || field[1]?.value !== ":")
+      return;
+    value2 = field.slice(2);
+  }
+  return value2;
+}
+function literalDiscoveryNames(value2) {
+  if (value2?.[0]?.value !== "[" || value2.at(-1)?.value !== "]")
+    return;
+  const names = [];
+  for (const element of arrayElements(value2)) {
+    if (element.length !== 1 || element[0]?.kind !== "string")
+      return;
+    names.push(element[0].value);
+  }
+  return names.length > 0 ? names : undefined;
+}
+function discoveryHelpers(tokens) {
+  const helpers = [];
+  for (let index = 0;index < tokens.length; index += 1) {
+    if (tokens[index]?.value !== "function" || tokens[index + 1]?.kind !== "ident")
+      continue;
+    let open = index + 2;
+    if (tokens[open]?.value === "<")
+      open = (matchBracket(tokens, open, "<", ">") ?? tokens.length) + 1;
+    if (tokens[open]?.value !== "(")
+      continue;
+    const close = matchBracket(tokens, open, "(", ")");
+    if (close === undefined)
+      continue;
+    let bodyOpen = close + 1;
+    while (bodyOpen < tokens.length && tokens[bodyOpen]?.value !== "{")
+      bodyOpen += 1;
+    const bodyClose = matchBracket(tokens, bodyOpen, "{", "}");
+    if (bodyClose === undefined)
+      continue;
+    const preceding = tokens[index - (tokens[index - 1]?.value === "async" ? 2 : 1)]?.value;
+    helpers.push({
+      name: tokens[index + 1].value,
+      nameIndex: index + 1,
+      params: splitTopLevelArguments({ method: "parallel", argsOpen: open }, tokens),
+      bodyOpen,
+      bodyClose,
+      declaration: preceding === undefined || ["export", ";", "{", "}"].includes(preceding)
+    });
+  }
+  return helpers;
+}
+function hasDiscoveryDestructuringWrite(tokens, parameter) {
+  for (let index = 0;index < tokens.length; index += 1) {
+    const open = tokens[index]?.value;
+    if (open !== "[" && open !== "{")
+      continue;
+    const close = matchBracket(tokens, index, open, open === "[" ? "]" : "}");
+    if (close === undefined || !["=", "of", "in"].includes(tokens[close + 1]?.value ?? ""))
+      continue;
+    if (tokens.slice(index + 1, close).some((token) => token.kind === "ident" && token.value === parameter))
+      return true;
+  }
+  return false;
+}
+function discoveryCalls(tokens, name, declaration) {
+  const calls = [];
+  for (let index = 0;index < tokens.length; index += 1) {
+    if (tokens[index]?.value === "import") {
+      while (index < tokens.length && tokens[index]?.kind !== "string")
+        index += 1;
+      continue;
+    }
+    if (tokens[index]?.value === "export" && tokens[index + 1]?.value === "{") {
+      const close = matchBracket(tokens, index + 1, "{", "}") ?? tokens.length;
+      const exported = tokens.slice(index + 2, close);
+      if (exported.some((token, offset) => token.value === name && (declaration === undefined || exported[offset + 1]?.value === "as")))
+        return;
+      index = close;
+      continue;
+    }
+    if (tokens[index]?.kind !== "ident" || tokens[index]?.value !== name || index === declaration)
+      continue;
+    if (tokens[index + 1]?.value !== "(" || [".", "?.", "function"].includes(tokens[index - 1]?.value ?? ""))
+      return;
+    calls.push(index + 1);
+  }
+  return calls;
+}
 
 class PossibleStagesScanner {
   stages = new Set;
@@ -82131,6 +82289,7 @@ class PossibleStagesScanner {
   maxDepth;
   units = new Map;
   aliasPool = new Set;
+  closure = [];
   constructor(maxDepth) {
     this.maxDepth = maxDepth;
   }
@@ -82166,11 +82325,17 @@ class PossibleStagesScanner {
         this.aliasPool.add(alias);
       }
     }
-    for (const path of ordered) {
-      const unit = this.units.get(path);
-      if (unit === undefined)
-        continue;
-      this.scanUnit(unit, path, boundaryPrefix, depth, ancestorStack);
+    const previousClosure = this.closure;
+    this.closure = ordered;
+    try {
+      for (const path of ordered) {
+        const unit = this.units.get(path);
+        if (unit === undefined)
+          continue;
+        this.scanUnit(unit, path, boundaryPrefix, depth, ancestorStack);
+      }
+    } finally {
+      this.closure = previousClosure;
     }
   }
   unitFor(path) {
@@ -82284,7 +82449,127 @@ class PossibleStagesScanner {
     }
     return resolveRelativeSpecifier(specifier, importingFile);
   }
+  hasDataOnlyDiscoveryOptions(argument) {
+    if (argument?.[0]?.value !== "{" || argument.at(-1)?.value !== "}")
+      return false;
+    return arrayElements(argument).every((field) => (field[0]?.kind === "ident" || field[0]?.kind === "string") && field[0].value !== "__proto__" && field[1]?.value === ":");
+  }
+  discoveryNames(call, unit, path) {
+    if (call.method !== "parallel")
+      return;
+    const value2 = discoveryField(splitTopLevelArguments(call, unit.tokens)[1]);
+    const literal = literalDiscoveryNames(value2);
+    if (literal !== undefined)
+      return literal;
+    if (value2?.length !== 3 || value2[0]?.kind !== "ident" || value2[1]?.value !== "." || value2[2]?.value !== "possibleStageNames")
+      return;
+    const owner = discoveryHelpers(unit.tokens).filter((helper) => helper.bodyOpen < call.argsOpen && helper.bodyClose > call.argsOpen).at(-1);
+    if (owner === undefined || !owner.declaration)
+      return;
+    const parameter = owner.params.findIndex((param) => param[0]?.value === value2[0]?.value);
+    if (parameter < 0)
+      return;
+    for (const param of owner.params) {
+      if (param[0]?.kind !== "ident")
+        return;
+      const assignment = param.findIndex((token) => token.value === "=");
+      if (assignment < 0)
+        continue;
+      const initial = param.slice(assignment + 1);
+      const emptyObject = initial.length === 2 && initial[0]?.value === "{" && initial[1]?.value === "}";
+      const scalar = initial.length === 1 && (initial[0]?.kind === "string" || ["true", "false", "null", "undefined"].includes(initial[0]?.value ?? ""));
+      if (!emptyObject && !scalar)
+        return;
+    }
+    const body = unit.tokens.slice(owner.bodyOpen, owner.bodyClose);
+    if (body.some((token) => token.kind === "ident" && token.value === "arguments"))
+      return;
+    if (hasDiscoveryDestructuringWrite(body, value2[0].value))
+      return;
+    const forwarded = new Set;
+    const spreadOptions = new Set;
+    for (let index = 0;index < body.length; index += 1) {
+      const parallel = matchCtxCall(body, index, this.aliasPool);
+      if (parallel?.method !== "parallel")
+        continue;
+      const parallelOptions = splitTopLevelArguments(parallel, body)[1];
+      const field = discoveryField(parallelOptions);
+      if (parallelOptions?.[0]?.value === "{") {
+        for (const entry of arrayElements(parallelOptions)) {
+          if (entry.length === 4 && entry.slice(0, 3).every((token) => token.value === "."))
+            spreadOptions.add(entry[3]);
+        }
+      }
+      if (field?.length === 3 && field[0]?.value === value2[0].value && field[1]?.value === "." && field[2]?.value === "possibleStageNames")
+        forwarded.add(field[0]);
+    }
+    for (let index = 0;index < body.length; index += 1) {
+      if (body[index]?.value !== value2[0]?.value)
+        continue;
+      if (body[index + 2]?.value === "possibleStageNames" && !forwarded.has(body[index]))
+        return;
+      const destructured = body[index - 2]?.value === "}" && body[index - 1]?.value === "=" && body[index + 1]?.value === ";";
+      if (destructured) {
+        let matched = false;
+        for (let open = 0;open < index - 2; open += 1) {
+          if (body[open]?.value !== "{" || matchBracket(body, open, "{", "}") !== index - 2)
+            continue;
+          if (body[open - 1]?.value !== "const")
+            return;
+          matched = true;
+          for (const entry of arrayElements(body.slice(open, index - 1))) {
+            if (entry.length === 1 && entry[0]?.kind === "ident" && entry[0].value !== "possibleStageNames")
+              continue;
+            if (entry.length !== 4 || !entry.slice(0, 3).every((token) => token.value === ".") || entry[3]?.kind !== "ident")
+              return;
+            const rest = entry[3];
+            for (let use = 0;use < body.length; use += 1) {
+              const token = body[use];
+              if (token?.kind !== "ident" || token.value !== rest.value || token === rest)
+                continue;
+              if (spreadOptions.has(token))
+                continue;
+              if (body[use - 3]?.value === "const" && body[use - 2]?.kind === "ident" && body[use - 1]?.value === "=" && body[use + 1]?.value === "." && body[use + 2]?.value === "concurrency" && body[use + 3]?.value === ";")
+                continue;
+              return;
+            }
+          }
+        }
+        if (!matched)
+          return;
+      }
+      if (!destructured && !forwarded.has(body[index]))
+        return;
+    }
+    const names = [];
+    for (const callerPath of this.closure) {
+      const caller = this.units.get(callerPath);
+      if (caller === undefined)
+        continue;
+      if ([...caller.imports.values()].some((binding) => binding.importedName === undefined && resolveRelativeSpecifier(binding.specifier, callerPath) === path))
+        return;
+      const references = callerPath === path ? [owner.name] : [...caller.imports].filter(([, binding]) => binding.importedName === owner.name && resolveRelativeSpecifier(binding.specifier, callerPath) === path).map(([local]) => local);
+      for (const reference of references) {
+        const calls = discoveryCalls(caller.tokens, reference, callerPath === path ? owner.nameIndex : undefined);
+        if (calls === undefined)
+          return;
+        for (const argsOpen of calls) {
+          const argument = splitTopLevelArguments({ method: "parallel", argsOpen }, caller.tokens)[parameter];
+          if (!this.hasDataOnlyDiscoveryOptions(argument))
+            return;
+          const declared = literalDiscoveryNames(discoveryField(argument));
+          if (declared === undefined)
+            return;
+          names.push(...declared);
+        }
+      }
+    }
+    return names.length > 0 || this.closure[0] !== path ? names : undefined;
+  }
   stepNamesForStepsCall(call, unit, path) {
+    const declared = this.discoveryNames(call, unit, path);
+    if (declared !== undefined)
+      return declared;
     const first = firstArgumentTokens(call, unit.tokens);
     if (first === undefined || first.length === 0)
       return [];
@@ -90858,7 +91143,8 @@ async function warm_first_fan_out(ctx, steps, prefixKeyOf, options = {}) {
       const warmResults = await ctx.parallel(warmSteps, {
         ...parallelOptions,
         concurrency: boundedConcurrency(warmSteps.length, warmConcurrency ?? DEFAULT_WARM_CONCURRENCY, inheritedConcurrency),
-        failFast: false
+        failFast: false,
+        possibleStageNames: options.possibleStageNames
       });
       for (const [resultIndex, result] of warmResults.entries()) {
         const originalIndex = warmIndices[resultIndex];
@@ -90873,7 +91159,8 @@ async function warm_first_fan_out(ctx, steps, prefixKeyOf, options = {}) {
     const restSteps = restIndices.map((index) => steps[index]);
     const restResults = await ctx.parallel(restSteps, {
       ...parallelOptions,
-      concurrency: boundedConcurrency(restSteps.length, undefined, inheritedConcurrency)
+      concurrency: boundedConcurrency(restSteps.length, undefined, inheritedConcurrency),
+      possibleStageNames: options.possibleStageNames
     });
     for (const [resultIndex, result] of restResults.entries()) {
       const originalIndex = restIndices[resultIndex];
@@ -91082,7 +91369,7 @@ async function runAdversarialVerification(ctx) {
     const runWave = async (pending, reaskWave) => {
       if (pending.length === 0)
         return { valid: [], invalid: [], results: [] };
-      const reports = await warm_first_fan_out(ctx, pending.map((cell) => scoreStep(cell, reaskWave, scoringHead, criteriaPath)), () => scoringHead, { concurrency: Math.min(pending.length, 4), failFast: false });
+      const reports = await warm_first_fan_out(ctx, pending.map((cell) => scoreStep(cell, reaskWave, scoringHead, criteriaPath)), () => scoringHead, { concurrency: Math.min(pending.length, 4), failFast: false, possibleStageNames: ["verifier-*-*-*", "verifier-*-*-*-reask-*"] });
       const byName = new Map;
       for (const report of reports) {
         const name = report.name ?? report.stageName;
@@ -96470,7 +96757,7 @@ async function runTournament(ctx) {
     if (stages.length === 0)
       return { preferences: [], results: [] };
     executed += stages.length;
-    const results = await warm_first_fan_out(ctx, stages.map((stage) => stage.step), (_step, index) => `${stages[index].slot1}:${stages[index].slot2}`, { concurrency: maxConcurrency, failFast: false });
+    const results = await warm_first_fan_out(ctx, stages.map((stage) => stage.step), (_step, index) => `${stages[index].slot1}:${stages[index].slot2}`, { concurrency: maxConcurrency, failFast: false, possibleStageNames: ["judge-*-*-*-r*"] });
     const phaseResults = [...results];
     for (const stage of stages) {
       let report = judgeReport(resultFor(results, stage.name)?.structured);
@@ -104255,21 +104542,17 @@ function throwFinalizationError(error) {
 function createTrackedStageCaller(input) {
   const { runtime } = input;
   const readinessGateEnabled = runtime.opts.confirmStageReadiness !== undefined || runtime.opts.usePromptNodesForUi === true;
-  const confirmReadiness = async () => {
-    try {
-      if (runtime.opts.confirmStageReadiness !== undefined) {
-        const ready = await runtime.opts.confirmStageReadiness({
-          runId: runtime.runId,
-          stageId: runtime.stageId,
-          stageName: runtime.name,
-          signal: runtime.signal
-        });
-        return ready ? { action: "advance" } : { action: "stay" };
-      }
-      return await askReadinessViaStageBroker(runtime.runId, runtime.stageId, runtime.signal);
-    } catch {
-      return { action: "advance" };
-    }
+  const confirmReadiness = async (signal) => {
+    if (runtime.opts.confirmStageReadiness !== undefined) {
+      const ready = await raceAbort(runtime.opts.confirmStageReadiness({
+        runId: runtime.runId,
+        stageId: runtime.stageId,
+        stageName: runtime.name,
+        signal
+      }), signal);
+      return ready ? { action: "advance" } : { action: "stay" };
+    }
+    return await askReadinessViaStageBroker(runtime.runId, runtime.stageId, signal);
   };
   const suppressReadinessForCurrentTurn = () => {
     runtime.state.askUserQuestionObservedThisTurn = false;
@@ -104423,9 +104706,35 @@ function createTrackedStageCaller(input) {
           });
           try {
             while (runtime.state.askUserQuestionObservedThisTurn || repeatReadinessAfterChatTurn) {
-              const decision = await confirmReadiness();
+              runtime.signal.throwIfAborted();
+              if (runtime.stageSnapshot.status === "paused" || runtime.stageSnapshot.status === "blocked") {
+                await runtime.scheduler.waitForStageRelease(runtime.stageId, runtime.releaseLiveHandle);
+                continue;
+              }
+              const controller = new AbortController;
+              runtime.state.readinessController = controller;
+              let decision;
+              try {
+                decision = await confirmReadiness(AbortSignal.any([runtime.signal, controller.signal]));
+                if (decision.action === "advance" || decision.message !== undefined) {
+                  await runtime.scheduler.waitForStageRelease(runtime.stageId, runtime.releaseLiveHandle);
+                }
+                runtime.signal.throwIfAborted();
+                if (controller.signal.aborted) {
+                  await runtime.scheduler.waitForStageRelease(runtime.stageId, runtime.releaseLiveHandle);
+                  continue;
+                }
+              } catch (error) {
+                runtime.signal.throwIfAborted();
+                if (controller.signal.aborted) {
+                  await runtime.scheduler.waitForStageRelease(runtime.stageId, runtime.releaseLiveHandle);
+                  continue;
+                }
+                throw error;
+              }
               if (decision.action === "advance")
                 break;
+              delete runtime.state.readinessController;
               if (runtime.signal.aborted)
                 break;
               runtime.state.askUserQuestionObservedThisTurn = false;
@@ -104568,9 +104877,17 @@ function createTrackedStageCaller(input) {
           const failure = runtime.classifyExecutorFailure(durableCheckpointError.error);
           applyTerminalStageState = () => applyFailureToStage(runtime.stageSnapshot, failure);
         }
-        if (!runtime.state.stageFinalized)
-          applyTerminalStageState?.();
         try {
+          if (terminalStateIsSuccess && runtime.state.readinessController !== undefined) {
+            let pauseVersion;
+            do {
+              pauseVersion = runtime.state.readinessPauseVersion;
+              await runtime.scheduler.waitForStageRelease(runtime.stageId, runtime.releaseLiveHandle);
+            } while (pauseVersion !== runtime.state.readinessPauseVersion);
+            runtime.signal.throwIfAborted();
+          }
+          if (!runtime.state.stageFinalized)
+            applyTerminalStageState?.();
           await runtime.finalizeStageSnapshot();
         } catch (err) {
           finalizationError ??= { thrown: true, error: err };
@@ -104588,6 +104905,9 @@ function createTrackedStageCaller(input) {
       input.limiter.release();
       if (finalizationError !== undefined)
         throwFinalizationError(finalizationError.error);
+      delete runtime.state.readinessController;
+      if (terminalStateIsSuccess && readinessGateEnabled)
+        runtime.signal.throwIfAborted();
     }
   };
 }
@@ -104908,12 +105228,26 @@ function createStageControlHandle(runtime) {
     async pause() {
       runtime.throwIfStageMutationBlocked();
       const statusBeforePause = runtime.stageSnapshot.status;
+      let readinessPauseVersion;
+      if (runtime.state.readinessController !== undefined) {
+        runtime.scheduler.ensureReleaseBarrier(runtime.stageId);
+        readinessPauseVersion = (runtime.state.readinessPauseVersion ?? 0) + 1;
+        runtime.state.readinessPauseVersion = readinessPauseVersion;
+      }
       if (statusBeforePause === "pending" || statusBeforePause === "running" || runtime.innerCtx.isStreaming) {
-        await runtime.innerCtx.__requestPause();
+        try {
+          await runtime.innerCtx.__requestPause();
+        } catch (error) {
+          if (readinessPauseVersion !== undefined && runtime.state.readinessPauseVersion === readinessPauseVersion && runtime.stageSnapshot.status !== "paused" && runtime.stageSnapshot.status !== "blocked" && !runtime.scheduler.hasCascadePauseOwners(runtime.stageId)) {
+            runtime.scheduler.releaseStageBarrier(runtime.stageId);
+          }
+          throw error;
+        }
       }
       const changed = runtime.activeStore.recordStagePaused(runtime.runId, runtime.stageId);
       if (changed) {
         runtime.scheduler.ensureReleaseBarrier(runtime.stageId);
+        runtime.state.readinessController?.abort(new Error("atomic-workflows: readiness paused"));
         await runtime.scheduler.cascadePauseFrom(runtime.stageId);
         const run = runtime.activeStore.runs().find((candidate) => candidate.id === runtime.runId);
         const stillActive = run?.stages.some((stage) => stage.status === "running" && stage.id !== runtime.stageId) ?? false;
@@ -117179,7 +117513,7 @@ var DEFAULT_PROMPT_GUIDANCE = [
   - After creating and reloading a newly authored custom workflow, close the loop by stating the folder containing the workflow file just written, for example \`.atomic/workflows/\`, in this shape: \`Custom workflow created. You can inspect its code at: <workflow-folder-path>\`. Do this only for newly created custom workflows, never builtin or pre-existing workflows.
   - Keep a small, readable workflow in one entry file and write it for human maintainers. Keep the graph and control flow visible in the top-level workflow entry file, use stage names that state each stage's responsibility, and make its inputs, outputs, evidence, and success contract explicit. A developer reading the entry file from top to bottom should be able to identify the graph, branches, gates, artifacts, and stop conditions. Avoid both monolithic prompt blobs and gratuitous fragmentation. Do not split short one-use prompts, create one file per stage, add wrapper-only modules, hide the graph across files, or use line counts alone as a module boundary.
   - When a meaningful source boundary improves clarity, reuse, ownership, or testability, keep the graph and control flow in the top-level workflow entry file and extract cohesive concerns such as long or reused prompt builders, shared TypeBox schemas and workflow-specific types, model-policy constants shared by several stages, deterministic helpers with their own testable behavior, or reusable child workflow definitions into a subdirectory below the top-level discovery directory — either one owned by a single workflow or a shared support directory. Project and user discovery scans only top-level \`.ts\`/\`.js\`/\`.mjs\`/\`.cjs\` files in the workflow directory, so those support modules are not scanned as extra top-level workflow candidates; use \`.js\` import extensions from TypeScript source.
-  - Evaluate Atomic extension hooks when a workflow needs fine-grained, cross-cutting tool or session event control. Workflow TypeScript owns the inspectable DAG, stages, handoffs, durable \`ctx.tool\` side effects, and gates; extension hooks own cross-cutting session and model-tool policy such as \`tool_call\` interception, input mutation, or blocking, \`tool_result\` transformation, context and provider hooks, lifecycle observation, or reusable custom tools. Use hooks only when cross-stage or cross-workflow event control is materially clearer than embedding the policy in each stage; do not prescribe a companion extension for ordinary workflow logic. Consult \`packages/coding-agent/docs/extensions.md#events\` for the authoritative hook contracts.
+  - Evaluate Atomic extension hooks when a workflow needs fine-grained, cross-cutting tool or session event control. Workflow TypeScript owns the inspectable DAG, stages, handoffs, durable \`ctx.tool\` side effects, and gates; extension hooks own cross-cutting session and model-tool policy such as \`tool_call\` interception, input mutation, or blocking, \`tool_result\` transformation, context and provider hooks, lifecycle observation, or reusable custom tools. Use hooks only when cross-stage or cross-workflow event control is materially clearer than embedding the policy in each stage; do not prescribe a companion extension for ordinary workflow logic. Consult \`packages/coding-agent/docs/extensions/events.md#events\` for the authoritative hook contracts.
   - When a workflow depends on a companion extension, make the dependency explicit, package and document it with the workflow, include any extension-provided custom tools in stage \`tools\` allowlists, and document hook-driven behavior so the workflow remains inspectable.
   - When creating or editing a workflow that pins an explicit stage \`model\` or \`fallbackModels\`, consult \`packages/coding-agent/docs/models/model-selection.md\` for role-based recommendations and \`packages/coding-agent/docs/models/evals.md\` for the measured per-evaluation scores behind them (its task-type picker maps each stage type to the eval that measures it), treating benchmark thinking levels as measurement configurations rather than universal workflow defaults, then call \`workflow({ action: "models" })\` to see the models actually present in the user's configured catalog. Use only the catalog's returned \`fullId\` values as model strings, and append a thinking suffix only when that exact level appears in the entry's \`availableThinkingLevels\`; apply the stage role and failure-cost policy independently to the primary and every fallback; treat an absent or empty \`availableThinkingLevels\` as no suffix support rather than inferring one. If a guide-recommended model for the role is unavailable, try another guide-recommended model that is present in the catalog. If the selected model does not support the role's level, choose another catalog model that does or leave the stage unpinned rather than inventing or silently promoting a level. An explicit user request for a level overrides the role default, but never fabricate an unsupported catalog level. If no recommendation intersects with the catalog, leave the stage unpinned rather than inventing a substitute, and mention the limitation, asking the user only if the workflow requires an explicit model choice. If the catalog is empty, continue with unpinned stages, state that no configured models were returned, and do not fabricate model IDs. Do not inspect or infer credentials, environment variables, auth files, token validity, entitlements, or the reason a model is absent; \`isCurrent\` marks the active selection, not a quality recommendation.
   - Consult docs/workflows/reliable-design.md and its starter patterns (Classify-and-act, Fan-out-and-synthesize, Adversarial verification, Generate-and-filter, Tournament, Loop until done, and Stacked implementation slices) when designing a stage graph.