@bastani/atomic 0.9.13-alpha.1 → 0.9.13-alpha.3

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

@@ -35556,6 +35556,7 @@ Defaulting to 2020, but this will stop working in the future.`)), t3.ecmaVersion
 });
 
 // dist/builtin/workflows/src/intercom/intercom-routing.ts
+import { isStaleExtensionContextError } from "@bastani/atomic";
 function toNoticeLevel(raw) {
   if (raw === "warning" || raw === "error")
     return raw;
@@ -35579,12 +35580,17 @@ function buildIntercomCallbacks(deps) {
         requiresAck: true
       });
       const accepted = typeof confirm === "function" ? await confirm("Subagent needs decision", payload.message).catch(() => false) : false;
-      emit?.("subagent:control-intercom:response", {
-        requestId: payload.requestId ?? "",
-        runId: payload.runId ?? "",
-        stageId: payload.stageId ?? "",
-        accepted
-      });
+      try {
+        emit?.("subagent:control-intercom:response", {
+          requestId: payload.requestId ?? "",
+          runId: payload.runId ?? "",
+          stageId: payload.stageId ?? "",
+          accepted
+        });
+      } catch (error) {
+        if (!isStaleExtensionContextError(error))
+          throw error;
+      }
       store.ackNotice(noticeId);
     },
     onNotify(payload) {
@@ -35611,6 +35617,7 @@ function buildIntercomCallbacks(deps) {
 }
 
 // dist/builtin/workflows/src/intercom/result-intercom.ts
+import { isStaleExtensionContextError as isStaleExtensionContextError2 } from "@bastani/atomic";
 function subscribeIntercomControl(pi, callbacks) {
   if (typeof pi.events?.on !== "function")
     return null;
@@ -35635,11 +35642,23 @@ function subscribeIntercomControl(pi, callbacks) {
       Promise.reject(new Error(`atomic-workflows: intercom callback error (type=${payload.type}): ${err instanceof Error ? err.message : String(err)}`));
     });
   };
-  const unsubscribe = pi.events.on("subagent:control-intercom", handler);
+  let unsubscribe;
+  try {
+    unsubscribe = pi.events.on("subagent:control-intercom", handler);
+  } catch (error) {
+    if (!isStaleExtensionContextError2(error))
+      throw error;
+    return null;
+  }
   return () => {
     active = false;
-    if (typeof unsubscribe === "function")
-      unsubscribe();
+    try {
+      if (typeof unsubscribe === "function")
+        unsubscribe();
+    } catch (error) {
+      if (!isStaleExtensionContextError2(error))
+        throw error;
+    }
   };
 }
 
@@ -35650,6 +35669,7 @@ function flattenTruncatedString(value2) {
 
 // dist/builtin/workflows/src/shared/graph-store-snapshot.ts
 var COMPACT_RESULT_FIELD_LIMIT = 1024;
+var COMPACT_EXIT_OUTPUT_LIMIT = COMPACT_RESULT_FIELD_LIMIT * 4;
 function compactResultField(value2) {
   if (typeof value2 !== "string")
     return;
@@ -35657,7 +35677,7 @@ function compactResultField(value2) {
     return value2;
   return flattenTruncatedString(value2.slice(0, COMPACT_RESULT_FIELD_LIMIT));
 }
-function compactRunResult(result) {
+function compactRunResult(result, preserveExitedOutputs = false) {
   if (result === undefined)
     return;
   const status = compactResultField(result.status);
@@ -35670,8 +35690,31 @@ function compactRunResult(result) {
     ...remainingWork !== undefined ? { remaining_work: remainingWork } : {},
     ...resultText !== undefined ? { result: resultText } : {}
   };
+  if (!preserveExitedOutputs)
+    return Object.keys(compact).length === 0 ? undefined : compact;
+  return compactExitedOutputs(result, compact);
+}
+function compactExitedOutputs(result, compact) {
+  try {
+    const serialized = JSON.stringify(result);
+    if (serialized !== undefined && serialized.length <= COMPACT_EXIT_OUTPUT_LIMIT) {
+      const parsed = JSON.parse(serialized);
+      if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) {
+        return compactExitedObject(parsed);
+      }
+    }
+  } catch {}
   return Object.keys(compact).length === 0 ? undefined : compact;
 }
+function compactExitedObject(result) {
+  const compacted = { ...result };
+  for (const key of ["status", "summary", "remaining_work", "result"]) {
+    const value2 = compacted[key];
+    if (typeof value2 === "string")
+      compacted[key] = compactResultField(value2) ?? "";
+  }
+  return Object.keys(compacted).length === 0 ? undefined : compacted;
+}
 function clonePrompt(prompt) {
   return {
     ...prompt,
@@ -35730,7 +35773,7 @@ function compactToolNode(node) {
 }
 function compactRun(run) {
   const { inputs: _inputs, result: sourceResult, stages, toolNodes, pendingPrompt, ...metadata } = run;
-  const result = compactRunResult(sourceResult);
+  const result = compactRunResult(sourceResult, run.exited === true && run.status === "failed");
   return {
     ...metadata,
     inputs: {},
@@ -37296,10 +37339,14 @@ function renderInputsSegment(inputs, budget, theme) {
     fitted: false
   };
 }
+var ROW_BREAKING_RE = /[\p{Cc}\u2028\u2029]+/gu;
+function toSingleLine(value2) {
+  return value2.replace(ROW_BREAKING_RE, " ");
+}
 function renderInputValue(value2, budget) {
   if (typeof value2 === "string") {
     const interior = Math.max(0, budget - 2);
-    const trimmed = truncateToWidth(value2, interior, ELLIPSIS);
+    const trimmed = truncateToWidth(toSingleLine(value2), interior, ELLIPSIS);
     return `"${trimmed}"`;
   }
   if (typeof value2 === "number" || typeof value2 === "boolean") {
@@ -37308,7 +37355,7 @@ function renderInputValue(value2, budget) {
   if (value2 === null)
     return "null";
   const json = JSON.stringify(value2);
-  return truncateToWidth(json ?? "", budget, ELLIPSIS);
+  return truncateToWidth(toSingleLine(json ?? ""), budget, ELLIPSIS);
 }
 function effectiveWidth(width) {
   return chatWidth(width);
@@ -37508,6 +37555,8 @@ function summaryRows(detail, now) {
     rows.push(["error", detail.error.split(`
 `)[0] ?? ""]);
   }
+  if (detail.resumeGuidance)
+    rows.push(["guidance", detail.resumeGuidance]);
   return rows;
 }
 function artifactRowsFor(detail) {
@@ -37621,6 +37670,8 @@ function stateBadges(detail, theme) {
   switch (detail.status) {
     case "running":
       return [{ text: "● running", fg: theme.warning }];
+    case "crashed":
+      return [{ text: detail.resumable === true ? "✗ crashed · resumable" : "✗ crashed", fg: theme.error }];
     case "paused":
       return [{ text: "❚❚ paused", fg: theme.warning }];
     case "completed":
@@ -37643,6 +37694,8 @@ function stateLabel(detail) {
   switch (detail.status) {
     case "running":
       return "● running";
+    case "crashed":
+      return detail.resumable === true ? "✗ crashed · resumable" : "✗ crashed";
     case "paused":
       return "❚❚ paused";
     case "completed":
@@ -37682,8 +37735,10 @@ function renderIdentifierRows2(id, width, theme) {
   });
 }
 function renderDetailHintRows(detail, width, theme) {
-  const prefix = detail.endedAt === undefined ? detail.status === "paused" ? " ▸ workflow resume id=" : " ▸ workflow interrupt   id=" : " ▸ workflow resume id=";
-  const suffix = detail.endedAt === undefined ? detail.status === "paused" ? "    continue workflow " : "    cancel " : "    reopen graph ";
+  const resumable = detail.status === "paused" && detail.resumable !== false || detail.resumable === true && (detail.status === "crashed" || detail.status === "failed" || detail.status === "blocked");
+  const inspectOnly = detail.ownerActiveElsewhere === true || detail.status === "crashed" && !resumable || detail.endedAt !== undefined && !resumable;
+  const prefix = inspectOnly ? " ▸ workflow status id=" : resumable ? " ▸ workflow resume id=" : " ▸ workflow interrupt   id=";
+  const suffix = inspectOnly ? detail.ownerActiveElsewhere === true ? "    inspect; owner active elsewhere " : "    inspect retained state " : resumable ? "    continue workflow " : "    cancel ";
   const continuation = "    ";
   const rows = wrapIdentifierLines(detail.runId, width, prefix, continuation);
   const last = rows[rows.length - 1];
@@ -37961,6 +38016,8 @@ function runCardMeta(run, now) {
     return parts.join(" · ");
   }
   if (effectiveRunStatus(run) === "failed" || effectiveRunStatus(run) === "killed") {
+    if (run.exitReason !== undefined && run.exitReason.length > 0 && run.exited === true)
+      parts.push(run.exitReason);
     const failed = run.stages.find((s) => s.status === "failed");
     if (failed && isChain)
       parts.push(`failed at ${failed.name}`);
@@ -38526,6 +38583,9 @@ function deriveGraphThemeFromPiTheme(theme) {
   return deriveGraphTheme(cleaned);
 }
 
+// dist/builtin/workflows/src/tui/inline-form-overlay.ts
+import { isStaleExtensionContextError as isStaleExtensionContextError3 } from "@bastani/atomic";
+
 // dist/builtin/workflows/src/tui/header.ts
 function pillFor(run, theme) {
   if (run.status === "failed")
@@ -38887,7 +38947,8 @@ function computeInvalid(fields, raw) {
 
 // dist/builtin/workflows/src/tui/keybindings-adapter.ts
 var APP_ACTION = {
-  toolsExpand: "app.tools.expand"
+  toolsExpand: "app.tools.expand",
+  thinkingToggle: "app.thinking.toggle"
 };
 var TUI_ACTION = {
   editorCursorUp: "tui.editor.cursorUp",
@@ -38958,6 +39019,30 @@ function deleteRange(text, start, end, caret) {
 }
 
 // dist/builtin/workflows/src/tui/inputs-picker-input.ts
+function isInputsPickerKey(key, state, fields, keybindings) {
+  if (fields.length === 0)
+    return isCancelKey(key);
+  if (isCancelKey(key) || matchesKey(key, Key.tab) || matchesKey(key, Key.shift("tab")))
+    return true;
+  if (state.focusedIdx === fields.length) {
+    return matchesAction(keybindings, key, TUI_ACTION.selectUp) || matchesAction(keybindings, key, TUI_ACTION.selectDown) || matchesAction(keybindings, key, TUI_ACTION.editorCursorUp) || matchesAction(keybindings, key, TUI_ACTION.editorCursorDown) || matchesKey(key, Key.enter) || matchesAction(keybindings, key, TUI_ACTION.selectConfirm) || matchesAction(keybindings, key, TUI_ACTION.inputSubmit);
+  }
+  const field = fields[state.focusedIdx];
+  if (!field)
+    return false;
+  if (field.type === "select") {
+    if ((field.choices ?? []).length === 0)
+      return false;
+    return matchesAction(keybindings, key, TUI_ACTION.selectUp) || matchesAction(keybindings, key, TUI_ACTION.selectDown) || matchesAction(keybindings, key, TUI_ACTION.editorCursorLeft) || matchesAction(keybindings, key, TUI_ACTION.editorCursorRight) || matchesAction(keybindings, key, TUI_ACTION.selectConfirm) || matchesAction(keybindings, key, TUI_ACTION.inputSubmit);
+  }
+  if (field.type === "boolean") {
+    return matchesKey(key, Key.space) || matchesAction(keybindings, key, TUI_ACTION.selectUp) || matchesAction(keybindings, key, TUI_ACTION.selectDown) || matchesAction(keybindings, key, TUI_ACTION.editorCursorLeft) || matchesAction(keybindings, key, TUI_ACTION.editorCursorRight) || matchesAction(keybindings, key, TUI_ACTION.selectConfirm) || matchesAction(keybindings, key, TUI_ACTION.inputSubmit);
+  }
+  if (matchesAction(keybindings, key, TUI_ACTION.editorCursorUp) || matchesAction(keybindings, key, TUI_ACTION.editorCursorDown) || matchesAction(keybindings, key, "tui.editor.cursorWordLeft") || matchesAction(keybindings, key, "tui.editor.cursorWordRight") || matchesAction(keybindings, key, "tui.editor.cursorLineStart") || matchesAction(keybindings, key, "tui.editor.cursorLineEnd") || matchesAction(keybindings, key, TUI_ACTION.editorCursorLeft) || matchesAction(keybindings, key, TUI_ACTION.editorCursorRight) || matchesAction(keybindings, key, "tui.editor.deleteWordBackward") || matchesAction(keybindings, key, "tui.editor.deleteWordForward") || matchesAction(keybindings, key, "tui.editor.deleteToLineStart") || matchesAction(keybindings, key, "tui.editor.deleteToLineEnd") || matchesAction(keybindings, key, "tui.editor.deleteCharBackward") || matchesAction(keybindings, key, "tui.editor.deleteCharForward") || matchesAction(keybindings, key, TUI_ACTION.inputSubmit) || matchesAction(keybindings, key, "tui.input.newLine")) {
+    return true;
+  }
+  return isPrintableGrapheme(decodePrintableKey(key) ?? key);
+}
 function handleInputsPickerInput(key, state, fields, keybindings) {
   if (fields.length === 0) {
     if (isCancelKey(key))
@@ -39855,7 +39940,7 @@ class InlineFormEditor {
   handleInput(data) {
     const state = getForm(this.opts.formId);
     if (state?.status !== "editing")
-      return;
+      return false;
     if (data.includes(PASTE_START)) {
       this.isInPaste = true;
       this.pasteBuffer = "";
@@ -39865,7 +39950,7 @@ class InlineFormEditor {
       this.pasteBuffer += data;
       const endIdx = this.pasteBuffer.indexOf(PASTE_END);
       if (endIdx === -1)
-        return;
+        return true;
       const content = this.pasteBuffer.slice(0, endIdx);
       const remaining = this.pasteBuffer.slice(endIdx + PASTE_END.length);
       this.isInPaste = false;
@@ -39876,20 +39961,22 @@ class InlineFormEditor {
       }
       if (remaining.length > 0)
         this.handleInput(remaining);
-      return;
+      return true;
     }
     if (data.length > 1 && isPrintableTextChunk(data)) {
-      if (this.applyPaste(data, state)) {
+      const consumed2 = this.applyPaste(data, state);
+      if (consumed2) {
         touch(state);
         this.tui.requestRender?.();
       }
-      return;
+      return consumed2;
     }
     const consumed = this.routeKey(data, state);
     if (consumed) {
       touch(state);
       this.tui.requestRender?.();
     }
+    return consumed;
   }
   applyPaste(content, state) {
     const field = state.fields[state.focusedIdx];
@@ -40209,7 +40296,7 @@ async function openInlineInputsForm(pi, ctx, opts) {
       try {
         return getEditor.call(ctx.ui) === installedFactory;
       } catch (err) {
-        if (err instanceof Error && err.message.includes("This extension ctx is stale")) {
+        if (isStaleExtensionContextError3(err)) {
           return false;
         }
         return true;
@@ -40505,15 +40592,8 @@ function subscribeStoreInvalidation(store2, listener) {
 }
 
 // dist/builtin/workflows/src/tui/overlay-terminal-modes.ts
-var MOUSE_SCROLL_TRACKING_ON = "\x1B[?1000h\x1B[?1002h\x1B[?1006h";
-var MOUSE_SCROLL_TRACKING_OFF = "\x1B[?1006l\x1B[?1002l\x1B[?1000l";
 var TERMINAL_AUTOWRAP_ON = "\x1B[?7h";
 var TERMINAL_AUTOWRAP_OFF = "\x1B[?7l";
-function setMouseScrollTracking(enabled, output) {
-  if (!output.isTTY)
-    return;
-  output.write(enabled ? MOUSE_SCROLL_TRACKING_ON : MOUSE_SCROLL_TRACKING_OFF);
-}
 function setTerminalAutowrap(enabled, output) {
   if (output.platform !== "win32" || !output.isTTY)
     return;
@@ -40521,13 +40601,9 @@ function setTerminalAutowrap(enabled, output) {
 }
 function remoteTerminalControlFrom(tui) {
   const terminal = tui.terminal;
-  if (terminal === undefined || typeof terminal.setMouseScrollTracking !== "function" || typeof terminal.setAutowrap !== "function") {
+  if (terminal === undefined || typeof terminal.setAutowrap !== "function")
     return null;
-  }
-  return {
-    setMouseScrollTracking: terminal.setMouseScrollTracking.bind(terminal),
-    setAutowrap: terminal.setAutowrap.bind(terminal)
-  };
+  return { setAutowrap: terminal.setAutowrap.bind(terminal) };
 }
 
 // dist/builtin/workflows/src/runs/foreground/stage-queued-user-messages.ts
@@ -40957,12 +41033,9 @@ var COMPACT_HINT_KEYS = [
   { key: "↵", label: "stage chat" }
 ];
 var MODE_PILL_LABEL = "GRAPH";
-var OVERLAY_LINE_COUNT = 32;
-var OVERLAY_VERTICAL_MARGIN_ROWS = 1;
 var ANIMATION_TICK_MS = 100;
 var PULSE_PERIOD_MS = 2000;
 var GRAPH_SCROLL_STEP_COLS = 4;
-var GRAPH_SCROLL_STEP_ROWS = 4;
 
 // dist/builtin/workflows/src/tui/graph-canvas.ts
 function dirsForGlyph(ch) {
@@ -42016,7 +42089,7 @@ class GraphViewState {
   onDetach;
   initialFocusedStageId;
   initialFocusedRunId;
-  getViewportRows;
+  piTui;
   requestRender;
   piKeybindings;
   footerData;
@@ -42036,12 +42109,11 @@ class GraphViewState {
     targets: new Map
   };
   currentSnapshot = null;
-  graphScrollOffset = 0;
   graphScrollColOffset = 0;
   graphNodeHitRects = [];
   lastGraphViewport = null;
-  lastGraphTotalRows = 0;
-  lastOverlayFrameWidth = 80;
+  lastGraphTopPad = 0;
+  lastGraphVisibleRows = 0;
   pendingEnsureFocusedVisible = true;
   lastAutoFocusedAwaitingInputKey = null;
   lastBuiltSnapshotVersion = null;
@@ -42063,7 +42135,7 @@ class GraphViewState {
     this.onDetach = opts.onDetach;
     this.initialFocusedStageId = opts.initialFocusedStageId;
     this.initialFocusedRunId = opts.initialFocusedRunId;
-    this.getViewportRows = opts.getViewportRows;
+    this.piTui = opts.piTui;
     this.requestRender = opts.requestRender;
     this.piKeybindings = opts.piKeybindings;
     this.footerData = opts.footerData;
@@ -42098,7 +42170,6 @@ class GraphViewState {
       this.cachedRenderGeometry = { canvasWidth: 0, totalRows: 0, bands: [], edges: [] };
       this.expandedGraph = { stages: [], renderStages: [], tools: [], nodes: [], targets: new Map };
       this.focusedIndex = 0;
-      this.graphScrollOffset = 0;
       this.graphScrollColOffset = 0;
       this.graphNodeHitRects = [];
       this.lastGraphViewport = null;
@@ -42230,7 +42301,6 @@ class GraphViewState {
     }
     if (this.cachedLayout.length === 0) {
       this.focusedIndex = 0;
-      this.graphScrollOffset = 0;
       this.graphScrollColOffset = 0;
     } else if (this.focusedIndex >= this.cachedLayout.length) {
       this.focusedIndex = this.cachedLayout.length - 1;
@@ -42373,48 +42443,10 @@ class GraphViewState {
 
 // dist/builtin/workflows/src/tui/workflow-status.ts
 var WORKFLOW_STATUS_KEY = "pi-workflows";
-var OVERLAY_HIDDEN_STATUS_KEYS = new Set(["mcp"]);
+var OVERLAY_HIDDEN_STATUS_KEYS = new Set(["mcp", "i-have-adhd"]);
 
 // dist/builtin/workflows/src/tui/graph-view-render-helpers.ts
 class GraphViewRenderHelpers extends GraphViewState {
-  _overlayLineCount() {
-    const reported = this.getViewportRows?.();
-    if (typeof reported !== "number" || !Number.isFinite(reported)) {
-      return OVERLAY_LINE_COUNT;
-    }
-    return Math.max(7, Math.floor(reported));
-  }
-  _overlayBodyRows(lineCount) {
-    return Math.max(1, lineCount - 3 - 3);
-  }
-  _overlayVerticalMarginRows(lineCount = this._overlayLineCount()) {
-    return lineCount >= 9 ? OVERLAY_VERTICAL_MARGIN_ROWS : 0;
-  }
-  _overlayPanelLineCount() {
-    const lineCount = this._overlayLineCount();
-    const margins = this._overlayVerticalMarginRows(lineCount) * 2;
-    return Math.max(7, lineCount - margins);
-  }
-  _marginRow(width) {
-    return " ".repeat(width);
-  }
-  _withVerticalMargins(panelLines, width) {
-    const expected = this._overlayLineCount();
-    const marginRows = this._overlayVerticalMarginRows(expected);
-    const panelTarget = this._overlayPanelLineCount();
-    const body = panelLines.slice(0, panelTarget);
-    while (body.length < panelTarget)
-      body.push(this._blankRow(width));
-    const margins = Array.from({ length: marginRows }, () => this._marginRow(width));
-    const lines = [...margins, ...body, ...margins];
-    if (lines.length > expected)
-      return lines.slice(0, expected);
-    while (lines.length < expected) {
-      const insertAt = marginRows > 0 ? Math.max(0, lines.length - marginRows) : lines.length;
-      lines.splice(insertAt, 0, this._blankRow(width));
-    }
-    return lines;
-  }
   _externalStatusText() {
     const entries = Array.from(this.footerData?.getExtensionStatuses() ?? []).filter(([key, value2]) => value2.trim().length > 0 && key !== WORKFLOW_STATUS_KEY && !key.startsWith(`${WORKFLOW_STATUS_KEY}:`) && !OVERLAY_HIDDEN_STATUS_KEYS.has(key)).sort(([a], [b]) => a.localeCompare(b));
     if (entries.length === 0)
@@ -42477,10 +42509,6 @@ class GraphViewRenderHelpers extends GraphViewState {
     const rightPadLen = Math.max(0, totalWidth - leftPad - cardW);
     return `${bg}${" ".repeat(leftPad)}${RESET}${cardLine}${bg}${" ".repeat(rightPadLen)}${RESET}`;
   }
-  _clampGraphScroll(totalRows, bodyRows) {
-    const maxOffset = Math.max(0, totalRows - bodyRows);
-    this.graphScrollOffset = Math.max(0, Math.min(maxOffset, this.graphScrollOffset));
-  }
   _clampGraphHorizontalScroll(totalCols, viewportCols) {
     const maxOffset = Math.max(0, totalCols - viewportCols);
     this.graphScrollColOffset = Math.max(0, Math.min(maxOffset, this.graphScrollColOffset));
@@ -42498,23 +42526,6 @@ class GraphViewRenderHelpers extends GraphViewState {
     }
     this._clampGraphHorizontalScroll(totalCols, viewportCols);
   }
-  _scrollFocusedIntoView(frameWidth, bodyRows, totalRows) {
-    const range = this._focusedGraphRowRange(frameWidth);
-    if (!range)
-      return;
-    if (range.start < this.graphScrollOffset) {
-      this.graphScrollOffset = range.start;
-    } else if (range.end >= this.graphScrollOffset + bodyRows) {
-      this.graphScrollOffset = range.end - bodyRows + 1;
-    }
-    this._clampGraphScroll(totalRows, bodyRows);
-  }
-  _focusedGraphRowRange(_frameWidth) {
-    const node = this.cachedLayout[this.focusedIndex];
-    if (!node)
-      return null;
-    return { start: node.y, end: node.y + NODE_H - 1 };
-  }
   _plotEdge(canvas, px, py, cx, cy, color) {
     const parentCol = px + Math.floor(NODE_W / 2);
     const childCol = cx + Math.floor(NODE_W / 2);
@@ -42649,7 +42660,7 @@ function metaText(stage) {
     return "topology unavailable";
   const deps = stage.parentIds.length;
   const dependencyText = deps === 0 ? "root" : deps === 1 ? "1 dep" : `${deps} deps`;
-  return stage.fastMode === true ? `${dependencyText} · fast` : dependencyText;
+  return dependencyText;
 }
 function workflowChildRunRows(stage, width) {
   const child = stage.workflowChild ?? stage.workflowChildRun;
@@ -42767,56 +42778,53 @@ function renderNodeCard(stage, opts) {
 
 // dist/builtin/workflows/src/tui/graph-view-graph-render.ts
 class GraphViewGraphRenderer extends GraphViewRenderHelpers {
-  _renderGraph(width) {
-    const run = this._getCurrentRun();
+  _renderGraph(width, viewportTop, viewportRows, renderRun) {
+    const safeRows = Math.max(0, Math.floor(viewportRows));
+    const run = renderRun !== undefined ? renderRun : this._getCurrentRun();
     if (!run || this.cachedLayout.length === 0) {
       this.lastGraphViewport = null;
       this.graphNodeHitRects = [];
-      this.lastGraphTotalRows = 1;
-      const dim = hexToAnsi(this.graphTheme.dim);
-      return [this._centerCanvasContent(`${dim}waiting for stage events…${RESET}`, width)];
+      this.lastGraphTopPad = 0;
+      this.lastGraphVisibleRows = safeRows;
+      const lines = Array.from({ length: safeRows }, () => "");
+      if (safeRows > 0) {
+        const dim = hexToAnsi(this.graphTheme.dim);
+        lines[Math.floor((safeRows - 1) / 2)] = this._centerCanvasContent(`${dim}waiting for stage events…${RESET}`, width);
+      }
+      return lines;
     }
     const graphInner = Math.max(1, width - 4);
     const { canvasWidth, totalRows, bands, edges } = this.cachedRenderGeometry;
-    this.lastGraphTotalRows = totalRows;
     const leftMargin = Math.max(2, canvasWidth <= graphInner ? Math.floor((graphInner - canvasWidth) / 2) : 2);
     const viewportWidth = Math.max(1, width - leftMargin);
     const fullCanvasWidth = Math.max(canvasWidth, viewportWidth);
     this.lastGraphViewport = { leftMargin, viewportWidth };
+    const safeTop = Math.max(0, Math.min(totalRows, Math.floor(viewportTop)));
+    const graphRows = Math.max(0, Math.min(safeRows, totalRows - safeTop));
+    const viewportBottom = safeTop + graphRows;
     this._clampGraphHorizontalScroll(fullCanvasWidth, viewportWidth);
-    if (this.pendingEnsureFocusedVisible) {
-      this._scrollFocusedColumnIntoView(viewportWidth, fullCanvasWidth);
-    }
-    const bodyRows = this._overlayBodyRows(this._overlayPanelLineCount());
-    if (totalRows > bodyRows) {
-      this._clampGraphScroll(totalRows, bodyRows);
-      if (this.pendingEnsureFocusedVisible)
-        this._scrollFocusedIntoView(width, bodyRows, totalRows);
-      this._clampGraphScroll(totalRows, bodyRows);
-    } else {
-      this.graphScrollOffset = 0;
-    }
-    const viewportTop = this.graphScrollOffset;
-    const viewportBottom = Math.min(totalRows, viewportTop + bodyRows);
+    const topPad = safeTop === 0 && totalRows <= safeRows ? Math.min(3, Math.floor((safeRows - totalRows) / 2)) : 0;
+    this.lastGraphTopPad = topPad;
+    this.lastGraphVisibleRows = graphRows;
     const viewportLeft = this.graphScrollColOffset;
     const viewportRight = viewportLeft + viewportWidth;
     const pulsePhase = Date.now() % PULSE_PERIOD_MS / PULSE_PERIOD_MS;
     const edgeCanvas = new GraphCanvas({
-      top: viewportTop,
+      top: safeTop,
       bottom: viewportBottom,
       left: viewportLeft,
       right: viewportRight
     });
     const edgeColor = this.graphTheme.borderDim;
     for (const edge of edges) {
-      if (edge.bottom <= viewportTop || edge.top >= viewportBottom || edge.right <= viewportLeft || edge.left >= viewportRight) {
+      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);
     }
     const edgeLines = edgeCanvas.toLines();
     const placements = new Map;
-    for (let bandIndex = this._firstVisibleLayoutBand(viewportTop);bandIndex < bands.length; bandIndex++) {
+    for (let bandIndex = this._firstVisibleLayoutBand(safeTop);bandIndex < bands.length; bandIndex++) {
       const band = bands[bandIndex];
       if (band.top >= viewportBottom)
         break;
@@ -42837,9 +42845,9 @@ class GraphViewGraphRenderer extends GraphViewRenderHelpers {
         const visibleRight = Math.min(node.x + NODE_W, viewportRight);
         for (let li = 0;li < cardLines.length; li++) {
           const globalRow = node.y + li;
-          if (globalRow < viewportTop || globalRow >= viewportBottom)
+          if (globalRow < safeTop || globalRow >= viewportBottom)
             continue;
-          const localRow = globalRow - viewportTop;
+          const localRow = globalRow - safeTop;
           let bucket = placements.get(localRow);
           if (!bucket) {
             bucket = [];
@@ -42855,10 +42863,10 @@ class GraphViewGraphRenderer extends GraphViewRenderHelpers {
     }
     const bg = hexBg(this.graphTheme.bg);
     const leftPad = `${bg}${" ".repeat(leftMargin)}${RESET}`;
-    const composed = [];
-    for (let localRow = 0;localRow < viewportBottom - viewportTop; localRow++) {
+    const composed = Array.from({ length: safeRows }, () => "");
+    for (let localRow = 0;localRow < graphRows; localRow++) {
       const line = this._composeRow(edgeLines[localRow] ?? "", placements.get(localRow) ?? [], edgeColor);
-      composed.push(`${leftPad}${this._padCanvas(line, viewportWidth)}`);
+      composed[topPad + localRow] = `${leftPad}${this._padCanvas(line, viewportWidth)}`;
     }
     return composed;
   }
@@ -42873,8 +42881,8 @@ class GraphViewGraphRenderer extends GraphViewRenderHelpers {
     const viewportLeft = viewport.leftMargin;
     const viewportRight = viewport.leftMargin + viewport.viewportWidth;
     const rects = [];
-    const viewportTop = this.graphScrollOffset;
-    const viewportBottom = viewportTop + visibleRowCount;
+    const viewportTop = this._graphScrollTop();
+    const viewportBottom = Math.min(this.cachedRenderGeometry.totalRows, viewportTop + visibleRowCount);
     const { bands } = this.cachedRenderGeometry;
     for (let bandIndex = this._firstVisibleLayoutBand(viewportTop);bandIndex < bands.length; bandIndex++) {
       const band = bands[bandIndex];
@@ -42897,13 +42905,260 @@ class GraphViewGraphRenderer extends GraphViewRenderHelpers {
     }
     this.graphNodeHitRects = rects;
   }
-  _visibleGraphLines(graphLines, _frameWidth, bodyRows) {
-    this.pendingEnsureFocusedVisible = false;
+}
+
+// dist/builtin/workflows/src/tui/graph-view-layout.ts
+import { ScrollView, VStack } from "@earendil-works/pi-tui";
+import {
+  getScrollbarGeometry,
+  getScrollViewBox,
+  renderLayoutFrame
+} from "@earendil-works/pi-tui/dist/layout.js";
+
+// dist/builtin/workflows/src/tui/mouse-input.ts
+function parseTerminalMouseInput(data) {
+  const sgr = data.match(/^\x1b\[<(\d+);(\d+);(\d+)([Mm])$/);
+  if (sgr) {
+    const oneBasedCol = Number.parseInt(sgr[2], 10);
+    const oneBasedRow = Number.parseInt(sgr[3], 10);
+    if (oneBasedCol < 1 || oneBasedRow < 1)
+      return null;
+    return {
+      protocol: "sgr",
+      action: sgr[4] === "M" ? "press" : "release",
+      buttonCode: Number.parseInt(sgr[1], 10),
+      col: oneBasedCol - 1,
+      row: oneBasedRow - 1
+    };
+  }
+  if (!data.startsWith("\x1B[M") || data.length !== 6)
+    return null;
+  const buttonCode = data.charCodeAt(3) - 32;
+  const col = data.charCodeAt(4) - 33;
+  const row = data.charCodeAt(5) - 33;
+  if (buttonCode < 0 || col < 0 || row < 0)
+    return null;
+  return {
+    protocol: "x10",
+    action: (buttonCode & (64 | 32)) === 0 && (buttonCode & 3) === 3 ? "release" : "press",
+    buttonCode,
+    col,
+    row
+  };
+}
+function terminalMouseWheelDirection(event) {
+  if (event.action !== "press" || (event.buttonCode & 64) === 0)
+    return null;
+  const direction = event.buttonCode & 3;
+  if (direction === 0)
+    return "up";
+  if (direction === 1)
+    return "down";
+  if (direction === 2)
+    return "left";
+  return "right";
+}
+function isTerminalLeftMousePress(event) {
+  return event.action === "press" && (event.buttonCode & 64) === 0 && (event.buttonCode & 32) === 0 && (event.buttonCode & 3) === 0;
+}
+
+// dist/builtin/workflows/src/tui/graph-view-layout.ts
+var EMPTY_RENDER = () => {};
+var GRAPH_HEADER_ROWS = 3;
+var GRAPH_FOOTER_ROWS = 3;
+function graphLayoutMarginRows(height) {
+  return Math.max(1, Math.floor(height)) >= 9 ? 1 : 0;
+}
+function graphLayoutBodyRows(height) {
+  const safeHeight = Math.max(1, Math.floor(height));
+  return Math.max(0, safeHeight - GRAPH_HEADER_ROWS - GRAPH_FOOTER_ROWS - graphLayoutMarginRows(safeHeight) * 2);
+}
+function graphLayoutNaturalHeight(bodyRows) {
+  const safeBodyRows = Math.max(1, Math.floor(bodyRows));
+  const base = GRAPH_HEADER_ROWS + GRAPH_FOOTER_ROWS + safeBodyRows;
+  return base >= GRAPH_HEADER_ROWS + GRAPH_FOOTER_ROWS + 3 ? base + 2 : base;
+}
+function collectWrappedRows(box, height, wrappedRows) {
+  if (box.lines) {
+    const offset = box.lineOffset ?? 0;
+    const firstRow = Math.max(box.rect.y, box.clip.y, 0);
+    const lastRow = Math.min(box.rect.y + box.rect.height, box.clip.y + box.clip.height, height);
+    for (let row = firstRow;row < lastRow; row++) {
+      if (box.lines[offset + row - box.rect.y] !== undefined)
+        wrappedRows[row] = true;
+    }
+  }
+  for (const child of box.children)
+    collectWrappedRows(child, height, wrappedRows);
+}
+
+class CallbackComponent {
+  renderLines;
+  constructor(renderLines) {
+    this.renderLines = renderLines;
+  }
+  render(width) {
+    return this.renderLines(width);
+  }
+  invalidate() {}
+}
+
+class GraphViewLayout {
+  scrollView;
+  root;
+  callbacks;
+  bodyViewportRows = 0;
+  bodyContentRows = 0;
+  scrollbar;
+  draggingScrollbar;
+  constructor(callbacks) {
+    this.callbacks = callbacks;
+    const margin = new CallbackComponent(() => [""]);
+    const header = new CallbackComponent((width) => this.callbacks.renderHeader(width));
+    const body = new CallbackComponent((width) => this.renderBody(width));
+    const footer = new CallbackComponent((width) => this.callbacks.renderFooter(width));
+    this.scrollView = new ScrollView(body, {
+      axis: "vertical",
+      follow: "none",
+      overscroll: "contain",
+      scrollbar: "hidden"
+    });
+    const marginVisible = ({ height }) => graphLayoutMarginRows(height) > 0;
+    this.root = new VStack([
+      { component: margin, basis: 1, grow: 0, shrink: 0, minSize: 0, visible: marginVisible },
+      { component: header, basis: GRAPH_HEADER_ROWS, grow: 0, shrink: 1, minSize: 0 },
+      { component: this.scrollView, basis: 0, grow: 1, shrink: 1, minSize: 0 },
+      { component: footer, basis: GRAPH_FOOTER_ROWS, grow: 0, shrink: 1, minSize: 1 },
+      { component: margin, basis: 1, grow: 0, shrink: 0, minSize: 0, visible: marginVisible }
+    ]);
+  }
+  render(width, height) {
+    const safeWidth = Math.max(1, Math.floor(width));
+    const safeHeight = Math.max(1, Math.floor(height));
+    const marginRows = graphLayoutMarginRows(safeHeight);
+    this.bodyViewportRows = graphLayoutBodyRows(safeHeight);
+    this.bodyContentRows = Math.max(0, Math.floor(this.callbacks.bodyContentHeight(safeWidth, this.bodyViewportRows)));
+    const requestRender = this.callbacks.requestRender ?? EMPTY_RENDER;
+    this.scrollView.updateLayout(this.bodyContentRows, this.bodyViewportRows, requestRender);
+    this.scrollView.setScrollbar(this.bodyContentRows > this.bodyViewportRows ? "always" : "hidden");
+    this.callbacks.beforeFrame?.(this.scrollView, this.bodyViewportRows, this.bodyContentRows, safeWidth);
+    const frame = renderLayoutFrame(this.root, safeWidth, safeHeight, requestRender);
+    const bodyBox = getScrollViewBox(frame, this.scrollView);
+    this.scrollbar = bodyBox ? getScrollbarGeometry(bodyBox) : undefined;
+    if (!this.scrollbar)
+      this.draggingScrollbar = undefined;
+    const wrappedRows = Array.from({ length: safeHeight }, () => false);
+    collectWrappedRows(frame.root, safeHeight, wrappedRows);
     return {
-      lines: graphLines,
-      topPad: this.lastGraphTotalRows <= bodyRows ? Math.min(3, Math.max(0, Math.floor((bodyRows - this.lastGraphTotalRows) / 2))) : 0
+      frame,
+      bodyBox,
+      topMarginRows: marginRows,
+      bottomMarginRows: marginRows,
+      wrappedRows,
+      scrollbar: this.scrollbar
     };
   }
+  paintScrollbar(lines, width) {
+    const geometry = this.scrollbar;
+    if (!geometry)
+      return;
+    for (let offset = 0;offset < geometry.thumbHeight; offset++) {
+      const row = geometry.thumbTop + offset;
+      if (row < 0 || row >= lines.length || geometry.column < 0 || geometry.column >= width)
+        continue;
+      const line = lines[row] ?? " ".repeat(width);
+      const before = sliceColumns(line, 0, geometry.column, true);
+      const after = sliceColumns(line, geometry.column + 1, width - geometry.column - 1, true);
+      const beforePad = " ".repeat(Math.max(0, geometry.column - visibleWidth(before)));
+      const afterPad = " ".repeat(Math.max(0, width - geometry.column - 1 - visibleWidth(after)));
+      lines[row] = `${before}${beforePad}${this.scrollView.scrollbarStyle(" ")}${after}${afterPad}`;
+    }
+  }
+  dispose() {
+    this.draggingScrollbar = undefined;
+    this.scrollbar = undefined;
+    this.scrollView.updateLayout(this.bodyContentRows, this.bodyViewportRows, EMPTY_RENDER);
+    this.scrollView.setScrollbarActive(false);
+    this.scrollView.setScrollbar("hidden");
+  }
+  get viewportRows() {
+    return this.bodyViewportRows;
+  }
+  get contentRows() {
+    return this.bodyContentRows;
+  }
+  get scrollbarGeometry() {
+    return this.scrollbar;
+  }
+  isScrollbarInput(data) {
+    const event = parseTerminalMouseInput(data);
+    if (!event)
+      return false;
+    if (this.draggingScrollbar) {
+      return event.action === "release" || (event.buttonCode & 32) !== 0 && (event.buttonCode & 3) === 0;
+    }
+    const geometry = this.scrollbar;
+    return geometry !== undefined && event.action === "press" && (event.buttonCode & 64) === 0 && (event.buttonCode & 32) === 0 && (event.buttonCode & 3) === 0 && event.col === geometry.column && event.row >= geometry.trackTop && event.row < geometry.trackTop + geometry.trackHeight;
+  }
+  handleScrollbarInput(data) {
+    const event = parseTerminalMouseInput(data);
+    if (!event)
+      return false;
+    if (event.action === "release") {
+      if (!this.draggingScrollbar)
+        return false;
+      this.draggingScrollbar = undefined;
+      return true;
+    }
+    const moving = (event.buttonCode & 32) !== 0;
+    const leftButton = (event.buttonCode & 3) === 0;
+    if (this.draggingScrollbar && moving && leftButton) {
+      this.scrollToScrollbarRow(event.row);
+      return true;
+    }
+    const geometry = this.scrollbar;
+    if (!geometry)
+      return false;
+    if (!isTerminalLeftMousePress(event) || event.col !== geometry.column)
+      return false;
+    if (event.row < geometry.trackTop || event.row >= geometry.trackTop + geometry.trackHeight)
+      return false;
+    if (event.row >= geometry.thumbTop && event.row < geometry.thumbTop + geometry.thumbHeight) {
+      this.draggingScrollbar = { grabOffset: event.row - geometry.thumbTop };
+    } else {
+      this.scrollToScrollbarRow(event.row - Math.floor(geometry.thumbHeight / 2));
+    }
+    return true;
+  }
+  invalidate() {
+    this.root.invalidate();
+  }
+  renderBody(width) {
+    const contentRows = this.bodyContentRows;
+    const lines = new Array(contentRows);
+    const top = Math.max(0, Math.min(contentRows, this.scrollView.scrollTop));
+    const rows = Math.max(0, Math.min(this.bodyViewportRows, contentRows - top));
+    const visible = this.callbacks.renderBody(width, top, rows, contentRows);
+    for (let index = 0;index < visible.length && index < rows; index++) {
+      lines[top + index] = visible[index];
+    }
+    if (top > 0)
+      lines[top - 1] = " ";
+    return lines;
+  }
+  scrollToScrollbarRow(row) {
+    const geometry = this.scrollbar;
+    if (!geometry || geometry.maxScrollTop <= 0)
+      return;
+    const maxThumbTop = Math.max(0, geometry.trackHeight - geometry.thumbHeight);
+    if (maxThumbTop === 0) {
+      this.scrollView.scrollTo(0);
+      return;
+    }
+    const thumbTop = Math.max(geometry.trackTop, Math.min(geometry.trackTop + maxThumbTop, row - (this.draggingScrollbar?.grabOffset ?? 0)));
+    const ratio = (thumbTop - geometry.trackTop) / maxThumbTop;
+    this.scrollView.scrollTo(Math.round(ratio * geometry.maxScrollTop));
+  }
 }
 
 // dist/builtin/workflows/src/tui/switcher.ts
@@ -43000,18 +43255,47 @@ function renderSwitcher(stages, state, opts) {
 }
 
 // dist/builtin/workflows/src/tui/graph-view-render.ts
+var LAYOUT_OSC_RESET = "\x1B[0m\x1B]8;;\x07";
+function stripLayoutWrapper(line) {
+  const startsWithWrapper = line.startsWith(LAYOUT_OSC_RESET);
+  const endsWithWrapper = line.endsWith(LAYOUT_OSC_RESET);
+  const start = startsWithWrapper ? LAYOUT_OSC_RESET.length : 0;
+  const end = endsWithWrapper ? line.length - LAYOUT_OSC_RESET.length : line.length;
+  return line.slice(start, Math.max(start, end));
+}
+
 class GraphViewRenderer extends GraphViewGraphRenderer {
+  graphLayout;
+  lastOverlayFrameHeight = 0;
+  hasReportedViewportRows = false;
+  renderRun;
+  constructor(opts) {
+    super(opts);
+    this.graphLayout = new GraphViewLayout({
+      renderHeader: (width) => this._renderHeader(width),
+      renderBody: (width, top, rows, contentRows) => this._renderBody(width, top, rows, contentRows),
+      renderFooter: (width) => this._renderStatusline(width),
+      bodyContentHeight: (_width, viewportRows) => this._graphBodyContentHeight(viewportRows),
+      beforeFrame: (scrollView, viewportRows, contentRows, width) => this._prepareGraphScroll(scrollView, viewportRows, contentRows, width),
+      requestRender: () => this.requestRender?.()
+    });
+  }
+  _graphScrollTop() {
+    return this.graphLayout.scrollView.scrollTop;
+  }
   render(width) {
-    if (this.mode === "widget") {
+    if (this.mode === "widget")
       return this._renderWidget(width);
-    }
     return this._renderOverlay(width);
   }
+  dispose() {
+    this.graphLayout.dispose();
+    super.dispose();
+  }
   _renderWidget(width) {
     const run = this._getCurrentRun();
-    if (!run) {
+    if (!run)
       return [`${hexToAnsi(this.graphTheme.dim)}no active workflow${RESET}`];
-    }
     const displayStages = this._displayStages(run);
     const headerLines = renderHeader({ ...run, stages: displayStages }, { width, theme: this.graphTheme });
     const counts = this._counts(displayStages);
@@ -43020,95 +43304,150 @@ class GraphViewRenderer extends GraphViewGraphRenderer {
   }
   _renderOverlay(width) {
     const frameWidth = Math.max(40, width);
-    this.lastOverlayFrameWidth = frameWidth;
-    const lines = [];
     const run = this._getCurrentRun();
-    if (!run) {
-      return this._renderEmptyState(frameWidth);
-    }
-    lines.push(...renderHeader({ ...run, stages: this._displayStages(run) }, { width: frameWidth, theme: this.graphTheme }));
-    const graphLines = this._renderGraph(frameWidth);
-    const bodyTarget = this._overlayBodyRows(this._overlayPanelLineCount());
-    const visibleGraph = this._visibleGraphLines(graphLines, frameWidth, bodyTarget);
-    this._recordGraphNodeHitRects(this._overlayVerticalMarginRows() + 3 + visibleGraph.topPad, visibleGraph.lines.length);
-    for (let i = 0;i < visibleGraph.topPad; i++)
-      lines.push(this._blankRow(frameWidth));
-    for (const line of visibleGraph.lines) {
-      lines.push(this._canvasRow(line, frameWidth));
-    }
-    while (lines.length < 3 + bodyTarget)
-      lines.push(this._blankRow(frameWidth));
-    if (lines.length > 3 + bodyTarget)
-      lines.length = 3 + bodyTarget;
-    this._renderSwitcherOverlay(lines, run, frameWidth, bodyTarget);
-    this._renderPromptOverlay(lines, frameWidth, bodyTarget);
-    lines.push(...this._renderStatusline(frameWidth));
-    return this._withVerticalMargins(lines, frameWidth);
-  }
-  _renderEmptyState(width) {
-    this.graphNodeHitRects = [];
-    this.lastGraphViewport = null;
+    this.renderRun = run;
+    try {
+      const frameHeight = this._overlayFrameHeight(run);
+      const layoutFrame = this.graphLayout.render(frameWidth, frameHeight);
+      const lines = this._normalizeLayoutLines(layoutFrame.frame.lines, layoutFrame.wrappedRows, frameWidth, frameHeight, layoutFrame.topMarginRows, layoutFrame.bottomMarginRows);
+      const bodyStart = layoutFrame.bodyBox?.rect.y ?? layoutFrame.topMarginRows + GRAPH_HEADER_ROWS;
+      const bodyRows = layoutFrame.bodyBox?.rect.height ?? this.graphLayout.viewportRows;
+      if (run) {
+        this._recordGraphNodeHitRects(bodyStart + this.lastGraphTopPad, this.lastGraphVisibleRows);
+        this._renderSwitcherOverlay(lines, run, frameWidth, bodyStart, bodyRows);
+        this._renderPromptOverlay(lines, frameWidth, bodyStart, bodyRows);
+      } else {
+        this.graphNodeHitRects = [];
+        this.lastGraphViewport = null;
+      }
+      this.graphLayout.paintScrollbar(lines, frameWidth);
+      return lines;
+    } finally {
+      this.renderRun = undefined;
+    }
+  }
+  _overlayFrameHeight(run = this._currentRenderRun()) {
+    const reported = this.piTui?.terminal?.rows;
+    if (typeof reported === "number" && Number.isFinite(reported) && reported > 0) {
+      this.hasReportedViewportRows = true;
+      this.lastOverlayFrameHeight = Math.max(1, Math.floor(reported));
+      return this.lastOverlayFrameHeight;
+    }
+    if (this.hasReportedViewportRows && this.lastOverlayFrameHeight > 0)
+      return this.lastOverlayFrameHeight;
+    const bodyRows = run ? Math.max(1, this.cachedRenderGeometry.totalRows) : 2;
+    this.lastOverlayFrameHeight = graphLayoutNaturalHeight(bodyRows);
+    return this.lastOverlayFrameHeight;
+  }
+  _currentRenderRun() {
+    return this.renderRun !== undefined ? this.renderRun : this._getCurrentRun();
+  }
+  _graphBodyContentHeight(viewportRows) {
+    const rows = Math.max(0, Math.floor(viewportRows));
+    if (!this._currentRenderRun() || this.cachedRenderGeometry.totalRows <= 0)
+      return rows;
+    return Math.max(rows, this.cachedRenderGeometry.totalRows);
+  }
+  _prepareGraphScroll(scrollView, viewportRows, _contentRows, width) {
+    const run = this._currentRenderRun();
+    if (viewportRows <= 0)
+      return;
+    if (!run || this.cachedRenderGeometry.totalRows <= 0) {
+      scrollView.scrollToStart();
+      this.pendingEnsureFocusedVisible = false;
+      return;
+    }
+    if (this.pendingEnsureFocusedVisible) {
+      const node = this.cachedLayout[this.focusedIndex];
+      if (node) {
+        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;
+        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);
+        const viewportWidth = Math.max(1, width - leftMargin);
+        const fullCanvasWidth = Math.max(this.cachedRenderGeometry.canvasWidth, viewportWidth);
+        this._scrollFocusedColumnIntoView(viewportWidth, fullCanvasWidth);
+      }
+      this.pendingEnsureFocusedVisible = false;
+    }
+  }
+  _renderHeader(width) {
+    const run = this._currentRenderRun();
+    if (run)
+      return renderHeader({ ...run, stages: this._displayStages(run) }, { width, theme: this.graphTheme });
     const t = this.graphTheme;
     const muted = hexToAnsi(t.textMuted);
-    const dim = hexToAnsi(t.dim);
-    const accent = hexToAnsi(t.accent);
     const chromeBg = hexBg(t.backgroundPanel);
     const { top, mid, bot, visibleWidth: pillW } = renderOutlinePill("ORCHESTRATOR", t.accent, chromeBg);
-    const idleLabel = `  ${muted}idle${RESET}`;
     const fillerVisible = Math.max(0, width - 1 - pillW - 6 - 2);
     const filler = " ".repeat(fillerVisible);
-    const lines = [
+    return [
       `${chromeBg} ${RESET}${top}${chromeBg}${" ".repeat(6 + fillerVisible)}${" ".repeat(2)}${RESET}`,
-      `${chromeBg} ${RESET}${mid}${chromeBg}${idleLabel}${filler}${" ".repeat(2)}${RESET}`,
+      `${chromeBg} ${RESET}${mid}${chromeBg}  ${muted}idle${RESET}${filler}${" ".repeat(2)}${RESET}`,
       `${chromeBg} ${RESET}${bot}${chromeBg}${" ".repeat(6 + fillerVisible)}${" ".repeat(2)}${RESET}`
     ];
-    const bodyTarget = this._overlayBodyRows(this._overlayPanelLineCount());
+  }
+  _renderBody(width, top, rows, _contentRows) {
+    const run = this._currentRenderRun();
+    const raw = run ? this._renderGraph(width, top, rows, run) : this._renderEmptyBody(width, rows);
+    return raw.map((line) => this._canvasRow(line, width));
+  }
+  _renderEmptyBody(width, rows) {
     const body = [
-      this._canvasRow(`  ${muted}No active workflow run.${RESET}`, width),
-      this._canvasRow(`  ${dim}Start one with ${accent}/workflow <name>${RESET}${dim} or press ${accent}F2${RESET}${dim} on an active run.${RESET}`, width)
+      this._centerCanvasContent(`  ${hexToAnsi(this.graphTheme.textMuted)}No active workflow run.${RESET}`, width),
+      this._centerCanvasContent(`  ${hexToAnsi(this.graphTheme.dim)}Start one with ${hexToAnsi(this.graphTheme.accent)}/workflow <name>${RESET}${hexToAnsi(this.graphTheme.dim)} or press ${hexToAnsi(this.graphTheme.accent)}F2${RESET}${hexToAnsi(this.graphTheme.dim)} on an active run.${RESET}`, width)
     ];
-    const topPad = Math.max(0, Math.floor((bodyTarget - body.length) / 2));
-    for (let i = 0;i < topPad; i++)
-      lines.push(this._blankRow(width));
-    for (const l of body)
-      lines.push(l);
-    while (lines.length < 3 + bodyTarget)
-      lines.push(this._blankRow(width));
-    lines.push(...this._renderStatusline(width));
-    return this._withVerticalMargins(lines, width);
-  }
-  _renderSwitcherOverlay(lines, run, frameWidth, bodyTarget) {
+    const lines = Array.from({ length: rows }, () => "");
+    const topPad = Math.max(0, Math.floor((rows - body.length) / 2));
+    for (let index = 0;index < body.length; index++) {
+      const target = topPad + index;
+      if (target < lines.length)
+        lines[target] = body[index];
+    }
+    return lines;
+  }
+  _normalizeLayoutLines(lines, wrappedRows, width, height, topMarginRows, bottomMarginRows) {
+    return Array.from({ length: height }, (_, row) => {
+      if (row < topMarginRows || row >= height - bottomMarginRows)
+        return " ".repeat(width);
+      const source = lines[row] ?? "";
+      const clean = wrappedRows[row] === true ? stripLayoutWrapper(source) : source;
+      if (visibleWidth(clean) === 0)
+        return this._blankRow(width);
+      if (visibleWidth(clean) > width)
+        return truncateToWidth(clean, width, "…", true);
+      return `${clean}${" ".repeat(width - visibleWidth(clean))}`;
+    });
+  }
+  _renderSwitcherOverlay(lines, run, frameWidth, bodyStart, bodyRows) {
     if (!this.switcherOpen)
       return;
-    const bodyStart = 3;
-    const bodyEnd = 3 + bodyTarget;
-    for (let row = bodyStart;row < bodyEnd; row++) {
+    const bodyEnd = bodyStart + bodyRows;
+    for (let row = bodyStart;row < bodyEnd; row++)
       lines[row] = this._blankRow(frameWidth);
-    }
     const switcherWidth = Math.min(60, Math.max(40, frameWidth - 8));
     const switcherLines = renderSwitcher(this._displayStages(run), this.switcherState, {
       width: switcherWidth,
       theme: this.graphTheme,
       canOpenStageChat: (stage) => this._stageChatTarget(stage) !== undefined
     });
-    const insertAt = Math.max(bodyStart, bodyStart + Math.min(2, Math.floor((bodyTarget - switcherLines.length) / 3)));
+    const insertAt = Math.max(bodyStart, bodyStart + Math.min(2, Math.floor((bodyRows - switcherLines.length) / 3)));
     const switcherLeft = Math.max(2, Math.floor((frameWidth - switcherWidth) / 2));
-    for (let i = 0;i < switcherLines.length; i++) {
-      const lineIdx = insertAt + i;
-      if (lineIdx >= bodyEnd)
+    for (let index = 0;index < switcherLines.length; index++) {
+      const lineIndex = insertAt + index;
+      if (lineIndex >= bodyEnd)
         break;
-      const base = lines[lineIdx] ?? this._blankRow(frameWidth);
-      const merged = this._overlayCard(base, switcherLines[i], switcherLeft, frameWidth);
-      if (lineIdx < lines.length)
-        lines[lineIdx] = merged;
-      else
-        lines.push(merged);
+      lines[lineIndex] = this._overlayCard(lines[lineIndex] ?? this._blankRow(frameWidth), switcherLines[index], switcherLeft, frameWidth);
     }
   }
-  _renderPromptOverlay(lines, frameWidth, bodyTarget) {
+  _renderPromptOverlay(lines, frameWidth, bodyStart, bodyRows) {
     if (!this.promptState || this.switcherOpen)
       return;
-    const run = this._getCurrentRun();
+    const run = this._currentRenderRun();
     const cardWidth = Math.min(72, Math.max(40, frameWidth - 6));
     const cardLines = renderPromptCard({
       state: this.promptState,
@@ -43116,93 +43455,43 @@ class GraphViewRenderer extends GraphViewGraphRenderer {
       width: cardWidth,
       cursorOn: (Date.now() / 530 | 0) % 2 === 0,
       identity: run ? { runId: run.id, name: run.name } : undefined,
-      maxRows: bodyTarget
+      maxRows: bodyRows
     });
-    const bodyStart = 3;
-    const bodyEnd = bodyStart + bodyTarget;
-    const slot = Math.max(bodyStart, bodyStart + Math.floor((bodyTarget - cardLines.length) / 2));
-    if (cardLines.length > bodyTarget || slot + cardLines.length > bodyEnd)
+    const bodyEnd = bodyStart + bodyRows;
+    const slot = Math.max(bodyStart, bodyStart + Math.floor((bodyRows - cardLines.length) / 2));
+    if (cardLines.length > bodyRows || slot + cardLines.length > bodyEnd)
       return;
     const leftPad = Math.max(0, Math.floor((frameWidth - cardWidth) / 2));
-    for (let i = 0;i < cardLines.length; i++) {
-      const lineIdx = slot + i;
-      const base = lines[lineIdx] ?? this._blankRow(frameWidth);
-      lines[lineIdx] = this._overlayCard(base, cardLines[i], leftPad, frameWidth);
+    for (let index = 0;index < cardLines.length; index++) {
+      const lineIndex = slot + index;
+      lines[lineIndex] = this._overlayCard(lines[lineIndex] ?? this._blankRow(frameWidth), cardLines[index], leftPad, frameWidth);
     }
   }
 }
 
-// dist/builtin/workflows/src/tui/mouse-input.ts
-function parseTerminalMouseInput(data) {
-  const sgr = data.match(/^\x1b\[<(\d+);(\d+);(\d+)([Mm])$/);
-  if (sgr) {
-    const oneBasedCol = Number.parseInt(sgr[2], 10);
-    const oneBasedRow = Number.parseInt(sgr[3], 10);
-    if (oneBasedCol < 1 || oneBasedRow < 1)
-      return null;
-    return {
-      protocol: "sgr",
-      action: sgr[4] === "M" ? "press" : "release",
-      buttonCode: Number.parseInt(sgr[1], 10),
-      col: oneBasedCol - 1,
-      row: oneBasedRow - 1
-    };
-  }
-  if (!data.startsWith("\x1B[M") || data.length !== 6)
-    return null;
-  const buttonCode = data.charCodeAt(3) - 32;
-  const col = data.charCodeAt(4) - 33;
-  const row = data.charCodeAt(5) - 33;
-  if (buttonCode < 0 || col < 0 || row < 0)
-    return null;
-  return {
-    protocol: "x10",
-    action: (buttonCode & (64 | 32)) === 0 && (buttonCode & 3) === 3 ? "release" : "press",
-    buttonCode,
-    col,
-    row
-  };
-}
-function terminalMouseWheelDirection(event) {
-  if (event.action !== "press" || (event.buttonCode & 64) === 0)
-    return null;
-  const direction = event.buttonCode & 3;
-  if (direction === 0)
-    return "up";
-  if (direction === 1)
-    return "down";
-  if (direction === 2)
-    return "left";
-  return "right";
-}
-function isTerminalLeftMousePress(event) {
-  return event.action === "press" && (event.buttonCode & 64) === 0 && (event.buttonCode & 32) === 0 && (event.buttonCode & 3) === 0;
-}
-
 // dist/builtin/workflows/src/tui/graph-view-input.ts
+var GRAPH_SCROLL_WHEEL_LINES = 4;
+
 class GraphViewInputController extends GraphViewRenderer {
   handleInput(data) {
     if (this._isReturnToMainChatInput(data)) {
       this._returnToMainChat();
       return true;
     }
-    if (this.switcherOpen) {
+    if (this.graphLayout.isScrollbarInput(data))
+      return this._handleGraphInput(data);
+    if (this.switcherOpen)
       return this._handleSwitcherInput(data);
-    }
-    if (this.promptState) {
-      if (this._isNonTextGraphControlBeforePrompt(data)) {
-        return this._handleGraphInput(data);
-      }
+    const wheelDelta = this._mouseWheelDelta(data);
+    if (wheelDelta)
+      return this._handleWheelDelta(wheelDelta);
+    if (this.promptState)
       return this._handlePromptInput(data);
-    }
     return this._handleGraphInput(data);
   }
   _promptKeybindings() {
     return isKeybindingsLike(this.piKeybindings) ? this.piKeybindings : undefined;
   }
-  _isNonTextGraphControlBeforePrompt(data) {
-    return this._mouseWheelDelta(data) !== null;
-  }
   _isReturnToMainChatInput(data) {
     return matchesKey(data, Key.ctrl("x"));
   }
@@ -43236,14 +43525,13 @@ class GraphViewInputController extends GraphViewRenderer {
   }
   _handleGraphInput(data) {
     const stageCount = this.cachedLayout.length;
-    const wheelDelta = this._mouseWheelDelta(data);
-    if (wheelDelta) {
-      if (wheelDelta.rows !== 0)
-        this._scrollGraphBy(wheelDelta.rows);
-      if (wheelDelta.cols !== 0)
-        this._scrollGraphHorizontallyBy(wheelDelta.cols);
+    if (this.graphLayout.handleScrollbarInput(data)) {
+      this.pendingEnsureFocusedVisible = false;
       return true;
     }
+    const wheelDelta = this._mouseWheelDelta(data);
+    if (wheelDelta)
+      return this._handleWheelDelta(wheelDelta);
     const clickedNodeIndex = this._graphNodeIndexForClick(data);
     if (clickedNodeIndex !== undefined) {
       if (clickedNodeIndex !== null) {
@@ -43318,21 +43606,18 @@ class GraphViewInputController extends GraphViewRenderer {
       this.switcherOpen = false;
       return true;
     }
-    if (matchesKey(data, Key.down)) {
-      const filtered = filterStages(stages, this.switcherState.query);
-      this.switcherState = {
-        ...this.switcherState,
-        selectedIndex: Math.min(this.switcherState.selectedIndex + 1, filtered.length - 1)
-      };
-      return true;
-    }
-    if (matchesKey(data, Key.up)) {
-      this.switcherState = {
-        ...this.switcherState,
-        selectedIndex: Math.max(this.switcherState.selectedIndex - 1, 0)
-      };
+    const wheelEvent = parseTerminalMouseInput(data);
+    const wheelDirection = wheelEvent ? terminalMouseWheelDirection(wheelEvent) : null;
+    if (wheelDirection === "down")
+      return this._moveSwitcherSelection(1);
+    if (wheelDirection === "up")
+      return this._moveSwitcherSelection(-1);
+    if (wheelDirection !== null)
       return true;
-    }
+    if (matchesKey(data, Key.down))
+      return this._moveSwitcherSelection(1);
+    if (matchesKey(data, Key.up))
+      return this._moveSwitcherSelection(-1);
     if (matchesKey(data, Key.backspace)) {
       this.switcherState = {
         query: this.switcherState.query.slice(0, -1),
@@ -43349,6 +43634,16 @@ class GraphViewInputController extends GraphViewRenderer {
     }
     return false;
   }
+  _moveSwitcherSelection(step) {
+    const stages = this.cachedLayout.map((layoutNode) => layoutNode.stage);
+    const filtered = filterStages(stages, this.switcherState.query);
+    const maxIndex = Math.max(0, filtered.length - 1);
+    this.switcherState = {
+      ...this.switcherState,
+      selectedIndex: Math.max(0, Math.min(this.switcherState.selectedIndex + step, maxIndex))
+    };
+    return true;
+  }
   _moveByDepth(step) {
     const cur = this.cachedLayout[this.focusedIndex];
     if (!cur)
@@ -43405,9 +43700,16 @@ class GraphViewInputController extends GraphViewRenderer {
     this.focusedIndex = next;
     this.pendingEnsureFocusedVisible = true;
   }
-  _scrollGraphBy(deltaRows) {
+  _scrollGraphVertically(deltaRows) {
     this.pendingEnsureFocusedVisible = false;
-    this.graphScrollOffset = Math.max(0, this.graphScrollOffset + deltaRows);
+    this.graphLayout.scrollView.scrollBy(deltaRows);
+  }
+  _handleWheelDelta(delta) {
+    if (delta.rows !== 0)
+      this._scrollGraphVertically(delta.rows);
+    if (delta.cols !== 0)
+      this._scrollGraphHorizontallyBy(delta.cols);
+    return true;
   }
   _scrollGraphHorizontallyBy(deltaCols) {
     this.pendingEnsureFocusedVisible = false;
@@ -43440,15 +43742,18 @@ class GraphViewInputController extends GraphViewRenderer {
       return null;
     const direction = terminalMouseWheelDirection(event);
     if (direction === "up")
-      return { cols: 0, rows: -GRAPH_SCROLL_STEP_ROWS };
+      return { cols: 0, rows: -GRAPH_SCROLL_WHEEL_LINES };
     if (direction === "down")
-      return { cols: 0, rows: GRAPH_SCROLL_STEP_ROWS };
+      return { cols: 0, rows: GRAPH_SCROLL_WHEEL_LINES };
     if (direction === "left")
       return { cols: -GRAPH_SCROLL_STEP_COLS, rows: 0 };
     if (direction === "right")
       return { cols: GRAPH_SCROLL_STEP_COLS, rows: 0 };
     return null;
   }
+  get _graphScrollbarGeometry() {
+    return this.graphLayout.scrollbarGeometry;
+  }
   get _focusedIndex() {
     return this.focusedIndex;
   }
@@ -43459,7 +43764,7 @@ class GraphViewInputController extends GraphViewRenderer {
     return this.switcherState;
   }
   get _graphScrollOffset() {
-    return this.graphScrollOffset;
+    return this._graphScrollTop();
   }
   get _graphScrollColOffset() {
     return this.graphScrollColOffset;
@@ -43664,16 +43969,6 @@ function renderHintsForPrompt(kind, theme) {
   return `${paint2("enter", theme.textMuted, { bold: true })} Select · ${paint2("ctrl+c", theme.textMuted, { bold: true })} Skip`;
 }
 
-// dist/builtin/workflows/src/tui/stage-chat-view-types.ts
-var VIEW_LINE_COUNT = 32;
-var PROMPT_SCROLL_STEP_ROWS = 4;
-var HEADER_ROWS = 2;
-var SEP_ROWS = 1;
-var STAGE_CHAT_MOUSE_SCROLL_TOGGLE_LABEL = "ctrl+t";
-function isReadOnlyArchiveStatus(status) {
-  return status === "completed" || status === "failed" || status === "skipped";
-}
-
 // dist/builtin/workflows/src/tui/stage-chat-view-footer-status.ts
 function renderHeader2(ctx, width, stage) {
   const t = ctx.theme;
@@ -43762,14 +44057,13 @@ function embedOrchestratorReturnHintInWidget(ctx, widgetLines, width) {
   return lines;
 }
 function mergeOrchestratorReturnHintIntoLine(ctx, line, width, options = {}) {
-  const copyModeState = ctx.mouseScrollCaptureEnabled ? "off" : "on";
   const fullHint = {
-    plain: `ctrl+x return to graph · ${STAGE_CHAT_MOUSE_SCROLL_TOGGLE_LABEL} copy mode ${copyModeState}`,
-    styled: paint2("ctrl+x", ctx.theme.text, { bold: true }) + paint2(" return to graph · ", ctx.theme.textMuted) + paint2(STAGE_CHAT_MOUSE_SCROLL_TOGGLE_LABEL, ctx.theme.text, { bold: true }) + paint2(` copy mode ${copyModeState}`, ctx.theme.textMuted)
+    plain: "ctrl+x return to graph",
+    styled: paint2("ctrl+x", ctx.theme.text, { bold: true }) + paint2(" return to graph", ctx.theme.textMuted)
   };
   const compactHint = {
-    plain: `ctrl+x graph · ${STAGE_CHAT_MOUSE_SCROLL_TOGGLE_LABEL} ${copyModeState}`,
-    styled: paint2("ctrl+x", ctx.theme.text, { bold: true }) + paint2(" graph · ", ctx.theme.textMuted) + paint2(STAGE_CHAT_MOUSE_SCROLL_TOGGLE_LABEL, ctx.theme.text, { bold: true }) + paint2(` ${copyModeState}`, ctx.theme.textMuted)
+    plain: "ctrl+x graph",
+    styled: paint2("ctrl+x", ctx.theme.text, { bold: true }) + paint2(" graph", ctx.theme.textMuted)
   };
   const trailingBorder = options.preserveTrailingBorder === true ? trailingWidgetBorderChar(line) : "";
   const suffixWidth = visibleWidth(trailingBorder);
@@ -44286,7 +44580,7 @@ async function mountStageCustomUi(request, tui, theme, keybindings, broker, onDo
   });
   const component = {
     render: (width) => rawComponent.render(width),
-    ...rawComponent.handleInput !== undefined ? { handleInput: (data) => rawComponent.handleInput?.(data) } : {},
+    ...rawComponent.handleInput !== undefined ? { handleInput: (data) => rawComponent.handleInput?.(data) === true } : {},
     invalidate: () => rawComponent.invalidate?.(),
     ...rawComponent.dispose !== undefined ? { dispose: () => rawComponent.dispose?.() } : {}
   };
@@ -44870,6 +45164,15 @@ function stageNoticeFields(entry, valueTone = "text") {
   ];
 }
 
+// dist/builtin/workflows/src/tui/stage-chat-view-types.ts
+var VIEW_LINE_COUNT = 32;
+var PROMPT_SCROLL_STEP_ROWS = 4;
+var HEADER_ROWS = 2;
+var SEP_ROWS = 1;
+function isReadOnlyArchiveStatus(status) {
+  return status === "completed" || status === "failed" || status === "skipped";
+}
+
 // dist/builtin/workflows/src/tui/stage-chat-view-state.ts
 function initializeStageChatView(ctx, opts) {
   ctx.store = opts.store;
@@ -44884,7 +45187,6 @@ function initializeStageChatView(ctx, opts) {
   ctx.requestRender = opts.requestRender;
   ctx.requestFocus = opts.requestFocus;
   ctx.focusHoldTimer = undefined;
-  ctx.getViewportRows = opts.getViewportRows;
   ctx.piTui = opts.piTui;
   ctx.piTheme = opts.piTheme;
   ctx.piKeybindings = opts.piKeybindings;
@@ -44904,7 +45206,6 @@ function initializeStageChatView(ctx, opts) {
   ctx.promptMaxScroll = 0;
   ctx.promptVisibleRows = 0;
   ctx.localPaused = false;
-  ctx.mouseScrollCaptureEnabled = true;
   ctx.lastObservedStageStatus = undefined;
   ctx.lastObservedRunStatus = undefined;
   ctx.seenNoticeIds = new Set;
@@ -45113,6 +45414,7 @@ function snapshotMessagesFromHandle(ctx) {
   if (!handle)
     return;
   ctx.chatHost.appendMessages(handle.messages);
+  ctx.chatHost.hydrateStreamingAssistantMessage(handle.agentSession?.agent?.state.streamingMessage);
 }
 function snapshotMessagesFromSessionFile(ctx, stage) {
   ctx.chatHost.loadSessionFile(liveHandle(ctx)?.sessionFile ?? stage?.sessionFile);
@@ -45245,7 +45547,7 @@ function resolvePromptResponse(ctx, promptId, response, metadata = {}) {
     ctx.onDetach("prompt-resolved", metadata);
 }
 function viewLineCount(ctx) {
-  const reported = ctx.getViewportRows?.();
+  const reported = ctx.piTui?.terminal?.rows;
   if (typeof reported !== "number" || !Number.isFinite(reported)) {
     return VIEW_LINE_COUNT;
   }
@@ -45342,6 +45644,10 @@ function promptPageSize(ctx) {
 
 // dist/builtin/workflows/src/tui/stage-chat-view-input.ts
 function handleStageChatInput(ctx, data) {
+  const keybindings = isKeybindingsLike(ctx.piKeybindings) ? ctx.piKeybindings : undefined;
+  if (matchesKey(data, Key.ctrl("t")) && matchesAction(keybindings, data, APP_ACTION.thinkingToggle)) {
+    return false;
+  }
   if (matchesKey(data, Key.ctrl("x"))) {
     if (ctx.mountedCustomUi)
       releaseMountedCustomUi(ctx);
@@ -45353,11 +45659,6 @@ function handleStageChatInput(ctx, data) {
     ctx.onDetach();
     return true;
   }
-  if (matchesKey(data, Key.ctrl("t"))) {
-    ctx.mouseScrollCaptureEnabled = !ctx.mouseScrollCaptureEnabled;
-    ctx.requestRender?.();
-    return true;
-  }
   if (ctx.mountedCustomUi) {
     return handleMountedCustomUiInput(ctx, data);
   }
@@ -45435,9 +45736,9 @@ function handleMountedCustomUiInput(ctx, data) {
   }
   const component = mounted.component;
   setComponentFocused(component, ctx.focused);
-  component.handleInput?.(data);
+  const handled = component.handleInput?.(data) === true;
   ctx.requestRender?.();
-  return true;
+  return handled;
 }
 function handlePromptInput(ctx, data) {
   const state = ctx.promptState;
@@ -45535,7 +45836,6 @@ class StageChatView {
   requestRender;
   requestFocus;
   focusHoldTimer;
-  getViewportRows;
   piTui;
   piTheme;
   piKeybindings;
@@ -45556,7 +45856,6 @@ class StageChatView {
   promptMaxScroll;
   promptVisibleRows;
   localPaused;
-  mouseScrollCaptureEnabled;
   seenNoticeIds;
   _unsubscribeStore;
   _unsubscribeHandle;
@@ -45630,9 +45929,6 @@ class StageChatView {
     ];
     return fitStageChatFrame(lines, totalRows, blankLine(w));
   }
-  wantsMouseScrollTracking() {
-    return this.mouseScrollCaptureEnabled;
-  }
   handleInput(data) {
     return handleStageChatInput(this._ctx(), data);
   }
@@ -45655,7 +45951,6 @@ class StageChatView {
     this.requestRender;
     this.requestFocus;
     this.focusHoldTimer;
-    this.getViewportRows;
     this.piTui;
     this.piTheme;
     this.piKeybindings;
@@ -45672,7 +45967,6 @@ class StageChatView {
     this.promptScrollOffset;
     this.promptMaxScroll;
     this.promptVisibleRows;
-    this.mouseScrollCaptureEnabled;
     this.seenNoticeIds;
     this._unsubscribeStore;
     this._unsubscribeHandle;
@@ -45727,10 +46021,8 @@ class WorkflowAttachPane {
   onClose;
   onHide;
   onPromptResolve;
-  getViewportRows;
   hostRequestRender;
   hostRequestFocus;
-  setMouseScrollTracking;
   piTui;
   piTheme;
   piKeybindings;
@@ -45762,10 +46054,8 @@ class WorkflowAttachPane {
     this.onClose = opts.onClose;
     this.onHide = opts.onHide;
     this.onPromptResolve = opts.onPromptResolve;
-    this.getViewportRows = opts.getViewportRows;
     this.hostRequestRender = opts.requestRender;
     this.hostRequestFocus = opts.requestFocus;
-    this.setMouseScrollTracking = opts.setMouseScrollTracking;
     this.piTui = opts.piTui;
     this.piTheme = opts.piTheme;
     this.piKeybindings = opts.piKeybindings;
@@ -45783,7 +46073,6 @@ class WorkflowAttachPane {
     } else {
       this._syncAwaitingInputKeys(readGraphStoreSnapshot(this.store));
       this._armGraphEnterQuarantineIfRunNeedsInput();
-      this._syncMouseScrollTracking();
     }
   }
   _buildGraphView(initialFocusedStageId, initialFocusedRunId) {
@@ -45804,7 +46093,7 @@ class WorkflowAttachPane {
       },
       initialFocusedStageId,
       initialFocusedRunId,
-      getViewportRows: this.getViewportRows,
+      piTui: this.piTui,
       piKeybindings: this.piKeybindings,
       footerData: this.footerData,
       getStageQueuedMessageCount: (runId, stageId) => this._stageQueuedMessageCount(runId, stageId),
@@ -45866,14 +46155,12 @@ class WorkflowAttachPane {
       getToolsExpanded: this.getToolsExpanded,
       setToolsExpanded: this.setToolsExpanded,
       footerData: this.footerData,
-      getViewportRows: this.getViewportRows,
       stageUiBroker: this.stageUiBroker,
       canSubmitPrompt: (candidateRunId, candidateStageId) => this.visible && this.mode === "stage-chat" && this.chatView === chatView && this.attachedRunId === candidateRunId && this.lastAttachedStageId === candidateStageId && this._isStageMarkedAttached(candidateRunId, candidateStageId)
     });
     this.chatView = chatView;
     this.mode = "stage-chat";
     this.store.recordStageAttached(runId, stageId, this.visible);
-    this._syncMouseScrollTracking();
   }
   _detachFromStage(reason = "user", metadata = {}) {
     this.composerDrafts.capture(this.attachedRunId, this.lastAttachedStageId, this.chatView?._inputBuffer);
@@ -45890,7 +46177,6 @@ class WorkflowAttachPane {
     this.lastStageAwaitingInputKey = null;
     this.lastGraphAwaitingInputKey = this.runId ? this._runAwaitingInputKey(readGraphStoreSnapshot(this.store), this.runId) : null;
     this.graphEnterQuarantineUntil = reason === "prompt-resolved" && metadata.suppressNextGraphSubmit === true ? this.now() + ENTER_TRANSITION_QUARANTINE_MS : 0;
-    this._syncMouseScrollTracking();
   }
   retarget(runId, stageId, stageRunId) {
     if (this.chatView && this.attachedRunId && this.lastAttachedStageId) {
@@ -45915,7 +46201,6 @@ class WorkflowAttachPane {
       }
     }
     this._armGraphEnterQuarantineIfRunNeedsInput();
-    this._syncMouseScrollTracking();
   }
   _resolveGraphStageTarget(rootRunId, stageId) {
     const graph = expandWorkflowGraph(readGraphStoreSnapshot(this.store), rootRunId);
@@ -45971,15 +46256,6 @@ class WorkflowAttachPane {
       this.store.recordStageAttached(this.attachedRunId, this.lastAttachedStageId, visible);
     }
   }
-  _syncMouseScrollTracking() {
-    this.setMouseScrollTracking?.(this.wantsMouseScrollTracking());
-  }
-  wantsMouseScrollTracking() {
-    if (this.mode === "stage-chat" && this.chatView) {
-      return this.chatView.wantsMouseScrollTracking();
-    }
-    return this.mode === "graph";
-  }
   wantsFocusForAwaitingInput(snapshot) {
     if (!this.visible)
       return false;
@@ -46010,12 +46286,7 @@ class WorkflowAttachPane {
     if (this.mode === "stage-chat" && this.chatView) {
       if (this._shouldQuarantineStagePromptEnter(data))
         return true;
-      const beforeMouseTracking = this.chatView.wantsMouseScrollTracking();
-      const handled = this.chatView.handleInput(data);
-      const afterMouseTracking = this.chatView?.wantsMouseScrollTracking();
-      if (afterMouseTracking !== undefined && afterMouseTracking !== beforeMouseTracking)
-        this._syncMouseScrollTracking();
-      return handled;
+      return this.chatView.handleInput(data);
     }
     if (this._shouldQuarantineGraphEnter(data))
       return true;
@@ -46133,7 +46404,6 @@ class WorkflowAttachPane {
     this.chatView?.dispose();
     this.chatView = null;
     this.graphView.dispose();
-    this.setMouseScrollTracking?.(false);
   }
   get _mode() {
     return this.mode;
@@ -46173,12 +46443,7 @@ function buildGraphOverlayAdapter(pi, store2, buildOpts = {}) {
     }
   };
   let remoteTerminalControl = null;
-  const updateMouseScrollTracking = (enabled) => {
-    if (remoteTerminalControl)
-      remoteTerminalControl.setMouseScrollTracking(enabled);
-    else
-      setMouseScrollTracking(enabled, terminalOutput);
-  };
+  let localTerminalModesSuppressed = false;
   let currentView = null;
   let currentHandle = null;
   let mounted = false;
@@ -46197,7 +46462,8 @@ function buildGraphOverlayAdapter(pi, store2, buildOpts = {}) {
         remoteTerminalControl.setAutowrap(!visible);
       return;
     }
-    setTerminalAutowrap(!visible, terminalOutput);
+    if (!localTerminalModesSuppressed)
+      setTerminalAutowrap(!visible, terminalOutput);
   }
   function readHostCustomUiActive(ui = observedUi) {
     const state = ui?.getHostCustomUiState?.();
@@ -46231,7 +46497,6 @@ function buildGraphOverlayAdapter(pi, store2, buildOpts = {}) {
     updateMainChatInputHint(readHostCustomUiActive(ui));
   }
   function close() {
-    updateMouseScrollTracking(false);
     currentHandle?.hide();
     updateTerminalAutowrap(false);
     finishMounted?.();
@@ -46242,11 +46507,11 @@ function buildGraphOverlayAdapter(pi, store2, buildOpts = {}) {
     currentView = null;
     mounted = false;
     remoteTerminalControl = null;
+    localTerminalModesSuppressed = false;
     requestMountedRender = null;
     clearHostCustomUiObservation();
   }
   function hideMounted() {
-    updateMouseScrollTracking(false);
     observedUi?.setStatus?.(MAIN_CHAT_INPUT_STATUS_KEY, undefined);
     if (currentHandle) {
       currentView?.setVisible(false);
@@ -46289,11 +46554,11 @@ function buildGraphOverlayAdapter(pi, store2, buildOpts = {}) {
         const consumed = view.handleInput(data);
         if (consumed)
           tui.requestRender?.();
+        return consumed === true;
       },
       invalidate: () => tui.requestRender?.(),
       dispose: () => {
         updateTerminalAutowrap(false);
-        updateMouseScrollTracking(false);
         remoteTerminalControl = null;
         requestMountedRender = null;
         unsubscribe();
@@ -46308,7 +46573,6 @@ function buildGraphOverlayAdapter(pi, store2, buildOpts = {}) {
       currentView?.retarget(runId, stageId, stageRunId);
       currentView?.setVisible(true);
       updateTerminalAutowrap(true);
-      updateMouseScrollTracking(currentView?.wantsMouseScrollTracking() ?? true);
       currentHandle.setHidden(false);
       currentHandle.focus();
       requestMountedRender?.();
@@ -46317,7 +46581,6 @@ function buildGraphOverlayAdapter(pi, store2, buildOpts = {}) {
     if (mounted) {
       currentView?.retarget(runId, stageId, stageRunId);
       updateTerminalAutowrap(true);
-      updateMouseScrollTracking(currentView?.wantsMouseScrollTracking() ?? true);
       currentHandle?.focus();
       return;
     }
@@ -46326,12 +46589,12 @@ function buildGraphOverlayAdapter(pi, store2, buildOpts = {}) {
       return;
     let settled = false;
     const factory = (tui, theme, keybindings, done) => {
+      localTerminalModesSuppressed = tui.mode === "fullscreen";
       remoteTerminalControl = remoteTerminalControlFrom(tui);
       const finish = () => {
         if (settled)
           return;
         settled = true;
-        updateMouseScrollTracking(false);
         observedUi?.setStatus?.(MAIN_CHAT_INPUT_STATUS_KEY, undefined);
         currentView?.dispose();
         currentView = null;
@@ -46345,6 +46608,7 @@ function buildGraphOverlayAdapter(pi, store2, buildOpts = {}) {
         } finally {
           updateTerminalAutowrap(false);
           remoteTerminalControl = null;
+          localTerminalModesSuppressed = false;
         }
       };
       const view = new WorkflowAttachPane({
@@ -46366,7 +46630,6 @@ function buildGraphOverlayAdapter(pi, store2, buildOpts = {}) {
         getToolsExpanded: ui?.getToolsExpanded,
         setToolsExpanded: ui?.setToolsExpanded,
         footerData: ui?.getFooterDataProvider?.(),
-        getViewportRows: () => tui.terminal?.rows,
         requestRender: () => {
           if (currentHandle?.isHidden() === true)
             return;
@@ -46379,14 +46642,12 @@ function buildGraphOverlayAdapter(pi, store2, buildOpts = {}) {
             return;
           currentHandle?.focus();
         },
-        setMouseScrollTracking: updateMouseScrollTracking,
         now: buildOpts.now
       });
       currentView = view;
       finishMounted = finish;
       mounted = true;
       updateTerminalAutowrap(true);
-      updateMouseScrollTracking(view.wantsMouseScrollTracking());
       updateMainChatInputHint(readHostCustomUiActive(ui));
       return makeComponent2(view, tui);
     };
@@ -46409,7 +46670,6 @@ function buildGraphOverlayAdapter(pi, store2, buildOpts = {}) {
       currentView?.setVisible(!nowHidden);
       if (!nowHidden)
         updateTerminalAutowrap(true);
-      updateMouseScrollTracking(nowHidden ? false : currentView?.wantsMouseScrollTracking() ?? true);
       currentHandle.setHidden(nowHidden);
       if (nowHidden)
         updateTerminalAutowrap(false);
@@ -46431,7 +46691,8 @@ function buildGraphOverlayAdapter(pi, store2, buildOpts = {}) {
 // dist/builtin/workflows/src/tui/store-widget-installer.ts
 import {
   decideReactiveWidgetAction,
-  installReactiveWidget
+  installReactiveWidget,
+  isStaleExtensionContextError as isStaleExtensionContextError4
 } from "@bastani/atomic";
 
 // dist/builtin/workflows/src/tui/widget.ts
@@ -46710,10 +46971,6 @@ var defaultTimerApi = {
   clearTimeout: (handle) => clearTimeout(handle)
 };
 var WIDGET_KEY = "workflow.run";
-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(),
@@ -46740,7 +46997,7 @@ function installStoreWidget(pi, storeInstance, timers = defaultTimerApi) {
     render: (snap, { theme, width, now }) => buildThemedWidgetLines(snap, theme, width, now),
     getNextRefreshDelayMs: (snap, now) => nextWidgetRefreshDelayMs(snap, now),
     requestRenderOnStateNoop: false,
-    isStaleError: isStale
+    isStaleError: isStaleExtensionContextError4
   });
   return () => controller.dispose();
 }
@@ -47590,7 +47847,7 @@ function isModelUsage(value2) {
   if (typeof value2 !== "object" || value2 === null || Array.isArray(value2))
     return false;
   const usage = value2;
-  return ["input", "output", "cacheRead", "cacheWrite", "cost", "turns"].every((key2) => usage[key2] === undefined || typeof usage[key2] === "number" && Number.isFinite(usage[key2]));
+  return ["input", "output", "cacheRead", "cacheWrite", "cost", "turns"].every((key2) => usage[key2] === undefined || typeof usage[key2] === "number" && Number.isFinite(usage[key2]) && usage[key2] >= 0);
 }
 function isUiPromptKind(value2) {
   return value2 === "input" || value2 === "confirm" || value2 === "select" || value2 === "editor" || value2 === "custom";
@@ -47818,7 +48075,7 @@ class InMemoryDurableBackend {
       ...handle.label !== undefined ? { label: handle.label } : {},
       ...handle.rootWorkflowId !== undefined ? { rootWorkflowId: handle.rootWorkflowId } : {},
       ...handle.resumable !== undefined ? { resumable: handle.resumable } : {},
-      ...workflowFailureFields(handle.error !== undefined ? handle : handle.status === "running" ? undefined : existing?.handle),
+      ...workflowFailureFields(hasWorkflowFailureMetadata(handle) ? handle : handle.status === "running" ? undefined : existing?.handle),
       ...handle.ownerExecutorId !== undefined ? { ownerExecutorId: handle.ownerExecutorId } : existing?.handle.ownerExecutorId !== undefined ? { ownerExecutorId: existing.handle.ownerExecutorId } : {}
     };
     if (existing)
@@ -47916,6 +48173,12 @@ class InMemoryDurableBackend {
     return this.getWorkflow(workflowId);
   }
   async hydrateWorkflow(_workflowId) {}
+  async hydrateWorkflowForInspection(workflowId) {
+    const handle = this.getLoadableWorkflow(workflowId);
+    if (handle !== undefined)
+      return { kind: "current", handle };
+    return { kind: this.deletedWorkflowIds.has(workflowId) ? "deleted" : "absent" };
+  }
   async hydrateResumableWorkflows() {}
   async prepareWorkflowCatalog() {
     return { resumable: this.listResumableWorkflows(), completed: this.listCompletedWorkflows() };
@@ -47927,6 +48190,8 @@ class InMemoryDurableBackend {
     rec.handle = {
       ...rec.handle,
       error: undefined,
+      exited: undefined,
+      exitReason: undefined,
       failureKind: undefined,
       failureCode: undefined,
       failureRecoverability: undefined,
@@ -48061,11 +48326,16 @@ function hasResumeProgress(handle) {
 function isHistoricalHandle(handle) {
   return handle.status === "completed" && hasResumeProgress(handle) || handle.status === "failed" && !isDurableWorkflowResumable(handle) && hasResumeProgress(handle);
 }
+function hasWorkflowFailureMetadata(handle) {
+  return handle.error !== undefined || handle.exited !== undefined || handle.exitReason !== undefined || handle.failureKind !== undefined || handle.failureCode !== undefined || handle.failureRecoverability !== undefined || handle.failureDisposition !== undefined || handle.failedToolNodeId !== undefined;
+}
 function workflowFailureFields(handle) {
   if (handle === undefined)
     return {};
   return {
     ...handle.error !== undefined ? { error: handle.error } : {},
+    ...handle.exited !== undefined ? { exited: handle.exited } : {},
+    ...handle.exitReason !== undefined ? { exitReason: handle.exitReason } : {},
     ...handle.failureKind !== undefined ? { failureKind: handle.failureKind } : {},
     ...handle.failureCode !== undefined ? { failureCode: handle.failureCode } : {},
     ...handle.failureRecoverability !== undefined ? { failureRecoverability: handle.failureRecoverability } : {},
@@ -48306,7 +48576,7 @@ function isWorkflowChildResult(value2) {
   return parseWorkflowChildResult(value2) !== undefined;
 }
 function isWorkflowExitStatus(value2) {
-  return value2 === "completed" || value2 === "skipped" || value2 === "cancelled" || value2 === "blocked";
+  return value2 === "completed" || value2 === "skipped" || value2 === "cancelled" || value2 === "blocked" || value2 === "failed";
 }
 function isOrdinaryObject(value2) {
   if (typeof value2 !== "object" || value2 === null || Array.isArray(value2))
@@ -49294,6 +49564,8 @@ function encodeMetadata(metadata) {
       ...metadata.label !== undefined ? { label: metadata.label } : {},
       ...metadata.rootWorkflowId !== undefined ? { rootWorkflowId: metadata.rootWorkflowId } : {},
       ...metadata.resumable !== undefined ? { resumable: metadata.resumable } : {},
+      ...metadata.exited !== undefined ? { exited: metadata.exited } : {},
+      ...metadata.exitReason !== undefined ? { exitReason: metadata.exitReason } : {},
       ...metadata.error !== undefined ? { error: metadata.error } : {},
       ...metadata.failureKind !== undefined ? { failureKind: metadata.failureKind } : {},
       ...metadata.failureCode !== undefined ? { failureCode: metadata.failureCode } : {},
@@ -49344,7 +49616,7 @@ function parseDurableWorkflowMetadata(value2, workflowId) {
   if (typeof value2 !== "object" || value2 === null || Array.isArray(value2))
     return;
   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")
+  if (metadata.workflowId !== workflowId || typeof metadata.workflowId !== "string" || typeof metadata.name !== "string" || typeof metadata.inputs !== "object" || metadata.inputs === null || Array.isArray(metadata.inputs) || typeof metadata.status !== "string" || !isDurableWorkflowStatus(metadata.status) || typeof metadata.completedCheckpoints !== "number" || typeof metadata.createdAt !== "number" || typeof metadata.pendingPrompts !== "number" || typeof metadata.promptReservationEpoch !== "string" || typeof metadata.updatedAt !== "number" || metadata.ownerExecutorId !== undefined && typeof metadata.ownerExecutorId !== "string" || metadata.transitionClaimId !== undefined && typeof metadata.transitionClaimId !== "string" || metadata.sessionFile !== undefined && typeof metadata.sessionFile !== "string" || metadata.label !== undefined && typeof metadata.label !== "string" || metadata.rootWorkflowId !== undefined && typeof metadata.rootWorkflowId !== "string" || metadata.resumable !== undefined && typeof metadata.resumable !== "boolean" || metadata.exited !== undefined && typeof metadata.exited !== "boolean" || metadata.exitReason !== undefined && typeof metadata.exitReason !== "string" || metadata.error !== undefined && typeof metadata.error !== "string" || metadata.failureKind !== undefined && !isWorkflowFailureKind(metadata.failureKind) || metadata.failureCode !== undefined && !isWorkflowFailureCode(metadata.failureCode) || metadata.failureRecoverability !== undefined && !isWorkflowFailureRecoverability(metadata.failureRecoverability) || metadata.failureDisposition !== undefined && !isWorkflowFailureDisposition(metadata.failureDisposition) || metadata.failedToolNodeId !== undefined && typeof metadata.failedToolNodeId !== "string" || metadata.invocationCwd !== undefined && typeof metadata.invocationCwd !== "string" || metadata.workflowCwd !== undefined && typeof metadata.workflowCwd !== "string" || metadata.repositoryRoot !== undefined && typeof metadata.repositoryRoot !== "string" || metadata.gitWorktreeRoot !== undefined && typeof metadata.gitWorktreeRoot !== "string")
     return;
   const { origin, ...metadataWithoutOrigin } = metadata;
   return {
@@ -50042,17 +50314,24 @@ class DbosDurableBackend {
     throw first;
   }
   async hydrateWorkflow(workflowId) {
-    if (this.locallyRegistered.has(workflowId))
-      return;
-    const info = await this.sdk.retrieveWorkflow(workflowId);
-    if (info !== undefined) {
-      await this.hydrateInfo(info);
-      return;
+    await this.hydrateWorkflowForInspection(workflowId);
+  }
+  async hydrateWorkflowForInspection(workflowId) {
+    if (this.locallyRegistered.has(workflowId)) {
+      const handle = this.getLoadableWorkflow(workflowId);
+      return handle === undefined ? { kind: "malformed" } : { kind: "current", handle };
     }
+    const info = await this.sdk.retrieveWorkflow(workflowId);
+    if (info !== undefined)
+      return await this.hydrateInfo(info);
     const records = await this.sdk.listStepRecords(workflowId);
     const deletion = classifyDbosDeletionTombstone(records, workflowId);
-    if (deletion !== "absent")
-      await this.suppressWorkflow(workflowId);
+    if (deletion === "absent" && records.length === 0)
+      return { kind: "absent" };
+    await this.suppressWorkflow(workflowId);
+    if (deletion === "absent")
+      return { kind: "malformed" };
+    return { kind: deletion === "current" ? "deleted" : "malformed" };
   }
   async hydrateResumableWorkflows() {
     const all = await this.sdk.listAllWorkflows();
@@ -50064,10 +50343,15 @@ class DbosDurableBackend {
   }
   async hydrateInfo(info) {
     const records = await this.sdk.listStepRecords(info.workflowId);
+    const deletion = classifyDbosDeletionTombstone(records, info.workflowId);
+    if (deletion !== "absent") {
+      await this.suppressWorkflow(info.workflowId);
+      return { kind: deletion === "current" ? "deleted" : "malformed" };
+    }
     const metadata = classifyLatestMetadata(records, info.workflowId);
     if (metadata.kind !== "current") {
       await this.suppressWorkflow(info.workflowId);
-      return;
+      return { kind: "malformed" };
     }
     const checkpoints = [];
     for (const record of records) {
@@ -50076,7 +50360,7 @@ class DbosDurableBackend {
       const classified = classifyCheckpointPayload(info.workflowId, record.stepName, record.output);
       if (classified.kind === "unknown") {
         await this.suppressWorkflow(info.workflowId);
-        return;
+        return { kind: "malformed" };
       }
       checkpoints.push(classified.checkpoint);
     }
@@ -50087,14 +50371,21 @@ class DbosDurableBackend {
     for (const checkpoint of checkpoints)
       this.mem.recordCheckpoint(checkpoint);
     const current = this.mem.getWorkflow(info.workflowId);
-    if (current !== undefined) {
-      const pendingPrompts2 = this.promptReservations.hydrate(info.workflowId, metadata.metadata.pendingPrompts, records, metadata.metadata.promptReservationEpoch);
-      this.applyMetadata(info.workflowId, {
-        ...metadata.metadata,
-        pendingPrompts: pendingPrompts2,
-        completedCheckpoints: current.completedCheckpoints
-      });
+    if (current === undefined) {
+      await this.suppressWorkflow(info.workflowId);
+      return { kind: "malformed" };
     }
+    const pendingPrompts2 = this.promptReservations.hydrate(info.workflowId, metadata.metadata.pendingPrompts, records, metadata.metadata.promptReservationEpoch);
+    this.applyMetadata(info.workflowId, {
+      ...metadata.metadata,
+      pendingPrompts: pendingPrompts2,
+      completedCheckpoints: current.completedCheckpoints
+    });
+    const handle = this.getLoadableWorkflow(info.workflowId);
+    if (handle !== undefined)
+      return { kind: "current", handle };
+    await this.suppressWorkflow(info.workflowId);
+    return { kind: "malformed" };
   }
   async suppressWorkflow(workflowId) {
     this.invalid.add(workflowId);
@@ -50158,13 +50449,14 @@ import { dirname, join } from "node:path";
 // dist/builtin/workflows/src/durable/local-command.ts
 import { spawn } from "node:child_process";
 import { connect } from "node:net";
+import { createChildProcessEnvironment } from "@bastani/atomic";
 var OUTPUT_LIMIT_BYTES = 16384;
 function runLocalCommand(command, args, options) {
   return new Promise((resolve, reject) => {
     const child = spawn(command, [...args], {
       stdio: ["ignore", "pipe", "pipe"],
       windowsHide: true,
-      ...options?.env !== undefined ? { env: { ...process.env, ...options.env } } : {},
+      env: createChildProcessEnvironment(options?.env ? { ...options.env } : undefined),
       ...options?.uid !== undefined ? { uid: options.uid } : {},
       ...options?.gid !== undefined ? { gid: options.gid } : {}
     });
@@ -50807,20 +51099,34 @@ function priorRunElapsedMs(backend, workflowId) {
   return elapsedMs;
 }
 function recordRunTimingCheckpoint(backend, run, options) {
+  const checkpoint = runTimingCheckpoint(backend, run, options);
+  if (checkpoint === undefined)
+    return false;
+  backend.recordCheckpoint(checkpoint);
+  return true;
+}
+async function recordRunTimingCheckpointAsync(backend, run, options) {
+  const checkpoint = runTimingCheckpoint(backend, run, options);
+  if (checkpoint === undefined)
+    return false;
+  await backend.recordCheckpointAsync(checkpoint);
+  return true;
+}
+function runTimingCheckpoint(backend, run, options) {
   const now = options?.now ?? Date.now();
   const elapsedMs = elapsedRunMs(run, now);
   if (elapsedMs <= 0)
-    return false;
+    return;
   if (backend.listCheckpoints(run.id).length === 0)
-    return false;
+    return;
   const recorded = priorRunElapsedMs(backend, run.id);
   if (recorded !== undefined) {
     if (elapsedMs <= recorded)
-      return false;
+      return;
     if (options?.debounce === true && timingBucket(elapsedMs) === timingBucket(recorded))
-      return false;
+      return;
   }
-  const checkpoint = {
+  return {
     kind: "tool",
     workflowId: run.id,
     checkpointId: `run-timing:${elapsedMs}`,
@@ -50829,8 +51135,6 @@ function recordRunTimingCheckpoint(backend, run, options) {
     output: { elapsedMs },
     completedAt: now
   };
-  backend.recordCheckpoint(checkpoint);
-  return true;
 }
 function inheritedRunElapsedMs(input) {
   const now = input.now ?? Date.now();
@@ -51669,6 +51973,16 @@ async function resumeRun(runId, opts) {
       message: "This workflow is not resumable; inspect the snapshot and start a new workflow run when ready."
     };
   }
+  if (current.status === "failed" && current.endedAt !== undefined && current.exited === true && current.resumable === true) {
+    return {
+      ok: true,
+      runId,
+      snapshot,
+      resumed: resumedCopy,
+      mode: "snapshot",
+      message: `This failed run is marked resumable; use /workflow resume ${runId} to ask the durable backend to retry it or start a new workflow run.`
+    };
+  }
   if (current.endedAt === undefined && current.resumable === true && current.failureRecoverability === "recoverable" && current.failedStageId !== undefined) {
     return {
       ok: true,
@@ -52303,7 +52617,9 @@ function formatWorkflowLifecycleNoticeText(details) {
     const tool = lifecycleToolOrigin(details);
     const failureSite = stage2 ? `, stage ${stage2}` : tool !== undefined ? `, tool ${tool}` : "";
     const errorText = details.error ? `: ${details.error}` : "";
-    return `✗ Workflow "${workflowName}" failed (run ${details.runId}${failureSite})${origin}${errorText}. Inspect: /workflow status ${details.runId}`;
+    const outputsText = formatLifecycleOutputs(details.outputs);
+    const outputSuffix = outputsText === undefined ? "" : ` Partial outputs: ${outputsText}`;
+    return `✗ Workflow "${workflowName}" failed (run ${details.runId}${failureSite})${origin}${errorText}${outputSuffix}. Inspect: /workflow status ${details.runId}`;
   }
   if (details.kind === "blocked") {
     const errorText = details.error ? `: ${details.error}` : "";
@@ -52339,7 +52655,8 @@ function makeTerminalNotice(run, kind) {
   const failedToolNodeId = kind === "failed" && run.failedStageId === undefined ? run.failedToolNodeId : undefined;
   const failedTool = (run.toolNodes ?? []).find((node) => node.id === failedToolNodeId);
   const activeBlocked = kind === "blocked" && isActiveRecoverableBlockedRun(run);
-  const error = activeBlocked ? run.failureMessage ?? structuredRecoverableWorkflowFailureText(run) ?? run.error : run.error ?? returnedNoticeError(run, kind) ?? (kind === "blocked" ? run.exitReason : undefined);
+  const outputs = kind === "failed" && run.exited === true && run.result !== undefined ? run.result : undefined;
+  const error = activeBlocked ? run.failureMessage ?? structuredRecoverableWorkflowFailureText(run) ?? run.error : run.error ?? returnedNoticeError(run, kind) ?? (kind === "blocked" || kind === "failed" ? run.exitReason : undefined);
   return {
     kind,
     scope: "run",
@@ -52347,7 +52664,9 @@ function makeTerminalNotice(run, kind) {
     workflowName: run.name,
     status: effectiveRunStatus(run),
     ...activeBlocked ? { active: true } : {},
+    ...run.exited === true && run.status === "failed" && run.resumable !== undefined ? { resumable: run.resumable } : {},
     ...error ? { error: truncateSnippet(error) } : {},
+    ...outputs !== undefined ? { outputs } : {},
     ...run.failedStageId ? { failedStageId: run.failedStageId } : {},
     ...failedStage ? { stageId: failedStage.id, stageName: failedStage.name } : {},
     ...failedToolNodeId !== undefined ? { toolNodeId: failedToolNodeId } : {},
@@ -52409,6 +52728,8 @@ function lifecycleOccurrenceAt(run, kind) {
   return run.endedAt;
 }
 function returnedNoticeError(run, kind) {
+  if (run.exited === true && (kind === "failed" || kind === "blocked"))
+    return run.exitReason;
   const structuredFailureText = structuredRecoverableWorkflowFailureText(run);
   if (kind === "blocked" && structuredFailureText !== undefined)
     return structuredFailureText;
@@ -52491,6 +52812,16 @@ function truncateSnippet(value2) {
     return normalized;
   return `${normalized.slice(0, LIFECYCLE_NOTICE_SNIPPET_LIMIT - 1)}…`;
 }
+function formatLifecycleOutputs(outputs) {
+  if (outputs === undefined)
+    return;
+  try {
+    const serialized = JSON.stringify(outputs);
+    return serialized === undefined ? "available; inspect the run result" : truncateSnippet(serialized);
+  } catch {
+    return "available; inspect the run result";
+  }
+}
 function makeNoticeComponent2(details, theme) {
   const text = formatWorkflowLifecycleNoticeText(details);
   return {
@@ -52522,6 +52853,11 @@ function renderLifecycleNoticeCard(details, opts) {
       { label: "launched", value: details.origin, tone: "muted" },
       { label: "prompt", value: details.promptMessage, tone: "muted" },
       { label: "error", value: details.error, tone: "error" },
+      {
+        label: "partial outputs",
+        value: formatLifecycleOutputs(details.outputs),
+        tone: "muted"
+      },
       { label: "resumable", value: resumableFieldValue(details), tone: "muted" },
       { label: "duration", value: formatDurationMs(details.durationMs), tone: "muted" }
     ],
@@ -52701,33 +53037,33 @@ function isRunStatus(value2) {
       return false;
   }
 }
-function resolveRunId(target) {
+function resolveRunId(target, activeStore = store) {
   if (!isFullRunId(target))
     return { kind: "malformed", message: malformedRunIdMessage(target) };
-  const exact = store.runs().find((r) => r.id === target);
+  const exact = activeStore.runs().find((r) => r.id === target);
   if (exact)
     return { kind: "exact", runId: exact.id };
   return { kind: "not_found" };
 }
-function resolveToolRunTarget(args, emptyMessage) {
+function resolveToolRunTarget(args, emptyMessage, activeStore = store) {
   const rawTarget = args.runId?.trim() ?? "";
   if (args.all === true || rawTarget === "--all")
     return { kind: "all" };
-  const target = rawTarget || store.activeRunId() || "";
+  const target = rawTarget || activeStore.activeRunId() || "";
   if (!target)
     return { kind: "not_found", target: rawTarget, message: emptyMessage };
-  const resolved = resolveRunId(target);
+  const resolved = resolveRunId(target, activeStore);
   if (resolved.kind === "exact")
     return { kind: "run", runId: resolved.runId };
   if (resolved.kind === "malformed")
     return { kind: "malformed", target, message: resolved.message };
   return { kind: "not_found", target, message: `Run not found: ${target}` };
 }
-function resolveStageTarget(runId, stageTarget) {
+function resolveStageTarget(runId, stageTarget, activeStore = store) {
   const target = stageTarget?.trim();
   if (!target)
     return { ok: true, runId };
-  const graph = expandWorkflowGraph(readGraphStoreSnapshot(store), runId);
+  const graph = expandWorkflowGraph(readGraphStoreSnapshot(activeStore), runId);
   const exactVirtualIds = graph.stages.filter((stage) => stage.id === target);
   if (exactVirtualIds.length === 1)
     return resolvedStageTarget(exactVirtualIds[0]);
@@ -52763,8 +53099,8 @@ function ambiguousStageTarget(target, stages) {
     message: `Ambiguous stage identifier "${target}" matches: ${stages.map(expandedStageLabel).join(", ")}`
   };
 }
-function resolveToolStageTarget(runId, stageTarget) {
-  return resolveStageTarget(runId, stageTarget);
+function resolveToolStageTarget(runId, stageTarget, activeStore = store) {
+  return resolveStageTarget(runId, stageTarget, activeStore);
 }
 function resolveControlNodeTarget(runId, stageTarget) {
   const target = stageTarget?.trim();
@@ -53504,10 +53840,13 @@ var CONTRACT_FIDELITY_AUDIT = [
 ].join(`
 `);
 var REVIEWER_INTERCOM_COORDINATION_PROTOCOL = [
-  "Concurrent reviewer coordination:",
+  "Concurrent reviewer coordination (constructive quorum):",
   "- At review start, use Intercom to discover sibling reviewers and share validation plans and check ownership.",
   "- Claim, serialize, announce, and release expensive or conflicting shared-checkout/environment work such as suites, builds, package operations, browser/E2E sessions, migrations, and generated-artifact steps; share reusable command evidence.",
-  "- Coordination is operational only: inspect independently and return your own verdict rather than copying or deferring to sibling conclusions."
+  "- First, inspect independently and form a preliminary assessment before reading or relying on sibling findings or verdicts. After the exchange, inspect independently and return your own verdict rather than copying or deferring to sibling conclusions.",
+  "- Then run exactly one bounded evidence-exchange round over Intercom: share your preliminary verdict, concise findings, and evidence; challenge blocking findings, surface defects a sibling missed, and correct objective/acceptance-criteria misreadings. Do not start a second round or continue substantive discussion.",
+  "- Verdicts change only through concrete evidence, never through deference to a sibling's approval or rejection; inspect shared evidence yourself before deciding.",
+  "- In `overall_explanation`, record whether deliberation changed your preliminary verdict and, if it did, which concrete evidence caused the change. If it did not, say so; return your own structured decision even when dissent remains."
 ].join(`
 `);
 var REVIEWER_INDEPENDENT_VERIFICATION_CONTRACT = [
@@ -54636,8 +54975,12 @@ import { existsSync as existsSync3 } from "node:fs";
 import { mkdir as mkdir2, readdir, rm, stat } from "node:fs/promises";
 import { dirname as dirname3, join as join10 } from "node:path";
 import { getAgentDir as getAgentDir2, getEnvValue as getEnvValue2 } from "@bastani/atomic";
+
+// dist/builtin/workflows/src/shared/workflow-artifact-env.ts
 var WORKFLOW_ARTIFACT_RETENTION_MS = 30 * 24 * 60 * 60 * 1000;
 var ENV_WORKFLOW_ARTIFACT_DIR = "ATOMIC_WORKFLOW_ARTIFACT_DIR";
+
+// dist/builtin/workflows/src/shared/workflow-artifacts.ts
 var ARTIFACT_PRUNE_RECHECK_MS = 60 * 60 * 1000;
 var lastArtifactPruneAt = new Map;
 var pendingArtifactPrunes = new Map;
@@ -55703,6 +56046,7 @@ import { mkdirSync as mkdirSync2 } from "node:fs";
 import { tmpdir as tmpdir2, userInfo } from "node:os";
 import { join as join13 } from "node:path";
 import { Type as Type11 } from "typebox";
+import { createChildProcessEnvironment as createChildProcessEnvironment2 } from "@bastani/atomic";
 var OUTPUT_TYPES = [
   "prototype",
   "wireframe",
@@ -55812,7 +56156,8 @@ function ensurePlaywrightCli() {
       const probe = spawnSync(isWindows ? "where" : "which", ["playwright-cli"], {
         stdio: "ignore",
         timeout: 15000,
-        shell: isWindows
+        shell: isWindows,
+        env: createChildProcessEnvironment2()
       });
       return probe.status === 0;
     } catch {
@@ -55832,7 +56177,8 @@ function ensurePlaywrightCli() {
     const install = spawnSync("npm", ["install", "-g", "@playwright/cli@latest"], {
       stdio: "ignore",
       timeout: 180000,
-      shell: isWindows
+      shell: isWindows,
+      env: createChildProcessEnvironment2()
     });
     if (install.status === 0) {
       return {
@@ -57617,29 +57963,34 @@ var promptEngineerModelConfig = {
   excludedTools: ["ask_user_question"]
 };
 var researchModelConfig = {
-  model: "openai-codex/gpt-5.6-luna:max",
+  model: "anthropic/claude-opus-5:high",
   fallbackModels: [
-    "github-copilot/gpt-5.6-luna:max",
-    "openai/gpt-5.6-luna:max",
-    "anthropic/claude-opus-5:low",
-    "github-copilot/claude-opus-5:low",
-    "anthropic/claude-fable-5:low",
-    "github-copilot/claude-fable-5:low",
-    "openai-codex/gpt-5.5:medium",
-    "github-copilot/gpt-5.5:medium",
-    "openai/gpt-5.5:medium",
-    "anthropic/claude-opus-4-8:medium",
-    "github-copilot/claude-opus-4.8:medium",
+    "github-copilot/claude-opus-5:high",
+    "openai-codex/gpt-5.6-sol:xhigh",
+    "github-copilot/gpt-5.6-sol:xhigh",
+    "openai/gpt-5.6-sol:xhigh",
+    "anthropic/claude-fable-5:high",
+    "github-copilot/claude-fable-5:high",
+    "kimi-coding/k3:max",
+    "moonshotai/kimi-k3:max",
+    "moonshotai-cn/kimi-k3:max",
+    "openai-codex/gpt-5.5:xhigh",
+    "github-copilot/gpt-5.5:xhigh",
+    "openai/gpt-5.5:xhigh",
+    "anthropic/claude-opus-4-8:high",
+    "github-copilot/claude-opus-4.8:high",
     "xai/grok-4.5:high",
-    "zai/glm-5.2:high",
-    "zai-coding-cn/glm-5.2:high",
-    "openrouter/openai/gpt-5.6-luna:max",
-    "openrouter/anthropic/claude-opus-5:low",
-    "openrouter/openai/gpt-5.5:medium",
-    "openrouter/anthropic/claude-fable-5:low",
-    "openrouter/anthropic/claude-opus-4-8:medium",
+    "zai/glm-5.2:xhigh",
+    "zai-coding-cn/glm-5.2:xhigh",
+    "openrouter/anthropic/claude-opus-5:high",
+    "openrouter/openai/gpt-5.6-sol:xhigh",
+    "openrouter/anthropic/claude-fable-5:high",
+    "openrouter/moonshotai/kimi-k3:max",
+    "openrouter/sakana/fugu-ultra:high",
+    "openrouter/openai/gpt-5.5:xhigh",
+    "openrouter/anthropic/claude-opus-4-8:high",
     "openrouter/x-ai/grok-4.5",
-    "openrouter/z-ai/glm-5.2:high"
+    "openrouter/z-ai/glm-5.2:xhigh"
   ],
   excludedTools: ["ask_user_question"]
 };
@@ -58615,7 +58966,8 @@ var WORKFLOW_EXIT_STATUSES = new Set([
   "completed",
   "skipped",
   "cancelled",
-  "blocked"
+  "blocked",
+  "failed"
 ]);
 function makeWorkflowExitSignal(input) {
   return {
@@ -58623,6 +58975,7 @@ function makeWorkflowExitSignal(input) {
     scope: input.scope,
     status: input.status,
     ...input.reason !== undefined ? { reason: input.reason } : {},
+    ...input.resumable !== undefined ? { resumable: input.resumable } : {},
     ...input.outputSnapshot !== undefined ? { outputSnapshot: input.outputSnapshot } : {},
     ...input.validationError !== undefined ? { validationError: input.validationError } : {}
   };
@@ -58859,6 +59212,9 @@ function readWorkflowExitSignalCandidate(value2, scope) {
   const reason = safeGetProperty(value2, "reason");
   if (!reason.ok || reason.value !== undefined && typeof reason.value !== "string")
     return;
+  const resumable = safeGetProperty(value2, "resumable");
+  if (!resumable.ok || resumable.value !== undefined && typeof resumable.value !== "boolean")
+    return;
   const outputSnapshotValue = safeGetProperty(value2, "outputSnapshot");
   if (!outputSnapshotValue.ok)
     return;
@@ -58873,6 +59229,7 @@ function readWorkflowExitSignalCandidate(value2, scope) {
     scope,
     status: status.value,
     ...reason.value !== undefined ? { reason: reason.value } : {},
+    ...resumable.value !== undefined ? { resumable: resumable.value } : {},
     ...outputSnapshot !== undefined ? { outputSnapshot } : {},
     ...validationError.value !== undefined ? { validationError: safeErrorValue(validationError.value) } : {}
   };
@@ -60789,6 +61146,9 @@ class ScopedDurableBackend {
   hydrateWorkflow(_workflowId) {
     return Promise.resolve();
   }
+  hydrateWorkflowForInspection(_workflowId) {
+    return Promise.resolve({ kind: "absent" });
+  }
   hydrateResumableWorkflows() {
     return Promise.resolve();
   }
@@ -61138,7 +61498,7 @@ function openGitWorktreeGenerationAnchor(worktreeRoot) {
 
 // dist/builtin/workflows/src/runs/shared/worktree-git-runner.ts
 import { spawnSync as spawnSync2 } from "node:child_process";
-import { createGitEnvironment } from "@bastani/atomic";
+import { createChildProcessEnvironment as createChildProcessEnvironment3, createGitEnvironment } from "@bastani/atomic";
 var DISABLED_GIT_HOOKS_PATH = process.platform === "win32" ? "NUL" : "/dev/null";
 var GIT_COMMAND_TIMEOUT_MS = 60000;
 var GIT_READ_ONLY_PROBE_TIMEOUT_ATTEMPTS = 2;
@@ -61162,7 +61522,7 @@ function spawnGit(cwd, args, plain) {
   const result = spawnSync2("git", plain ? args : gitCommandArgs(args), {
     cwd,
     encoding: "utf-8",
-    env: createGitEnvironment({ GIT_OPTIONAL_LOCKS: "0", GIT_TERMINAL_PROMPT: "0", GCM_INTERACTIVE: "never" }),
+    env: createGitEnvironment({ GIT_OPTIONAL_LOCKS: "0", GIT_TERMINAL_PROMPT: "0", GCM_INTERACTIVE: "never" }, createChildProcessEnvironment3()),
     timeout: GIT_COMMAND_TIMEOUT_MS
   });
   return {
@@ -61798,6 +62158,7 @@ import { spawnSync as spawnSync3 } from "node:child_process";
 import * as fs6 from "node:fs";
 import * as os from "node:os";
 import * as path6 from "node:path";
+import { createChildProcessEnvironment as createChildProcessEnvironment4 } from "@bastani/atomic";
 
 // dist/builtin/workflows/src/runs/shared/worktree-post-create.ts
 import * as fs5 from "node:fs";
@@ -62080,6 +62441,7 @@ function runWorktreeSetupHook(hook, input) {
     cwd: input.worktreePath,
     encoding: "utf-8",
     input: JSON.stringify(input),
+    env: createChildProcessEnvironment4(),
     timeout: hook.timeoutMs,
     shell: false
   });
@@ -63499,8 +63861,9 @@ function createRunFinalizers(input) {
     } catch (err) {
       return finalizeWorkflowExitValidationFailure(err, signal.reason);
     }
+    const resumable = signal.status === "failed" && signal.resumable === true;
     const metadata = {
-      resumable: false,
+      resumable,
       exited: true,
       ...signal.reason !== undefined ? { exitReason: signal.reason } : {}
     };
@@ -63511,7 +63874,7 @@ function createRunFinalizers(input) {
       result: outputs,
       exited: true,
       ...signal.reason !== undefined ? { exitReason: signal.reason } : {},
-      resumable: false,
+      resumable,
       ts: Date.now()
     });
     return reconcileTerminalRunResult(input.runId, input.runSnapshot, input.activeStore, {
@@ -63879,7 +64242,7 @@ function createWorkflowExitManager(input) {
     if (!statusRead.ok) {
       captureValidationError(statusRead.error);
     } else if (!isWorkflowExitStatus2(rawStatus)) {
-      captureValidationError(new TypeError(`atomic-workflows: ctx.exit() status must be one of completed, skipped, cancelled, blocked; got ${describeWorkflowExitOptionValue(rawStatus)}`));
+      captureValidationError(new TypeError(`atomic-workflows: ctx.exit() status must be one of completed, skipped, cancelled, blocked, failed; got ${describeWorkflowExitOptionValue(rawStatus)}`));
     }
     const status = isWorkflowExitStatus2(rawStatus) ? rawStatus : "completed";
     const reasonRead = readWorkflowExitOption(rawOptions, "reason");
@@ -63891,6 +64254,17 @@ function createWorkflowExitManager(input) {
       captureValidationError(new TypeError(`atomic-workflows: ctx.exit() reason must be a string when provided; got ${workflowSerializableTypeName(rawReason)}`));
     }
     const reason = typeof rawReason === "string" ? rawReason : undefined;
+    const resumableRead = readWorkflowExitOption(rawOptions, "resumable");
+    throwNestedSelectedExit();
+    const rawResumable = resumableRead.ok ? resumableRead.value : undefined;
+    if (!resumableRead.ok) {
+      captureValidationError(resumableRead.error);
+    } else if (rawResumable !== undefined && typeof rawResumable !== "boolean") {
+      captureValidationError(new TypeError(`atomic-workflows: ctx.exit() resumable must be a boolean when provided; got ${workflowSerializableTypeName(rawResumable)}`));
+    } else if (rawResumable !== undefined && rawStatus !== "failed") {
+      captureValidationError(new TypeError(`atomic-workflows: ctx.exit() resumable is only valid with status failed; got ${describeWorkflowExitOptionValue(rawStatus)}`));
+    }
+    const resumable = status === "failed" && rawResumable === true;
     const outputsRead = readWorkflowExitOption(rawOptions, "outputs");
     throwNestedSelectedExit();
     const outputSnapshot = !outputsRead.ok ? freezeWorkflowExitOutputSnapshot({ ok: false, error: outputsRead.error }) : outputsRead.value !== undefined ? captureWorkflowExitOutputSnapshot(outputsRead.value) : undefined;
@@ -63899,6 +64273,7 @@ function createWorkflowExitManager(input) {
       scope: input.exitScope,
       status,
       ...reason !== undefined ? { reason } : {},
+      ...status === "failed" ? { resumable } : {},
       ...outputSnapshot !== undefined ? { outputSnapshot } : {},
       ...validationError !== undefined ? { validationError } : {}
     }));
@@ -64329,7 +64704,7 @@ function createChildWorkflowRunner(input) {
       if (childRun.status === "paused" && childRun.exitReason === WORKFLOW_GRACEFUL_QUIT_EXIT_REASON && childRunId !== undefined) {
         throw new WorkflowGracefulQuitError(childRunId, `child workflow "${childName}" (${child.name})`);
       }
-      if (!isWorkflowExitStatus2(childRun.status)) {
+      if (!isWorkflowExitStatus2(childRun.status) || childRun.status === "failed" && childRun.exited !== true) {
         const failedChildStage = childRun.stages.find((stage) => stage.failureKind !== undefined);
         throw new Error(`atomic-workflows: child workflow "${childName}" (${child.name}) failed with status ${childRun.status}${childRun.error !== undefined ? `: ${childRun.error}` : ""}`, {
           cause: {
@@ -64418,8 +64793,12 @@ async function finalizeDurableTerminalStatus(input) {
     if (durableStatus === "failed" || durableStatus === "blocked") {
       recordRunTimingCheckpoint(input.durableBackend, input.runSnapshot);
     }
-    const failure3 = durableStatus === "failed" && input.runSnapshot.error !== undefined ? {
-      error: input.runSnapshot.error,
+    const failure3 = durableStatus === "failed" ? {
+      ...input.runSnapshot.error !== undefined ? { error: input.runSnapshot.error } : {},
+      ...input.runSnapshot.exited === true ? {
+        exited: true,
+        ...input.runSnapshot.exitReason !== undefined ? { exitReason: input.runSnapshot.exitReason } : {}
+      } : {},
       ...input.runSnapshot.failureKind !== undefined ? { failureKind: input.runSnapshot.failureKind } : {},
       ...input.runSnapshot.failureCode !== undefined ? { failureCode: input.runSnapshot.failureCode } : {},
       ...input.runSnapshot.failureRecoverability !== undefined ? { failureRecoverability: input.runSnapshot.failureRecoverability } : {},
@@ -64453,7 +64832,7 @@ function createDurableStageSessionRecorder(input) {
     if (stageRunId === input.runId) {
       await recordStageSessionCheckpoint(input.deps, snapshot, { force: options?.forceDurable === true });
       if (input.runSnapshot !== undefined) {
-        recordRunTimingCheckpoint(input.deps.backend, input.runSnapshot, {
+        await recordRunTimingCheckpointAsync(input.deps.backend, input.runSnapshot, {
           debounce: options?.forceDurable !== true
         });
       }
@@ -64502,7 +64881,7 @@ function hasUsableContentBlock(block) {
 }
 
 // dist/builtin/workflows/src/durable/completed-catalog-stage-groups.ts
-function validBoundaryRecordSet(checkpoints, strict) {
+function validBoundaryRecordSet(checkpoints, strict, requireActiveFingerprint = false) {
   const stages = checkpoints.filter((item) => item.kind === "stage");
   const boundaries = stages.filter((item) => item.topology?.boundary !== undefined);
   const startsByReplay = new Map;
@@ -64517,42 +64896,59 @@ function validBoundaryRecordSet(checkpoints, strict) {
     return false;
   if (boundaries.some((checkpoint) => checkpoint.topology.boundary.event === "terminal" && startsByReplay.get(checkpoint.replayKey)?.length !== 1))
     return false;
-  return [...startsByReplay.values()].every((starts) => boundaryTransitionError(starts[0], stages, strict) === undefined);
+  return [...startsByReplay.values()].every((starts) => {
+    const start = starts[0];
+    if (boundaryTransitionError(start, stages, strict) !== undefined)
+      return false;
+    if (!requireActiveFingerprint || start.topology.boundary.invocationFingerprint !== undefined)
+      return true;
+    return stages.some((stage) => stage.replayKey === start.replayKey && stage.topology?.boundary?.event === "terminal" && stage.topology.boundary.status === "completed") && boundaryTransitionError(start, stages, true) === undefined;
+  });
 }
-function validStageGroup(drafts, runId, allowedNodeIds = new Set) {
+function validStageGroup(drafts, runId, rootRunId, tools = []) {
   if (drafts.some((draft) => draft.topology.stageId.length === 0))
     return false;
-  const stageIds = new Set(drafts.map((draft) => draft.topology.stageId));
-  if (stageIds.size !== drafts.length)
+  if (tools.some((tool) => tool.topology !== undefined && (tool.topology.version !== DURABLE_TOOL_TOPOLOGY_VERSION || tool.topology.nodeId.length === 0)))
     return false;
-  const ids = new Set([...allowedNodeIds, ...stageIds]);
-  if (ids.size !== allowedNodeIds.size + stageIds.size)
+  const stageIds = drafts.map((draft) => draft.topology.stageId);
+  const toolIds = tools.map((tool) => tool.topology?.nodeId ?? tool.checkpointId);
+  const ids = new Set([...stageIds, ...toolIds]);
+  if (ids.size !== stageIds.length + toolIds.length)
     return false;
   const orders = drafts.flatMap((draft) => draft.topology.sourceOrder === undefined ? [] : [draft.topology.sourceOrder]);
   if (new Set(orders).size !== orders.length)
     return false;
-  if (drafts.some((draft) => draft.topology.parentIds.some((parentId) => !ids.has(parentId))))
+  const parentEntries = [
+    ...drafts.map((draft) => [draft.topology.stageId, draft.topology.parentIds]),
+    ...tools.map((tool) => [tool.topology?.nodeId ?? tool.checkpointId, tool.topology?.parentIds ?? []])
+  ];
+  if (parentEntries.some(([, parentIds]) => parentIds.some((parentId) => !ids.has(parentId))))
     return false;
-  const runs = drafts.flatMap((draft) => draft.topology?.run === undefined ? [] : [draft.topology.run]);
+  const runs = [
+    ...drafts.flatMap((draft) => draft.topology?.run === undefined ? [] : [draft.topology.run]),
+    ...tools.flatMap((tool) => tool.topology?.run === undefined ? [] : [tool.topology.run])
+  ];
   const first = runs[0];
   if (runs.some((run) => run.runId !== runId || first !== undefined && (run.runName !== first.runName || run.parentRunId !== first.parentRunId || run.parentStageId !== first.parentStageId || run.rootRunId !== first.rootRunId)))
     return false;
-  const parents = new Map(drafts.map((draft) => [draft.topology.stageId, draft.topology.parentIds]));
+  if (runId === rootRunId && runs.some((run) => run.parentRunId !== undefined || run.parentStageId !== undefined || run.rootRunId !== undefined))
+    return false;
+  const parents = new Map(parentEntries);
   const visiting = new Set;
   const visited = new Set;
-  const cyclic = (stageId) => {
-    if (visiting.has(stageId))
+  const cyclic = (nodeId) => {
+    if (visiting.has(nodeId))
       return true;
-    if (visited.has(stageId))
+    if (visited.has(nodeId))
       return false;
-    visiting.add(stageId);
-    if ((parents.get(stageId) ?? []).some(cyclic))
+    visiting.add(nodeId);
+    if ((parents.get(nodeId) ?? []).some(cyclic))
       return true;
-    visiting.delete(stageId);
-    visited.add(stageId);
+    visiting.delete(nodeId);
+    visited.add(nodeId);
     return false;
   };
-  return ![...stageIds].some(cyclic);
+  return ![...ids].some(cyclic);
 }
 function compareDraftSourceOrder(left, right) {
   const leftOrder = left.topology?.sourceOrder;
@@ -64568,16 +64964,24 @@ function compareDraftSourceOrder(left, right) {
 function runTopologyFor(drafts, tools) {
   return drafts.find((draft) => draft.topology?.run !== undefined)?.topology?.run ?? tools.find((checkpoint) => checkpoint.topology?.run !== undefined)?.topology?.run;
 }
-function validateRunGroups(grouped, rootRunId, tools) {
+function validateRunGroups(grouped, rootRunId, tools, checkpoints) {
   const toolsFor = (runId) => tools.filter((checkpoint) => (checkpoint.topology?.run?.runId ?? rootRunId) === runId);
   const owners = new Map;
+  const syntheticChildIds = new Set;
   for (const [parentRunId, drafts] of grouped) {
     for (const draft of drafts) {
       const childRunId = childRunIdFromDraft(draft);
       if (childRunId === undefined)
         continue;
-      if (!grouped.has(childRunId) || childRunId === parentRunId || owners.has(childRunId))
+      if (childRunId === parentRunId || owners.has(childRunId))
         return false;
+      if (!grouped.has(childRunId)) {
+        if (!isSyntheticExitedChild(draft, parentRunId, childRunId, rootRunId) || childScopedEvidenceExists(checkpoints, draft.replayKey, childRunId))
+          return false;
+        syntheticChildIds.add(childRunId);
+        owners.set(childRunId, draft);
+        continue;
+      }
       const childRun = runTopologyFor(grouped.get(childRunId), toolsFor(childRunId));
       if (childRun?.parentRunId !== parentRunId || childRun.parentStageId !== draft.topology?.stageId || childRun.rootRunId !== undefined && childRun.rootRunId !== rootRunId)
         return false;
@@ -64589,6 +64993,8 @@ function validateRunGroups(grouped, rootRunId, tools) {
       return false;
   }
   for (const runId of owners.keys()) {
+    if (syntheticChildIds.has(runId))
+      continue;
     const seen = new Set;
     let current = runId;
     while (current !== undefined && current !== rootRunId) {
@@ -64602,6 +65008,18 @@ function validateRunGroups(grouped, rootRunId, tools) {
   }
   return true;
 }
+function isSyntheticExitedChild(draft, parentRunId, childRunId, rootRunId) {
+  const child = workflowChildFromDraft(draft);
+  const boundary = draft.topology?.boundary;
+  return child?.runId === childRunId && child.exited === true && boundary?.event === "terminal" && boundary.status === "completed" && boundary.child.runId === childRunId && boundary.child.parentRunId === parentRunId && boundary.child.parentStageId === draft.topology?.stageId && boundary.child.rootRunId === rootRunId;
+}
+function childScopedEvidenceExists(checkpoints, boundaryReplayKey, childRunId) {
+  const prefix = `${boundaryReplayKey}:`;
+  return checkpoints.some((checkpoint) => {
+    const lookupIdentity = checkpoint.kind === "tool" ? checkpoint.argsHash : checkpoint.kind === "ui" ? checkpoint.promptHash : checkpoint.replayKey;
+    return checkpoint.checkpointId.startsWith(prefix) || lookupIdentity.startsWith(prefix) || checkpoint.kind !== "ui" && checkpoint.topology?.run?.runId === childRunId;
+  });
+}
 function retainReachableRunGroups(grouped, rootRunId) {
   const reachable = new Set([rootRunId]);
   const pending = [rootRunId];
@@ -64699,15 +65117,17 @@ function valueOrExisting(key2, checkpoint, existing) {
 }
 function workflowChildFromDraft(draft) {
   const strict = parseWorkflowChildResult(draft.output);
-  const child = strict ?? (hasCurrentStageIdentity(draft) ? undefined : parseLegacyWorkflowChildResult(draft.output));
+  const legacy = hasCurrentStageIdentity(draft) ? undefined : parseLegacyWorkflowChildResult(draft.output);
+  const child = strict ?? legacy;
   if (child === undefined)
     return;
+  const exited = strict?.exited ?? false;
   return {
     alias: child.workflow,
     workflow: child.workflow,
     runId: child.runId,
     status: child.status,
-    ...child.exited !== undefined ? { exited: child.exited } : {},
+    exited,
     outputs: child.outputs,
     ...typeof child.exitReason === "string" ? { exitReason: child.exitReason } : {}
   };
@@ -65070,7 +65490,7 @@ function completedWorkflowRunSnapshots(backend, entry) {
   const checkpoints = backend.listCheckpoints(entry.workflowId);
   if (checkpoints.length === 0)
     return [];
-  const runs = runSnapshotsFromCheckpoints(checkpoints, handle.workflowId, handle.name, handle.updatedAt).map((run2) => ({ ...run2, stages: run2.stages.map(validatedStageTranscript) }));
+  const runs = runSnapshotsFromCheckpoints(checkpoints, handle.workflowId, handle.name, handle.updatedAt, COMPLETED_RECONSTRUCTION).map((run2) => ({ ...run2, stages: run2.stages.map(validatedStageTranscript) }));
   const rootIndex = runs.findIndex((run2) => run2.id === handle.workflowId);
   if (rootIndex < 0)
     return [];
@@ -65083,6 +65503,8 @@ function completedWorkflowRunSnapshots(backend, entry) {
     endedAt: handle.updatedAt,
     durationMs: rootDuration,
     ...handle.error !== undefined ? { error: handle.error } : {},
+    ...handle.exited !== undefined ? { exited: handle.exited } : {},
+    ...handle.exitReason !== undefined ? { exitReason: handle.exitReason } : {},
     ...handle.failureKind !== undefined ? { failureKind: handle.failureKind } : {},
     ...handle.failureCode !== undefined ? { failureCode: handle.failureCode } : {},
     ...handle.failureRecoverability !== undefined ? { failureRecoverability: handle.failureRecoverability } : {},
@@ -65092,11 +65514,45 @@ function completedWorkflowRunSnapshots(backend, entry) {
   };
   return [root, ...runs.filter((_, index) => index !== rootIndex)];
 }
+function durableWorkflowRunSnapshots(backend, handle) {
+  const checkpoints = backend.listCheckpoints(handle.workflowId);
+  if (checkpoints.length === 0) {
+    return [rootSnapshot(backend, handle, { stages: [], toolNodes: [] })];
+  }
+  const requiresTerminalTopology = handle.status === "completed" || handle.status === "failed";
+  const runs = runSnapshotsFromCheckpoints(checkpoints, handle.workflowId, handle.name, handle.updatedAt, requiresTerminalTopology ? COMPLETED_RECONSTRUCTION : ACTIVE_INSPECTION_RECONSTRUCTION);
+  const rootIndex = runs.findIndex((run2) => run2.id === handle.workflowId);
+  if (rootIndex < 0)
+    return [];
+  return [rootSnapshot(backend, handle, runs[rootIndex]), ...runs.filter((_, index) => index !== rootIndex)];
+}
+function rootSnapshot(backend, handle, graph) {
+  const terminal = handle.status === "completed" || handle.status === "failed" || handle.status === "cancelled";
+  const priorDurationMs = priorRunElapsedMs(backend, handle.workflowId);
+  const terminalDurationMs = priorDurationMs ?? Math.max(0, handle.updatedAt - handle.createdAt);
+  return {
+    id: handle.workflowId,
+    name: handle.name,
+    inputs: { ...handle.inputs },
+    status: handle.status,
+    stages: graph.stages,
+    toolNodes: graph.toolNodes,
+    startedAt: handle.createdAt,
+    ...terminal ? { endedAt: handle.updatedAt, durationMs: terminalDurationMs } : priorDurationMs === undefined ? {} : { accumulatedDurationMs: priorDurationMs },
+    ...handle.error !== undefined ? { error: handle.error } : {},
+    ...handle.failureKind !== undefined ? { failureKind: handle.failureKind } : {},
+    ...handle.failureCode !== undefined ? { failureCode: handle.failureCode } : {},
+    ...handle.failureRecoverability !== undefined ? { failureRecoverability: handle.failureRecoverability } : {},
+    ...handle.failureDisposition !== undefined ? { failureDisposition: handle.failureDisposition } : {},
+    ...handle.failedToolNodeId !== undefined ? { failedToolNodeId: handle.failedToolNodeId } : {},
+    resumable: isDurableWorkflowResumable(handle)
+  };
+}
 function durableNestedRunSnapshots(backend, rootWorkflowId) {
   const handle = backend.getWorkflow(rootWorkflowId);
   if (handle === undefined)
     return [];
-  return runSnapshotsFromCheckpoints(backend.listCheckpoints(rootWorkflowId), rootWorkflowId, handle.name, handle.updatedAt, false).filter((run2) => run2.id !== rootWorkflowId);
+  return runSnapshotsFromCheckpoints(backend.listCheckpoints(rootWorkflowId), rootWorkflowId, handle.name, handle.updatedAt, LEGACY_ACTIVE_RECONSTRUCTION).filter((run2) => run2.id !== rootWorkflowId);
 }
 function validatedStageTranscript(stage) {
   if (stage.sessionFile === undefined || isReopenableSessionTranscript(stage.sessionFile))
@@ -65166,15 +65622,36 @@ function summarizeCompletedToolResult(value2) {
     return flattenTruncatedString(String(value2).slice(0, 240));
   return serialized.length <= 240 ? serialized : `${flattenTruncatedString(serialized.slice(0, 237))}...`;
 }
-function runSnapshotsFromCheckpoints(checkpoints, rootRunId, rootRunName, fallbackCompletedAt, strict = true) {
-  if (!validBoundaryRecordSet(checkpoints, strict))
+var COMPLETED_RECONSTRUCTION = {
+  requireTerminal: true,
+  failClosed: true,
+  retainActive: false,
+  failOnUnreachable: false,
+  requireActiveBoundaryFingerprint: false
+};
+var ACTIVE_INSPECTION_RECONSTRUCTION = {
+  requireTerminal: false,
+  failClosed: true,
+  retainActive: true,
+  failOnUnreachable: true,
+  requireActiveBoundaryFingerprint: true
+};
+var LEGACY_ACTIVE_RECONSTRUCTION = {
+  requireTerminal: false,
+  failClosed: false,
+  retainActive: true,
+  failOnUnreachable: false,
+  requireActiveBoundaryFingerprint: false
+};
+function runSnapshotsFromCheckpoints(checkpoints, rootRunId, rootRunName, fallbackCompletedAt, policy = COMPLETED_RECONSTRUCTION) {
+  if (!validBoundaryRecordSet(checkpoints, policy.requireTerminal, policy.requireActiveBoundaryFingerprint))
     return [];
   const stageRecords = checkpoints.filter((checkpoint) => checkpoint.kind === "stage");
   const identityRecords = stageRecords.filter((stage) => stage.topology?.sourceOrder !== undefined || stage.topology?.status !== undefined || stage.topology?.occurrenceKey !== undefined || stage.topology?.boundary !== undefined);
   if (immutableStageGroupError(identityRecords) !== undefined)
     return [];
   const recordsByGroup = groupByDurableStageKey(stageRecords);
-  const candidates = [...recordsByGroup.values()].map((records) => mergeStageGroup(records, stageRecords, checkpoints)).filter((draft) => !strict || draft.topology?.run === undefined || draft.endedAt !== undefined || draft.output !== undefined).map((draft) => draft.topology !== undefined ? draft : {
+  const candidates = [...recordsByGroup.values()].map((records) => mergeStageGroup(records, stageRecords, checkpoints)).filter((draft) => policy.retainActive || draft.topology?.run === undefined || draft.endedAt !== undefined || draft.output !== undefined).map((draft) => draft.topology !== undefined ? draft : {
     ...draft,
     topology: {
       version: DURABLE_STAGE_TOPOLOGY_VERSION,
@@ -65185,13 +65662,36 @@ function runSnapshotsFromCheckpoints(checkpoints, rootRunId, rootRunName, fallba
   }).sort(compareDraftSourceOrder);
   const drafts = checkpointDrafts(checkpoints);
   const toolCheckpoints = drafts.tools;
+  if (policy.failClosed) {
+    for (const draft of candidates) {
+      const boundary = draft.topology?.boundary;
+      if (boundary === undefined || childRunIdFromDraft(draft) === undefined)
+        continue;
+      if (boundary.replayScope !== draft.replayKey)
+        return [];
+      const expectedChildRun = {
+        runId: boundary.child.runId,
+        runName: boundary.child.runName,
+        parentRunId: boundary.child.parentRunId,
+        parentStageId: boundary.child.parentStageId,
+        rootRunId: boundary.child.rootRunId
+      };
+      const childToolIds = new Set(toolCheckpoints.flatMap((checkpoint) => checkpoint.topology?.run?.runId === expectedChildRun.runId ? [checkpoint.topology.nodeId] : []));
+      if (directChildTopologyError(stageRecords, boundary.replayScope, expectedChildRun, true, childToolIds) !== undefined)
+        return [];
+    }
+  }
   if (candidates.length === 0 && toolCheckpoints.length === 0) {
-    return strict ? [] : [syntheticRun(rootRunId, rootRunName, checkpoints.length, fallbackCompletedAt)];
+    const supportedNonGraphState = checkpoints.every((checkpoint) => checkpoint.kind === "ui" || checkpoint.kind === "tool" && checkpoint.argsHash === RUN_TIMING_CHECKPOINT_NAME);
+    if (policy.failClosed && supportedNonGraphState) {
+      return [emptyGraphRun(rootRunId, rootRunName, fallbackCompletedAt)];
+    }
+    return policy.failClosed ? [] : [syntheticRun(rootRunId, rootRunName, checkpoints.length, fallbackCompletedAt)];
   }
   const grouped = new Map;
   for (const draft of candidates) {
     if (draft.topology?.version !== DURABLE_STAGE_TOPOLOGY_VERSION) {
-      if (strict)
+      if (policy.failClosed)
         return [];
       continue;
     }
@@ -65207,13 +65707,30 @@ function runSnapshotsFromCheckpoints(checkpoints, rootRunId, rootRunName, fallba
   }
   for (const group of grouped.values())
     group.sort(compareDraftSourceOrder);
+  const groupedCount = grouped.size;
   retainReachableRunGroups(grouped, rootRunId);
-  if (!validateRunGroups(grouped, rootRunId, toolCheckpoints))
+  if (policy.failOnUnreachable && grouped.size !== groupedCount)
+    return [];
+  if (!validateRunGroups(grouped, rootRunId, toolCheckpoints, checkpoints))
     return [];
+  const syntheticChildren = [];
+  for (const [parentRunId, runDrafts] of grouped) {
+    for (const draft of runDrafts) {
+      const child = workflowChildFromDraft(draft);
+      if (child?.exited !== true || grouped.has(child.runId))
+        continue;
+      if (!isSyntheticExitedChild(draft, parentRunId, child.runId, rootRunId) || childScopedEvidenceExists(checkpoints, draft.replayKey, child.runId)) {
+        if (policy.failClosed)
+          return [];
+        continue;
+      }
+      syntheticChildren.push({ parentRunId, owner: draft, child });
+    }
+  }
   const idMaps = new Map;
   for (const [runId, runDrafts] of grouped) {
-    const ownedToolIds = new Set(toolCheckpoints.flatMap((checkpoint) => (checkpoint.topology?.run?.runId ?? rootRunId) === runId ? [checkpoint.topology?.nodeId ?? checkpoint.checkpointId] : []));
-    if (!validStageGroup(runDrafts, runId, ownedToolIds))
+    const ownedTools = toolCheckpoints.filter((checkpoint) => (checkpoint.topology?.run?.runId ?? rootRunId) === runId);
+    if (!validStageGroup(runDrafts, runId, rootRunId, ownedTools))
       return [];
     const ids = new Map;
     let hasIdentityConflict = false;
@@ -65229,7 +65746,7 @@ function runSnapshotsFromCheckpoints(checkpoints, rootRunId, rootRunName, fallba
       }
     });
     if (hasIdentityConflict) {
-      if (strict)
+      if (policy.failClosed)
         return [];
       grouped.delete(runId);
       continue;
@@ -65243,12 +65760,13 @@ function runSnapshotsFromCheckpoints(checkpoints, rootRunId, rootRunName, fallba
     idMaps.set(runId, ids);
   }
   const runs = [];
+  const emittedRunIds = new Set;
   for (const [runId, runDrafts] of grouped) {
     const ids = idMaps.get(runId);
     const ownedTools = toolCheckpoints.filter((checkpoint) => (checkpoint.topology?.run?.runId ?? rootRunId) === runId);
     const hasUnknownParents = runDrafts.some((draft) => draft.topology.parentIds.some((parentId) => !ids.has(parentId))) || ownedTools.some((checkpoint) => checkpoint.topology?.parentIds.some((parentId) => !ids.has(parentId)) === true);
     if (hasUnknownParents) {
-      if (strict)
+      if (policy.failClosed)
         return [];
       continue;
     }
@@ -65258,23 +65776,66 @@ function runSnapshotsFromCheckpoints(checkpoints, rootRunId, rootRunName, fallba
     const startedAt = Math.min(...stages.map((stage) => stage.startedAt ?? fallbackCompletedAt), ...toolNodes.map((tool) => tool.startedAt ?? tool.endedAt ?? fallbackCompletedAt));
     const endedAt = Math.max(...stages.map((stage) => stage.endedAt ?? fallbackCompletedAt), ...toolNodes.map((tool) => tool.endedAt ?? fallbackCompletedAt));
     const owner = runId === rootRunId ? undefined : boundaryOwner(grouped, runId);
+    const status = owner === undefined ? "completed" : childRunStatus(owner);
+    const terminal = status !== "running" && status !== "pending" && status !== "paused" && status !== "blocked";
     const parentRunId = run2?.parentRunId ?? rootRunId;
     const boundarySourceId = grouped.get(parentRunId)?.find((draft) => childRunIdFromDraft(draft) === runId)?.topology?.stageId;
     const declaredParentStageId = run2?.parentStageId === undefined ? undefined : idMaps.get(parentRunId)?.get(run2.parentStageId);
     const parentStageId = declaredParentStageId ?? (boundarySourceId === undefined ? undefined : idMaps.get(parentRunId)?.get(boundarySourceId));
+    const ownerChild = owner === undefined ? undefined : workflowChildFromDraft(owner);
     runs.push({
       id: runId,
       name: run2?.runName ?? rootRunName,
       inputs: {},
-      status: owner === undefined ? "completed" : childRunStatus(owner),
+      status,
       stages,
       toolNodes,
       startedAt,
-      endedAt,
-      durationMs: Math.max(0, endedAt - startedAt),
+      ...terminal ? { endedAt, durationMs: Math.max(0, endedAt - startedAt) } : {},
       ...run2?.parentRunId !== undefined ? { parentRunId: run2.parentRunId } : {},
       ...parentStageId !== undefined ? { parentStageId } : {},
       ...run2?.rootRunId !== undefined ? { rootRunId: run2.rootRunId } : {},
+      ...ownerChild?.exited === true ? {
+        result: ownerChild.outputs,
+        exited: true,
+        ...ownerChild.exitReason !== undefined ? { exitReason: ownerChild.exitReason } : {}
+      } : {},
+      resumable: false
+    });
+    emittedRunIds.add(runId);
+  }
+  for (const { parentRunId, owner, child } of syntheticChildren) {
+    if (!emittedRunIds.has(parentRunId)) {
+      if (policy.failClosed)
+        return [];
+      continue;
+    }
+    const topology = owner.topology;
+    const boundary = topology.boundary;
+    const parentStageId = idMaps.get(parentRunId)?.get(topology.stageId);
+    if (parentStageId === undefined) {
+      if (policy.failClosed)
+        return [];
+      continue;
+    }
+    const startedAt = owner.startedAt ?? owner.firstCompletedAt;
+    const endedAt = owner.endedAt ?? owner.firstCompletedAt;
+    runs.push({
+      id: child.runId,
+      name: boundary.child.runName,
+      inputs: {},
+      status: child.status,
+      stages: [],
+      toolNodes: [],
+      startedAt,
+      endedAt,
+      durationMs: Math.max(0, endedAt - startedAt),
+      parentRunId,
+      parentStageId,
+      rootRunId: boundary.child.rootRunId,
+      result: child.outputs,
+      exited: true,
+      ...child.exitReason !== undefined ? { exitReason: child.exitReason } : {},
       resumable: false
     });
   }
@@ -65322,6 +65883,20 @@ function stageResult(draft) {
     return;
   return typeof draft.output === "string" ? draft.output : JSON.stringify(draft.output);
 }
+function emptyGraphRun(runId, runName, completedAt) {
+  return {
+    id: runId,
+    name: runName,
+    inputs: {},
+    status: "completed",
+    stages: [],
+    toolNodes: [],
+    startedAt: completedAt,
+    endedAt: completedAt,
+    durationMs: 0,
+    resumable: false
+  };
+}
 function syntheticRun(runId, runName, checkpointCount, completedAt) {
   return {
     id: runId,
@@ -65355,6 +65930,14 @@ function durableCompletedNestedRunSubtree(backend, rootWorkflowId, childRunId) {
   const nested = durableNestedRunSnapshots(backend, rootWorkflowId);
   if (!nested.some((run2) => run2.id === childRunId))
     return;
+  const intentionalExitStatuses = new Map;
+  for (const checkpoint of backend.listCheckpoints(rootWorkflowId)) {
+    if (checkpoint.kind !== "stage")
+      continue;
+    const child = parseWorkflowChildResult(checkpoint.output);
+    if (child?.exited === true)
+      intentionalExitStatuses.set(child.runId, child.status);
+  }
   const included = new Set([childRunId]);
   let priorSize = -1;
   while (priorSize !== included.size) {
@@ -65365,9 +65948,17 @@ function durableCompletedNestedRunSubtree(backend, rootWorkflowId, childRunId) {
     }
   }
   const subtree = nested.filter((run2) => included.has(run2.id));
-  const complete = subtree.length === included.size && subtree.every((run2) => run2.status === "completed" && run2.endedAt !== undefined && run2.stages.every((stage) => isTerminalStage2(stage.status) && stage.endedAt !== undefined));
+  const complete = subtree.length === included.size && subtree.every((run2) => isCompleteCachedRun(run2, intentionalExitStatuses));
   return complete ? subtree : undefined;
 }
+function isCompleteCachedRun(run2, intentionalExitStatuses) {
+  if (run2.endedAt === undefined || !run2.stages.every((stage) => isTerminalStage2(stage.status) && stage.endedAt !== undefined)) {
+    return false;
+  }
+  if (run2.status === "completed" || run2.exited === true)
+    return true;
+  return intentionalExitStatuses.get(run2.id) === run2.status;
+}
 function isTerminalStage2(status) {
   return status === "completed" || status === "failed" || status === "skipped";
 }
@@ -65509,6 +66100,8 @@ function createDurableCachedStageRecorder(input) {
 }
 function reconcileCachedDirectChildParentStage(input) {
   const existingRun = input.store.runs().find((run2) => run2.id === input.checkpointChildRunId);
+  if (existingRun === undefined)
+    return false;
   const runById = new Map(input.store.runs().map((run2) => [run2.id, run2]));
   const storedParentRun = runById.get(input.parentRun.id);
   if (storedParentRun !== undefined && (storedParentRun.parentRunId !== input.parentRun.parentRunId || storedParentRun.parentStageId !== input.parentRun.parentStageId))
@@ -65519,7 +66112,8 @@ function reconcileCachedDirectChildParentStage(input) {
   if (expectedRootRunId === undefined)
     return false;
   const storedBoundary = storedParentRun?.stages.find((stage) => stage.id === input.boundary.id);
-  if (!rootMatches(input.parentRun.rootRunId, expectedRootRunId) || !rootMatches(storedParentRun?.rootRunId, expectedRootRunId) || authoritativeWorkflowChildRunId(input.boundary) !== input.checkpointChildRunId || storedParentRun !== undefined && authoritativeWorkflowChildRunId(storedBoundary) !== input.checkpointChildRunId || input.catalogRun.id !== input.checkpointChildRunId || existingRun?.status !== "completed" || input.catalogRun.status !== "completed" || existingRun.parentRunId !== input.parentRun.id || input.catalogRun.parentRunId !== input.parentRun.id || input.catalogRun.parentStageId === undefined || existingRun.parentStageId !== input.catalogRun.parentStageId || !rootMatches(existingRun.rootRunId, expectedRootRunId) || !rootMatches(input.catalogRun.rootRunId, expectedRootRunId))
+  const cachedChildStatusMatches = existingRun?.status === "completed" && input.catalogRun.status === "completed" || input.boundary.workflowChild?.exited === true && input.boundary.workflowChild.runId === input.checkpointChildRunId && existingRun?.status === input.catalogRun.status && input.boundary.workflowChild.status === input.catalogRun.status;
+  if (!rootMatches(input.parentRun.rootRunId, expectedRootRunId) || !rootMatches(storedParentRun?.rootRunId, expectedRootRunId) || authoritativeWorkflowChildRunId(input.boundary) !== input.checkpointChildRunId || storedParentRun !== undefined && authoritativeWorkflowChildRunId(storedBoundary) !== input.checkpointChildRunId || input.catalogRun.id !== input.checkpointChildRunId || !cachedChildStatusMatches || existingRun.parentRunId !== input.parentRun.id || input.catalogRun.parentRunId !== input.parentRun.id || input.catalogRun.parentStageId === undefined || existingRun.parentStageId !== input.catalogRun.parentStageId || !rootMatches(existingRun.rootRunId, expectedRootRunId) || !rootMatches(input.catalogRun.rootRunId, expectedRootRunId))
     return false;
   return input.store.reconcileRunParentStage(existingRun.id, input.catalogRun.parentStageId, input.boundary.id);
 }
@@ -65873,11 +66467,12 @@ function createTrackedToolPrimitive(input) {
 
 // dist/builtin/workflows/src/runs/foreground/executor-child-boundary.ts
 function workflowChildResultFromReplay(snapshot) {
+  const exited = snapshot.exited ?? (snapshot.status === "completed" ? false : undefined);
   const candidate = {
     workflow: snapshot.workflow,
     runId: snapshot.runId,
     status: snapshot.status,
-    exited: snapshot.exited,
+    exited,
     outputs: cloneWorkflowChildValue(snapshot.outputs),
     ...snapshot.exitReason !== undefined ? { exitReason: snapshot.exitReason } : {}
   };
@@ -66185,7 +66780,7 @@ function createTrackedStageCaller(input) {
       if (suppressQueuedContinuation)
         runtime.state.suppressQueuedUserMessageContinuation = true;
       try {
-        result = await raceAbort(runtime.innerCtx.prompt(RESUME_CONTINUATION_PROMPT), runtime.signal);
+        result = await runtime.raceStageSessionHeartbeat(raceAbort(runtime.innerCtx.prompt(RESUME_CONTINUATION_PROMPT), runtime.signal));
       } finally {
         if (suppressQueuedContinuation)
           runtime.state.suppressQueuedUserMessageContinuation = false;
@@ -66212,46 +66807,51 @@ function createTrackedStageCaller(input) {
       throw err;
     }
     const trackStageLifecycle = !runtime.state.stageFinalized;
-    let refreshedParentIds;
-    if (trackStageLifecycle && !input.hasContinuation && runtime.stageSnapshot.startedAt === undefined && !input.hasScopedParents) {
-      const actualParentIds = runtime.scheduler.tracker.currentParents();
-      const sameParents = actualParentIds.length === runtime.stageSnapshot.parentIds.length && actualParentIds.every((value2) => runtime.stageSnapshot.parentIds.includes(value2));
-      if (!sameParents) {
-        runtime.scheduler.tracker.replaceParents(runtime.stageId, actualParentIds);
-        refreshedParentIds = actualParentIds;
-      }
-    }
-    if (trackStageLifecycle) {
-      const now = Date.now();
-      const hasNoExplicitModelConfig = input.options?.model === undefined && input.options?.fallbackModels === undefined;
-      const promptAdapterHandlesInitialPrompt = input.adapters.prompt !== undefined;
-      if (callOptions.eagerSession && !promptAdapterHandlesInitialPrompt && (hasNoExplicitModelConfig || await hasExplicitFastModeCandidate({
-        model: input.options?.model,
-        fallbackModels: input.options?.fallbackModels,
-        models: runtime.opts.models
-      }))) {
-        try {
-          await runtime.innerCtx.__ensureSession();
-          runtime.captureStageSessionMeta();
-        } catch (err) {
-          if (!(err instanceof Error && err.message.includes("prompt adapter not configured")))
-            throw err;
+    let applyTerminalStageState;
+    let terminalStateIsSuccess = false;
+    try {
+      let refreshedParentIds;
+      if (trackStageLifecycle && !input.hasContinuation && runtime.stageSnapshot.startedAt === undefined && !input.hasScopedParents) {
+        const actualParentIds = runtime.scheduler.tracker.currentParents();
+        const sameParents = actualParentIds.length === runtime.stageSnapshot.parentIds.length && actualParentIds.every((value2) => runtime.stageSnapshot.parentIds.includes(value2));
+        if (!sameParents) {
+          runtime.scheduler.tracker.replaceParents(runtime.stageId, actualParentIds);
+          refreshedParentIds = actualParentIds;
         }
       }
-      if (refreshedParentIds !== undefined) {
-        runtime.scheduler.setStageParentIds(runtime.stageSnapshot, refreshedParentIds);
+      if (trackStageLifecycle) {
+        const now = Date.now();
+        const hasNoExplicitModelConfig = input.options?.model === undefined && input.options?.fallbackModels === undefined;
+        const promptAdapterHandlesInitialPrompt = input.adapters.prompt !== undefined;
+        if (callOptions.eagerSession && !promptAdapterHandlesInitialPrompt && (hasNoExplicitModelConfig || await hasExplicitFastModeCandidate({
+          model: input.options?.model,
+          fallbackModels: input.options?.fallbackModels,
+          models: runtime.opts.models
+        }))) {
+          try {
+            await runtime.innerCtx.__ensureSession();
+          } catch (err) {
+            if (!(err instanceof Error && err.message.includes("prompt adapter not configured")))
+              throw err;
+          }
+        }
+        if (refreshedParentIds !== undefined) {
+          runtime.scheduler.setStageParentIds(runtime.stageSnapshot, refreshedParentIds);
+        }
+        runtime.stageSnapshot.status = "running";
+        runtime.stageSnapshot.startedAt ??= rebasedStageStartedAt(input.options?.durableAccumulatedDurationMs, now);
+        runtime.applyModelFallbackMeta(runtime.innerCtx.__modelFallbackMeta());
+        runtime.activeStore.recordStageStart(runtime.runId, runtime.stageSnapshot);
+        runtime.appendStageStartOnce();
+        const sessionMeta = runtime.innerCtx.__sessionMeta();
+        if (sessionMeta.sessionId !== undefined || sessionMeta.sessionFile !== undefined) {
+          await runtime.captureStageSessionMeta({ awaitDurable: true });
+        }
+        runtime.startStageSessionHeartbeat();
+      } else {
+        runtime.applyModelFallbackMeta(runtime.innerCtx.__modelFallbackMeta());
       }
-      runtime.stageSnapshot.status = "running";
-      runtime.stageSnapshot.startedAt ??= rebasedStageStartedAt(input.options?.durableAccumulatedDurationMs, now);
-      runtime.applyModelFallbackMeta(runtime.innerCtx.__modelFallbackMeta());
-      runtime.activeStore.recordStageStart(runtime.runId, runtime.stageSnapshot);
-      runtime.appendStageStartOnce();
-    } else {
-      runtime.applyModelFallbackMeta(runtime.innerCtx.__modelFallbackMeta());
-    }
-    runtime.mcpScope.apply();
-    let applyTerminalStageState;
-    try {
+      runtime.mcpScope.apply();
       const abortSession = () => {
         runtime.innerCtx.abort().catch(() => {});
       };
@@ -66263,7 +66863,7 @@ function createTrackedStageCaller(input) {
       try {
         runtime.state.askUserQuestionObservedThisTurn = false;
         runtime.state.chatAnswerObservedThisTurn = false;
-        result = await raceAbort(call(), runtime.signal);
+        result = await runtime.raceStageSessionHeartbeat(raceAbort(call(), runtime.signal));
         const initialDrain = await drainResumeContinuations(result);
         result = initialDrain.result;
         let repeatReadinessAfterChatTurn = initialDrain.chatAnswerObserved;
@@ -66287,10 +66887,10 @@ function createTrackedStageCaller(input) {
               runtime.state.chatAnswerObservedThisTurn = false;
               runtime.state.waitingForStageChatTurn = true;
               try {
-                await raceAbort(new Promise((resolve12) => {
+                await runtime.raceStageSessionHeartbeat(raceAbort(new Promise((resolve12) => {
                   resolveNextTurnEnd = resolve12;
                   runtime.state.wakeWaitingForStageChatTurn = resolve12;
-                }), runtime.signal);
+                }), runtime.signal));
               } finally {
                 runtime.state.wakeWaitingForStageChatTurn = undefined;
                 runtime.state.waitingForStageChatTurn = false;
@@ -66314,7 +66914,7 @@ function createTrackedStageCaller(input) {
         runtime.signal.removeEventListener("abort", abortSession);
       }
       await runtime.innerCtx.__closeGeneration();
-      runtime.captureStageSessionMeta();
+      await runtime.captureStageSessionMeta({ awaitDurable: true });
       runtime.applyModelFallbackMeta(runtime.innerCtx.__modelFallbackMeta());
       if (trackStageLifecycle && runtime.stageFailFastScope?.failed === true && runtime.stageFailFastScope.activeStages.has(runtime.stageId)) {
         runtime.markSkippedForParallelFailFast();
@@ -66324,6 +66924,7 @@ function createTrackedStageCaller(input) {
         throw runtime.parallelFailFastError();
       if (trackStageLifecycle) {
         const assistantText = runtime.innerCtx.__getLastAssistantText();
+        terminalStateIsSuccess = true;
         applyTerminalStageState = () => {
           runtime.stageSnapshot.status = "completed";
           if (assistantText !== undefined)
@@ -66348,15 +66949,30 @@ function createTrackedStageCaller(input) {
       }
       throw err;
     } finally {
-      runtime.mcpScope.clear();
       let finalizationError;
+      let durableCheckpointError;
       try {
-        await runtime.innerCtx.__closeGeneration();
-        runtime.captureStageSessionMeta();
+        runtime.mcpScope.clear();
       } catch (err) {
         finalizationError = { thrown: true, error: err };
       }
+      try {
+        await runtime.drainStageSessionHeartbeat();
+      } catch (err) {
+        durableCheckpointError = { thrown: true, error: err };
+      }
+      try {
+        await runtime.innerCtx.__closeGeneration();
+        await runtime.captureStageSessionMeta({ awaitDurable: true });
+      } catch (err) {
+        durableCheckpointError ??= { thrown: true, error: err };
+      }
+      finalizationError ??= durableCheckpointError;
       if (trackStageLifecycle) {
+        if (durableCheckpointError !== undefined && terminalStateIsSuccess) {
+          const failure3 = runtime.classifyExecutorFailure(durableCheckpointError.error);
+          applyTerminalStageState = () => applyFailureToStage(runtime.stageSnapshot, failure3);
+        }
         if (!runtime.state.stageFinalized)
           applyTerminalStageState?.();
         try {
@@ -66593,7 +67209,7 @@ function createStageControlHandle(runtime) {
     if (sessionFile === undefined)
       return;
     await runtime.innerCtx.__ensureSessionFromFile(sessionFile);
-    runtime.captureStageSessionMeta();
+    await runtime.captureStageSessionMeta({ awaitDurable: true });
   };
   const toolExecutions = new StageToolExecutionBuffer;
   const queuedUserMessages = new StageQueuedUserMessageBuffer;
@@ -66637,7 +67253,7 @@ function createStageControlHandle(runtime) {
       await ensureMessagingSession();
       await runtime.innerCtx.__ensureSession();
       runtime.throwIfStageMutationBlocked();
-      runtime.captureStageSessionMeta();
+      await runtime.captureStageSessionMeta({ awaitDurable: true });
     },
     async sendUserMessage(text, options, beforeDelivery) {
       runtime.throwIfStageMutationBlocked();
@@ -67795,6 +68411,28 @@ function terminatingToolCallId(event) {
 }
 
 // dist/builtin/workflows/src/runs/foreground/stage-runner-controller.ts
+function hasMeaningfulUsage(usage) {
+  if (usage === undefined)
+    return false;
+  const values = [usage.input, usage.output, usage.cacheRead, usage.cacheWrite, usage.totalTokens, usage.cost.total];
+  return values.every((value2) => Number.isFinite(value2) && value2 >= 0) && values.some((value2) => value2 > 0);
+}
+function usageForAttempt(messages, start, discarded) {
+  const totals = { ...discarded };
+  let meaningful = totals.turns > 0;
+  for (const message of messages.slice(start)) {
+    if (message.role !== "assistant" || !hasMeaningfulUsage(message.usage))
+      continue;
+    totals.input += message.usage.input;
+    totals.output += message.usage.output;
+    totals.cacheRead += message.usage.cacheRead;
+    totals.cacheWrite += message.usage.cacheWrite;
+    totals.cost += message.usage.cost.total;
+    totals.turns += 1;
+    meaningful = true;
+  }
+  return meaningful ? totals : undefined;
+}
 function isSessionCreationPauseResult(value2) {
   return "kind" in value2 && value2.kind === "paused";
 }
@@ -67857,6 +68495,15 @@ class StageSessionController {
   sessionPromise;
   reattachSessionFile;
   lastPromptStartIndex;
+  attemptUsageStartIndex;
+  discardedAttemptUsage = {
+    input: 0,
+    output: 0,
+    cacheRead: 0,
+    cacheWrite: 0,
+    cost: 0,
+    turns: 0
+  };
   terminatingToolCallIds = new Set;
   latestStructuredOutputToolErrorValue;
   unsubscribeTerminateWatcher;
@@ -68056,6 +68703,7 @@ class StageSessionController {
         this.activeCandidateIndex = index;
         this.selectedModel = candidate.id;
         this.notifyModelFallbackMetaChange();
+        this.beginAttemptUsage(activeSession);
         const { terminalScanStartIndex } = await this.promptWithThrownErrorRetry(activeSession, promptText, sdkOptions);
         const terminalFailure = latestTerminalAssistantFailureSince(activeSession.messages, terminalScanStartIndex);
         if (terminalFailure !== undefined) {
@@ -68194,9 +68842,38 @@ class StageSessionController {
     }
     return;
   }
+  beginAttemptUsage(session) {
+    this.attemptUsageStartIndex = session.messages.length;
+    this.discardedAttemptUsage = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0 };
+  }
+  takeAttemptUsage(session) {
+    const start = this.attemptUsageStartIndex;
+    const usage = session === undefined || start === undefined ? undefined : usageForAttempt(session.messages, start, this.discardedAttemptUsage);
+    this.clearAttemptUsage();
+    return usage;
+  }
+  clearAttemptUsage() {
+    this.attemptUsageStartIndex = undefined;
+    this.discardedAttemptUsage = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0 };
+  }
+  accrueDiscardedAttemptUsage(message) {
+    if (!hasMeaningfulUsage(message.usage))
+      return;
+    this.discardedAttemptUsage.input += message.usage.input;
+    this.discardedAttemptUsage.output += message.usage.output;
+    this.discardedAttemptUsage.cacheRead += message.usage.cacheRead;
+    this.discardedAttemptUsage.cacheWrite += message.usage.cacheWrite;
+    this.discardedAttemptUsage.cost += message.usage.cost.total;
+    this.discardedAttemptUsage.turns += 1;
+  }
   restoreSessionMessages(session, snapshot, promptText, keepPrompt) {
     const snapshotMessages = new Set(snapshot);
     const admitted = session.messages.filter((message) => !snapshotMessages.has(message));
+    for (const message of admitted) {
+      if (message.role !== "assistant" || message.stopReason !== "error")
+        continue;
+      this.accrueDiscardedAttemptUsage(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) => {
@@ -68545,7 +69222,11 @@ class StageSessionController {
         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));
+    const session = attachCreatedStageSession(created, this.disposed, this.opts.stageName, (result) => this.attachSession(result));
+    if (session instanceof Promise)
+      return await session;
+    await this.opts.onSessionReady?.();
+    return session;
   }
   attachSession(created) {
     const result = normalizeSessionCreateResult(created);
@@ -68653,11 +69334,17 @@ class StageSessionController {
     const resumedSession = this.session;
     const resumedLabel = this.selectedModel ?? workflowModelId(resumedSession.model) ?? candidates[0].id;
     this.notifyModelFallbackMetaChange();
+    this.beginAttemptUsage(resumedSession);
     try {
       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 });
+        const usage = this.takeAttemptUsage(resumedSession);
+        this.modelAttempts.push({
+          model: resumedLabel,
+          success: true,
+          ...usage === undefined ? {} : { usage }
+        });
         this.pendingFallbackWarnings.length = 0;
         this.resumeCurrentSession = true;
         return true;
@@ -68665,13 +69352,24 @@ class StageSessionController {
       throw new WorkflowPromptModelFailure(terminalFailure);
     } catch (err) {
       if (this.capturedStructuredOutputForAttempt() && isRetryableModelFailure(err)) {
-        this.modelAttempts.push({ model: resumedLabel, success: true });
+        const usage2 = this.takeAttemptUsage(resumedSession);
+        this.modelAttempts.push({
+          model: resumedLabel,
+          success: true,
+          ...usage2 === undefined ? {} : { usage: usage2 }
+        });
         this.pendingFallbackWarnings.length = 0;
         this.resumeCurrentSession = true;
         return true;
       }
       const message = errorMessage3(err);
-      this.modelAttempts.push({ model: resumedLabel, success: false, error: message });
+      const usage = this.takeAttemptUsage(resumedSession);
+      this.modelAttempts.push({
+        model: resumedLabel,
+        success: false,
+        ...usage === undefined ? {} : { usage },
+        error: message
+      });
       if (this.opts.signal?.aborted || !isRetryableModelFailure(err)) {
         this.modelWarnings.push(...this.pendingFallbackWarnings);
         this.pendingFallbackWarnings.length = 0;
@@ -68697,10 +69395,12 @@ class StageSessionController {
       this.recordSuccessfulAttempt(candidate);
       return "handled";
     }
+    const usage = this.takeAttemptUsage(this.session);
     this.modelAttempts.push({
       model: candidate.id,
       success: false,
       ...modelAttemptReasoning(candidate, this.effectiveStageOptions?.thinkingLevel),
+      ...usage === undefined ? {} : { usage },
       error: message
     });
     if (this.opts.signal?.aborted || !isRetryableModelFailure(err) || index === candidates.length - 1) {
@@ -68718,10 +69418,12 @@ class StageSessionController {
     return this.structuredOutputCapture?.called === true && this.opts.signal?.aborted !== true;
   }
   recordSuccessfulAttempt(candidate) {
+    const usage = this.takeAttemptUsage(this.session);
     this.modelAttempts.push({
       model: candidate.id,
       success: true,
-      ...modelAttemptReasoning(candidate, this.effectiveStageOptions?.thinkingLevel)
+      ...modelAttemptReasoning(candidate, this.effectiveStageOptions?.thinkingLevel),
+      ...usage === undefined ? {} : { usage }
     });
     this.pendingFallbackWarnings.length = 0;
     this.resumeCurrentSession = true;
@@ -69158,6 +69860,81 @@ function createStageContext2(opts) {
     }
   };
 }
+// dist/builtin/workflows/src/runs/foreground/stage-session-heartbeat.ts
+var STAGE_SESSION_HEARTBEAT_INTERVAL_MS = 30000;
+function createStageSessionHeartbeat(checkpoint, intervalMs = STAGE_SESSION_HEARTBEAT_INTERVAL_MS) {
+  let active2 = false;
+  let timer;
+  let generation = 0;
+  let nextDeadline = 0;
+  let failure3;
+  let inFlight;
+  let rejectFailure;
+  const failureSignal = new Promise((_resolve, reject) => {
+    rejectFailure = reject;
+  });
+  failureSignal.catch(() => {
+    return;
+  });
+  const stopScheduling = () => {
+    active2 = false;
+    generation += 1;
+    if (timer !== undefined)
+      clearTimeout(timer);
+    timer = undefined;
+  };
+  const fail = (error) => {
+    if (failure3 !== undefined)
+      return;
+    failure3 = error;
+    stopScheduling();
+    rejectFailure(error);
+  };
+  const schedule = (scheduledGeneration) => {
+    if (!active2 || failure3 !== undefined || scheduledGeneration !== generation)
+      return;
+    const delayMs = Math.max(0, nextDeadline - Date.now());
+    timer = setTimeout(() => {
+      timer = undefined;
+      const startedAt = Date.now();
+      do
+        nextDeadline += intervalMs;
+      while (nextDeadline <= startedAt);
+      const running = checkpoint().catch(fail).finally(() => {
+        if (inFlight === running)
+          inFlight = undefined;
+        schedule(scheduledGeneration);
+      });
+      inFlight = running;
+    }, delayMs);
+    timer.unref?.();
+  };
+  const drain = async () => {
+    stopScheduling();
+    await inFlight;
+    if (failure3 !== undefined)
+      throw failure3;
+  };
+  return {
+    start() {
+      if (active2 || failure3 !== undefined)
+        return;
+      active2 = true;
+      generation += 1;
+      nextDeadline = Date.now() + intervalMs;
+      schedule(generation);
+    },
+    stop: stopScheduling,
+    drain,
+    fail,
+    race(work) {
+      if (failure3 !== undefined)
+        return Promise.reject(failure3);
+      return Promise.race([work, failureSignal]);
+    }
+  };
+}
+
 // dist/builtin/workflows/src/runs/foreground/executor-stage-factory.ts
 function createWorkflowStageFactory(input) {
   return (name, options, stageFailFastScope) => {
@@ -69238,6 +70015,15 @@ function createWorkflowStageFactory(input) {
       if (meta2.modelAttempts !== undefined)
         stageSnapshot.modelAttempts = meta2.modelAttempts;
     };
+    let runtime;
+    const stageSessionHeartbeat = createStageSessionHeartbeat(async () => {
+      try {
+        await runtime.captureStageSessionMeta({ awaitDurable: true });
+      } catch (error) {
+        await runtime.innerCtx.abort().catch(() => {});
+        throw error;
+      }
+    });
     const innerCtx = createStageContext2({
       stageId,
       stageName: name,
@@ -69253,6 +70039,12 @@ function createWorkflowStageFactory(input) {
         applyModelFallbackMeta(meta2);
         if (stageSnapshot.status === "running")
           input.activeStore.recordStageStart(input.runId, stageSnapshot);
+      },
+      async onSessionReady() {
+        if (stageSnapshot.status !== "running")
+          return;
+        await runtime.captureStageSessionMeta({ awaitDurable: true });
+        runtime.startStageSessionHeartbeat();
       }
     });
     const state2 = {
@@ -69315,8 +70107,7 @@ function createWorkflowStageFactory(input) {
       stageUiBroker.clearStagePrompt(input.runId, stageId);
       await innerCtx.__dispose();
     };
-    let runtime;
-    const captureStageSessionMeta = (checkpointOptions) => {
+    const captureStageSessionMeta = async (checkpointOptions) => {
       const meta2 = innerCtx.__sessionMeta();
       if (meta2.sessionId !== undefined)
         stageSnapshot.sessionId = meta2.sessionId;
@@ -69325,15 +70116,17 @@ function createWorkflowStageFactory(input) {
       if (meta2.sessionId !== undefined || meta2.sessionFile !== undefined)
         input.activeStore.recordStageSession(input.runId, stageId, meta2);
       const pending = input.opts.onStageSession?.(input.runId, stageSnapshot, checkpointOptions);
-      if (checkpointOptions?.forceDurable === true)
-        return pending;
+      if (checkpointOptions?.forceDurable === true || checkpointOptions?.awaitDurable === true) {
+        await pending;
+        return;
+      }
       Promise.resolve(pending).catch(() => {});
-      return;
     };
     const releaseLiveHandle = async () => {
       if (state2.liveHandleReleased)
         return;
       state2.liveHandleReleased = true;
+      stageSessionHeartbeat.stop();
       runtime.dropStageControlHandle();
       runtime.unregisterStageHandle();
       await disposeInnerContext();
@@ -69366,6 +70159,7 @@ function createWorkflowStageFactory(input) {
       });
     };
     const finalizeStageSnapshot = async () => {
+      stageSessionHeartbeat.stop();
       if (state2.stageFinalized)
         return false;
       if (stageSnapshot.endedAt !== undefined && isTerminalStage(stageSnapshot)) {
@@ -69438,6 +70232,9 @@ function createWorkflowStageFactory(input) {
       dropStageControlHandle: () => {},
       unregisterWorkflowExitCleanup: () => {},
       captureStageSessionMeta,
+      startStageSessionHeartbeat: stageSessionHeartbeat.start,
+      drainStageSessionHeartbeat: stageSessionHeartbeat.drain,
+      raceStageSessionHeartbeat: stageSessionHeartbeat.race,
       applyModelFallbackMeta,
       appendStageStartOnce,
       finalizeStageSnapshot,
@@ -69590,9 +70387,22 @@ class EngineRuntime {
       apply: () => {
         if (!this.childRunOptions.mcp || !hasScope)
           return;
-        if (depth === 0)
+        if (depth > 0) {
+          depth += 1;
+          return;
+        }
+        depth = 1;
+        try {
           this.childRunOptions.mcp.setScope(stageId, allow, deny);
-        depth += 1;
+        } catch (error) {
+          depth = 0;
+          try {
+            this.childRunOptions.mcp.clearScope(stageId);
+          } catch (cleanupError) {
+            throw new AggregateError([error, cleanupError], "MCP scope setup failed and compensating cleanup failed");
+          }
+          throw error;
+        }
       },
       clear: () => {
         if (!this.childRunOptions.mcp || !hasScope)
@@ -70935,6 +71745,72 @@ function disposeCompletedChatHandle(handle) {
   });
 }
 
+// dist/builtin/workflows/src/durable/targeted-inspection.ts
+async function inspectTargetedDurableWorkflow(backend, workflowId, now = Date.now()) {
+  const hydrated = backend.hydrateWorkflowForInspection ? await backend.hydrateWorkflowForInspection(workflowId) : await hydrateWithoutClassification(backend, workflowId);
+  if (hydrated.kind !== "current")
+    return hydrationFailure(workflowId, hydrated.kind);
+  const handle = hydrated.handle;
+  if (handle.rootWorkflowId !== undefined && handle.rootWorkflowId !== handle.workflowId) {
+    return malformed(workflowId, "the requested id belongs to a nested workflow rather than a durable root");
+  }
+  const reconstructed = durableWorkflowRunSnapshots(backend, handle);
+  if (reconstructed.length === 0)
+    return malformed(workflowId, "durable checkpoint topology is malformed or incomplete");
+  const runs = structuredClone(reconstructed);
+  const inspectionStore = createStore();
+  for (const run2 of runs)
+    inspectionStore.recordRunStart(structuredClone(run2));
+  const inspected = inspectRun(workflowId, { store: inspectionStore });
+  if (!inspected.ok)
+    return malformed(workflowId, "the durable checkpoint graph has no reciprocal root");
+  const foreignLive = isForeignLiveWorkflow(handle, getAtomicExecutorId(), now);
+  const live = isLiveRunningWorkflow(handle, now);
+  const crashed = handle.status === "running" && !live;
+  const resumeGuidance = crashed ? inspected.detail.resumable === true ? `This workflow appears to have crashed and is resumable. Resume it explicitly with /workflow resume ${workflowId}.` : "This workflow appears to have crashed, but its retained state is not resumable." : foreignLive ? "This workflow is actively running in another Atomic session. Inspect it here, but control it from its owner session." : live ? "This workflow still has a fresh durable heartbeat. Inspect it here without starting another executor." : terminalGuidance(handle.status, workflowId, inspected.detail.resumable === true);
+  return {
+    kind: "found",
+    runs,
+    store: inspectionStore,
+    detail: {
+      ...inspected.detail,
+      ...crashed ? { status: "crashed" } : {},
+      ...live ? { resumable: false } : {},
+      ...foreignLive ? { ownerActiveElsewhere: true } : {},
+      resumeGuidance
+    }
+  };
+}
+function terminalGuidance(status, workflowId, resumable) {
+  if (resumable)
+    return `This retained workflow is ${status} and resumable. Resume it explicitly with /workflow resume ${workflowId}.`;
+  return `This retained workflow is ${status} and available for read-only inspection.`;
+}
+async function hydrateWithoutClassification(backend, workflowId) {
+  await backend.hydrateWorkflow(workflowId);
+  const handle = backend.getLoadableWorkflow(workflowId);
+  return handle === undefined ? { kind: "absent" } : { kind: "current", handle };
+}
+function hydrationFailure(workflowId, kind) {
+  switch (kind) {
+    case "absent":
+      return {
+        kind,
+        message: `Run not found: ${workflowId} (not present in the current session or durable store).`
+      };
+    case "deleted":
+      return { kind, message: `Durable workflow was deleted: ${workflowId}` };
+    case "malformed":
+      return malformed(workflowId, "current DBOS metadata or checkpoints are malformed");
+  }
+}
+function malformed(workflowId, reason) {
+  return {
+    kind: "malformed",
+    message: `Durable workflow ${workflowId} cannot be inspected safely: ${reason}.`
+  };
+}
+
 // dist/builtin/workflows/src/extension/runtime-durable-resume.ts
 function createDurableResumeRuntime(deps) {
   const hydrateStoredWorkflowCandidates = async (backend, target) => {
@@ -70944,6 +71820,10 @@ function createDurableResumeRuntime(deps) {
   };
   let preparedCatalog = [];
   return {
+    async inspectDurableWorkflow(workflowId) {
+      await deps.ensureReady();
+      return await inspectTargetedDurableWorkflow(getDurableBackend(), workflowId);
+    },
     async resumeDurableWorkflow(workflowId, options) {
       await deps.ensureReady();
       const backend = getDurableBackend();
@@ -71387,6 +72267,7 @@ function workflowModelCatalogFromContext(ctx) {
 }
 
 // dist/builtin/workflows/src/extension/mcp.ts
+import { isStaleExtensionContextError as isStaleExtensionContextError5 } from "@bastani/atomic";
 function setMcpScope(pi, opts) {
   if (!pi.events)
     return;
@@ -71395,7 +72276,12 @@ function setMcpScope(pi, opts) {
     allow: opts.allow ?? null,
     deny: opts.deny ?? null
   };
-  pi.events.emit("mcp.scope.set", payload);
+  try {
+    pi.events.emit("mcp.scope.set", payload);
+  } catch (error) {
+    if (!isStaleExtensionContextError5(error))
+      throw error;
+  }
 }
 function clearMcpScope(pi, stageId) {
   if (!pi.events)
@@ -71405,7 +72291,12 @@ function clearMcpScope(pi, stageId) {
     allow: null,
     deny: null
   };
-  pi.events.emit("mcp.scope.set", payload);
+  try {
+    pi.events.emit("mcp.scope.set", payload);
+  } catch (error) {
+    if (!isStaleExtensionContextError5(error))
+      throw error;
+  }
 }
 
 // dist/builtin/workflows/src/extension/workflow-ports.ts
@@ -71433,14 +72324,18 @@ function makeMcpPort(pi) {
   };
   return {
     setScope(stageId, allow, deny) {
-      setMcpScope(piForMcp, {
-        stageId,
-        allow: allow ?? undefined,
-        deny: deny ?? undefined
-      });
+      try {
+        setMcpScope(piForMcp, {
+          stageId,
+          allow: allow ?? undefined,
+          deny: deny ?? undefined
+        });
+      } catch {}
     },
     clearScope(stageId) {
-      clearMcpScope(piForMcp, stageId);
+      try {
+        clearMcpScope(piForMcp, stageId);
+      } catch {}
     }
   };
 }
@@ -71603,6 +72498,9 @@ function createWorkflowExtensionRuntimeState(pi, adapters, resolveCwd = () => pi
     resumeDurableWorkflow(workflowId, options) {
       return runtimeRef.current.resumeDurableWorkflow(workflowId, options);
     },
+    inspectDurableWorkflow(workflowId) {
+      return runtimeRef.current.inspectDurableWorkflow(workflowId);
+    },
     listDurableResumable() {
       return runtimeRef.current.listDurableResumable();
     },
@@ -71919,11 +72817,16 @@ function renderRunSummary(payload) {
   return `${icon} workflow [${payload.runId}] ${payload.status}`;
 }
 
+// dist/builtin/workflows/src/extension/wiring.ts
+import {
+  isStaleExtensionContextError as isStaleExtensionContextError6
+} from "@bastani/atomic";
+
 // 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,
+  fanoutAuthorized: true,
   inheritProjectContext: true,
   inheritSkills: true
 };
@@ -72130,11 +73033,26 @@ function emitLateIntercomRoute(pi, meta2, messages, options, batch) {
     workflowStageId: meta2.stageId,
     workflowStageName: meta2.stageName
   };
-  pi.events.emit(LATE_STAGE_MESSAGE_EVENT2, event);
+  try {
+    pi.events.emit(LATE_STAGE_MESSAGE_EVENT2, event);
+  } catch (error) {
+    if (!isStaleExtensionContextError6(error))
+      throw error;
+    return Promise.reject(error);
+  }
   if (!event.handled)
     return;
   return event.completion ?? Promise.resolve();
 }
+function routeThroughStaleContextGuard(route) {
+  try {
+    return route();
+  } catch (error) {
+    if (!isStaleExtensionContextError6(error))
+      throw error;
+    return Promise.reject(error);
+  }
+}
 function makeWorkflowStageOrchestrationContext(meta2, pi) {
   const intercomGroup = stageHasIntercomAccess(meta2.stageOptions) ? resolveStageGroup(meta2.stageOptions, meta2.workflowIntercomGroup) : undefined;
   return {
@@ -72149,16 +73067,18 @@ function makeWorkflowStageOrchestrationContext(meta2, pi) {
         const intercomRoute = emitLateIntercomRoute(pi, meta2, [message], options, false);
         if (intercomRoute)
           return intercomRoute;
-        if (!pi.sendMessage)
+        const sendMessage = pi.sendMessage;
+        if (!sendMessage)
           throw new Error("atomic-workflows: main-chat late-message route is unavailable");
-        return pi.sendMessage(message, options);
+        return routeThroughStaleContextGuard(() => sendMessage(message, options));
       },
       routeMessages(messages, options) {
         const intercomRoute = emitLateIntercomRoute(pi, meta2, messages, options, true);
         if (intercomRoute)
           return intercomRoute;
-        if (pi.sendMessages)
-          return pi.sendMessages(messages, options);
+        const sendMessages = pi.sendMessages;
+        if (sendMessages)
+          return routeThroughStaleContextGuard(() => sendMessages(messages, options));
         const sendMessage = pi.sendMessage;
         if (!sendMessage)
           throw new Error("atomic-workflows: main-chat late-message route is unavailable");
@@ -72489,12 +73409,14 @@ function openInputsPicker(ui, opts) {
         }),
         handleInput: (data) => {
           const kb = keys;
+          const consumed = isInputsPickerKey(data, state2, fields, kb);
           const action = handleInputsPickerInput(data, state2, fields, kb);
           if (action.kind === "noop") {
             tui.requestRender?.();
-            return;
+            return consumed;
           }
           finish(action);
+          return true;
         },
         invalidate: () => tui.requestRender?.(),
         dispose: () => {
@@ -72733,6 +73655,15 @@ function renderSessionPicker(opts) {
   lines.push(renderHintsRow(width, theme, state2));
   return lines;
 }
+function isSessionPickerKey(data, state2, rows) {
+  if (state2.filterFocused) {
+    return matchesKey(data, Key.escape) || data === DOUBLE_ESCAPE_SEQUENCE || matchesKey(data, Key.enter) || matchesKey(data, Key.backspace) || data.length === 1 && data >= " " && data <= "~";
+  }
+  if (matchesKey(data, "/") || matchesKey(data, Key.escape) || matchesKey(data, "q") || matchesKey(data, Key.shift("q")) || matchesKey(data, "a") || matchesKey(data, Key.shift("a")) || matchesKey(data, Key.down) || matchesKey(data, "j") || matchesKey(data, Key.up) || matchesKey(data, "k")) {
+    return true;
+  }
+  return matchesKey(data, Key.enter) && rows[state2.selectedIndex] !== undefined;
+}
 function handleSessionPickerInput(data, state2, rows) {
   if (state2.filterFocused) {
     if (matchesKey(data, Key.escape) || data === DOUBLE_ESCAPE_SEQUENCE) {
@@ -73115,10 +74046,11 @@ function openSessionPicker(ui, store2, theme, intent = "connect") {
         },
         handleInput: (data) => {
           const rows = selectRows();
+          const consumed = isSessionPickerKey(data, state2, rows);
           const action = handleSessionPickerInput(data, state2, rows);
           if (action.kind === "noop") {
             tui.requestRender?.();
-            return;
+            return consumed;
           }
           if (action.kind === "close")
             finish({ kind: "close" });
@@ -73126,6 +74058,7 @@ function openSessionPicker(ui, store2, theme, intent = "connect") {
             finish(toResult(action));
           else
             finish(toResult(action));
+          return true;
         },
         invalidate: () => tui.requestRender?.(),
         dispose: () => {
@@ -73237,6 +74170,7 @@ function toPickerRow(session) {
     modifiedAt: session.modified.getTime(),
     messageCount: session.messageCount,
     firstMessage: session.firstMessage,
+    ...session.summary !== undefined ? { summary: session.summary } : {},
     allMessagesText: session.allMessagesText,
     ...session.name !== undefined ? { name: session.name } : {},
     ...session.messageColor !== undefined ? { messageColor: session.messageColor } : {}
@@ -73811,7 +74745,11 @@ Picker requires an interactive UI surface. Pass a runId: /workflow attach <id> [
           }
           const run3 = store.runs().find((r) => r.id === resolved.runId);
           const isPaused3 = run3 !== undefined && workflowHasPausedState(store, resolved.runId);
+          const isDurableAuthorExit2 = run3?.exited === true && run3.status === "failed" && run3.resumable === true;
           const isResumableContinuation2 = run3 !== undefined && !isPaused3 && run3.exitReason !== "quit" && isWorkflowRunResumable(workflowRunResumeCandidate(run3));
+          if (isDurableAuthorExit2) {
+            return await handleDurableResume(resolved.runId, ctx, reporter, deps);
+          }
           if (isResumableContinuation2) {
             await ensureWorkflowResourcesVisible();
             const continuation = await deps.runtimeForContext(ctx).resumeFailedRun(resolved.runId, undefined, { policy, actor: "user" });
@@ -73945,12 +74883,16 @@ Picker requires an interactive UI surface. Pass a runId: /workflow attach <id> [
     const hadPausedRunState = run2?.status === "paused";
     const hadPausedStageState = run2 !== undefined && workflowHasPausedStages(store, stageRunId);
     const isPaused2 = run2 !== undefined && workflowHasPausedState(store, stageRunId);
+    const isDurableAuthorExit = run2?.exited === true && run2.status === "failed" && run2.resumable === true;
     const isResumableContinuation = run2 !== undefined && !isPaused2 && run2.exitReason !== "quit" && isWorkflowRunResumable(workflowRunResumeCandidate(run2));
     const isActivelyRunning = run2 !== undefined && run2.endedAt === undefined && run2.status === "running" && !isPaused2 && run2.exitReason !== "quit";
     if (isActivelyRunning && !isResumableContinuation && action === "resume" && !hasPendingDurableResumeTransition(stageRunId)) {
       fail(`Workflow ${stageRunId} is already running in this session. Attach with \`/workflow connect ${stageRunId}\` instead of resuming.`);
       return true;
     }
+    if (isDurableAuthorExit) {
+      return await handleDurableResume(stageRunId, ctx, reporter, deps);
+    }
     if (isResumableContinuation) {
       await ensureWorkflowResourcesVisible();
       const continuation = await deps.runtimeForContext(ctx).resumeFailedRun(stageRunId, stageId, { policy, actor: "user" });
@@ -74078,8 +75020,13 @@ Available: ${formatAvailableWorkflowNames(deps.runtimeProxy.registry.names())}`)
       const resolved = resolveRunId(target);
       if (resolved.kind === "malformed")
         return fail(resolved.message);
-      if (resolved.kind === "not_found")
-        return fail(`Run not found: ${target}`);
+      if (resolved.kind === "not_found") {
+        const durable = await deps.runtimeForContext(ctx).inspectDurableWorkflow(target);
+        if (durable.kind !== "found")
+          return fail(durable.message);
+        emitChatSurface(pi, { kind: "detail", detail: durable.detail });
+        return;
+      }
       const inspected = inspectRun(resolved.runId);
       if (!inspected.ok)
         return fail(`Run not found: ${target}`);
@@ -74942,7 +75889,10 @@ async function workflowResumeAction(args, deps) {
   const hadPausedRunState = run2?.status === "paused";
   const hadPausedStageState = run2 !== undefined && workflowHasPausedStages(store, stageRunId);
   const isPaused2 = run2 !== undefined && workflowHasPausedState(store, stageRunId);
+  const isDurableAuthorExit = run2?.exited === true && run2.status === "failed" && run2.resumable === true;
   const isResumableContinuation = run2 !== undefined && !isPaused2 && run2.exitReason !== "quit" && isWorkflowRunResumable(workflowRunResumeCandidate(run2));
+  if (isDurableAuthorExit)
+    return resumeDurableShadow(stageRunId, deps);
   if (isResumableContinuation) {
     try {
       await deps.ensureWorkflowResourcesLoaded();
@@ -75150,8 +76100,9 @@ function snapshotTranscriptEntryCount(snapshot) {
 }
 
 // dist/builtin/workflows/src/extension/workflow-tool-inspection.ts
-function workflowStagesResult(args) {
-  const target = resolveToolRunTarget(args, "No active run to inspect.");
+function workflowStagesResult(args, source) {
+  const activeStore = source?.store ?? store;
+  const target = resolveToolRunTarget(args, "No active run to inspect.", activeStore);
   const filter = args.statusFilter ?? "all";
   if (target.kind === "all") {
     return {
@@ -75171,19 +76122,20 @@ function workflowStagesResult(args) {
       error: target.message
     };
   }
-  const run2 = store.runs().find((r) => r.id === target.runId);
-  const stages = (run2?.stages ?? []).filter((stage) => filter === "all" || stage.status === filter).map(summarizeStage);
+  const stageSnapshots = source?.store === undefined ? activeStore.runs().find((run2) => run2.id === target.runId)?.stages ?? [] : expandWorkflowGraph(readGraphStoreSnapshot(activeStore), target.runId).stages;
+  const stages = stageSnapshots.filter((stage) => filter === "all" || stage.status === filter).map(summarizeStage);
   return { action: "stages", runId: target.runId, filter, stages };
 }
-function workflowStageResult(args) {
-  const target = resolveToolRunTarget(args, "No active run to inspect.");
+function workflowStageResult(args, source) {
+  const activeStore = source?.store ?? store;
+  const target = resolveToolRunTarget(args, "No active run to inspect.", activeStore);
   if (target.kind === "all") {
     return { action: "stage", runId: "--all", error: "Stage inspection requires a single run." };
   }
   if (target.kind === "malformed" || target.kind === "not_found") {
     return { action: "stage", runId: target.target, error: target.message };
   }
-  const stage = resolveToolStageTarget(target.runId, args.stageId);
+  const stage = resolveToolStageTarget(target.runId, args.stageId, activeStore);
   if (!stage.ok || stage.stageId === undefined) {
     return {
       action: "stage",
@@ -75192,7 +76144,7 @@ function workflowStageResult(args) {
     };
   }
   const stageRunId = stage.runId ?? target.runId;
-  const run2 = store.runs().find((r) => r.id === stageRunId);
+  const run2 = activeStore.runs().find((r) => r.id === stageRunId);
   const snapshot = run2?.stages.find((s) => s.id === stage.stageId);
   return snapshot ? { action: "stage", runId: stageRunId, stage: cloneStage(snapshot) } : {
     action: "stage",
@@ -75200,8 +76152,9 @@ function workflowStageResult(args) {
     error: `Stage not found in run ${stageRunId}: ${stage.stageId}`
   };
 }
-function workflowTranscriptResult(args) {
-  const target = resolveToolRunTarget(args, "No active run to inspect.");
+function workflowTranscriptResult(args, source) {
+  const activeStore = source?.store ?? store;
+  const target = resolveToolRunTarget(args, "No active run to inspect.", activeStore);
   if (target.kind === "all") {
     return {
       action: "transcript",
@@ -75222,7 +76175,7 @@ function workflowTranscriptResult(args) {
       truncated: false
     };
   }
-  const stage = resolveToolStageTarget(target.runId, args.stageId);
+  const stage = resolveToolStageTarget(target.runId, args.stageId, activeStore);
   if (!stage.ok || stage.stageId === undefined) {
     return {
       action: "transcript",
@@ -75234,9 +76187,9 @@ function workflowTranscriptResult(args) {
     };
   }
   const stageRunId = stage.runId ?? target.runId;
-  const run2 = store.runs().find((r) => r.id === stageRunId);
+  const run2 = activeStore.runs().find((r) => r.id === stageRunId);
   const snapshot = run2?.stages.find((s) => s.id === stage.stageId);
-  const liveHandle2 = stageControlRegistry.get(stageRunId, stage.stageId);
+  const liveHandle2 = source?.allowLiveHandles === false ? undefined : stageControlRegistry.get(stageRunId, stage.stageId);
   if (liveHandle2 !== undefined) {
     const sessionFile = liveHandle2.sessionFile ?? snapshot?.sessionFile;
     const sessionId = liveHandle2.sessionId ?? snapshot?.sessionId;
@@ -75296,6 +76249,41 @@ function brokerAnswerFromArgs(args) {
   const text = textPayloadFromArgs(args);
   return text !== undefined ? { text } : {};
 }
+function answersPendingPrompt(delivery, promptId) {
+  return delivery === "answer" || delivery === "auto" || promptId !== undefined;
+}
+function answerablePromptIds(stage) {
+  const target = stage.workflowGraphTarget;
+  const ids = [];
+  const brokered = stageUiBroker.peekStagePrompt(target.runId, target.stageId);
+  if (brokered !== undefined)
+    ids.push(brokered.id);
+  if (stage.pendingPrompt !== undefined)
+    ids.push(stage.pendingPrompt.id);
+  if (stage.status === "awaiting_input" && stage.promptFootprint?.kind === "custom") {
+    ids.push(stage.promptFootprint.id);
+  }
+  return ids;
+}
+function inferPromptStageTarget(runId, delivery, promptId) {
+  if (!answersPendingPrompt(delivery, promptId))
+    return { ok: true, runId };
+  const pending = expandWorkflowGraph(readGraphStoreSnapshot(store), runId).stages.filter((stage) => {
+    const ids = answerablePromptIds(stage);
+    return promptId === undefined ? ids.length > 0 : ids.includes(promptId);
+  });
+  const only = pending[0];
+  if (pending.length === 1 && only !== undefined) {
+    return { ok: true, runId: only.workflowGraphTarget.runId, stageId: only.workflowGraphTarget.stageId };
+  }
+  if (pending.length === 0) {
+    return promptId === undefined ? { ok: true, runId } : { ok: false, message: `No pending prompt ${promptId} in run ${runId}.` };
+  }
+  return {
+    ok: false,
+    message: `${pending.length} prompts pending; pass stageId: ${pending.map(expandedStageLabel).join(", ")}`
+  };
+}
 function workflowSendResult(runId, stageId, delivery, status, message) {
   return { action: "send", runId, stageId, delivery, status, message };
 }
@@ -75356,7 +76344,8 @@ async function workflowSendAction(args, deps = {}) {
   if (rootRun !== undefined && isTerminalRunStatus(rootRun.status)) {
     return terminalWorkflowSendResult(rootRun.id, args.stageId?.trim() ?? "", rootRun.status);
   }
-  const stage = resolveToolStageTarget(target.runId, args.stageId);
+  const requested = resolveToolStageTarget(target.runId, args.stageId);
+  const stage = requested.ok && requested.stageId === undefined ? inferPromptStageTarget(target.runId, requestedDelivery, args.promptId) : requested;
   if (!stage.ok || stage.stageId === undefined) {
     return workflowSendResult(target.runId, "", requestedDelivery, "noop", stage.ok ? "Stage id or name is required." : stage.message);
   }
@@ -75497,6 +76486,32 @@ async function workflowSendAction(args, deps = {}) {
 }
 
 // dist/builtin/workflows/src/extension/workflow-tool.ts
+async function resolveDurableInspectionSource(args, runtime) {
+  const target = args.runId?.trim();
+  if (args.all === true || target === undefined || target.length === 0 || target === "--all")
+    return { kind: "local" };
+  const local = resolveRunId(target);
+  if (local.kind !== "not_found")
+    return { kind: "local" };
+  const durable = await runtime.inspectDurableWorkflow(target);
+  if (durable.kind !== "found")
+    return { kind: "error", message: durable.message };
+  return { kind: "durable", source: { store: durable.store, allowLiveHandles: false } };
+}
+function durableInspectionError(action, runId, message) {
+  if (action === "stages")
+    return { action, runId, filter: "all", stages: [], error: message };
+  if (action === "stage")
+    return { action, runId, error: message };
+  return {
+    action,
+    runId,
+    stageId: "",
+    source: "error",
+    entries: [{ role: "notice", text: message }],
+    truncated: false
+  };
+}
 function makeExecuteWorkflowTool(runtime, reloadWorkflowResources, ensureWorkflowResourcesLoaded = () => {}, sendDeps = {}) {
   return async function executeWorkflowTool(args, ctx) {
     const action = args.action ?? "run";
@@ -75552,7 +76567,8 @@ function makeExecuteWorkflowTool(runtime, reloadWorkflowResources, ensureWorkflo
             return { action: "statusDetail", runId: target, error: resolved.message };
           }
           if (resolved.kind === "not_found") {
-            return { action: "statusDetail", runId: target, error: `run not found: ${target}` };
+            const durable = await getRuntime().inspectDurableWorkflow(target);
+            return durable.kind === "found" ? { action: "statusDetail", runId: target, detail: durable.detail } : { action: "statusDetail", runId: target, error: durable.message };
           }
           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}` };
@@ -75568,11 +76584,18 @@ function makeExecuteWorkflowTool(runtime, reloadWorkflowResources, ensureWorkflo
         return result;
       }
       case "stages":
-        return workflowStagesResult(args);
       case "stage":
-        return workflowStageResult(args);
-      case "transcript":
-        return workflowTranscriptResult(args);
+      case "transcript": {
+        const resolved = await resolveDurableInspectionSource(args, getRuntime());
+        if (resolved.kind === "error")
+          return durableInspectionError(action, args.runId ?? "", resolved.message);
+        const source = resolved.kind === "durable" ? resolved.source : undefined;
+        if (action === "stages")
+          return workflowStagesResult(args, source);
+        if (action === "stage")
+          return workflowStageResult(args, source);
+        return workflowTranscriptResult(args, source);
+      }
       case "send":
         return workflowSendAction(args, sendDeps);
       case "pause":
@@ -75789,7 +76812,7 @@ function renderResult(result, opts) {
         const guidance = r.details.message === undefined ? "" : ` — ${r.details.message}`;
         return renderNotice("WORKFLOW RUN", `${r.runId}${label2}: ${r.details.mode} ${r.details.status}${guidance}`, opts, themed);
       }
-      if (r.status === "completed" || r.status === "skipped" || r.status === "cancelled" || r.status === "blocked" || r.status === "killed") {
+      if (r.status === "completed" || r.status === "failed" || r.status === "skipped" || r.status === "cancelled" || r.status === "blocked" || r.status === "killed") {
         const label2 = r.name ? ` (${r.name})` : "";
         return renderNotice("WORKFLOW RUN", `${r.runId}${label2}: ${r.status}`, opts, themed);
       }
@@ -75876,7 +76899,7 @@ var DEFAULT_PROMPT_GUIDANCE = [
   - Workflow fit check: prefer a workflow for implementation, build, debug/diagnosis, bug-fix, migration, new-feature, scoped multi-file, or docs/code changes with validation; and whenever there are multiple steps, dependencies, handoffs, uncertainty, review/validation needs, long-running work, measurable done criteria, or an outcome that needs evidence.
   - Treat loop or stop-condition wording as a strong workflow signal, especially "do X until Y", "repeat until", "iterate until", "review/fix until passing", "run checks and fix until green", "keep going until done", or any prompt that names an approval gate or evidence requirement.
   - Do not force-fit an installed workflow. When another graph better matches the task, write a task-specific TypeScript workflow inline. Rich custom workflows may use deterministic branching, dynamic fan-out, child workflows, artifacts, structured outputs, human-in-the-loop prompts, gates, retries, and explicit stop conditions.
-  - Before launching any workflow for a non-trivial task, perform a short workflow-architecture pass. Derive implementation lifecycle needs, whole-codebase research needs, independent slices, competing strategies, exact API/type/build contracts, schema or generated-artifact contracts, state transitions/lifecycle behavior, deterministic stop conditions, and required evidence. Use a compact internal coverage matrix: \`requirement/risk | required evidence | workflow/stage that produces it | gap\`. Add the topology row \`acyclic topology | node/edge sketch for branches and loops | architecture pass | unresolved back-edge\`. Unresolved material rows or back-edges must change the graph before launch.
+  - Before launching any workflow for a non-trivial task, perform a short workflow-architecture pass. Derive implementation lifecycle needs, whole-codebase research needs, independent slices, competing strategies, exact API/type/build contracts, schema or generated-artifact contracts, state transitions/lifecycle behavior, deterministic stop conditions, and required evidence. Enumerate implementation slices in this same pass, not a second planning ritual; give each slice its own objective, acceptance criteria, and gates, and require each to leave a buildable, testable repository state before the next slice. Use a compact internal coverage matrix: \`requirement/risk | required evidence | workflow/stage that produces it | gap\`. Add the topology row \`acyclic topology | node/edge sketch for branches and loops | architecture pass | unresolved back-edge\`. Unresolved material rows or back-edges must change the graph before launch.
   - In that architecture pass, sketch each branch, loop, and nested workflow boundary. Identify which stages repeat, require distinct tracked work for every iteration, name the current frontier before each repeat, reject self-edges and ancestor edges, compose nested workflows through \`ctx.workflow(...)\` boundaries rather than recursive \`run\` invocation, and preserve stable per-iteration identity and call order for resume/replay.
   - Compare candidate workflows by guarantees, not broad objectives: run one named workflow only when it covers the lifecycle and produces evidence for every material requirement/risk. A generic implementation workflow may cover the lifecycle without covering exact API/type/build contracts, schemas/generated artifacts, state transitions, or domain-specific gates. Do not treat "has reviewers" as proof that a task-specific risk is covered.
   - Use these routing signals without adding decorative stages: broad repository uncertainty → Fan-out-and-synthesize with repository-focused branches; independent slices → Fan-out-and-synthesize; plausible-but-wrong contract risk → Adversarial verification or a task-specific verification stage; competing architectures or implementations → Generate-and-filter or Tournament; an explicit repeat-until condition → Loop until done; implementation lifecycle → a task-specific worker/reviewer loop; exact API/build/schema requirements → dedicated deterministic gates.
@@ -75890,9 +76913,11 @@ var DEFAULT_PROMPT_GUIDANCE = [
   - When plausible-but-wrong behavior is a material risk in an arbitrary task-specific workflow, prefer a bounded evidence-backed adversarial loop. Give a fresh-context grumpy/skeptical-but-fair reviewer the literal objective and require actionable, evidence-backed falsification probes without invented requirements. Have it emit a structured verifier plan containing each exact probe, inputs, command/assertion, expected success condition, and requirement/risk covered.
   - Support both verifier shapes: for explicit known contracts, author direct task-specific \`ctx.tool(...)\` gates before launch; for risks requiring adversarial discovery, let the model select high-value probes through structured output, then execute the selected compile, test, schema generation/validation, runtime, or artifact-inspection checks authoritatively through durable \`ctx.tool(...)\` calls. Actual tool results—not model self-report—must feed skeptical evaluation, consolidated evidence-backed repair findings, and reruns after the implementation child repairs them.
   - Define bounded pass, repair, failure, and iteration-limit conditions before launch. Use \`ctx.tool\` for workflow-owned external checks and side effects whose results should be durably checkpointed. Each \`ctx.tool\` call is tracked as a durable, non-chat graph node and may run before, between, after, or without model stages; a tool-only workflow is valid tracked execution; keep pure transformations as ordinary TypeScript, and do not wrap every model-stage action in a tool call.
-  - Choose the cheapest graph that covers every material coverage row. Avoid decorative composition and duplicated research or review loops. Prefer composing a proven builtin or shared child over copying its prompt/graph.
+  - Choose the cheapest graph that covers every material coverage row without collapsing independently verifiable implementation slices merely to minimize stage count. Avoid decorative composition and duplicated research or review loops. Prefer composing a proven builtin or shared child over copying its prompt/graph.
   - Before the first launch, state the selected graph, why one broad builtin is sufficient or insufficient, the evidence each major stage produces, and the stop/repair conditions. A simple direct match may use one sentence; a composed graph must briefly name its children and task-specific gates. For a custom adversarial loop, also name the skeptical reviewer, deterministic \`ctx.tool\` verifier gates, how model-selected plans become tool executions, and how failures reach bounded repair.
-  - Example custom shapes: classify a request and dispatch category-specific stages; fan out per package and synthesize artifact-backed results; implement, run fresh-context verifiers, reduce findings, and loop through repairs until approved; generate several plans and filter or tournament-rank them; or rerun checks and fixes until green with a progress ledger and max-iteration escape hatch.
+  - Before launching an authored workflow, assign every model stage a role, failure cost, primary model, thinking level, and fallback policy. Use the role/risk defaults in the model-selection guide: reserve \`max\` for high-cost-of-error roles such as security, identity, adversarial challenge, and final approval; use \`high\` for demanding codebase mapping, lifecycle analysis, compatibility, planning, synthesis, triage, and repair; use \`medium\` for user-impact review and final reporting; keep deterministic checks as tool nodes with no model call. An explicit user request for a thinking level always wins over these defaults, subject to catalog support. For a mixed workflow, mapping may be \`high\`, approval \`max\`, reporting \`medium\`, and tests tool-only; never assign \`max\` to every model stage without a stage-specific reason.
+  - Print a compact \`Stage | Model | Thinking | Role\` assignment before launch with a short cost/quality rationale for each model stage. Apply the same role/risk policy to every fallback attempt rather than inheriting \`max\` mechanically; choose each primary and fallback level from the configured catalog, and if no selected catalog model supports the role's level, leave the stage unpinned rather than inventing an unsupported level.
+  - Example custom shapes: classify a request and dispatch category-specific stages; fan out per package and synthesize artifact-backed results; decompose one implementation objective into stacked, independently verified slices with a bounded child lifecycle per slice; implement, run fresh-context verifiers, reduce findings, and loop through repairs until approved; generate several plans and filter or tournament-rank them; or rerun checks and fixes until green with a progress ledger and max-iteration escape hatch.
   - Budget reconnaissance: once workflow fit is clear, keep pre-workflow exploration to a few quick reads that sharpen the objective and validation criteria. Put deep research, upstream/design comparison, and behavior probing inside the workflow. Pass large context through files/artifacts and \`reads\` rather than injecting it into prompts.
   - Course-correct instead of drifting: after roughly ten exploratory tool calls with no artifact, edit, or commit, or repeated "let me verify one more thing" loops, stop, write findings to a context file, and hand the task to the best-fit named or custom workflow. Sunk inline research transfers through files; it is not a reason to stay inline.
   - Only skip workflows for tiny, deterministic, low-risk answers or direct edits where stage tracking clearly costs more than it adds, typically a single-file/no-test/no-review change or a simple answer.`,
@@ -75908,12 +76933,15 @@ var DEFAULT_PROMPT_GUIDANCE = [
   `**Workflow authoring and handoffs**:
   - When a user asks to create or edit a workflow, clarify only unresolved requirements that materially affect its purpose, inputs, stages, handoffs, validation, success criteria, or starter pattern. Read the workflow docs/examples, implement the TypeScript definition with normal coding tools, reload it, and run representative test inputs before presenting it. Use the create-spec skill when it adds value; it is not mandatory when context is already sufficient.
   - 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.
-  - 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, 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\`; 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 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.md and its starter patterns (Classify-and-act, Fan-out-and-synthesize, Adversarial verification, Generate-and-filter, Tournament, and Loop until done) when designing a stage graph.
+  - 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, 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.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.
   - Treat workflow composition as a first-class authoring option. Before duplicating stages, inspect reusable workflow modules and builtin exports; import their definitions and invoke them with \`ctx.workflow(...)\`, mapping typed inputs and consuming only declared outputs. Nested workflows can themselves import children, so combine small reusable graphs into a richer parent while respecting \`maxDepth\`.
+  - For implementation objectives, prefer the smallest independently verifiable slice: target roughly 100–500 changed lines between verification points by default, with one reviewable concern that builds and tests on its own. This is a default, not a law: a genuinely atomic change (for example, a mechanical rename across many files or a generated-artifact refresh) stays one slice, and a small objective is not split merely to reach a count.
+  - Decompose those slices during the pre-launch architecture pass, not in a second planning ritual. Run every slice through a child workflow with its own implement/review/repair lifecycle: invoke imported \`goal\`, \`ralph\`, or a task-specific child via \`ctx.workflow(...)\`, rather than making one parent stage own all slices.
+  - Stack implementation slices in order: give each slice an explicit branch input and, before invoking its child, create or check out that named branch in its worktree with a durable \`ctx.tool(...)\` step; \`base_branch\` and \`git_worktree_dir\` alone do not create/check out a feature branch. Slice N+1 must be created from slice N's verified branch, pass that branch as \`base_branch\`, and use a distinct worktree. Verify each slice before proceeding; if a slice fails its gates, stop at the first unverified slice; earlier verified slices remain verified and are reported as such; do not roll them back or continue past the failure.
   - Atomic \`workflow({ run })\` definitions are imperative, dynamic TypeScript. Discovery validates module loading, imports, and definition shape, including schemas and the \`run\` function, but it does not compile \`run\` into a complete graph or prove acyclicity. Runtime inputs, branches, loops, files, network data, model or human output, helpers, and nested workflows determine the materialized graph during execution.
   - Cyclic workflow graphs are unsupported. Workflow authors and coding agents MUST NOT create self-edges or dependency edges from the current frontier to an existing ancestor. Every materialized execution topology must remain a DAG. Redesign or stop before launch if a cycle cannot be removed.
-  - Bounded loops must create distinct tracked work for every iteration; never reopen an ancestor below its downstream work. If a retained session receives follow-up without new dependency work, keep it as non-topological activity metadata rather than adding a back-edge. Before launch, sketch nodes and dependencies for every branch and loop and reject any proposed parent edge to the node itself or an ancestor.
+  - Bounded loops must create distinct tracked work for every iteration; never reopen an ancestor below its downstream work. Stacked implementation slices are unrolled, not looped: each slice gets a fresh child boundary and distinct tracked nodes, and no slice may add an edge back to the current frontier, itself, or an ancestor. If a retained session receives follow-up without new dependency work, keep it as non-topological activity metadata rather than adding a back-edge. Before launch, sketch nodes and dependencies for every branch and loop and reject any proposed parent edge to the node itself or an ancestor.
   - Treat dynamic graph validation during execution, replay, and DBOS hydration as the authoritative cycle boundary. If runtime topology code changes, require incremental edge checks and DBOS hydration validation; prompt guidance and TypeScript types cannot replace those runtime checks.
   - Every workflow invocation automatically receives one stable, non-default Intercom group. Intercom-capable stages inherit it, nested workflows keep the top-level invocation group, and subagents inherit their launching stage's group. Do not mint or thread group names through ordinary workflow definitions. Use an explicit \`group\` only for an intentional override: a named group or \`group: true\` creates a subgroup, while \`group: "default"\` opts into the shared default group. Stages without Intercom access receive no group, and \`contact_supervisor\` still crosses group boundaries for authorized escalation.
   - Prefer \`ctx.tool(name, args, fn)\` for workflow-owned TypeScript operations with side effects, such as filesystem writes, network mutations, and external API actions. It creates a tracked, non-attachable durable graph node before invoking \`fn\`; it may be used before, between, after, or without model stages. A completed \`ctx.tool\` call is durably checkpointed with its serializable result, so resume replays that result without rerunning \`fn\`. For checks that may fail during a bounded repair loop, opt into \`failureMode: "return"\`, branch on the typed outcome, and pass only the needed error fields to the repair stage or artifact yourself; Atomic does not inject failure evidence into later prompts. Cancellation and storage faults still throw. Keep pure computation and side-effect-free transformations as ordinary TypeScript. Do not wrap agent-stage internals or every function call indiscriminately; this rule applies to side effects orchestrated directly by the workflow definition.