@bastani/atomic 0.9.9 → 0.9.10-alpha.1

package/dist/builtin/workflows/src/runs/background/status.ts

@@ -1,16 +1,16 @@
 /**
- * Status / kill / resume helpers for retained workflow runs and live controls.
+ * Status, internal cancellation, and resume helpers for retained workflow runs.
  *
  * These helpers operate against the singleton store and are consumed by:
- *   - The `workflow` tool execute handler (action: "status" | "kill" | "resume")
- *   - The /workflow slash command
+ *   - Workflow inspection/resume surfaces
+ *   - Internal lifecycle cancellation
  *
  * cross-ref: spec §5.5, §8.1 Phase D
  */
 
 import type { Store } from "../../shared/store.js";
 import type { RunSnapshot, RunStatus, StageSnapshot } from "../../shared/store-types.js";
-import type { WorkflowInputValues, WorkflowOutputValues, WorkflowPersistencePort } from "../../shared/types.js";
+import type { WorkflowPersistencePort } from "../../shared/types.js";
 import type { CancellationRegistry } from "./cancellation-registry.js";
 import type { StageControlRegistry } from "../foreground/stage-control-registry.js";
 import { store as defaultStore } from "../../shared/store.js";
@@ -18,8 +18,10 @@ import { stageControlRegistry as defaultStageControlRegistry } from "../foregrou
 import { appendRunEnd } from "../../shared/persistence-session-entries.js";
 import { expandWorkflowGraph } from "../../shared/expanded-workflow-graph.js";
 import { topLevelWorkflowRuns } from "../../shared/run-visibility.js";
-import { actionableReturnedStatusText, effectiveRunStatus, structuredRecoverableWorkflowFailureText } from "../../shared/returned-run-status.js";
-
+import { effectiveRunStatus } from "../../shared/returned-run-status.js";
+import { markDurableResumed } from "./durable-resume-transition.js";
+import { resumeAcknowledgementMessage, settleResumeAcknowledgements, waitForResumeReconciliation } from "./resume-acknowledgements.js";
+import { aggregateWorkflowRootRunId, expandedControlRunIds, workflowHasPausedStages } from "./workflow-lifecycle-aggregate.js";
 // ---------------------------------------------------------------------------
 // Types
 // ---------------------------------------------------------------------------
@@ -43,7 +45,7 @@ export type ResumeResult =
       runId: string;
       snapshot: RunSnapshot;
       resumed: readonly StageSnapshot[];
-      mode?: "snapshot" | "paused" | "not_resumable";
+      mode?: "snapshot" | "paused" | "partial" | "not_resumable";
       message?: string;
     }
   | { ok: false; runId: string; reason: "not_found" };
@@ -62,43 +64,7 @@ export type PauseResult =
 
 export type InterruptRunResult = PauseResult;
 
-/**
- * Per-run detail returned by {@link inspectRun}. A read-only view over the
- * store snapshot suitable for the "  RUN" detail surface — same data the
- * resume snapshot carries, plus a normalised `mode` field derived from
- * stage shape so renderers don't have to recompute it.
- */
-export interface RunDetail {
-  readonly runId: string;
-  readonly name: string;
-  readonly status: RunStatus;
-  readonly mode: "single" | "chain";
-  readonly startedAt: number;
-  readonly endedAt?: number;
-  readonly durationMs?: number;
-  readonly pausedDurationMs?: number;
-  readonly pausedAt?: number;
-  readonly resumedAt?: number;
-  readonly inputs: Readonly<WorkflowInputValues>;
-  readonly stages: readonly RunSnapshot["stages"][number][];
-  readonly result?: WorkflowOutputValues;
-  readonly error?: string;
-  readonly exited?: boolean;
-  readonly exitReason?: string;
-  readonly failureKind?: RunSnapshot["failureKind"];
-  readonly failureCode?: RunSnapshot["failureCode"];
-  readonly failureRecoverability?: RunSnapshot["failureRecoverability"];
-  readonly failureDisposition?: RunSnapshot["failureDisposition"];
-  readonly failedStageId?: string;
-  readonly resumable?: boolean;
-  readonly retryAfterMs?: number;
-  readonly blockedAt?: number;
-}
-
-export type InspectRunResult =
-  | { ok: true; runId: string; detail: RunDetail }
-  | { ok: false; runId: string; reason: "not_found" };
-
+export { inspectRun, type InspectRunResult, type RunDetail } from "./run-inspect.js";
 // ---------------------------------------------------------------------------
 // statusRuns
 // ---------------------------------------------------------------------------
@@ -122,7 +88,6 @@ export function statusRuns(opts?: { all?: boolean; store?: Store }): RunStatusEn
     stageCount: expandWorkflowGraph(snapshot, run.id).stages.length,
   }));
 }
-
 // ---------------------------------------------------------------------------
 // killRun
 // ---------------------------------------------------------------------------
@@ -198,28 +163,20 @@ export function killAllRuns(opts?: {
     killRun(r.id, { store: activeStore, cancellation: opts?.cancellation, persistence: opts?.persistence }),
   );
 }
-
 // ---------------------------------------------------------------------------
 // resumeRun
 // ---------------------------------------------------------------------------
 
 /**
- * Reopen a run for display, and resume any paused live work along the way.
+ * Reopen a run for display, awaiting every live stage-control resume before
+ * recording the corresponding store and durable transitions.
  *
- * Behaviour matrix:
- *   - non-paused run (running / ended / completed / failed / killed):
- *     returns a deep-copy snapshot, `resumed` is empty. Used by the
- *     existing slash-command path to re-summon the graph overlay.
- *   - paused run with a live `WorkflowRunControlHandle` in the
- *     stage-control registry: clears the paused state, resumes every
- *     currently-paused stage (or only `stageId` when supplied), and
- *     returns the resumed stage snapshots alongside the deep-copy.
- *
- * Returns ok:false "not_found" when the runId is unknown to the store.
- * Read-only against cancellation/persistence/job tracker; mutates the
- * store only when paused stages were actually resumed.
+ * Non-paused and terminal runs still return a read-only snapshot. Every
+ * paused control is attempted. An all-failed acknowledgement set rejects;
+ * partial success returns the actual running/paused split with qualified
+ * failures so callers never misreport externally visible progress as a no-op.
  */
-export function resumeRun(
+export async function resumeRun(
   runId: string,
   opts?: {
     store?: Store;
@@ -229,51 +186,91 @@ export function resumeRun(
     /** Optional resume message forwarded to each resumed stage. */
     message?: string;
   },
-): ResumeResult {
+): Promise<ResumeResult> {
   const activeStore = opts?.store ?? defaultStore;
   const registry = opts?.stageControlRegistry ?? defaultStageControlRegistry;
   const runs = activeStore.runs();
-  const run = runs.find((r) => r.id === runId);
+  const run = runs.find((candidate) => candidate.id === runId);
 
-  if (!run) {
-    return { ok: false, runId, reason: "not_found" };
-  }
+  if (!run) return { ok: false, runId, reason: "not_found" };
 
   const resumed: StageSnapshot[] = [];
+  const aggregateRootRunId = aggregateWorkflowRootRunId(activeStore, runId);
+  let partialFailureMessage: string | undefined;
+  let durabilityFailure: string | undefined;
+  let acknowledgedTargets = 0;
   const controlRunIds = opts?.stageId ? [runId] : expandedControlRunIds(activeStore, runId);
   const hasPausedState = controlRunIds.some((controlRunId) => {
     const controlRun = runs.find((candidate) => candidate.id === controlRunId);
-    return controlRun?.status === "paused" || (controlRun?.stages.some((s) => s.status === "paused") ?? false);
+    return controlRun?.status === "paused" || (controlRun?.stages.some((stage) => stage.status === "paused") ?? false);
   });
   if (hasPausedState) {
     const handles = opts?.stageId
       ? [registry.get(runId, opts.stageId)].filter(
-          (h): h is NonNullable<typeof h> => h !== undefined,
+          (handle): handle is NonNullable<typeof handle> => handle !== undefined && handle.status === "paused",
         ).map((handle) => ({ controlRunId: runId, handle }))
       : controlRunIds.flatMap((controlRunId) =>
           registry.run(controlRunId).pausedStages().map((handle) => ({ controlRunId, handle })),
         );
-    // Fire-and-forget the resume promise — the executor will mark each
-    // stage running once `__resume()` settles. The snapshot returned
-    // below reflects the *current* paused state; subscribers see the
-    // transition through the usual store notify path.
-    for (const { controlRunId, handle } of handles) {
-      if (handle.status !== "paused") continue;
-      void handle.resume(opts?.message);
-      const controlRun = runs.find((candidate) => candidate.id === controlRunId);
-      const stageSnap = controlRun?.stages.find((s) => s.id === handle.stageId);
-      if (stageSnap) resumed.push(stageSnap);
-      activeStore.recordRunResumed(controlRunId);
-    }
-    if (!opts?.stageId || resumed.length > 0) {
+    const acknowledgements = await settleResumeAcknowledgements(activeStore, handles, opts?.message);
+    acknowledgedTargets = acknowledgements.acknowledged;
+    resumed.push(...acknowledgements.resumed);
+    const currentRun = activeStore.runs().find((candidate) => candidate.id === runId);
+    const hasPausedDescendant = workflowHasPausedStages(activeStore, runId);
+    if (acknowledgements.acknowledged > 0 || (
+      handles.length === 0 && acknowledgements.failures.length === 0 &&
+      !hasPausedDescendant && currentRun?.status === "paused"
+    )) {
       activeStore.recordRunResumed(runId);
+      if (aggregateRootRunId !== runId) activeStore.recordRunResumed(aggregateRootRunId);
+    }
+    const reconciledRoot = activeStore.runs().find((candidate) => candidate.id === runId);
+    if (acknowledgements.failures.length > 0) {
+      const failureMessage = "Failed to resume workflow stages: " + acknowledgements.failures.join("; ");
+      if (reconciledRoot?.status !== "running") throw new Error(failureMessage);
+      partialFailureMessage = "Partially resumed " + runId + ": " + resumed.length
+        + " stage(s) running; " + failureMessage + ". Failed paused stages remain resumable.";
+    } else if (acknowledgements.lateFailures.length > 0) {
+      partialFailureMessage = "Resumed " + resumed.length + " stage(s) on " + runId
+        + "; acknowledgements reported after visible resume: " + acknowledgements.lateFailures.join("; ")
+        + ". Running stages are not retryable.";
     }
   }
 
-  // Return a deep copy of the snapshot for safe consumption
-  const snapshot = structuredClone(run);
+  await waitForResumeReconciliation(acknowledgedTargets);
+
+  const locallyReconciledRoot = activeStore.runs().find((candidate) => candidate.id === aggregateRootRunId);
+  if (locallyReconciledRoot?.endedAt === undefined && locallyReconciledRoot?.status === "running") {
+    try {
+      const transition = await markDurableResumed(aggregateRootRunId);
+      if (transition === "refused") {
+        durabilityFailure = "authoritative durable workflow " + aggregateRootRunId + " refused the running transition";
+      }
+    } catch (error) {
+      durabilityFailure = error instanceof Error ? error.message : String(error);
+    }
+  }
+  if (durabilityFailure !== undefined) {
+    const durableMessage = "Durable resume transition failed after visible local resume: " + durabilityFailure + ".";
+    partialFailureMessage = partialFailureMessage === undefined
+      ? durableMessage
+      : partialFailureMessage + " " + durableMessage;
+  }
+
+  const current = activeStore.runs().find((candidate) => candidate.id === runId) ?? run;
+  const snapshot = structuredClone(current);
   const resumedCopy = structuredClone(resumed);
-  if (run.status === "killed" || run.resumable === false) {
+  if (partialFailureMessage !== undefined) {
+    return {
+      ok: true,
+      runId,
+      snapshot,
+      resumed: resumedCopy,
+      mode: "partial",
+      message: partialFailureMessage,
+    };
+  }
+  if (current.status === "killed" || current.resumable === false) {
     return {
       ok: true,
       runId,
@@ -284,10 +281,10 @@ export function resumeRun(
     };
   }
   if (
-    run.endedAt === undefined &&
-    run.resumable === true &&
-    run.failureRecoverability === "recoverable" &&
-    run.failedStageId !== undefined
+    current.endedAt === undefined &&
+    current.resumable === true &&
+    current.failureRecoverability === "recoverable" &&
+    current.failedStageId !== undefined
   ) {
     return {
       ok: true,
@@ -295,46 +292,25 @@ export function resumeRun(
       snapshot,
       resumed: resumedCopy,
       mode: resumedCopy.length > 0 ? "paused" : "snapshot",
-      message: `Workflow is blocked on a recoverable ${run.failureCode ?? run.failureKind ?? "workflow"} failure at stage ${run.failedStageId}; retry/resume after the issue clears.`,
+      message: `Workflow is blocked on a recoverable ${current.failureCode ?? current.failureKind ?? "workflow"} failure at stage ${current.failedStageId}; retry/resume after the issue clears.`,
     };
   }
+  const acknowledgementMessage = resumeAcknowledgementMessage(
+    acknowledgedTargets, resumedCopy.length, runId, current,
+  );
   return {
     ok: true,
     runId,
     snapshot,
     resumed: resumedCopy,
     mode: resumedCopy.length > 0 ? "paused" : "snapshot",
+    ...(acknowledgementMessage !== undefined ? { message: acknowledgementMessage } : {}),
   };
 }
 
-// ---------------------------------------------------------------------------
 // pauseRun
-// ---------------------------------------------------------------------------
-
-/**
- * Pause a run or a specific stage within a run.
- *
- *  - With no `stageId`: every currently-running stage with a live handle
- *    in the stage-control registry is paused. If at least one stage is
- *    paused, the run is marked `paused` in the store.
- *  - With `stageId`: only that stage is paused. The run is marked paused
- *    only when *every* still-active stage in the run is paused after the
- *    operation.
- *
- * Refuses runs that are already terminal (completed / failed / killed)
- * with `reason: "already_ended"`. Refuses runs with no pausable stage
- * handles in the registry with `reason: "no_active_stages"`. Refuses a
- * stage-scoped pause when no matching handle exists with
- * `reason: "stage_not_found"`.
- */
-function expandedControlRunIds(activeStore: Store, runId: string): string[] {
-  const graph = expandWorkflowGraph(activeStore.snapshot(), runId);
-  const ids = new Set<string>([runId]);
-  for (const stage of graph.stages) ids.add(stage.workflowGraphTarget.runId);
-  return [...ids];
-}
-
-export function pauseRun(
+/** Pause a run only after its live stage controls acknowledge the request. */
+export async function pauseRun(
   runId: string,
   opts?: {
     store?: Store;
@@ -342,34 +318,30 @@ export function pauseRun(
     /** Pause only this stage. */
     stageId?: string;
   },
-): PauseResult {
+): Promise<PauseResult> {
   const activeStore = opts?.store ?? defaultStore;
   const registry = opts?.stageControlRegistry ?? defaultStageControlRegistry;
-  const runs = activeStore.runs();
-  const run = runs.find((r) => r.id === runId);
+  const run = activeStore.runs().find((candidate) => candidate.id === runId);
 
-  if (!run) {
-    return { ok: false, runId, reason: "not_found" };
-  }
-  if (run.endedAt !== undefined) {
-    return { ok: false, runId, reason: "already_ended" };
-  }
+  if (!run) return { ok: false, runId, reason: "not_found" };
+  if (run.endedAt !== undefined) return { ok: false, runId, reason: "already_ended" };
 
   if (opts?.stageId !== undefined) {
     const handle = registry.get(runId, opts.stageId);
-    if (!handle) {
-      return { ok: false, runId, reason: "stage_not_found" };
-    }
+    if (!handle) return { ok: false, runId, reason: "stage_not_found" };
     if (handle.status !== "running" && handle.status !== "pending") {
       return { ok: false, runId, reason: "no_active_stages" };
     }
-    void handle.pause();
-    const stageSnap = run.stages.find((s) => s.id === opts.stageId);
-    const paused: StageSnapshot[] = stageSnap ? [structuredClone(stageSnap)] : [];
-    // Only mark the whole run paused when every active stage is paused.
-    const stillActive = run.stages.some(
-      (s) => s.status === "running" && s.id !== opts.stageId,
-    );
+    await handle.pause();
+    activeStore.recordStagePaused(runId, opts.stageId);
+    const currentRun = activeStore.runs().find((candidate) => candidate.id === runId);
+    const stage = currentRun?.stages.find((candidate) => candidate.id === opts.stageId);
+    const paused = stage === undefined ? [] : [structuredClone(stage)];
+    const stillActive = currentRun?.stages.some(
+      (candidate) =>
+        candidate.id !== opts.stageId &&
+        (candidate.status === "running" || candidate.status === "pending"),
+    ) ?? false;
     if (!stillActive) activeStore.recordRunPaused(runId);
     return { ok: true, runId, paused };
   }
@@ -377,123 +349,60 @@ export function pauseRun(
   const controlRunIds = expandedControlRunIds(activeStore, runId);
   const handles = controlRunIds.flatMap((controlRunId) =>
     registry.run(controlRunId).stages().filter(
-      (h) => h.status === "running" || h.status === "pending",
+      (handle) => handle.status === "running" || handle.status === "pending",
     ).map((handle) => ({ controlRunId, handle })),
   );
-  if (handles.length === 0) {
-    return { ok: false, runId, reason: "no_active_stages" };
-  }
-  const pausedSnaps: StageSnapshot[] = [];
+  if (handles.length === 0) return { ok: false, runId, reason: "no_active_stages" };
+
+  const paused: StageSnapshot[] = [];
+  const pausedRunIds = new Set<string>();
   for (const { controlRunId, handle } of handles) {
-    void handle.pause();
+    await handle.pause();
+    activeStore.recordStagePaused(controlRunId, handle.stageId);
+    pausedRunIds.add(controlRunId);
     const controlRun = activeStore.runs().find((candidate) => candidate.id === controlRunId);
-    const stageSnap = controlRun?.stages.find((s) => s.id === handle.stageId);
-    if (stageSnap) pausedSnaps.push(structuredClone(stageSnap));
-    activeStore.recordRunPaused(controlRunId);
+    const stage = controlRun?.stages.find((candidate) => candidate.id === handle.stageId);
+    if (stage !== undefined) paused.push(structuredClone(stage));
   }
+  for (const pausedRunId of pausedRunIds) activeStore.recordRunPaused(pausedRunId);
   activeStore.recordRunPaused(runId);
-  return { ok: true, runId, paused: pausedSnaps };
+  return { ok: true, runId, paused };
 }
 
-export function pauseAllRuns(opts?: {
+export async function pauseAllRuns(opts?: {
   store?: Store;
   stageControlRegistry?: StageControlRegistry;
-}): PauseResult[] {
+}): Promise<PauseResult[]> {
   const activeStore = opts?.store ?? defaultStore;
-  const inFlight = topLevelWorkflowRuns(activeStore.runs()).filter((r) => r.endedAt === undefined);
-  return inFlight.map((r) =>
-    pauseRun(r.id, { store: activeStore, stageControlRegistry: opts?.stageControlRegistry }),
-  );
+  const inFlight = topLevelWorkflowRuns(activeStore.runs()).filter((run) => run.endedAt === undefined);
+  return Promise.all(inFlight.map((run) =>
+    pauseRun(run.id, { store: activeStore, stageControlRegistry: opts?.stageControlRegistry })
+  ));
 }
-
-
 // ---------------------------------------------------------------------------
 // interruptRun
 // ---------------------------------------------------------------------------
 
-/**
- * Interrupt a run in a resumable way by pausing live stage handles when
- * available. This never aborts the workflow controller and
- * never removes the run from status/history.
- */
-export function interruptRun(
+/** Interrupt a run in a resumable way without destructive cancellation. */
+export async function interruptRun(
   runId: string,
   opts?: {
     store?: Store;
     stageControlRegistry?: StageControlRegistry;
     stageId?: string;
   },
-): InterruptRunResult {
+): Promise<InterruptRunResult> {
   return pauseRun(runId, opts);
 }
 
 /** Interrupt all in-flight runs without removing them from history/status. */
-export function interruptAllRuns(opts?: {
+export async function interruptAllRuns(opts?: {
   store?: Store;
   stageControlRegistry?: StageControlRegistry;
-}): InterruptRunResult[] {
+}): Promise<InterruptRunResult[]> {
   const activeStore = opts?.store ?? defaultStore;
-  const inFlight = topLevelWorkflowRuns(activeStore.runs()).filter((r) => r.endedAt === undefined);
-  return inFlight.map((r) =>
-    interruptRun(r.id, { store: activeStore, stageControlRegistry: opts?.stageControlRegistry }),
-  );
-}
-
-// ---------------------------------------------------------------------------
-// inspectRun
-// ---------------------------------------------------------------------------
-
-/**
- * Look up a single run by id (full UUID or unique prefix) and return a
- * normalised {@link RunDetail} for the per-run text/TUI surfaces.
- *
- * Returns ok:false "not_found" when no run matches, "ambiguous" when a
- * prefix matches multiple. Read-only: does not mutate the store.
- */
-export function inspectRun(
-  runId: string,
-  opts?: { store?: Store },
-): InspectRunResult {
-  const activeStore = opts?.store ?? defaultStore;
-  const runs = activeStore.runs();
-
-  const exact = runs.find((r) => r.id === runId);
-  const candidate = exact ?? (runs.length > 0 ? runs.find((r) => r.id.startsWith(runId)) : undefined);
-
-  if (!candidate) {
-    return { ok: false, runId, reason: "not_found" };
-  }
-
-  // Deep copy so callers cannot mutate the store via the snapshot.
-  const copy = structuredClone(candidate);
-  const expandedStages = expandWorkflowGraph(activeStore.snapshot(), copy.id).stages;
-
-  const detail: RunDetail = {
-    runId: copy.id,
-    name: copy.name,
-    status: effectiveRunStatus(copy),
-    mode: expandedStages.length > 1 ? "chain" : "single",
-    startedAt: copy.startedAt,
-    endedAt: copy.endedAt,
-    durationMs: copy.durationMs,
-    pausedDurationMs: copy.pausedDurationMs,
-    pausedAt: copy.pausedAt,
-    resumedAt: copy.resumedAt,
-    inputs: copy.inputs,
-    stages: expandedStages.map((stage) => structuredClone(stage)),
-    result: copy.result,
-    error: copy.error ?? (effectiveRunStatus(copy) === copy.status ? undefined : (structuredRecoverableWorkflowFailureText(copy) ?? actionableReturnedStatusText(copy.result))),
-    exited: copy.exited,
-    exitReason: copy.exitReason,
-    failureKind: copy.failureKind,
-    failureCode: copy.failureCode,
-    failureRecoverability: copy.failureRecoverability,
-    failureDisposition: copy.failureDisposition,
-    failedStageId: copy.failedStageId,
-    resumable: copy.resumable,
-    retryAfterMs: copy.retryAfterMs,
-    blockedAt: copy.blockedAt,
-  };
-
-  return { ok: true, runId: copy.id, detail };
+  const inFlight = topLevelWorkflowRuns(activeStore.runs()).filter((run) => run.endedAt === undefined);
+  return Promise.all(inFlight.map((run) =>
+    interruptRun(run.id, { store: activeStore, stageControlRegistry: opts?.stageControlRegistry })
+  ));
 }

package/dist/builtin/workflows/src/runs/background/workflow-lifecycle-aggregate.ts

@@ -0,0 +1,44 @@
+import { expandWorkflowGraph } from "../../shared/expanded-workflow-graph.js";
+import type { Store } from "../../shared/store-public-types.js";
+
+/** Control-run ids visible below one workflow boundary, in graph order. */
+export function expandedControlRunIds(store: Store, runId: string): string[] {
+  const graph = expandWorkflowGraph(store.snapshot(), runId);
+  const ids = new Set<string>([runId]);
+  for (const stage of graph.stages) ids.add(stage.workflowGraphTarget.runId);
+  return [...ids];
+}
+
+/** Find the aggregate top-level lifecycle owner for a nested child run. */
+export function aggregateWorkflowRootRunId(store: Store, runId: string): string {
+  let current = runId;
+  const visited = new Set<string>();
+  while (!visited.has(current)) {
+    visited.add(current);
+    const parent = store.runs().find((run) => run.stages.some((stage) =>
+      stage.workflowChildRun?.runId === current || stage.workflowChild?.runId === current
+    ));
+    if (parent === undefined) return current;
+    current = parent.id;
+  }
+  return current;
+}
+
+/** Whether this workflow boundary contains a paused/blocked descendant stage. */
+export function workflowHasPausedStages(store: Store, runId: string): boolean {
+  return expandedControlRunIds(store, runId).some((controlRunId) =>
+    store.runs().find((run) => run.id === controlRunId)?.stages.some(
+      (stage) => stage.status === "paused" || stage.status === "blocked",
+    ) ?? false
+  );
+}
+
+/** Whether this workflow boundary or any descendant remains paused. */
+export function workflowHasPausedState(store: Store, runId: string): boolean {
+  return expandedControlRunIds(store, runId).some((controlRunId) => {
+    const run = store.runs().find((candidate) => candidate.id === controlRunId);
+    return run?.status === "paused" || run?.stages.some(
+      (stage) => stage.status === "paused" || stage.status === "blocked",
+    ) === true;
+  });
+}