@bastani/atomic 0.9.19-alpha.9 → 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]));
@@ -79145,8 +79183,26 @@ function buildThemedWidgetLines(snap, piTheme, width = 120, now = Date.now(), la
   });
 }
 
+// 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
-import { ScrollableComponentViewport } from "@bastani/atomic";
 var WORKFLOW_WIDGET_MAX_ROWS = 10;
 
 class WorkflowWidgetViewport {
@@ -79154,53 +79210,60 @@ class WorkflowWidgetViewport {
   terminalRows;
   requestRender;
   getRunRows;
-  viewport = new ScrollableComponentViewport;
+  getHint;
+  position = 0;
+  version = 0;
+  collapsed = false;
+  state;
   lines = [];
-  scrollable = false;
   runRows = [];
-  constructor(content, terminalRows, requestRender, getRunRows) {
+  constructor(content, terminalRows, requestRender, getRunRows, getHint = () => "") {
     this.content = content;
     this.terminalRows = terminalRows;
     this.requestRender = requestRender;
     this.getRunRows = getRunRows;
-    this.viewport.setComponents([{ render: () => this.lines, invalidate() {} }]);
-    this.viewport.scrollTo(0);
+    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.scrollable)
+    if (this.collapsed)
       return;
-    this.viewport.scrollBy(direction);
+    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 cap = Math.max(1, Math.min(WORKFLOW_WIDGET_MAX_ROWS, Math.floor(this.terminalRows() / 3)));
-    const nextLines = this.content.render(width);
-    const nextRunRows = this.getRunRows?.() ?? [];
-    if (this.getRunRows && nextLines.length === 1 && nextRunRows.length === 0) {
-      this.scrollable = false;
+    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 previousLineCount = this.lines.length;
-    const offset = this.viewport.getMaxScroll() - this.viewport.getScrollFromBottom();
-    const anchoredOffset = this.getRunRows ? this.resolveAnchor(offset, nextRunRows) : undefined;
+    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;
-    if (anchoredOffset !== undefined) {
-      this.viewport.scrollTo(anchoredOffset);
-    } else if (previousLineCount <= 1 || this.lines.length < previousLineCount && this.lines.length <= cap) {
-      this.viewport.scrollTo(0);
-    }
-    this.scrollable = this.lines.length > 1;
-    this.viewport.setVisibleRows(1);
-    this.viewport.render(width);
-    if (!this.scrollable)
-      return this.lines;
-    const first = this.viewport.getMaxScroll() - this.viewport.getScrollFromBottom() + 1;
-    const visible = this.lines.slice(first - 1, first - 1 + Math.max(1, cap - 1));
-    if (cap === 1)
-      return visible;
-    const hint = ` ${first}–${first + visible.length - 1}/${this.lines.length} · Alt+PgUp/PgDn scroll workflows`;
-    return [...visible, truncateToWidth2(hint, width, "…")];
+    return nextLines;
   }
   resolveAnchor(offset, next) {
     if (offset === 0 || next.length === 0)
@@ -79272,7 +79335,7 @@ function installStoreWidget(pi, storeInstance, timers = defaultTimerApi) {
           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);
+          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);
@@ -79282,6 +79345,7 @@ function installStoreWidget(pi, storeInstance, timers = defaultTimerApi) {
     },
     key: WIDGET_KEY,
     placement: "belowEditor",
+    scroll: { maxHeight: 10, maxHeightFraction: 1 / 3 },
     timers,
     getSnapshot: () => liveWidgetSnapshot(storeInstance),
     subscribe: (listener) => subscribeStoreInvalidation(storeInstance, listener),
@@ -106724,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();
 }
@@ -107130,6 +107230,8 @@ class StageSessionController {
   abortReason;
   abortReasonGeneration = 0;
   sessionPromise;
+  sessionShutdownPromise;
+  bindingCleanupFailure;
   reattachSessionFile;
   lastPromptStartIndex;
   attemptUsageStartIndex;
@@ -107246,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;
   }
@@ -107275,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)
@@ -107289,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?.();
@@ -107394,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);
@@ -107785,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 }));
     }
@@ -107798,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;
@@ -107882,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;
@@ -107915,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(() => {
@@ -107941,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;
@@ -108004,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;
@@ -108020,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;
@@ -108129,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)) {
@@ -108158,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() {
@@ -112910,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)
@@ -112930,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)
@@ -112938,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",
@@ -113061,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) {
@@ -113909,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;
       }
@@ -117845,10 +118009,14 @@ function registerWorkflowShortcut(pi, overlay) {
   });
   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)
   });
 }