@bastani/atomic 0.9.11-alpha.1 → 0.9.11-alpha.2

package/dist/builtin/workflows/src/durable/stage-primitive.ts

@@ -9,7 +9,7 @@ import { durableHash } from "./backend.js";
 import { recordCheckpointDurably } from "./tool-primitive.js";
 import { elapsedStageMs } from "../shared/timing.js";
 import { RESUME_CONTINUATION_PROMPT } from "../shared/resume-continuation.js";
-import { DURABLE_STAGE_TOPOLOGY_VERSION, type DurableStageCheckpoint } from "./types.js";
+import { DURABLE_STAGE_TOPOLOGY_VERSION, type DurableStageCheckpoint, type DurableStageRunTopology } from "./types.js";
 export type DurableCompletedStageCheckpoint = DurableStageCheckpoint & { readonly output: WorkflowSerializableValue };
 
 export interface DurableStageDeps {
@@ -18,13 +18,14 @@ export interface DurableStageDeps {
   readonly nextCheckpointId: () => string;
   readonly nextReplayKey: (stageName: string) => string;
   readonly replayKeyForCompletedStage?: (stage: StageSnapshot) => string | undefined;
+  readonly runTopology?: DurableStageRunTopology;
   readonly now?: () => number;
 }
 
 export async function recordStageCheckpoint(deps: DurableStageDeps, stage: StageSnapshot): Promise<boolean> {
   if (stage.status !== "completed") return false;
   const replayKey = deps.replayKeyForCompletedStage?.(stage) ?? stage.replayKey ?? deps.nextReplayKey(stage.name);
-  const metadata = checkpointMetadata(stage);
+  const metadata = durableStageCheckpointMetadata(stage, deps.runTopology);
   const hasExistingOutput = deps.backend.getStageOutput(deps.workflowId, replayKey) !== undefined;
   const checkpoint: DurableStageCheckpoint = hasExistingOutput
     ? {
@@ -62,13 +63,17 @@ function stageSessionDurationBucket(durationMs: number | undefined): number {
   return Math.floor((durationMs ?? 0) / STAGE_SESSION_DURATION_BUCKET_MS);
 }
 
-export async function recordStageSessionCheckpoint(deps: DurableStageDeps, stage: StageSnapshot): Promise<boolean> {
+export async function recordStageSessionCheckpoint(
+  deps: DurableStageDeps,
+  stage: StageSnapshot,
+  options?: { readonly force?: boolean },
+): Promise<boolean> {
   const replayKey = deps.replayKeyForCompletedStage?.(stage) ?? stage.replayKey ?? deps.nextReplayKey(stage.name);
   if (stage.sessionFile === undefined) return false;
   const checkpointNow = deps.now?.() ?? Date.now();
   const durationMs = elapsedStageMs(stage, checkpointNow) ?? 0;
   const current = deps.backend.getStageSession(deps.workflowId, replayKey);
-  if (current !== undefined
+  if (options?.force !== true && current !== undefined
     && current.sessionId === stage.sessionId
     && current.sessionFile === stage.sessionFile
     && current.startedAt === stage.startedAt
@@ -79,6 +84,7 @@ export async function recordStageSessionCheckpoint(deps: DurableStageDeps, stage
     checkpointId: stageSessionCheckpointId(replayKey, stage, durationMs),
     name: stage.name,
     replayKey,
+    ...durableStageCheckpointMetadata(stage, deps.runTopology),
     ...(stage.sessionId !== undefined ? { sessionId: stage.sessionId } : {}),
     sessionFile: stage.sessionFile,
     ...(stage.startedAt !== undefined ? { startedAt: stage.startedAt } : {}),
@@ -256,9 +262,17 @@ function stageOutput(stage: StageSnapshot): WorkflowSerializableValue {
   return { status: stage.status, stageId: stage.id };
 }
 
-function checkpointMetadata(stage: StageSnapshot): Partial<DurableStageCheckpoint> {
+export function durableStageCheckpointMetadata(
+  stage: StageSnapshot,
+  run?: DurableStageRunTopology,
+): Partial<DurableStageCheckpoint> {
   return {
-    topology: { version: DURABLE_STAGE_TOPOLOGY_VERSION, stageId: stage.id, parentIds: [...stage.parentIds] },
+    topology: {
+      version: DURABLE_STAGE_TOPOLOGY_VERSION,
+      stageId: stage.id,
+      parentIds: [...stage.parentIds],
+      ...(run !== undefined ? { run: { ...run } } : {}),
+    },
     ...(stage.startedAt !== undefined ? { startedAt: stage.startedAt } : {}),
     ...(stage.endedAt !== undefined ? { endedAt: stage.endedAt } : {}),
     ...(stage.durationMs !== undefined ? { durationMs: stage.durationMs } : {}),
@@ -311,6 +325,7 @@ function mergeCheckpointHydrationMetadata(
   if (checkpoints.length === 0) return replayValueCheckpoint;
   return {
     ...replayValueCheckpoint,
+    ...preferredHydrationTopology(replayValueCheckpoint, checkpoints),
     ...(replayValueCheckpoint.startedAt === undefined ? metadataValue(checkpoints, "startedAt") : {}),
     ...(replayValueCheckpoint.endedAt === undefined ? metadataValue(checkpoints, "endedAt") : {}),
     ...(replayValueCheckpoint.durationMs === undefined ? metadataValue(checkpoints, "durationMs") : {}),
@@ -323,6 +338,19 @@ function mergeCheckpointHydrationMetadata(
     ...(replayValueCheckpoint.modelAttempts === undefined ? metadataValue(checkpoints, "modelAttempts") : {}),
   };
 }
+function preferredHydrationTopology(
+  replayValueCheckpoint: DurableCompletedStageCheckpoint,
+  checkpoints: readonly DurableStageCheckpoint[],
+): Pick<DurableStageCheckpoint, "topology"> | Record<string, never> {
+  for (let index = checkpoints.length - 1; index >= 0; index -= 1) {
+    const topology = checkpoints[index]?.topology;
+    if (topology?.run !== undefined) return { topology };
+  }
+  return replayValueCheckpoint.topology === undefined
+    ? metadataValue(checkpoints, "topology")
+    : {};
+}
+
 
 function metadataValue<K extends keyof DurableStageCheckpoint>(
   checkpoints: readonly DurableStageCheckpoint[],
@@ -390,6 +418,7 @@ export function recordCachedStageIntoStore(
     id: stageId, name, status: "completed", parentIds: parentIds !== undefined ? Object.freeze([...parentIds]) : [],
     startedAt: checkpoint?.startedAt ?? endedAt, endedAt, durationMs: checkpoint?.durationMs ?? 0, result,
     replayKey, replayed: true, skippedReason: "durable checkpoint replay", toolEvents: [], attachable: false,
+    ...(checkpoint?.topology !== undefined ? { replayedFromStageId: checkpoint.topology.stageId } : {}),
     ...(workflowChild !== undefined ? { workflowChild } : {}),
     ...(checkpoint?.sessionId !== undefined ? { sessionId: checkpoint.sessionId } : {}),
     ...(checkpoint?.sessionFile !== undefined ? { sessionFile: checkpoint.sessionFile } : {}),
@@ -420,10 +449,19 @@ export function recordCachedStageWithTracker(
 ): void {
   const stageId = cachedStageId(runId, replayKey);
   let parentIds = tracker.onSpawn(stageId, name);
-  const scopeParentIds = stageFailFastScope?.parentIds ?? [];
-  if (stageFailFastScope !== undefined) {
-    tracker.replaceParents(stageId, scopeParentIds);
-    parentIds = [...scopeParentIds];
+  const sourceParents = checkpoint.topology?.run?.runId === runId
+    ? checkpoint.topology.parentIds
+    : undefined;
+  const run = store.runs().find((candidate) => candidate.id === runId);
+  const restored = sourceParents?.map((sourceId) =>
+    run?.stages.find((stage) => stage.replayedFromStageId === sourceId)?.id
+  );
+  if (restored !== undefined && restored.every((id): id is string => id !== undefined)) {
+    parentIds = restored;
+    tracker.replaceParents(stageId, parentIds);
+  } else if (stageFailFastScope !== undefined) {
+    parentIds = [...(stageFailFastScope.parentIds ?? [])];
+    tracker.replaceParents(stageId, parentIds);
   }
   recordCachedStageIntoStore(store, runId, name, replayKey, checkpoint.output, completedStageReplayKeys, parentIds, checkpoint);
   tracker.onSettle(stageId);

package/dist/builtin/workflows/src/durable/types.ts

@@ -110,11 +110,22 @@ export interface DurableUiCheckpoint {
 
 export const DURABLE_STAGE_TOPOLOGY_VERSION = 1 as const;
 
+/** Durable ownership metadata needed to rebuild nested workflow runs. */
+export interface DurableStageRunTopology {
+  readonly runId: string;
+  readonly runName: string;
+  readonly parentRunId?: string;
+  readonly parentStageId?: string;
+  readonly rootRunId?: string;
+}
+
 /** Versioned source-stage lineage used to reconstruct completed DAGs after restart. */
 export interface DurableStageTopology {
   readonly version: typeof DURABLE_STAGE_TOPOLOGY_VERSION;
   readonly stageId: string;
   readonly parentIds: readonly string[];
+  /** Owning run and boundary linkage for nested workflow graph reconstruction. */
+  readonly run?: DurableStageRunTopology;
 }
 
 /** A `ctx.stage(...)` / `ctx.task(...)` durable checkpoint or resumable session marker. */

package/dist/builtin/workflows/src/engine/run-durable-stage-session.ts

@@ -1,11 +1,12 @@
 import type { RunSnapshot, StageSnapshot } from "../shared/store-types.js";
 import { recordStageSessionCheckpoint, type DurableStageDeps } from "../durable/stage-primitive.js";
+import type { StageSessionCheckpointOptions } from "../runs/foreground/executor-types.js";
 import { recordRunTimingCheckpoint } from "../durable/run-timing.js";
 
 export interface DurableStageSessionRecorderInput {
   readonly runId: string;
   readonly deps: DurableStageDeps;
-  readonly onStageSession?: (runId: string, snapshot: StageSnapshot) => unknown;
+  readonly onStageSession?: (runId: string, snapshot: StageSnapshot, options?: StageSessionCheckpointOptions) => unknown;
   /**
    * Live root-run snapshot. When present, stage-session checkpoints also
    * refresh the debounced run-level elapsed record so a durable resume can
@@ -17,15 +18,14 @@ export interface DurableStageSessionRecorderInput {
 
 export function createDurableStageSessionRecorder(
   input: DurableStageSessionRecorderInput,
-): (stageRunId: string, snapshot: StageSnapshot) => void {
-  return (stageRunId, snapshot) => {
+): (stageRunId: string, snapshot: StageSnapshot, options?: StageSessionCheckpointOptions) => Promise<void> {
+  return async (stageRunId, snapshot, options) => {
     if (stageRunId === input.runId) {
-      void recordStageSessionCheckpoint(input.deps, snapshot).then(() => {
-        if (input.runSnapshot !== undefined) {
-          recordRunTimingCheckpoint(input.deps.backend, input.runSnapshot, { debounce: true });
-        }
-      }).catch(() => {});
+      await recordStageSessionCheckpoint(input.deps, snapshot, { force: options?.forceDurable === true });
+      if (input.runSnapshot !== undefined) {
+        recordRunTimingCheckpoint(input.deps.backend, input.runSnapshot, { debounce: options?.forceDurable !== true });
+      }
     }
-    void input.onStageSession?.(stageRunId, snapshot);
+    await input.onStageSession?.(stageRunId, snapshot, options);
   };
 }

package/dist/builtin/workflows/src/engine/run-durable-topology.ts

@@ -0,0 +1,89 @@
+import { durableHash, type DurableWorkflowBackend } from "../durable/backend.js";
+import { durableNestedRunSnapshots } from "../durable/completed-catalog.js";
+import {
+  durableStageCheckpointMetadata,
+  recordCachedStageWithTracker,
+  type DurableCompletedStageCheckpoint,
+  type DurableStageDeps,
+} from "../durable/stage-primitive.js";
+import type { DurableStageRunTopology } from "../durable/types.js";
+import type { GraphFrontierTracker } from "./graph-inference.js";
+import type { RunSnapshot } from "../shared/store-types.js";
+import type { Store } from "../shared/store.js";
+import type { ParallelFailFastScope } from "../runs/foreground/executor-types.js";
+
+export function durableRunTopology(run: RunSnapshot): DurableStageRunTopology {
+  return {
+    runId: run.id,
+    runName: run.name,
+    ...(run.parentRunId !== undefined ? { parentRunId: run.parentRunId } : {}),
+    ...(run.parentStageId !== undefined ? { parentStageId: run.parentStageId } : {}),
+    ...(run.rootRunId !== undefined ? { rootRunId: run.rootRunId } : {}),
+  };
+}
+
+export function createDurableStageDeps(input: {
+  readonly backend: DurableWorkflowBackend;
+  readonly run: RunSnapshot;
+  readonly nextCheckpointId: () => string;
+  readonly nextReplayKey: (stageName: string) => string;
+  readonly completedReplayKeys: Map<string, string>;
+}): DurableStageDeps {
+  return {
+    workflowId: input.run.id,
+    backend: input.backend,
+    nextCheckpointId: input.nextCheckpointId,
+    nextReplayKey: input.nextReplayKey,
+    replayKeyForCompletedStage: (stage) => input.completedReplayKeys.get(stage.id),
+    runTopology: durableRunTopology(input.run),
+  };
+}
+
+export function createDurableCachedStageRecorder(input: {
+  readonly store: Store;
+  readonly tracker: GraphFrontierTracker;
+  readonly run: RunSnapshot;
+  readonly backend: DurableWorkflowBackend;
+  readonly rootBackend: DurableWorkflowBackend;
+  readonly completedStageReplayKeys: Map<string, string>;
+}): {
+  readonly record: (name: string, replayKey: string, checkpoint: DurableCompletedStageCheckpoint, scope?: ParallelFailFastScope) => void;
+  readonly metadata: (replayKey: string) => Partial<DurableCompletedStageCheckpoint>;
+} {
+  return {
+    record(name, replayKey, checkpoint, scope): void {
+      recordCachedStageWithTracker(
+        input.store, input.tracker, input.run.id, name, replayKey, checkpoint,
+        input.completedStageReplayKeys, scope,
+      );
+      const stage = input.store.runs().find((run) => run.id === input.run.id)?.stages
+        .find((candidate) => candidate.replayKey === replayKey);
+      if (stage !== undefined) {
+        input.backend.recordCheckpoint({
+          kind: "stage", workflowId: input.run.id,
+          checkpointId: `stage-replay-meta:${durableHash({ replayKey, stageId: stage.id, parentIds: stage.parentIds })}`,
+          name, replayKey, completedAt: Date.now(),
+          ...durableStageCheckpointMetadata(stage, durableRunTopology(input.run)),
+        });
+      }
+      if (workflowChildRunId(checkpoint) === undefined) return;
+      const durableRootId = input.run.rootRunId ?? input.run.id;
+      for (const childRun of durableNestedRunSnapshots(input.rootBackend, durableRootId)) {
+        if (!input.store.runs().some((candidate) => candidate.id === childRun.id)) input.store.recordRunStart(childRun);
+      }
+    },
+    metadata(replayKey) {
+      const stage = input.run.stages.find((candidate) => candidate.replayKey === replayKey);
+      return stage === undefined ? {} : durableStageCheckpointMetadata(stage, durableRunTopology(input.run));
+    },
+  };
+}
+
+function workflowChildRunId(checkpoint: DurableCompletedStageCheckpoint): string | undefined {
+  const output = checkpoint.output;
+  if (typeof output !== "object" || output === null || Array.isArray(output)) return undefined;
+  const record = output as Record<string, import("../shared/types.js").WorkflowSerializableValue>;
+  const runId = record["runId"];
+  const workflow = record["workflow"];
+  return typeof runId === "string" && typeof workflow === "string" ? runId : undefined;
+}

package/dist/builtin/workflows/src/engine/run.ts

@@ -39,14 +39,14 @@ import { isWorkflowDefinition, workflowDefinitionRequirementMessage } from "../r
 import { getDurableBackend } from "../durable/factory.js";
 import { classifyReturnedRunStatus } from "./run-returned-status.js";
 import { createToolPrimitive, createCheckpointIdGenerator } from "../durable/tool-primitive.js";
-import { createDurableStagePrimitive, createDurableTaskPrimitive, recordStageCheckpoint, createStageReplayKeyGenerator, recordCachedStageWithTracker } from "../durable/stage-primitive.js";
-import { inheritedRunElapsedMs } from "../durable/run-timing.js";
-import type { DurableCompletedStageCheckpoint } from "../durable/stage-primitive.js";
+import { createDurableStagePrimitive, createDurableTaskPrimitive, recordStageCheckpoint, createStageReplayKeyGenerator } from "../durable/stage-primitive.js";
+import { inheritedRunElapsedMs, recordRunTimingCheckpoint } from "../durable/run-timing.js";
 import { createDurableChildWorkflowPrimitive } from "../durable/child-primitive.js";
 import { ScopedDurableBackend, type DurableScope } from "../durable/scoped-backend.js";
 import { finalizeDurableTerminalStatus } from "./run-durable-finalize.js";
 import { createDurableStageSessionRecorder } from "./run-durable-stage-session.js";
 import type { DurableWorkflowBackend } from "../durable/backend.js";
+import { createDurableCachedStageRecorder, createDurableStageDeps } from "./run-durable-topology.js";
 
 type WorkflowRunInputArgument = Parameters<typeof resolveAndValidateInputs>[1];
 
@@ -201,13 +201,11 @@ export async function run<
   const checkpointIdGenerator = createCheckpointIdGenerator();
   const stageReplayKeyGenerator = createStageReplayKeyGenerator(runId);
   const completedStageReplayKeys = new Map<string, string>();
-  const durableStageDeps = {
-    workflowId: runId,
-    backend: durableBackend,
-    nextCheckpointId: checkpointIdGenerator,
-    nextReplayKey: stageReplayKeyGenerator,
-    replayKeyForCompletedStage: (stage: StageSnapshot) => completedStageReplayKeys.get(stage.id),
-  };
+  const durableStageDeps = createDurableStageDeps({
+    backend: durableBackend, run: runSnapshot,
+    nextCheckpointId: checkpointIdGenerator, nextReplayKey: stageReplayKeyGenerator,
+    completedReplayKeys: completedStageReplayKeys,
+  });
   const userOnStageEnd = opts.onStageEnd;
   const durableOnStageEnd = async (stageRunId: string, snapshot: StageSnapshot): Promise<void> => {
     if (stageRunId === runId && snapshot.status === "completed") {
@@ -340,18 +338,21 @@ export async function run<
 
   // Durable ctx.ui wrapper — caches completed user responses so a resumed workflow does not re-ask answered prompts.
   const durableUiDeps = { workflowId: runId, backend: durableBackend, nextCheckpointId: checkpointIdGenerator };
-  const recordCachedStage = (name: string, replayKey: string, checkpoint: DurableCompletedStageCheckpoint): void =>
-    recordCachedStageWithTracker(activeStore, tracker, runId, name, replayKey, checkpoint, completedStageReplayKeys);
+  const cachedStage = createDurableCachedStageRecorder({
+    store: activeStore, tracker, run: runSnapshot, backend: durableBackend,
+    rootBackend, completedStageReplayKeys,
+  });
   const durableTask = createDurableTaskPrimitive({
     workflowId: runId, backend: durableBackend,
     nextReplayKey: (stageName) => stageReplayKeyGenerator(stageName), task: taskRunners.task,
-    recordCachedTask: (name, replayKey, checkpoint, scope) =>
-      recordCachedStageWithTracker(activeStore, tracker, runId, name, replayKey, checkpoint, completedStageReplayKeys, scope),
+    recordCachedTask: cachedStage.record,
   });
   const durableWorkflow = createDurableChildWorkflowPrimitive({
     workflowId: runId, rootWorkflowId: opts.parentRun?.rootRunId ?? runId, backend: durableBackend,
     nextReplayKey: nextDurableChildReplayKey, setChildDurableScope: (scope) => { pendingChildDurableScope = scope; },
-    recordCachedStage, workflow,
+    recordCachedStage: cachedStage.record,
+    checkpointMetadata: cachedStage.metadata,
+    workflow,
   });
   const ctx: WorkflowRunContext<TInputs> = {
     inputs: resolvedInputs as TInputs,
@@ -380,7 +381,7 @@ export async function run<
       workflowId: runId,
       backend: durableBackend,
       nextReplayKey: (stageName) => stageReplayKeyGenerator(stageName),
-      recordCachedStage,
+      recordCachedStage: cachedStage.record,
       stage: (name, options, replayKey) => {
         const stage = runtime.stage(name, options);
         const stageId = activeStore.runs().find((r) => r.id === runId)?.stages.at(-1)?.id;
@@ -429,6 +430,7 @@ export async function run<
     const returned = classifyReturnedRunStatus(result, runSnapshot);
     const recorded = activeStore.recordRunEnd(runId, returned.status, result, returned.error, returned.metadata);
     appendRunEndWhenRecorded(opts.persistence, recorded, { runId, status: returned.status, result, ...(returned.error !== undefined ? { error: returned.error } : {}), ...(returned.metadata ?? {}), ...(runSnapshot.endedAt !== undefined ? { endedAt: runSnapshot.endedAt } : {}), ...(runSnapshot.durationMs !== undefined ? { durationMs: runSnapshot.durationMs } : {}), ts: Date.now() });
+    if (opts.parentRun === undefined) recordRunTimingCheckpoint(durableBackend, runSnapshot);
     durableBackend.setWorkflowStatus(runId, returned.status, undefined, returned.metadata?.resumable);
     await durableBackend.flush();
     return reconcileTerminalRunResult(runId, runSnapshot, activeStore, { status: returned.status, result, error: returned.error }, opts.onRunEnd);

package/dist/builtin/workflows/src/extension/runtime-durable-resume.ts

@@ -20,6 +20,7 @@ import {
 } from "../durable/completed-inspection.js";
 import type { ResumableWorkflowEntry } from "../durable/types.js";
 import type { DurableWorkflowCatalogEntries } from "../durable/backend.js";
+import { discoverWorkflows } from "./discovery.js";
 
 export interface DurableResumeRuntime {
   resumeDurableWorkflow(
@@ -76,6 +77,8 @@ export function createDurableResumeRuntime(
         registry: deps.registry,
         baseRunOpts: deps.baseRunOpts(options?.policy),
         durableBackend: backend,
+        resolveDefinition: async (name, cwd) =>
+          (await discoverWorkflows({ cwd: cwd ?? deps.runtimeCwd })).registry.get(name),
         ...(deps.jobs !== undefined ? { jobs: deps.jobs } : {}),
       };
       return await resumeDurableWorkflowAdapter(workflowIdOrPrefix, adapterDeps, preparedCatalog);

package/dist/builtin/workflows/src/runs/foreground/executor-stage-control.ts

@@ -134,6 +134,9 @@ export function createStageControlHandle(runtime: LiveStageRuntime): StageContro
         ) ?? false;
         if (!stillActive) runtime.activeStore.recordRunPaused(runtime.runId);
       }
+      // Graceful pause/quit is an exact durability boundary. Force the latest
+      // pause-adjusted stage elapsed time even inside the normal 30s bucket.
+      await runtime.captureStageSessionMeta({ forceDurable: true });
     },
     async resume(message?: string) {
       runtime.throwIfStageMutationBlocked();

package/dist/builtin/workflows/src/runs/foreground/executor-stage-factory.ts

@@ -12,7 +12,7 @@ import type { GraphFrontierTracker } from "../../engine/graph-inference.js";
 import type { EngineStageRuntimeOptions } from "../../engine/options.js";
 import { createStageContext as createInnerStageContext, type InternalStageContext, type StageAdapters } from "./stage-runner.js";
 import type { StageControlRegistry } from "./stage-control-registry.js";
-import type { ParallelFailFastScope } from "./executor-types.js";
+import type { ParallelFailFastScope, StageSessionCheckpointOptions } from "./executor-types.js";
 import type { WorkflowExitManager } from "./executor-exit-manager.js";
 import type { ContinuationReplayIndex } from "./executor-continuation.js";
 import { sameStringSet } from "./executor-continuation.js";
@@ -198,12 +198,15 @@ export function createWorkflowStageFactory(input: {
     };
 
     let runtime: LiveStageRuntime;
-    const captureStageSessionMeta = (): void => {
+    const captureStageSessionMeta = (checkpointOptions?: StageSessionCheckpointOptions): unknown => {
       const meta = innerCtx.__sessionMeta();
       if (meta.sessionId !== undefined) stageSnapshot.sessionId = meta.sessionId;
       if (meta.sessionFile !== undefined) stageSnapshot.sessionFile = meta.sessionFile;
       if (meta.sessionId !== undefined || meta.sessionFile !== undefined) input.activeStore.recordStageSession(input.runId, stageId, meta);
-      void input.opts.onStageSession?.(input.runId, stageSnapshot);
+      const pending = input.opts.onStageSession?.(input.runId, stageSnapshot, checkpointOptions);
+      if (checkpointOptions?.forceDurable === true) return pending;
+      void Promise.resolve(pending).catch(() => {});
+      return undefined;
     };
     const releaseLiveHandle = async (): Promise<void> => {
       if (state.liveHandleReleased) return;

package/dist/builtin/workflows/src/runs/foreground/executor-stage-types.ts

@@ -3,7 +3,7 @@ import type { Store } from "../../shared/store.js";
 import type { StageContext } from "../../shared/types.js";
 import type { InternalStageContext } from "./stage-runner.js";
 import type { StageControlRegistry } from "./stage-control-registry.js";
-import type { ParallelFailFastScope } from "./executor-types.js";
+import type { ParallelFailFastScope, StageSessionCheckpointOptions } from "./executor-types.js";
 import type { StageScheduler } from "./executor-scheduler.js";
 import type { WorkflowExitManager } from "./executor-exit-manager.js";
 import type { WorkflowFailure } from "../../shared/workflow-failures.js";
@@ -48,7 +48,7 @@ export interface LiveStageRuntime {
   unregisterStageHandle: () => void;
   dropStageControlHandle: () => void;
   unregisterWorkflowExitCleanup: () => void;
-  readonly captureStageSessionMeta: () => void;
+  readonly captureStageSessionMeta: (options?: StageSessionCheckpointOptions) => unknown;
   readonly applyModelFallbackMeta: (meta: ReturnType<InternalStageContext["__modelFallbackMeta"]>) => void;
   readonly appendStageStartOnce: () => void;
   readonly finalizeStageSnapshot: () => Promise<boolean>;

package/dist/builtin/workflows/src/runs/foreground/executor-types.ts

@@ -24,6 +24,9 @@ export interface RunContinuationOpts {
   readonly resumeFromStageId: string;
 }
 
+export interface StageSessionCheckpointOptions {
+  readonly forceDurable?: boolean;
+}
 export interface RunOpts extends Omit<AuthoringContract.RunOpts, "adapters" | "store" | "cancellation" | "overlay" | "registry" | "stageControlRegistry" | "continuation" | "onRunStart" | "onStageStart" | "onStageEnd" | "onRunEnd" | "ui"> {
   adapters?: StageAdapters;
   /** Invocation working directory exposed to workflow definitions as ctx.cwd. */
@@ -104,7 +107,7 @@ export interface RunOpts extends Omit<AuthoringContract.RunOpts, "adapters" | "s
   onRunStart?: (snapshot: RunSnapshot) => void;
   onStageStart?: (runId: string, snapshot: StageSnapshot) => void;
   onStageEnd?: (runId: string, snapshot: StageSnapshot) => unknown;
-  onStageSession?: (runId: string, snapshot: StageSnapshot) => unknown;
+  onStageSession?: (runId: string, snapshot: StageSnapshot, options?: StageSessionCheckpointOptions) => unknown;
   onRunEnd?: (runId: string, status: RunStatus, result?: WorkflowOutputValues, error?: string, exitReason?: string) => void;
 }
 

package/dist/builtin/workflows/src/tui/workflow-resume-selector.ts

@@ -103,7 +103,6 @@ function durableWorkflowSession(
   kind: "durable" | "completed",
 ): WorkflowResumeSelectorItem {
   const checkpointText = `${entry.completedCheckpoints} checkpoints`;
-  const promptText = `${entry.pendingPrompts} prompts`;
   const presentation = workflowStatusPresentation(entry.status, kind);
   return {
     result: { kind, workflowId: entry.workflowId },
@@ -114,8 +113,8 @@ function durableWorkflowSession(
       created: new Date(entry.createdAt),
       modified: new Date(entry.updatedAt),
       messageCount: entry.completedCheckpoints,
-      firstMessage: `${entry.name}  ${presentation.label}  ${checkpointText}  ${promptText}`,
-      allMessagesText: `${entry.workflowId} ${entry.name} ${presentation.label} ${checkpointText} ${promptText}`,
+      firstMessage: `${entry.name}  ${presentation.label}  ${checkpointText}`,
+      allMessagesText: `${entry.workflowId} ${entry.name} ${presentation.label} ${checkpointText}`,
       ...(presentation.color !== undefined ? { messageColor: presentation.color } : {}),
     },
   };

package/dist/cli/args.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"args.d.ts","sourceRoot":"","sources":["../../src/cli/args.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC;AAanE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAEjE,MAAM,MAAM,IAAI,GAAG,MAAM,GAAG,MAAM,GAAG,KAAK,CAAC;AAE3C,MAAM,WAAW,IAAI;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,kBAAkB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC9B,QAAQ,CAAC,EAAE,aAAa,CAAC;IACzB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,IAAI,CAAC,EAAE,IAAI,CAAC;IACZ,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IACjB,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;IACtB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;IAC3B,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,8EAA8E;IAC9E,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,GAAG,MAAM,CAAC,CAAC;IAC5C,WAAW,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,SAAS,GAAG,OAAO,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CACnE;AAID,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,IAAI,aAAa,CAE1E;AAED,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,IAAI,CA+J9C;AAED,wBAAgB,SAAS,CAAC,cAAc,CAAC,EAAE,aAAa,EAAE,GAAG,IAAI,CAsLhE"}
+{"version":3,"file":"args.d.ts","sourceRoot":"","sources":["../../src/cli/args.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC;AAanE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAEjE,MAAM,MAAM,IAAI,GAAG,MAAM,GAAG,MAAM,GAAG,KAAK,CAAC;AAE3C,MAAM,WAAW,IAAI;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,kBAAkB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC9B,QAAQ,CAAC,EAAE,aAAa,CAAC;IACzB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,IAAI,CAAC,EAAE,IAAI,CAAC;IACZ,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IACjB,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;IACtB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;IAC3B,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,8EAA8E;IAC9E,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,GAAG,MAAM,CAAC,CAAC;IAC5C,WAAW,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,SAAS,GAAG,OAAO,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CACnE;AAID,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,IAAI,aAAa,CAE1E;AAED,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,IAAI,CA+J9C;AAED,wBAAgB,SAAS,CAAC,cAAc,CAAC,EAAE,aAAa,EAAE,GAAG,IAAI,CAwLhE"}

package/dist/cli/args.js

@@ -367,6 +367,8 @@ ${chalk.bold("Environment Variables:")}
   CLOUDFLARE_API_KEY               - Cloudflare API token (Workers AI and AI Gateway)
   CLOUDFLARE_ACCOUNT_ID            - Cloudflare account id (required for both)
   CLOUDFLARE_GATEWAY_ID            - Cloudflare AI Gateway slug (required for AI Gateway)
+  QWEN_TOKEN_PLAN_API_KEY          - Qwen Token Plan API key (international region)
+  QWEN_TOKEN_PLAN_CN_API_KEY       - Qwen Token Plan API key (China region)
   XIAOMI_API_KEY                   - Xiaomi MiMo API key (api.xiaomimimo.com billing)
   XIAOMI_TOKEN_PLAN_CN_API_KEY     - Xiaomi MiMo Token Plan API key (China region)
   XIAOMI_TOKEN_PLAN_AMS_API_KEY    - Xiaomi MiMo Token Plan API key (Amsterdam region)