@bastani/atomic 0.8.21 → 0.8.22

package/dist/builtin/workflows/src/extension/wiring.ts

@@ -23,7 +23,7 @@
 
 import { basename } from "node:path";
 import type { ChatMessageRenderOptions, CreateAgentSessionOptions } from "@bastani/atomic";
-import type { StageAdapters, StageSessionRuntime } from "../runs/foreground/stage-runner.js";
+import type { StageAdapters, StageSessionCreateResult, StageSessionRuntime } from "../runs/foreground/stage-runner.js";
 import type { StageExecutionMeta, StageOptions } from "../shared/types.js";
 import { stageUiBroker, type StageUiBroker } from "../shared/stage-ui-broker.js";
 
@@ -56,12 +56,12 @@ export interface RuntimeWiringSurface {
   exec?: (command: string, args: string[], opts?: PiExecOpts) => Promise<PiExecResult>;
   ui?: PiUISurface;
   /** Test seam: inject a stub session factory instead of importing the SDK. */
-  createAgentSession?: (options?: CreateAgentSessionOptions) => Promise<{ session: StageSessionRuntime }>;
+  createAgentSession?: (options?: CreateAgentSessionOptions) => Promise<StageSessionCreateResult>;
 }
 
 export interface RuntimeAdapterBuildOptions {
   /** Test seam for SDK session creation. */
-  createAgentSession?: (options?: CreateAgentSessionOptions) => Promise<{ session: StageSessionRuntime }>;
+  createAgentSession?: (options?: CreateAgentSessionOptions) => Promise<StageSessionCreateResult>;
   /** Broker that routes stage-local custom UI into attached workflow nodes. */
   stageUiBroker?: StageUiBroker;
 }
@@ -90,7 +90,9 @@ function isTestContext(): boolean {
  * cross-ref: node_modules/@bastani/atomic/docs/sdk.md
  *            node_modules/@bastani/atomic/dist/core/sdk.d.ts
  */
-export interface PiSdkSettingsManager {}
+export interface PiSdkSettingsManager {
+  getCodexFastModeSettings(): { readonly chat: boolean; readonly workflow: boolean };
+}
 export interface PiSdkResourceLoader {
   reload(): Promise<void>;
 }
@@ -176,17 +178,24 @@ function stageBuiltinPackagePaths(paths: readonly string[]): string[] {
 
 async function createPiSdkAgentSession(
   options?: CreateAgentSessionOptions,
-): Promise<{ session: StageSessionRuntime }> {
+): Promise<StageSessionCreateResult> {
   const sdk = await import("@bastani/atomic") as PiCodingAgentSdk;
   const sessionOptions = await prepareAtomicStageSessionOptions(options, sdk);
   const result = await sdk.createAgentSession(sessionOptions);
   // `CreateAgentSessionResult` is `{ session, extensionsResult, modelFallbackMessage? }`;
   // workflow stages only consume `.session` (structurally an `AgentSession`,
   // which is a superset of our `StageSessionRuntime` projection).
-  return { session: result.session };
+  const resultSettingsManager = result.session.settingsManager;
+  const settingsManager = sessionOptions?.settingsManager ?? resultSettingsManager;
+  return {
+    session: result.session,
+    ...(settingsManager?.getCodexFastModeSettings !== undefined
+      ? { settingsManager }
+      : {}),
+  };
 }
 
-async function createTestAgentSession(_options?: CreateAgentSessionOptions): Promise<{ session: StageSessionRuntime }> {
+async function createTestAgentSession(_options?: CreateAgentSessionOptions): Promise<StageSessionCreateResult> {
   let lastAssistantText: string | undefined;
   const session: StageSessionRuntime = {
     async prompt(text: string): Promise<string> {
@@ -255,7 +264,14 @@ function withWorkflowStageSessionOptions(
 ): CreateAgentSessionOptions {
   // Workflow stage sessions should never see the workflow tool, even when older
   // meta-less callers cannot receive the richer runtime orchestration context.
-  const excludedTools = Array.from(new Set([...(options.excludedTools ?? []), "workflow"]));
+  // Non-interactive workflow runs also remove ask_user_question so child agents
+  // cannot block unattended automation on a prompt that no user can answer.
+  const policyExcludedTools = meta?.executionMode === "non_interactive"
+    ? ["workflow", "ask_user_question"]
+    : ["workflow"];
+  const excludedTools = Array.from(
+    new Set([...(options.excludedTools ?? []), ...policyExcludedTools]),
+  );
   return {
     ...options,
     excludedTools,
@@ -263,6 +279,11 @@ function withWorkflowStageSessionOptions(
   };
 }
 
+function shouldBindStageUiContext(pi: RuntimeWiringSurface, meta: StageExecutionMeta | undefined): boolean {
+  if (meta?.executionMode === "non_interactive") return false;
+  return pi.ui !== undefined || meta !== undefined;
+}
+
 function makeStageExtensionUiContext(
   ui: PiUISurface,
   meta: StageExecutionMeta | undefined,
@@ -297,7 +318,7 @@ function makeStageExtensionUiContext(
         const result = await ui.custom(factory as PiCustomOverlayFactory, options ?? { overlay: true });
         return result as T;
       }
-      throw new Error("pi-workflows: ask_user_question UI is unavailable");
+      throw new Error("atomic-workflows: ask_user_question UI is unavailable");
     },
     pasteToEditor: ui.pasteToEditor ?? (() => undefined),
     setEditorText: ui.setEditorText ?? (() => undefined),
@@ -309,7 +330,7 @@ function makeStageExtensionUiContext(
     theme: ui.theme,
     getAllThemes: ui.getAllThemes ?? (() => []),
     getTheme: ui.getTheme ?? (() => undefined),
-    setTheme: ui.setTheme ?? (() => ({ success: false, error: "pi-workflows: theme UI is unavailable" })),
+    setTheme: ui.setTheme ?? (() => ({ success: false, error: "atomic-workflows: theme UI is unavailable" })),
     getToolsExpanded: ui.getToolsExpanded ?? (() => false),
     setToolsExpanded: ui.setToolsExpanded ?? (() => undefined),
     getChatRenderSettings: ui.getChatRenderSettings ?? (() => undefined),
@@ -343,7 +364,7 @@ export function buildRuntimeAdapters(
   const broker = options.stageUiBroker ?? stageUiBroker;
   const adapters: StageAdapters = {
     agentSession: {
-      async create(stageOptions: CreateAgentSessionOptions & Pick<StageOptions, "mcp" | "fallbackModels">, meta?: StageExecutionMeta): Promise<StageSessionRuntime> {
+      async create(stageOptions: CreateAgentSessionOptions & Pick<StageOptions, "mcp" | "fallbackModels">, meta?: StageExecutionMeta): Promise<StageSessionRuntime | StageSessionCreateResult> {
         // Atomic's SDK handles extension / skills / prompt-template /
         // slash-command discovery via the SettingsManager / ResourceLoader.
         // The production default deliberately uses normal DefaultResourceLoader
@@ -357,12 +378,12 @@ export function buildRuntimeAdapters(
         );
         const result = await createSession(sessionOptions);
         const bindable = result.session as BindableStageSession;
-        if ((pi.ui !== undefined || meta !== undefined) && typeof bindable.bindExtensions === "function") {
+        if (shouldBindStageUiContext(pi, meta) && typeof bindable.bindExtensions === "function") {
           await bindable.bindExtensions({
             uiContext: makeStageExtensionUiContext(pi.ui ?? {}, meta, broker),
           });
         }
-        return result.session;
+        return result;
       },
     },
   };

package/dist/builtin/workflows/src/extension/workflow-module-loader.ts

@@ -0,0 +1,142 @@
+/**
+ * Shared workflow module loading helpers.
+ *
+ * Discovery loads user-authored workflow files through this jiti instance so
+ * TypeScript/ESM/CJS semantics and the @bastani/workflows virtual SDK alias
+ * stay consistent.
+ */
+
+import { createJiti } from "jiti/static";
+import * as workflowsSdkSurface from "../sdk-surface.js";
+import deepResearchCodebase from "../../builtin/deep-research-codebase.js";
+import goal from "../../builtin/goal.js";
+import openClaudeDesign from "../../builtin/open-claude-design.js";
+import ralph from "../../builtin/ralph.js";
+
+type RunWorkflowFunction = typeof import("../runs/shared/workflow-runner.js").runWorkflow;
+
+const runWorkflow: RunWorkflowFunction = async (...args) => {
+  const { runWorkflow: actualRunWorkflow } = await import("../runs/shared/workflow-runner.js");
+  return actualRunWorkflow(...args);
+};
+
+const WORKFLOWS_MODULE_SPECIFIER = "@bastani/workflows";
+const WORKFLOWS_BUILTIN_MODULE_SPECIFIER = `${WORKFLOWS_MODULE_SPECIFIER}/builtin`;
+// Keep this in sync with index.ts through sdk-surface.ts. runWorkflow stays as
+// a lazy wrapper because the public re-export comes from workflow-runner.ts,
+// which imports discovery.ts and would otherwise reintroduce a cycle.
+const WORKFLOWS_SDK_MODULE: Record<string, unknown> = {
+  ...workflowsSdkSurface,
+  runWorkflow,
+};
+const WORKFLOWS_BUILTIN_MODULE: Record<string, unknown> = {
+  deepResearchCodebase,
+  goal,
+  openClaudeDesign,
+  ralph,
+};
+const WORKFLOWS_VIRTUAL_MODULES: Record<string, unknown> = {
+  [WORKFLOWS_MODULE_SPECIFIER]: WORKFLOWS_SDK_MODULE,
+  [WORKFLOWS_BUILTIN_MODULE_SPECIFIER]: WORKFLOWS_BUILTIN_MODULE,
+  [`${WORKFLOWS_BUILTIN_MODULE_SPECIFIER}/deep-research-codebase`]: { default: deepResearchCodebase },
+  [`${WORKFLOWS_BUILTIN_MODULE_SPECIFIER}/goal`]: { default: goal },
+  [`${WORKFLOWS_BUILTIN_MODULE_SPECIFIER}/open-claude-design`]: { default: openClaudeDesign },
+  [`${WORKFLOWS_BUILTIN_MODULE_SPECIFIER}/ralph`]: { default: ralph },
+};
+
+const workflowModuleLoader = createJiti(import.meta.url, {
+  moduleCache: false,
+  // Keep workflow-file import semantics deterministic: jiti owns .ts/.js/.mjs/.cjs
+  // resolution instead of handing some imports back to native import().
+  tryNative: false,
+  // Resolve the @bastani/workflows SDK (and its builtin submodules) to in-memory
+  // surfaces in every runtime. This mirrors the compiled bun binary path and
+  // keeps discovery fast: aliasing the SDK to its on-disk package re-evaluated
+  // the entire SDK module graph once per workflow file (moduleCache stays false),
+  // which scaled discovery to multiple seconds on projects with many workflow
+  // files. Workflow files themselves are still evaluated fresh from disk, so
+  // `/workflow reload` continues to observe edits.
+  virtualModules: WORKFLOWS_VIRTUAL_MODULES,
+});
+
+function materializeModuleObject(mod: object): Record<string, unknown> {
+  const materialized: Record<string, unknown> = {};
+
+  // jiti's callable API can return an interop namespace proxy. Its own property
+  // descriptors contain the authored export values, but property access may apply
+  // default-export conveniences (and even expose a throwing inherited `then`
+  // getter for `export default null`). Copy own descriptors into a plain object
+  // so candidate collection sees the exact authored exports.
+  for (const key of Object.getOwnPropertyNames(mod)) {
+    const descriptor = Object.getOwnPropertyDescriptor(mod, key);
+    if (descriptor === undefined) continue;
+
+    const value = "value" in descriptor ? descriptor.value : descriptor.get?.call(mod);
+    Object.defineProperty(materialized, key, {
+      value,
+      enumerable: descriptor.enumerable,
+      configurable: true,
+      writable: true,
+    });
+  }
+
+  return materialized;
+}
+
+function normalizeWorkflowModule(mod: unknown): Record<string, unknown> {
+  if (mod !== null && typeof mod === "object") {
+    return materializeModuleObject(mod);
+  }
+  // CJS/default interop can return the exported value directly; wrap it so the
+  // candidate collector can handle it the same way as an ESM default export.
+  return { default: mod };
+}
+
+export interface WorkflowModuleCandidate {
+  readonly value: unknown;
+  readonly exportKey: string;
+}
+
+export function validateWorkflowDefinitionShape(value: unknown): string | null {
+  if (value === null || typeof value !== "object") {
+    return "export is not an object";
+  }
+  const d = value as Record<string, unknown>;
+
+  if (d["__piWorkflow"] !== true) {
+    return "missing or incorrect __piWorkflow sentinel (expected true)";
+  }
+  if (typeof d["name"] !== "string" || (d["name"] as string).trim().length === 0) {
+    return "name must be a non-empty string";
+  }
+  if (typeof d["normalizedName"] !== "string" || (d["normalizedName"] as string).trim().length === 0) {
+    return "normalizedName must be a non-empty string";
+  }
+  if (typeof d["run"] !== "function") {
+    return "run must be a function";
+  }
+  return null;
+}
+
+export function loadWorkflowModule(filePath: string): Record<string, unknown> {
+  return normalizeWorkflowModule(workflowModuleLoader(filePath));
+}
+
+export function collectWorkflowModuleCandidates(mod: Record<string, unknown>): WorkflowModuleCandidate[] {
+  const candidates: WorkflowModuleCandidate[] = [];
+
+  // Default export first (RFC §5.12: check mod.default before named exports)
+  if ("default" in mod && mod["default"] !== undefined) {
+    candidates.push({ value: mod["default"], exportKey: "default" });
+  }
+
+  // Then all named exports (a file may export multiple workflow definitions)
+  for (const [key, val] of Object.entries(mod)) {
+    if (key === "default") continue;
+    if (val !== undefined) {
+      candidates.push({ value: val, exportKey: key });
+    }
+  }
+
+  return candidates;
+}

package/dist/builtin/workflows/src/extension/workflow-schema.ts

@@ -113,7 +113,7 @@ export const WorkflowParametersSchema = Type.Object({
     Type.Literal("resume"),
     Type.Literal("reload"),
   ], {
-    description: "Workflow action: run/list/get/inputs/status, inspect stages/transcripts, send messages or prompt answers, pause/resume/interrupt/kill runs, or reload workflow resources.",
+    description: "Workflow action: run/list/get/inputs/status, inspect stage metadata, send messages or prompt answers, pause/resume/interrupt/kill runs, or reload workflow resources. For transcript inspection, prefer status/stages/stage first to get sessionFile/transcriptPath, quote the exact path without rewriting separators (Windows backslashes are valid), then search it with rg/grep and read small ranges; transcript defaults to at most 5 recent entries and explicit tail/limit overrides that preview.",
   })),
   runId: Type.Optional(Type.String({
     description: "Run identifier or unique prefix for status/stages/stage/transcript/send/pause/resume/interrupt/kill. Use '--all' or all:true for supported bulk run-control actions.",
@@ -145,14 +145,14 @@ export const WorkflowParametersSchema = Type.Object({
   })),
   limit: Type.Optional(Type.Integer({
     minimum: 0,
-    description: "Transcript-only: maximum number of most recent transcript entries to return; applied before tool output is serialized.",
+    description: "Transcript-only: explicitly inline at most this many recent entries. Omit both limit and tail to use the default 5-entry preview plus metadata/path; prefer rg/grep on the exact quoted sessionFile/transcriptPath for targeted lookup without rewriting platform path separators.",
   })),
   tail: Type.Optional(Type.Integer({
     minimum: 0,
-    description: "Transcript-only: return only the last N transcript entries; overrides limit when both are provided.",
+    description: "Transcript-only: explicitly inline the last N entries; overrides limit. Use for quick recent-context checks after status/stages/stage expose the transcript path.",
   })),
   includeToolOutput: Type.Optional(Type.Boolean({
-    description: "Transcript-only: include captured tool output entries when building results from stage snapshots; live session transcripts may not expose tool output.",
+    description: "Transcript-only: include captured tool output entries when building transcript results from stage snapshots; prefer rg/grep on the exact quoted sessionFile/transcriptPath for large outputs. Live session transcripts may not expose tool output.",
   })),
   text: Type.Optional(Type.String({
     description: "Text to send to a stage for prompt answers, steering, follow-ups, or resume messages.",

package/dist/builtin/workflows/src/index.ts

@@ -11,3 +11,5 @@ export * from "./sdk-surface.js";
 // discovery provides a lazy wrapper instead of importing this entry eagerly.
 export { runWorkflow } from "./runs/shared/workflow-runner.js";
 export type { WorkflowOptions, WorkflowRunOptions } from "./runs/shared/workflow-runner.js";
+
+// Note: `Type` / `Static` / `TSchema` are re-exported via ./sdk-surface.js.

package/dist/builtin/workflows/src/intercom/result-intercom.ts

@@ -225,7 +225,7 @@ export function subscribeIntercomControl(
       // Surface errors without breaking the event loop.
       Promise.reject(
         new Error(
-          `pi-workflows intercom callback error (type=${payload.type}): ${err instanceof Error ? err.message : String(err)}`,
+          `atomic-workflows: intercom callback error (type=${payload.type}): ${err instanceof Error ? err.message : String(err)}`,
         ),
       );
     });

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

@@ -14,7 +14,7 @@
  * cross-ref: spec detached-runner
  */
 
-import type { WorkflowDefinition } from "../../shared/types.js";
+import type { WorkflowDefinition, WorkflowExecutionMode, WorkflowInputValues } from "../../shared/types.js";
 import type { RunOpts, RunResult } from "../foreground/executor.js";
 import type { CancellationRegistry } from "./cancellation-registry.js";
 import type { JobTracker } from "./job-tracker.js";
@@ -52,6 +52,8 @@ export interface DetachedRunOpts
    * Override JobTracker (default: singleton jobTracker).
    */
   jobs?: JobTracker;
+  /** Runtime execution mode for UI/prompt policy. Defaults to interactive. */
+  executionMode?: WorkflowExecutionMode;
 }
 
 // ---------------------------------------------------------------------------
@@ -83,9 +85,9 @@ export function buildDetachedAccepted(
  * the store remains source of truth for run status. Cancellation is wired
  * through the provided (or default) CancellationRegistry.
  */
-export function runDetached<TInputs extends Record<string, unknown>>(
+export function runDetached<TInputs extends WorkflowInputValues>(
   def: WorkflowDefinition<TInputs>,
-  inputs: Record<string, unknown>,
+  inputs: Readonly<Record<string, unknown>>,
   opts: DetachedRunOpts = {},
 ): DetachedAccepted {
   const registry = opts.cancellation ?? defaultCancellationRegistry;
@@ -122,7 +124,7 @@ export function runDetached<TInputs extends Record<string, unknown>>(
     signal: controller.signal,
     cancellation: registry,
     store,
-    usePromptNodesForUi: true,
+    usePromptNodesForUi: opts.executionMode !== "non_interactive",
     deferWorkflowStart: true,
   };
 

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

@@ -10,12 +10,14 @@
 
 import type { Store } from "../../shared/store.js";
 import type { RunSnapshot, RunStatus, StageSnapshot } from "../../shared/store-types.js";
-import type { WorkflowPersistencePort } from "../../shared/types.js";
+import type { WorkflowInputValues, WorkflowOutputValues, 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";
 import { stageControlRegistry as defaultStageControlRegistry } from "../foreground/stage-control-registry.js";
 import { appendRunEnd } from "../../shared/persistence-session-entries.js";
+import { expandWorkflowGraph } from "../../shared/expanded-workflow-graph.js";
+import { topLevelWorkflowRuns } from "../../shared/run-visibility.js";
 
 // ---------------------------------------------------------------------------
 // Types
@@ -76,9 +78,9 @@ export interface RunDetail {
   readonly pausedDurationMs?: number;
   readonly pausedAt?: number;
   readonly resumedAt?: number;
-  readonly inputs: Readonly<Record<string, unknown>>;
+  readonly inputs: Readonly<WorkflowInputValues>;
   readonly stages: readonly RunSnapshot["stages"][number][];
-  readonly result?: Record<string, unknown>;
+  readonly result?: WorkflowOutputValues;
   readonly error?: string;
 }
 
@@ -99,13 +101,14 @@ export type InspectRunResult =
 export function statusRuns(opts?: { all?: boolean; store?: Store }): RunStatusEntry[] {
   const activeStore = opts?.store ?? defaultStore;
 
-  return activeStore.runs().map((run) => ({
+  const snapshot = activeStore.snapshot();
+  return topLevelWorkflowRuns(snapshot.runs).map((run) => ({
     runId: run.id,
     name: run.name,
     status: run.status,
     startedAt: run.startedAt,
     durationMs: run.durationMs,
-    stageCount: run.stages.length,
+    stageCount: expandWorkflowGraph(snapshot, run.id).stages.length,
   }));
 }
 
@@ -164,7 +167,7 @@ export function killAllRuns(opts?: {
   persistence?: WorkflowPersistencePort;
 }): KillResult[] {
   const activeStore = opts?.store ?? defaultStore;
-  const inFlight = activeStore.runs().filter((r) => r.endedAt === undefined);
+  const inFlight = topLevelWorkflowRuns(activeStore.runs()).filter((r) => r.endedAt === undefined);
   return inFlight.map((r) =>
     killRun(r.id, { store: activeStore, cancellation: opts?.cancellation, persistence: opts?.persistence }),
   );
@@ -211,24 +214,32 @@ export function resumeRun(
   }
 
   const resumed: StageSnapshot[] = [];
-  if (run.status === "paused" || run.stages.some((s) => s.status === "paused")) {
-    const runHandle = registry.run(runId);
+  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);
+  });
+  if (hasPausedState) {
     const handles = opts?.stageId
       ? [registry.get(runId, opts.stageId)].filter(
           (h): h is NonNullable<typeof h> => h !== undefined,
-        )
-      : runHandle.pausedStages();
+        ).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 handle of handles) {
+    for (const { controlRunId, handle } of handles) {
       if (handle.status !== "paused") continue;
       void handle.resume(opts?.message);
-      const stageSnap = run.stages.find((s) => s.id === handle.stageId);
+      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 (run.status === "paused" && (!opts?.stageId || resumed.length > 0)) {
+    if (!opts?.stageId || resumed.length > 0) {
       activeStore.recordRunResumed(runId);
     }
   }
@@ -275,6 +286,13 @@ export function resumeRun(
  * 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(
   runId: string,
   opts?: {
@@ -315,17 +333,22 @@ export function pauseRun(
     return { ok: true, runId, paused };
   }
 
-  const handles = registry.run(runId).stages().filter(
-    (h) => h.status === "running" || h.status === "pending",
+  const controlRunIds = expandedControlRunIds(activeStore, runId);
+  const handles = controlRunIds.flatMap((controlRunId) =>
+    registry.run(controlRunId).stages().filter(
+      (h) => h.status === "running" || h.status === "pending",
+    ).map((handle) => ({ controlRunId, handle })),
   );
   if (handles.length === 0) {
     return { ok: false, runId, reason: "no_active_stages" };
   }
   const pausedSnaps: StageSnapshot[] = [];
-  for (const handle of handles) {
+  for (const { controlRunId, handle } of handles) {
     void handle.pause();
-    const stageSnap = run.stages.find((s) => s.id === handle.stageId);
+    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);
   }
   activeStore.recordRunPaused(runId);
   return { ok: true, runId, paused: pausedSnaps };
@@ -336,7 +359,7 @@ export function pauseAllRuns(opts?: {
   stageControlRegistry?: StageControlRegistry;
 }): PauseResult[] {
   const activeStore = opts?.store ?? defaultStore;
-  const inFlight = activeStore.runs().filter((r) => r.endedAt === undefined);
+  const inFlight = topLevelWorkflowRuns(activeStore.runs()).filter((r) => r.endedAt === undefined);
   return inFlight.map((r) =>
     pauseRun(r.id, { store: activeStore, stageControlRegistry: opts?.stageControlRegistry }),
   );
@@ -368,7 +391,7 @@ export function interruptAllRuns(opts?: {
   stageControlRegistry?: StageControlRegistry;
 }): InterruptRunResult[] {
   const activeStore = opts?.store ?? defaultStore;
-  const inFlight = activeStore.runs().filter((r) => r.endedAt === undefined);
+  const inFlight = topLevelWorkflowRuns(activeStore.runs()).filter((r) => r.endedAt === undefined);
   return inFlight.map((r) =>
     interruptRun(r.id, { store: activeStore, stageControlRegistry: opts?.stageControlRegistry }),
   );
@@ -401,12 +424,13 @@ export function inspectRun(
 
   // 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: copy.status,
-    mode: copy.stages.length > 1 ? "chain" : "single",
+    mode: expandedStages.length > 1 ? "chain" : "single",
     startedAt: copy.startedAt,
     endedAt: copy.endedAt,
     durationMs: copy.durationMs,
@@ -414,7 +438,7 @@ export function inspectRun(
     pausedAt: copy.pausedAt,
     resumedAt: copy.resumedAt,
     inputs: copy.inputs,
-    stages: copy.stages,
+    stages: expandedStages.map((stage) => structuredClone(stage)),
     result: copy.result,
     error: copy.error,
   };