@bastani/atomic 0.9.19-alpha.8 → 0.9.19

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

@@ -68525,19 +68525,57 @@ function formatWorkflowStageTarget(rootRunId, ...segments) {
 
 // dist/builtin/workflows/src/shared/pending-stage-status.ts
 function workflowBoundarySegments(runs, runId) {
+  return createWorkflowBoundarySegmentsResolver(runs)(runId);
+}
+function createWorkflowBoundarySegmentsResolver(runs) {
   const runById = new Map(runs.map((run) => [run.id, run]));
-  const segments = [];
-  let current = runById.get(runId);
-  while (current !== undefined && current.parentRunId !== undefined) {
-    const parent = runById.get(current.parentRunId);
-    const boundary = parent?.stages.find((stage) => stage.id === current?.parentStageId);
-    if (parent === undefined || boundary === undefined)
-      return;
-    const boundaryName = boundary.name;
-    segments.unshift(boundaryName.length > 0 && !boundaryName.includes("/") && !boundaryName.includes("*") ? boundaryName : current.id);
-    current = parent;
+  const stagesByRun = new Map;
+  const childrenByParent = new Map;
+  for (const run of runs) {
+    const byId = new Map;
+    const byName = new Map;
+    for (const stage of run.stages) {
+      const ids = byId.get(stage.id) ?? [];
+      ids.push(stage);
+      byId.set(stage.id, ids);
+      const names = byName.get(stage.name) ?? [];
+      names.push(stage);
+      byName.set(stage.name, names);
+    }
+    stagesByRun.set(run.id, { byId, byName });
+    if (run.parentRunId === undefined || run.parentStageId === undefined)
+      continue;
+    const byStage = childrenByParent.get(run.parentRunId) ?? new Map;
+    const children = byStage.get(run.parentStageId) ?? [];
+    children.push(run);
+    byStage.set(run.parentStageId, children);
+    childrenByParent.set(run.parentRunId, byStage);
   }
-  return current === undefined ? undefined : segments;
+  const cachedSegments = new Map;
+  return (runId) => {
+    if (cachedSegments.has(runId))
+      return cachedSegments.get(runId);
+    const segments = [];
+    let current = runById.get(runId);
+    while (current !== undefined && current.parentRunId !== undefined) {
+      const parent = runById.get(current.parentRunId);
+      const stages = stagesByRun.get(current.parentRunId);
+      const boundary = current.parentStageId === undefined ? undefined : stages?.byId.get(current.parentStageId)?.[0];
+      if (parent === undefined || stages === undefined || boundary === undefined) {
+        cachedSegments.set(runId, undefined);
+        return;
+      }
+      const boundaryName = boundary.name;
+      const matchingBoundaries = stages.byId.get(boundaryName) ?? stages.byName.get(boundaryName);
+      const matchingBoundary = matchingBoundaries?.length === 1 ? matchingBoundaries[0] : undefined;
+      const children = matchingBoundary === undefined ? undefined : childrenByParent.get(parent.id)?.get(matchingBoundary.id);
+      segments.unshift(boundaryName.length > 0 && !boundaryName.includes("/") && !boundaryName.includes("*") && children?.length === 1 && children[0]?.id === current.id ? boundaryName : current.id);
+      current = parent;
+    }
+    const result = current === undefined ? undefined : segments;
+    cachedSegments.set(runId, result);
+    return result;
+  };
 }
 function workflowBoundaryHops(runs, runId) {
   const runById = new Map(runs.map((run) => [run.id, run]));
@@ -79093,7 +79131,9 @@ function plainCollapsed(counts, activeTools) {
   const tools = activeTools > 0 ? ` · ${activeTools} tool${activeTools === 1 ? "" : "s"}` : "";
   return ` ▾  ${total} background · ${counts.active} ●${paused}${quit}${blocked}${tools}`;
 }
-function buildThemedWidgetLines(snap, piTheme, width = 120, now = Date.now()) {
+function buildThemedWidgetLines(snap, piTheme, width = 120, now = Date.now(), layout) {
+  if (layout)
+    layout.runs = [];
   const display = selectDisplayRuns(snap, now);
   if (display.length === 0)
     return [];
@@ -79112,7 +79152,7 @@ function buildThemedWidgetLines(snap, piTheme, width = 120, now = Date.now()) {
   const activeTools = display.filter(isActive).reduce((total, run) => total + activeToolNodes(run).length, 0);
   if (width < COLLAPSED_BREAKPOINT_COLS) {
     return [
-      themed ? themedCollapsed(visibleCounts, activeTools, graphTheme) : plainCollapsed(visibleCounts, activeTools)
+      truncateToWidth2(themed ? themedCollapsed(visibleCounts, activeTools, graphTheme) : plainCollapsed(visibleCounts, activeTools), width, "…")
     ];
   }
   const total = display.length;
@@ -79126,6 +79166,11 @@ function buildThemedWidgetLines(snap, piTheme, width = 120, now = Date.now()) {
     const run = display[i];
     const runLines = themed ? themedRunLines(run, now, graphTheme, snap.runs, width, expandGraph) : plainRunLines(run, now, snap.runs, width, expandGraph);
     body.push(...runLines);
+    layout?.runs.push({
+      id: run.id,
+      start: body.length - runLines.length + 1,
+      end: body.length + (i === display.length - 1 ? 2 : 1)
+    });
     if (i < display.length - 1)
       body.push("");
   }
@@ -79138,7 +79183,120 @@ function buildThemedWidgetLines(snap, piTheme, width = 120, now = Date.now()) {
   });
 }
 
+// dist/builtin/workflows/src/tui/widget-scroll-hint.ts
+import { keybindingIdentity } from "@bastani/atomic";
+import { getKeybindings, matchesKey as matchesKey2 } from "@earendil-works/pi-tui";
+var legacyInputs = Array.from({ length: 128 }, (_, code) => String.fromCharCode(code)).flatMap((data) => [
+  data,
+  `\x1B${data}`
+]);
+function workflowScrollHint(bindings = getKeybindings().getResolvedBindings(), platform = process.platform) {
+  const keys = ["app.workflows.scrollUp", "app.workflows.scrollDown"].map((action) => {
+    const configured = bindings[action] ?? [];
+    return (Array.isArray(configured) ? configured : [configured]).find((key) => {
+      const inputs = legacyInputs.filter((data) => matchesKey2(data, key));
+      return !Object.entries(bindings).some(([other, values]) => other !== action && (Array.isArray(values) ? values : [values]).some((value2) => value2 !== undefined && (keybindingIdentity(value2) === keybindingIdentity(key) || inputs.some((data) => matchesKey2(data, value2)))));
+    });
+  }).filter((key) => key !== undefined);
+  const label = keys.map((key) => key.replace(/^alt\+/i, platform === "darwin" ? "Option+" : "Alt+")).join("/");
+  return ` ↑↓ scroll${label ? ` · ${label}` : ""}`;
+}
+
+// dist/builtin/workflows/src/tui/widget-viewport.ts
+var WORKFLOW_WIDGET_MAX_ROWS = 10;
+
+class WorkflowWidgetViewport {
+  content;
+  terminalRows;
+  requestRender;
+  getRunRows;
+  getHint;
+  position = 0;
+  version = 0;
+  collapsed = false;
+  state;
+  lines = [];
+  runRows = [];
+  constructor(content, terminalRows, requestRender, getRunRows, getHint = () => "") {
+    this.content = content;
+    this.terminalRows = terminalRows;
+    this.requestRender = requestRender;
+    this.getRunRows = getRunRows;
+    this.getHint = getHint;
+  }
+  getScrollRequest() {
+    return { version: this.version, scrollTop: this.collapsed ? 0 : this.position };
+  }
+  onScroll(state) {
+    this.state = state;
+    if (!this.collapsed)
+      this.position = state.scrollTop;
+  }
+  scroll(direction) {
+    if (this.collapsed)
+      return;
+    const height = this.state?.viewportHeight ?? Math.max(1, Math.min(WORKFLOW_WIDGET_MAX_ROWS, Math.floor(this.terminalRows() / 3)));
+    const next = Math.max(0, Math.min(Math.max(0, this.lines.length - height), this.position + direction));
+    if (next === this.position)
+      return;
+    this.position = next;
+    this.version++;
+    this.requestRender();
+  }
+  render(width) {
+    const content = this.content.render(width);
+    const hint = content.length > 1 ? this.getHint() : "";
+    const nextLines = hint ? [...content, truncateToWidth2(hint, width, "…")] : content;
+    const nextRunRows = (this.getRunRows?.() ?? []).map((run, index, rows) => hint && index === rows.length - 1 ? { ...run, end: run.end + 1 } : run);
+    const collapsed = Boolean(this.getRunRows && nextLines.length === 1 && nextRunRows.length === 0);
+    if (collapsed) {
+      if (!this.collapsed)
+        this.version++;
+      this.collapsed = true;
+      return nextLines;
+    }
+    const anchoredOffset = this.getRunRows ? this.resolveAnchor(this.position, nextRunRows) : this.position;
+    if (this.collapsed || anchoredOffset !== this.position) {
+      this.position = anchoredOffset;
+      this.version++;
+    }
+    this.collapsed = false;
+    this.lines = nextLines;
+    this.runRows = nextRunRows;
+    return nextLines;
+  }
+  resolveAnchor(offset, next) {
+    if (offset === 0 || next.length === 0)
+      return 0;
+    const index = this.runRows.findIndex((run) => offset >= run.start - 1 && offset < run.end);
+    const anchor = this.runRows[index];
+    if (!anchor)
+      return 0;
+    const byId = new Map(next.map((run) => [run.id, run]));
+    const retained = byId.get(anchor.id);
+    if (retained)
+      return Math.min(retained.end - 1, retained.start + offset - anchor.start);
+    const neighbours = [...this.runRows.slice(index + 1), ...this.runRows.slice(0, index).reverse()];
+    for (const neighbour of neighbours) {
+      const survivor = byId.get(neighbour.id);
+      if (survivor)
+        return survivor.start;
+    }
+    return 0;
+  }
+  invalidate() {
+    this.content.invalidate?.();
+  }
+  dispose() {
+    this.content.dispose?.();
+  }
+}
+
 // dist/builtin/workflows/src/tui/store-widget-installer.ts
+var widgetViewports = new WeakMap;
+function scrollStoreWidget(storeInstance, direction) {
+  widgetViewports.get(storeInstance)?.scroll(direction);
+}
 var defaultTimerApi = {
   setTimeout: (handler, delayMs) => setTimeout(handler, delayMs),
   clearTimeout: (handle) => clearTimeout(handle)
@@ -79169,19 +79327,30 @@ function installStoreWidget(pi, storeInstance, timers = defaultTimerApi) {
   const setWidget = ui.setWidget;
   const requestRender = ui.requestRender;
   const onWidgetRelease = ui.onWidgetRelease;
+  const layout = { runs: [] };
   const controller = installReactiveWidget({
     ui: {
-      setWidget: (key, factory, opts) => setWidget.call(ui, key, factory, opts),
+      setWidget: (key, factory, opts) => {
+        if (!factory)
+          widgetViewports.delete(storeInstance);
+        setWidget.call(ui, key, factory ? (tui, theme) => {
+          const host = tui;
+          const viewport = new WorkflowWidgetViewport(factory(tui, theme), () => host?.terminal?.rows ?? 30, () => requestRender ? requestRender.call(ui) : host?.requestRender?.(), () => layout.runs, workflowScrollHint);
+          widgetViewports.set(storeInstance, viewport);
+          return viewport;
+        } : undefined, opts);
+      },
       ...requestRender ? { requestRender: () => requestRender.call(ui) } : {},
       ...onWidgetRelease ? { onWidgetRelease: (key, listener) => onWidgetRelease.call(ui, key, listener) } : {}
     },
     key: WIDGET_KEY,
     placement: "belowEditor",
+    scroll: { maxHeight: 10, maxHeightFraction: 1 / 3 },
     timers,
     getSnapshot: () => liveWidgetSnapshot(storeInstance),
     subscribe: (listener) => subscribeStoreInvalidation(storeInstance, listener),
     getPreviewLines: (snap, now) => buildThemedWidgetLines(snap, undefined, 120, now),
-    render: (snap, { theme, width, now }) => buildThemedWidgetLines(snap, theme, width, now),
+    render: (snap, { theme, width, now }) => buildThemedWidgetLines(snap, theme, width, now, layout),
     getNextRefreshDelayMs: (snap, now) => nextWidgetRefreshDelayMs(snap, now),
     requestRenderOnStateNoop: false,
     isStaleError: isStaleExtensionContextError4,
@@ -79189,7 +79358,10 @@ function installStoreWidget(pi, storeInstance, timers = defaultTimerApi) {
       reportWidgetFailure(ui, `Workflow progress widget could not mount: ${error.message}`);
     }
   });
-  return () => controller.dispose();
+  return () => {
+    widgetViewports.delete(storeInstance);
+    controller.dispose();
+  };
 }
 function installToolExecutionHooks(pi, storeInstance) {
   const eventBusOn = pi.events?.on;
@@ -106616,16 +106788,52 @@ function stageSessionExtensionRunner(current) {
   }
   return;
 }
+var shutdowns = new WeakMap;
+function shutdownStageSession(current) {
+  if (!current)
+    return Promise.resolve();
+  const existing = shutdowns.get(current);
+  if (existing)
+    return existing;
+  const shutdown = Promise.resolve().then(async () => {
+    const runner = stageSessionExtensionRunner(current);
+    if (runner?.hasHandlers("session_shutdown"))
+      await runner.emit({ type: "session_shutdown", reason: "quit" });
+  });
+  shutdowns.set(current, shutdown);
+  return shutdown;
+}
+
+class StageSessionBindingCleanupFailure extends AggregateError {
+  constructor(bindingError, cleanupErrors) {
+    super([bindingError, ...cleanupErrors], "atomic-workflows: failed binding cleanup did not release session ownership", {
+      cause: bindingError
+    });
+    this.name = "StageSessionBindingCleanupFailure";
+  }
+}
+async function cleanupFailedStageSessionBinding(current, bindingError) {
+  const cleanupErrors = [];
+  try {
+    await shutdownStageSession(current);
+  } catch (error) {
+    cleanupErrors.push(error);
+  }
+  try {
+    await current.dispose();
+  } catch (error) {
+    cleanupErrors.push(error);
+  }
+  if (cleanupErrors.length > 0)
+    throw new StageSessionBindingCleanupFailure(bindingError, cleanupErrors);
+}
 async function disposeStageSession(current) {
   if (!current)
     return;
-  const runner = stageSessionExtensionRunner(current);
-  if (runner?.hasHandlers("session_shutdown")) {
-    try {
-      await runner.emit({ type: "session_shutdown", reason: "quit" });
-    } catch (error) {
-      console.error("atomic-workflows: stage session_shutdown handler failed", error);
-    }
+  try {
+    await shutdownStageSession(current);
+  } catch (error) {
+    console.error("atomic-workflows: stage session_shutdown handler failed", error);
   }
   await current.dispose();
 }
@@ -107022,6 +107230,8 @@ class StageSessionController {
   abortReason;
   abortReasonGeneration = 0;
   sessionPromise;
+  sessionShutdownPromise;
+  bindingCleanupFailure;
   reattachSessionFile;
   lastPromptStartIndex;
   attemptUsageStartIndex;
@@ -107138,8 +107348,7 @@ class StageSessionController {
     this.pendingFallbackWarnings.push(`[fallback] ${candidateLabel(candidate)} failed: ${error}. Retrying with ${candidateLabel(nextCandidate)}.`);
     this.modelWarnings.push(...this.pendingFallbackWarnings);
     this.pendingFallbackWarnings.length = 0;
-    await this.disposeCurrentSession();
-    this.activeCandidateIndex = index + 1;
+    await this.disposeCurrentSession(index + 1);
     this.notifyModelFallbackMetaChange();
     return true;
   }
@@ -107167,6 +107376,14 @@ class StageSessionController {
     this.session?.setThinkingLevel(level);
   }
   async ensureSession(consumer = "prompt") {
+    if (this.bindingCleanupFailure !== undefined)
+      throw this.bindingCleanupFailure;
+    if (this.sessionShutdownPromise !== undefined) {
+      const generation = this.abortGeneration;
+      await this.sessionShutdownPromise;
+      if (this.disposed || this.opts.signal?.aborted || this.abortGeneration !== generation)
+        throw this.staleCreationReason(generation);
+    }
     if (this.disposed)
       throw new Error(`atomic-workflows: stage "${this.opts.stageName}" session has been disposed`);
     if (this.session !== undefined)
@@ -107181,14 +107398,16 @@ class StageSessionController {
       };
       pending.then(release, () => {
         release();
-        if (this.sessionPromise === pending)
+        if (this.sessionPromise === pending) {
           this.sessionPromise = undefined;
+          this.activeCandidateIndex = undefined;
+        }
       });
     }
     return this.sessionPromise;
   }
   async ensureSessionFromFile(sessionFile, consumer = "prompt") {
-    if (!this.sessionPromise && !this.session)
+    if (!this.sessionShutdownPromise && !this.sessionPromise && !this.session)
       this.reattachSessionFile = sessionFile;
     const session = await this.ensureSession(consumer);
     await session.closeWorkflowStageGeneration?.();
@@ -107286,6 +107505,18 @@ class StageSessionController {
       return;
     let index = this.activeCandidateIndex ?? 0;
     while (index < candidates.length) {
+      if (this.session === undefined && this.ownedCreationPromise !== undefined) {
+        try {
+          await this.ownedCreationPromise;
+        } catch (error) {
+          if (error instanceof StageSessionCreationCancelled)
+            return;
+          throw error;
+        }
+        index = this.activeCandidateIndex ?? index;
+        promptText = this.pendingCreationResumeMessage ?? promptText;
+        this.pendingCreationResumeMessage = undefined;
+      }
       const candidate = candidates[index];
       try {
         const created = this.session && this.activeCandidateIndex === index ? this.session : await this.createSessionWithThrownErrorRetry(candidate, consumer);
@@ -107677,7 +107908,8 @@ class StageSessionController {
       return this.createSessionObservingPause(undefined, consumer).catch((error) => this.createInitialSessionWithRetry(undefined, consumer, { error }));
     }
     const candidates = await this.modelCandidates();
-    const first = candidates[0];
+    const initialIndex = this.activeCandidateIndex ?? 0;
+    const first = candidates[initialIndex];
     if (first === undefined) {
       return this.createSessionObservingPause(undefined, consumer).catch((error) => this.createInitialSessionWithRetry(undefined, consumer, { error }));
     }
@@ -107690,9 +107922,9 @@ class StageSessionController {
       this.resumeCurrentSession = true;
       return resumed;
     }
-    this.activeCandidateIndex = 0;
+    this.activeCandidateIndex = initialIndex;
     this.selectedModel = first.id;
-    return this.createSessionObservingPause(first, consumer).catch((error) => this.createInitialSessionCandidateWalk(candidates, consumer, 0, { error }));
+    return this.createSessionObservingPause(first, consumer).catch((error) => this.createInitialSessionCandidateWalk(candidates, consumer, initialIndex, { error }));
   }
   async createInitialSessionCandidateWalk(candidates, consumer, startIndex, initialFailure) {
     let index = startIndex;
@@ -107774,6 +108006,8 @@ class StageSessionController {
         }
         return await this.createSessionObservingPause(candidate, consumer);
       } catch (error) {
+        if (error instanceof StageSessionBindingCleanupFailure)
+          throw error;
         const errorSettingsManager = retrySettingsManagerFromError(error);
         if (errorSettingsManager !== undefined)
           this.sessionSettingsManager = errorSettingsManager;
@@ -107807,6 +108041,20 @@ class StageSessionController {
     }
   }
   createSession(candidate, consumer, resumeOptions) {
+    if (this.bindingCleanupFailure !== undefined)
+      return Promise.reject(this.bindingCleanupFailure);
+    if (this.sessionShutdownPromise !== undefined) {
+      const generation = this.abortGeneration;
+      return this.sessionShutdownPromise.then(() => {
+        if (this.disposed || this.opts.signal?.aborted || this.abortGeneration !== generation)
+          throw this.staleCreationReason(generation);
+        return this.createSession(candidate, consumer, resumeOptions);
+      });
+    }
+    if (this.activeCreation !== undefined)
+      return this.activeCreation;
+    if (this.session !== undefined)
+      return Promise.resolve(this.session);
     const creation = this.createSessionAttempt(candidate, consumer, resumeOptions);
     this.activeCreation = creation;
     creation.finally(() => {
@@ -107833,6 +108081,10 @@ class StageSessionController {
         ...this.sharedOrchestrationContext !== undefined ? { orchestrationContext: this.sharedOrchestrationContext } : {}
       }) : missingAdapter(consumer);
     } catch (error) {
+      if (error instanceof StageSessionBindingCleanupFailure) {
+        this.bindingCleanupFailure = error;
+        throw error;
+      }
       if (this.disposed || this.opts.signal?.aborted === true || this.abortGeneration !== startGeneration)
         throw this.disposed ? new Error(`atomic-workflows: stage "${this.opts.stageName}" session has been disposed`) : this.staleCreationReason(startGeneration);
       throw error;
@@ -107896,12 +108148,16 @@ class StageSessionController {
     });
     return result.session;
   }
-  async disposeCurrentSession() {
+  async disposeCurrentSession(nextCandidateIndex) {
+    if (this.sessionShutdownPromise !== undefined)
+      await this.sessionShutdownPromise;
+    const startGeneration = this.abortGeneration;
     this.abortThrownErrorRetries(new Error(`atomic-workflows: stage "${this.opts.stageName}" session was replaced`));
     const current = this.session;
     this.messageAdmission.reset();
     this.replacement.retire(current);
     this.session = undefined;
+    this.activeCandidateIndex = nextCandidateIndex;
     if (this.sessionPromise !== this.ownedCreationPromise)
       this.sessionPromise = undefined;
     this.sessionSettingsManager = undefined;
@@ -107912,6 +108168,15 @@ class StageSessionController {
     this.unsubscribeTerminateWatcher?.();
     this.unsubscribeTerminateWatcher = undefined;
     this.terminatingToolCallIds.clear();
+    const shutdown = Promise.resolve().then(() => shutdownStageSession(current));
+    this.sessionShutdownPromise = shutdown;
+    shutdown.then(() => {
+      if (this.sessionShutdownPromise === shutdown)
+        this.sessionShutdownPromise = undefined;
+    }, () => {});
+    await shutdown;
+    if (this.disposed || this.opts.signal?.aborted === true || this.abortGeneration !== startGeneration)
+      throw this.staleCreationReason(startGeneration);
   }
   async promptWithPauseResume(activeSession, initialText, sdkOptions) {
     let nextText = initialText;
@@ -108021,12 +108286,13 @@ class StageSessionController {
         throw err;
       }
       this.pendingFallbackWarnings.push(resumedOverflowNextIndex === undefined ? `[fallback] resume on ${resumedLabel} failed: ${message}. Restarting fallback from ${candidateLabel(candidates[0])}.` : `[fallback] resume on ${resumedLabel} failed: ${message}. Retrying with ${candidateLabel(candidates[resumedOverflowNextIndex])}.`);
-      await this.disposeCurrentSession();
-      this.activeCandidateIndex = resumedOverflowNextIndex;
+      await this.disposeCurrentSession(resumedOverflowNextIndex);
       return false;
     }
   }
   async handleCandidateFailure(err, candidate, candidates, index) {
+    if (err instanceof StageSessionBindingCleanupFailure)
+      throw err;
     const message = errorMessage4(err);
     const terminalStageDelivery = isWorkflowPendingStageDeliveryFailure(err);
     if (!terminalStageDelivery && this.capturedStructuredOutputForAttempt() && isRetryableModelFailure(err)) {
@@ -108050,7 +108316,7 @@ class StageSessionController {
     }
     const nextCandidate = candidates[index + 1];
     this.pendingFallbackWarnings.push(`[fallback] ${candidateLabel(candidate)} failed: ${message}. Retrying with ${candidateLabel(nextCandidate)}.`);
-    await this.disposeCurrentSession();
+    await this.disposeCurrentSession(index + 1);
     return "retry";
   }
   capturedStructuredOutputForAttempt() {
@@ -112802,6 +113068,7 @@ function registerPendingStageIntercomBridge(pi, activeStore) {
       return;
     const ownedRunIds = new Set;
     const runs = activeStore.runs();
+    const resolveBoundarySegments = createWorkflowBoundarySegmentsResolver(runs);
     for (const run of runs) {
       const rootRunId = durableRootRunIdForRun(runs, run.id);
       if (rootRunId === undefined)
@@ -112822,7 +113089,7 @@ function registerPendingStageIntercomBridge(pi, activeStore) {
           ...run.stages.filter((stage) => !isNonAgentStage(stage) && workflowInvocationOwnsGroup(workflowInvocationIntercomGroup(rootRunId), stage.intercomGroup ?? workflowInvocationIntercomGroup(rootRunId))).map((stage) => ({
             stageId: stage.id,
             stageName: stage.name,
-            target: stageRouteTarget(runs, rootRunId, run.id, stage.id),
+            target: stageRouteTarget(runs, rootRunId, run.id, stage.id, resolveBoundarySegments),
             lifecycle: stage.sessionId === undefined && stage.sessionFile === undefined ? "pending" : "running",
             routeEligible: stage.pendingStageDeliveryAvailable === true && (stage.status === "pending" || stage.status === "running" || stage.status === "awaiting_input" || stage.status === "paused" || stage.status === "blocked"),
             group: stage.intercomGroup ?? workflowInvocationIntercomGroup(rootRunId)
@@ -112830,7 +113097,7 @@ function registerPendingStageIntercomBridge(pi, activeStore) {
           ...nonAgentNodes(run).map((node) => ({
             stageId: node.id,
             stageName: node.name,
-            target: stageRouteTarget(runs, rootRunId, run.id, node.id),
+            target: stageRouteTarget(runs, rootRunId, run.id, node.id, resolveBoundarySegments),
             lifecycle: "pending",
             routeEligible: false,
             recipientPurpose: "control",
@@ -112953,8 +113220,8 @@ function registerPendingStageIntercomBridge(pi, activeStore) {
   pi.on?.("session_shutdown", dispose);
   return dispose;
 }
-function stageRouteTarget(runs, rootRunId, runId, stageId) {
-  const boundarySegments = runId === rootRunId ? [] : workflowBoundarySegments(runs, runId);
+function stageRouteTarget(runs, rootRunId, runId, stageId, resolveBoundarySegments = (id) => workflowBoundarySegments(runs, id)) {
+  const boundarySegments = runId === rootRunId ? [] : resolveBoundarySegments(runId);
   return formatWorkflowStageTarget(rootRunId, ...boundarySegments ?? [runId], stageId);
 }
 function possibleStageRows(runs, rootRunId, rootRun) {
@@ -113801,8 +114068,13 @@ function buildRuntimeAdapters(pi, options = {}) {
         const sessionOptions = withWorkflowStageSessionOptions(stripWorkflowOnlyOptions2(stageOptions) ?? {}, meta, pi);
         const result = await createSession(sessionOptions);
         const bindable = result.session;
-        if (typeof bindable.bindExtensions === "function") {
-          await bindable.bindExtensions(shouldBindStageUiContext(pi, meta) ? { uiContext: makeStageExtensionUiContext(pi.ui ?? {}, meta, broker) } : {});
+        try {
+          if (typeof bindable.bindExtensions === "function") {
+            await bindable.bindExtensions(shouldBindStageUiContext(pi, meta) ? { uiContext: makeStageExtensionUiContext(pi.ui ?? {}, meta, broker) } : {});
+          }
+        } catch (error) {
+          await cleanupFailedStageSessionBinding(result.session, error);
+          throw error;
         }
         return result;
       }
@@ -117735,6 +118007,18 @@ function registerWorkflowShortcut(pi, overlay) {
     description: "Open workflow orchestrator pane",
     handler: openPane
   });
+  pi.registerShortcut("alt+pageUp", {
+    description: "Scroll background workflows up",
+    keybinding: "app.workflows.scrollUp",
+    preferEditor: true,
+    handler: () => scrollStoreWidget(store, -1)
+  });
+  pi.registerShortcut("alt+pageDown", {
+    description: "Scroll background workflows down",
+    keybinding: "app.workflows.scrollDown",
+    preferEditor: true,
+    handler: () => scrollStoreWidget(store, 1)
+  });
 }
 function registerIntercomControl(pi, intercomControlRef) {
   intercomControlRef.current = subscribeIntercomControl(pi, buildIntercomCallbacks({