@bastani/atomic 0.9.11-alpha.4 → 0.9.11-alpha.6

package/dist/builtin/workflows/src/durable/dbos-envelope.ts

@@ -12,14 +12,20 @@
  */
 
 import type { WorkflowSerializableObject, WorkflowSerializableValue } from "../shared/types.js";
+import { workflowToolOutcomeFromValue } from "./tool-outcome.js";
 import {
+  DURABLE_BOUNDARY_TOPOLOGY_VERSION,
   DURABLE_STAGE_TOPOLOGY_VERSION,
+  DURABLE_TOOL_TOPOLOGY_VERSION,
   type DurableCheckpoint,
   type DurableCheckpointKind,
   type DurableStageCheckpoint,
+  type DurableStageLifecycleStatus,
   type DurableStageTopology,
   type DurableToolCheckpoint,
+  type DurableToolTopology,
   type DurableUiCheckpoint,
+  type DurableWorkflowBoundaryTopology,
   type UiPromptKind,
 } from "./types.js";
 import { isCurrentDurableFormat, DURABLE_FORMAT_VERSION } from "./format-version.js";
@@ -43,6 +49,8 @@ export interface DbosCheckpointEnvelope extends WorkflowSerializableObject {
   readonly name?: string;
   readonly argsHash?: string;
   readonly promptKind?: UiPromptKind;
+  readonly outcomeKind?: "return_success" | "return_failure";
+  readonly throwingFailureError?: string;
   readonly message?: string;
   readonly promptHash?: string;
   readonly replayKey?: string;
@@ -88,7 +96,23 @@ export function encodeCheckpoint(checkpoint: DurableCheckpoint): DbosCheckpointE
   };
   if (cp.kind === "tool") {
     const t = cp as DurableToolCheckpoint;
-    return { ...base, name: t.name, argsHash: t.argsHash };
+    return {
+      ...base,
+      name: t.name,
+      argsHash: t.argsHash,
+      ...(t.outcomeKind !== undefined ? { outcomeKind: t.outcomeKind } : {}),
+      ...(t.throwingFailureError !== undefined ? { throwingFailureError: t.throwingFailureError } : {}),
+      ...(t.topology !== undefined ? { topology: {
+        version: t.topology.version,
+        nodeId: t.topology.nodeId,
+        ordinal: t.topology.ordinal,
+        order: t.topology.order,
+        parentIds: [...t.topology.parentIds],
+        ...(t.topology.startedAt !== undefined ? { startedAt: t.topology.startedAt } : {}),
+        ...(t.topology.endedAt !== undefined ? { endedAt: t.topology.endedAt } : {}),
+        ...(t.topology.run !== undefined ? { run: { ...t.topology.run } } : {}),
+      } } : {}),
+    };
   }
   if (cp.kind === "ui") {
     const u = cp as DurableUiCheckpoint;
@@ -103,7 +127,15 @@ export function encodeCheckpoint(checkpoint: DurableCheckpoint): DbosCheckpointE
       version: s.topology.version,
       stageId: s.topology.stageId,
       parentIds: [...s.topology.parentIds],
+      ...(s.topology.sourceOrder !== undefined ? { sourceOrder: s.topology.sourceOrder } : {}),
+      ...(s.topology.occurrenceKey !== undefined ? { occurrenceKey: s.topology.occurrenceKey } : {}),
+      ...(s.topology.status !== undefined ? { status: s.topology.status } : {}),
+      ...(s.topology.order !== undefined ? { order: s.topology.order } : {}),
       ...(s.topology.run !== undefined ? { run: { ...s.topology.run } } : {}),
+      ...(s.topology.boundary !== undefined ? { boundary: {
+        ...s.topology.boundary,
+        child: { ...s.topology.boundary.child },
+      } } : {}),
     } } : {}),
     ...(s.sessionId !== undefined ? { sessionId: s.sessionId } : {}),
     ...(s.sessionFile !== undefined ? { sessionFile: s.sessionFile } : {}),
@@ -167,13 +199,23 @@ function decodeEnvelope(workflowId: string, env: DbosCheckpointEnvelope): Durabl
     || (env.hasOutput !== undefined && typeof env.hasOutput !== "boolean")) return undefined;
   const common = { workflowId, checkpointId: env.checkpointId, completedAt: env.completedAt };
   if (env.kind === "tool") {
-    if (typeof env.argsHash !== "string" || env.output === undefined) return undefined;
+    if (typeof env.argsHash !== "string" || env.output === undefined
+      || (env.outcomeKind !== undefined && env.outcomeKind !== "return_success" && env.outcomeKind !== "return_failure")
+      || (env.throwingFailureError !== undefined && typeof env.throwingFailureError !== "string")) return undefined;
+    const outcome = env.outcomeKind === undefined ? undefined : workflowToolOutcomeFromValue(env.output);
+    if ((env.outcomeKind === "return_success" && outcome?.ok !== true)
+      || (env.outcomeKind === "return_failure" && outcome?.ok !== false)) return undefined;
+    const topology = env.topology === undefined ? undefined : toolTopology(env.topology);
+    if (env.topology !== undefined && topology === undefined) return undefined;
     return {
       kind: "tool",
       ...common,
       name: env.name ?? "tool",
       argsHash: env.argsHash,
       output: env.output,
+      ...(env.outcomeKind !== undefined ? { outcomeKind: env.outcomeKind } : {}),
+      ...(env.throwingFailureError !== undefined ? { throwingFailureError: env.throwingFailureError } : {}),
+      ...(topology !== undefined ? { topology } : {}),
     } as DurableToolCheckpoint;
   }
   if (env.kind === "ui") {
@@ -222,21 +264,106 @@ function decodeEnvelope(workflowId: string, env: DbosCheckpointEnvelope): Durabl
 }
 
 
+function toolTopology(value: WorkflowSerializableValue): DurableToolTopology | undefined {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return undefined;
+  const record = value as Record<string, WorkflowSerializableValue>;
+  if (record["version"] !== DURABLE_TOOL_TOPOLOGY_VERSION
+    || typeof record["nodeId"] !== "string"
+    || typeof record["ordinal"] !== "number" || !Number.isInteger(record["ordinal"])
+    || typeof record["order"] !== "number" || !Number.isInteger(record["order"])
+    || !isStringArray(record["parentIds"])
+    || !isOptionalFiniteNumber(record["startedAt"])
+    || !isOptionalFiniteNumber(record["endedAt"])) return undefined;
+  const run = stageRunTopology(record["run"]);
+  if (record["run"] !== undefined && run === undefined) return undefined;
+  return {
+    version: DURABLE_TOOL_TOPOLOGY_VERSION,
+    nodeId: record["nodeId"],
+    ordinal: record["ordinal"],
+    order: record["order"],
+    parentIds: record["parentIds"],
+    ...(typeof record["startedAt"] === "number" ? { startedAt: record["startedAt"] } : {}),
+    ...(typeof record["endedAt"] === "number" ? { endedAt: record["endedAt"] } : {}),
+    ...(run !== undefined ? { run } : {}),
+  };
+}
+
 function stageTopology(value: WorkflowSerializableValue | undefined): DurableStageTopology | undefined {
   if (typeof value !== "object" || value === null || Array.isArray(value)) return undefined;
   const record = value as Record<string, WorkflowSerializableValue>;
   if (record["version"] !== DURABLE_STAGE_TOPOLOGY_VERSION
-    || typeof record["stageId"] !== "string" || !isStringArray(record["parentIds"])) return undefined;
+    || typeof record["stageId"] !== "string" || !isStringArray(record["parentIds"])
+    || !isOptionalSourceOrder(record["sourceOrder"])
+    || (record["occurrenceKey"] !== undefined && typeof record["occurrenceKey"] !== "string")
+    || (record["status"] !== undefined && !isStageLifecycleStatus(record["status"]))) return undefined;
   const run = stageRunTopology(record["run"]);
   if (record["run"] !== undefined && run === undefined) return undefined;
+  const boundary = boundaryTopology(record["boundary"]);
+  if (record["boundary"] !== undefined && boundary === undefined) return undefined;
   return {
     version: DURABLE_STAGE_TOPOLOGY_VERSION,
     stageId: record["stageId"],
     parentIds: record["parentIds"],
+    ...(typeof record["sourceOrder"] === "number" ? { sourceOrder: record["sourceOrder"] } : {}),
+    ...(typeof record["occurrenceKey"] === "string" ? { occurrenceKey: record["occurrenceKey"] } : {}),
+    ...(isStageLifecycleStatus(record["status"]) ? { status: record["status"] } : {}),
+    ...(typeof record["order"] === "number" && Number.isInteger(record["order"]) ? { order: record["order"] } : {}),
     ...(run !== undefined ? { run } : {}),
+    ...(boundary !== undefined ? { boundary } : {}),
   };
 }
 
+function boundaryTopology(value: WorkflowSerializableValue | undefined): DurableWorkflowBoundaryTopology | undefined {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return undefined;
+  const boundary = value as Record<string, WorkflowSerializableValue>;
+  const childValue = boundary["child"];
+  const event = boundary["event"];
+  const status = boundary["status"];
+  const invocationFingerprint = boundary["invocationFingerprint"];
+  if (boundary["version"] !== DURABLE_BOUNDARY_TOPOLOGY_VERSION
+    || (event !== "start" && event !== "terminal")
+    || (event === "start" ? status !== "running"
+      : status !== "completed" && status !== "failed" && status !== "skipped")
+    || typeof boundary["replayScope"] !== "string"
+    || typeof boundary["alias"] !== "string"
+    || typeof boundary["workflow"] !== "string"
+    || (invocationFingerprint !== undefined && typeof invocationFingerprint !== "string")
+    || typeof childValue !== "object" || childValue === null || Array.isArray(childValue)) return undefined;
+  const child = childValue as Record<string, WorkflowSerializableValue>;
+  if (!["runId", "runName", "parentRunId", "parentStageId", "rootRunId"]
+    .every((key) => typeof child[key] === "string")) return undefined;
+  const identity = {
+    version: DURABLE_BOUNDARY_TOPOLOGY_VERSION,
+    replayScope: boundary["replayScope"] as string,
+    alias: boundary["alias"] as string,
+    workflow: boundary["workflow"] as string,
+    ...(typeof invocationFingerprint === "string" ? { invocationFingerprint } : {}),
+    child: {
+      runId: child["runId"] as string,
+      runName: child["runName"] as string,
+      parentRunId: child["parentRunId"] as string,
+      parentStageId: child["parentStageId"] as string,
+      rootRunId: child["rootRunId"] as string,
+    },
+  };
+  if (event === "start") return { ...identity, event, status: "running" };
+  return {
+    ...identity,
+    event,
+    status: status as Extract<DurableStageLifecycleStatus, "completed" | "failed" | "skipped">,
+  };
+}
+
+function isOptionalSourceOrder(value: WorkflowSerializableValue | undefined): boolean {
+  return value === undefined || (typeof value === "number" && Number.isInteger(value) && value >= 0);
+}
+
+function isStageLifecycleStatus(value: WorkflowSerializableValue | undefined): value is DurableStageLifecycleStatus {
+  return value === "pending" || value === "running" || value === "awaiting_input"
+    || value === "paused" || value === "blocked" || value === "completed"
+    || value === "failed" || value === "skipped";
+}
+
 function stageRunTopology(value: WorkflowSerializableValue | undefined): NonNullable<DurableStageTopology["run"]> | undefined {
   if (typeof value !== "object" || value === null || Array.isArray(value)) return undefined;
   const run = value as Record<string, WorkflowSerializableValue>;

package/dist/builtin/workflows/src/durable/dbos-metadata.ts

@@ -3,6 +3,12 @@ import type { DbosStepRecord } from "./dbos-backend.js";
 import { isCurrentDurableFormat, DURABLE_FORMAT_VERSION } from "./format-version.js";
 import type { DurableWorkflowMetadata, DurableWorkflowStatus } from "./types.js";
 import { isAbsorbingDurableStatus } from "./workflow-status-transition.js";
+import {
+  isWorkflowFailureCode,
+  isWorkflowFailureDisposition,
+  isWorkflowFailureKind,
+  isWorkflowFailureRecoverability,
+} from "../shared/workflow-failures.js";
 
 const METADATA_STEP_PREFIX = "__atomic_metadata";
 
@@ -52,6 +58,12 @@ export function encodeMetadata(metadata: DurableWorkflowMetadata): WorkflowSeria
       ...(metadata.label !== undefined ? { label: metadata.label } : {}),
       ...(metadata.rootWorkflowId !== undefined ? { rootWorkflowId: metadata.rootWorkflowId } : {}),
       ...(metadata.resumable !== undefined ? { resumable: metadata.resumable } : {}),
+      ...(metadata.error !== undefined ? { error: metadata.error } : {}),
+      ...(metadata.failureKind !== undefined ? { failureKind: metadata.failureKind } : {}),
+      ...(metadata.failureCode !== undefined ? { failureCode: metadata.failureCode } : {}),
+      ...(metadata.failureRecoverability !== undefined ? { failureRecoverability: metadata.failureRecoverability } : {}),
+      ...(metadata.failureDisposition !== undefined ? { failureDisposition: metadata.failureDisposition } : {}),
+      ...(metadata.failedToolNodeId !== undefined ? { failedToolNodeId: metadata.failedToolNodeId } : {}),
       ...(metadata.invocationCwd !== undefined ? { invocationCwd: metadata.invocationCwd } : {}),
       ...(metadata.workflowCwd !== undefined ? { workflowCwd: metadata.workflowCwd } : {}),
       ...(metadata.repositoryRoot !== undefined ? { repositoryRoot: metadata.repositoryRoot } : {}),
@@ -132,6 +144,12 @@ function parseDurableWorkflowMetadata(
     || (metadata.label !== undefined && typeof metadata.label !== "string")
     || (metadata.rootWorkflowId !== undefined && typeof metadata.rootWorkflowId !== "string")
     || (metadata.resumable !== undefined && typeof metadata.resumable !== "boolean")
+    || (metadata.error !== undefined && typeof metadata.error !== "string")
+    || (metadata.failureKind !== undefined && !isWorkflowFailureKind(metadata.failureKind))
+    || (metadata.failureCode !== undefined && !isWorkflowFailureCode(metadata.failureCode))
+    || (metadata.failureRecoverability !== undefined && !isWorkflowFailureRecoverability(metadata.failureRecoverability))
+    || (metadata.failureDisposition !== undefined && !isWorkflowFailureDisposition(metadata.failureDisposition))
+    || (metadata.failedToolNodeId !== undefined && typeof metadata.failedToolNodeId !== "string")
     || (metadata.invocationCwd !== undefined && typeof metadata.invocationCwd !== "string")
     || (metadata.workflowCwd !== undefined && typeof metadata.workflowCwd !== "string")
     || (metadata.repositoryRoot !== undefined && typeof metadata.repositoryRoot !== "string")

package/dist/builtin/workflows/src/durable/scoped-backend.ts

@@ -19,7 +19,7 @@
  * cross-ref: issue #1498 — child side effects under the root durable workflow.
  */
 
-import type { DurableCheckpoint, DurableWorkflowStatus, ResumableWorkflowEntry } from "./types.js";
+import type { DurableCheckpoint, DurableStageCheckpoint, DurableWorkflowStatus, ResumableWorkflowEntry } from "./types.js";
 import type { WorkflowSerializableValue } from "../shared/types.js";
 import type { DurableInactiveDeleteResult, DurableWorkflowBackend, DurableWorkflowCatalogEntries, WorkflowRegistrationInput } from "./backend.js";
 import { claimDurablePromptToken, durablePromptScope, releaseDurablePrompt, reserveDurablePrompt, type PromptReservationToken } from "./prompt-reservations.js";
@@ -65,6 +65,10 @@ export class ScopedDurableBackend implements DurableWorkflowBackend {
     await this.inner.recordCheckpointAsync(this.remap(checkpoint));
   }
 
+  async recordAdditiveCheckpointBestEffort(checkpoint: DurableCheckpoint): Promise<boolean> {
+    return await this.inner.recordAdditiveCheckpointBestEffort(this.remap(checkpoint));
+  }
+
   flush(): Promise<void> {
     return this.inner.flush();
   }
@@ -73,6 +77,10 @@ export class ScopedDurableBackend implements DurableWorkflowBackend {
     return this.inner.getToolOutput(this.scope.rootWorkflowId, this.scopeKey(argsHash));
   }
 
+  getToolCheckpoint(_workflowId: string, argsHash: string) {
+    return this.inner.getToolCheckpoint(this.scope.rootWorkflowId, this.scopeKey(argsHash));
+  }
+
   getUiResponse(_workflowId: string, promptHash: string): WorkflowSerializableValue | undefined {
     return this.inner.getUiResponse(this.scope.rootWorkflowId, this.scopeKey(promptHash));
   }
@@ -90,15 +98,11 @@ export class ScopedDurableBackend implements DurableWorkflowBackend {
     return this.inner.getStageSession(this.scope.rootWorkflowId, this.scopeKey(replayKey));
   }
 
-  listCheckpoints(_workflowId: string): readonly DurableCheckpoint[] {
-    const all = this.inner.listCheckpoints(this.scope.rootWorkflowId);
-    const prefix = `${this.effectivePromptScope().scope}:`;
-    // Checkpoints are stored with their scope prefix already embedded in their
-    // ids (see remap()). Filter by the stored id directly — NOT by re-prefixing
-    // — so sibling scopes (e.g. "workflow:child:1") are excluded when the
-    // current scope is "workflow:child:2". Re-prefixing would prepend the
-    // current scope prefix to every id, causing sibling ids to falsely match.
-    return all.filter((cp) => storedScopeId(cp).startsWith(prefix));
+  listCheckpoints(workflowId: string): readonly DurableCheckpoint[] {
+    const prefix = `${this.scope.scopePrefix}:`;
+    return this.inner.listCheckpoints(this.scope.rootWorkflowId)
+      .filter((checkpoint) => checkpointHasPrefix(checkpoint, prefix))
+      .map((checkpoint) => localCheckpoint(checkpoint, workflowId, prefix));
   }
 
   getWorkflow(_workflowId: string): undefined {
@@ -222,15 +226,58 @@ export class ScopedDurableBackend implements DurableWorkflowBackend {
       workflowId,
       checkpointId: this.scopeKey(checkpoint.checkpointId),
       replayKey: this.scopeKey(checkpoint.replayKey),
+      ...remappedBoundaryScope(checkpoint, this.scopeKey(checkpoint.topology?.boundary?.replayScope ?? "")),
     };
   }
 }
 
-/**
- * Return the checkpoint's stored scope-qualified id, which includes any scope
- * prefix embedded by {@link ScopedDurableBackend.remap}. This is the raw stored
- * value used for prefix filtering in {@link ScopedDurableBackend.listCheckpoints}.
- */
-function storedScopeId(cp: DurableCheckpoint): string {
-  return cp.kind === "stage" ? cp.replayKey : cp.checkpointId;
+/** Return true only when every stored identity belongs to this immediate scope. */
+function checkpointHasPrefix(checkpoint: DurableCheckpoint, prefix: string): boolean {
+  if (!checkpoint.checkpointId.startsWith(prefix)) return false;
+  if (checkpoint.kind === "tool") return checkpoint.argsHash.startsWith(prefix);
+  if (checkpoint.kind === "ui") return checkpoint.promptHash.startsWith(prefix);
+  return checkpoint.replayKey.startsWith(prefix);
+}
+
+/** Strip exactly one wrapper prefix to expose a composable child-local view. */
+function localCheckpoint(
+  checkpoint: DurableCheckpoint,
+  workflowId: string,
+  prefix: string,
+): DurableCheckpoint {
+  const checkpointId = checkpoint.checkpointId.slice(prefix.length);
+  if (checkpoint.kind === "tool") {
+    return { ...checkpoint, workflowId, checkpointId, argsHash: checkpoint.argsHash.slice(prefix.length) };
+  }
+  if (checkpoint.kind === "ui") {
+    return { ...checkpoint, workflowId, checkpointId, promptHash: checkpoint.promptHash.slice(prefix.length) };
+  }
+  const replayKey = checkpoint.replayKey.slice(prefix.length);
+  const replayScope = stripOnePrefix(checkpoint.topology?.boundary?.replayScope, prefix);
+  return {
+    ...checkpoint,
+    workflowId,
+    checkpointId,
+    replayKey,
+    ...remappedBoundaryScope(checkpoint, replayScope),
+  };
+}
+
+function remappedBoundaryScope(
+  checkpoint: DurableStageCheckpoint,
+  replayScope: string | undefined,
+): Pick<DurableStageCheckpoint, "topology"> | Record<string, never> {
+  const topology = checkpoint.topology;
+  if (topology?.boundary === undefined || replayScope === undefined) return {};
+  return {
+    topology: {
+      ...topology,
+      boundary: { ...topology.boundary, replayScope },
+    },
+  };
+}
+
+function stripOnePrefix(value: string | undefined, prefix: string): string | undefined {
+  if (value === undefined || !value.startsWith(prefix)) return value;
+  return value.slice(prefix.length);
 }

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

@@ -9,7 +9,9 @@ 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, type DurableStageRunTopology } from "./types.js";
+import { type DurableStageCheckpoint, type DurableStageRunTopology } from "./types.js";
+import { activeStageTopology, durableStageCheckpointMetadata } from "./stage-topology.js";
+import { parseLegacyWorkflowChildResult, parseWorkflowChildResult } from "./workflow-child-result.js";
 export type DurableCompletedStageCheckpoint = DurableStageCheckpoint & { readonly output: WorkflowSerializableValue };
 
 export interface DurableStageDeps {
@@ -19,15 +21,21 @@ export interface DurableStageDeps {
   readonly nextReplayKey: (stageName: string) => string;
   readonly replayKeyForCompletedStage?: (stage: StageSnapshot) => string | undefined;
   readonly runTopology?: DurableStageRunTopology;
+  readonly sourceOrderForStage?: (stage: StageSnapshot) => number | undefined;
   readonly now?: () => number;
 }
 
-export async function recordStageCheckpoint(deps: DurableStageDeps, stage: StageSnapshot): Promise<boolean> {
-  if (stage.status !== "completed") return false;
+export async function recordStageCheckpoint(
+  deps: DurableStageDeps,
+  stage: StageSnapshot,
+  options?: { readonly metadataOnly?: boolean },
+): Promise<boolean> {
+  if (stage.status !== "completed" && stage.status !== "failed" && stage.status !== "skipped") return false;
   const replayKey = deps.replayKeyForCompletedStage?.(stage) ?? stage.replayKey ?? deps.nextReplayKey(stage.name);
-  const metadata = durableStageCheckpointMetadata(stage, deps.runTopology);
+  const metadata = durableStageCheckpointMetadata(stage, deps.runTopology, deps.sourceOrderForStage?.(stage));
   const hasExistingOutput = deps.backend.getStageOutput(deps.workflowId, replayKey) !== undefined;
-  const checkpoint: DurableStageCheckpoint = hasExistingOutput
+  const metadataOnly = options?.metadataOnly === true || stage.status !== "completed" || hasExistingOutput;
+  const checkpoint: DurableStageCheckpoint = metadataOnly
     ? {
         kind: "stage",
         workflowId: deps.workflowId,
@@ -51,12 +59,7 @@ export async function recordStageCheckpoint(deps: DurableStageDeps, stage: Stage
   return true;
 }
 
-/**
- * Debounce granularity for stage-session duration updates. `durationMs`
- * differs on virtually every prompt/steer event, so comparing it exactly
- * forced a full durable read-merge-rewrite per event; identity fields
- * (session id/file/start) still force an immediate write when they change.
- */
+// Duration-only session updates are bucketed; identity changes still persist immediately.
 const STAGE_SESSION_DURATION_BUCKET_MS = 30_000;
 
 function stageSessionDurationBucket(durationMs: number | undefined): number {
@@ -84,7 +87,7 @@ export async function recordStageSessionCheckpoint(
     checkpointId: stageSessionCheckpointId(replayKey, stage, durationMs),
     name: stage.name,
     replayKey,
-    ...durableStageCheckpointMetadata(stage, deps.runTopology),
+    ...durableStageCheckpointMetadata(stage, deps.runTopology, deps.sourceOrderForStage?.(stage)),
     ...(stage.sessionId !== undefined ? { sessionId: stage.sessionId } : {}),
     sessionFile: stage.sessionFile,
     ...(stage.startedAt !== undefined ? { startedAt: stage.startedAt } : {}),
@@ -99,11 +102,7 @@ const MID_SESSION_RESUME_PROMPT = RESUME_CONTINUATION_PROMPT;
 
 function withMidSessionResumePrompt<T extends StageContext>(stage: T, enabled: boolean): T {
   if (!enabled) return stage;
-  // Do NOT spread `stage` (e.g. `{ ...stage, prompt }`). The live StageContext
-  // exposes lazy getters for `sessionId`/`sessionFile`/`messages`/`isStreaming`
-  // that throw until the underlying SDK session has been created, and a spread
-  // would eagerly read them before the first `prompt()` lands. Override
-  // `prompt` in place instead — `prompt` is a normal configurable own property.
+  // Override in place: spreading would eagerly read lazy session getters before prompt().
   const originalPrompt = stage.prompt.bind(stage);
   Object.defineProperty(stage, "prompt", {
     value: (_text: string, options?: Parameters<StageContext["prompt"]>[1]) =>
@@ -114,8 +113,6 @@ function withMidSessionResumePrompt<T extends StageContext>(stage: T, enabled: b
   });
   return stage;
 }
-
-
 export function createDurableStagePrimitive(input: {
   readonly workflowId: string;
   readonly backend: DurableWorkflowBackend;
@@ -132,9 +129,14 @@ export function createDurableStagePrimitive(input: {
     }
     const session = input.backend.getStageSession(input.workflowId, replayKey);
     const isMidSessionResume = session?.sessionFile !== undefined;
+    const topology = activeStageTopology(input.backend, input.workflowId, replayKey);
     const liveOptions: StageOptions | undefined = {
       ...(options ?? {}),
       durableReplayKey: replayKey,
+      ...(topology !== undefined ? {
+        durableStageId: topology.stageId,
+        durableParentIds: [...topology.parentIds],
+      } : {}),
       ...(isMidSessionResume ? {
         resumeFromSessionFile: session.sessionFile,
         durableAccumulatedDurationMs: session.durationMs ?? 0,
@@ -152,6 +154,7 @@ export function createDurableStagePrimitive(input: {
   };
 }
 
+
 export function createDurableTaskPrimitive(input: {
   readonly workflowId: string;
   readonly backend: DurableWorkflowBackend;
@@ -167,15 +170,21 @@ export function createDurableTaskPrimitive(input: {
       return cached.output;
     }
     const session = input.backend.getStageSession(input.workflowId, replayKey);
+    const topology = activeStageTopology(input.backend, input.workflowId, replayKey);
     const taskOptions: WorkflowTaskOptions = {
       ...options,
       durableReplayKey: replayKey,
+      ...(topology !== undefined ? {
+        durableStageId: topology.stageId,
+        durableParentIds: [...topology.parentIds],
+      } : {}),
       ...(session?.sessionFile !== undefined ? {
         resumeFromSessionFile: session.sessionFile,
         durableAccumulatedDurationMs: session.durationMs ?? 0,
       } : {}),
     };
     const result = await input.task(name, taskOptions, stageFailFastScope);
+    const completedTopology = activeStageTopology(input.backend, input.workflowId, replayKey);
     await recordCheckpointDurably(input.backend, {
       kind: "stage",
       workflowId: input.workflowId,
@@ -185,6 +194,7 @@ export function createDurableTaskPrimitive(input: {
       output: result,
       completedAt: Date.now(),
       ...taskCheckpointMetadata(result),
+      ...(completedTopology !== undefined ? { topology: completedTopology } : {}),
     });
     return result;
   };
@@ -262,29 +272,6 @@ function stageOutput(stage: StageSnapshot): WorkflowSerializableValue {
   return { status: stage.status, stageId: stage.id };
 }
 
-export function durableStageCheckpointMetadata(
-  stage: StageSnapshot,
-  run?: DurableStageRunTopology,
-): Partial<DurableStageCheckpoint> {
-  return {
-    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 } : {}),
-    ...(stage.result !== undefined ? { result: stage.result } : {}),
-    ...(stage.sessionId !== undefined ? { sessionId: stage.sessionId } : {}),
-    ...(stage.sessionFile !== undefined ? { sessionFile: stage.sessionFile } : {}),
-    ...(stage.model !== undefined ? { model: stage.model } : {}),
-    ...(stage.fastMode !== undefined ? { fastMode: stage.fastMode } : {}),
-    ...(stage.attemptedModels !== undefined ? { attemptedModels: [...stage.attemptedModels] } : {}),
-    ...(stage.modelAttempts !== undefined ? { modelAttempts: [...stage.modelAttempts] } : {}),
-  };
-}
 
 function taskCheckpointMetadata(result: WorkflowTaskResult): Partial<DurableStageCheckpoint> {
   return {
@@ -322,7 +309,9 @@ function mergeCheckpointHydrationMetadata(
   replayValueCheckpoint: DurableCompletedStageCheckpoint,
   checkpoints: readonly DurableStageCheckpoint[],
 ): DurableCompletedStageCheckpoint {
-  if (checkpoints.length === 0) return replayValueCheckpoint;
+  if (checkpoints.length === 0 || replayValueCheckpoint.topology?.boundary?.event === "terminal") {
+    return replayValueCheckpoint;
+  }
   return {
     ...replayValueCheckpoint,
     ...preferredHydrationTopology(replayValueCheckpoint, checkpoints),
@@ -338,10 +327,15 @@ 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?.boundary !== undefined) return { topology };
+  }
   for (let index = checkpoints.length - 1; index >= 0; index -= 1) {
     const topology = checkpoints[index]?.topology;
     if (topology?.run !== undefined) return { topology };
@@ -392,6 +386,7 @@ export function cachedStageId(runId: string, replayKey: string): string {
 function stageMetadataCheckpointId(replayKey: string, stage: StageSnapshot): string {
   return `${stableCheckpointId("stage-meta", replayKey)}:${durableHash({
     stageId: stage.id,
+    status: stage.status,
     endedAt: stage.endedAt ?? 0,
     durationMs: stage.durationMs ?? 0,
     result: stage.result ?? "",
@@ -410,14 +405,24 @@ export function recordCachedStageIntoStore(
   checkpoint?: DurableCompletedStageCheckpoint,
 ): void {
   const now = Date.now();
-  const stageId = cachedStageId(runId, replayKey);
+  const sourceStageId = checkpoint?.topology?.run?.runId === runId
+    ? checkpoint.topology.stageId
+    : undefined;
+  const stageId = sourceStageId ?? cachedStageId(runId, replayKey);
   const result = checkpoint?.result ?? (typeof output === "string" ? output : JSON.stringify(output));
   const endedAt = checkpoint?.endedAt ?? checkpoint?.completedAt ?? now;
-  const workflowChild = isWorkflowChildResult(output) ? workflowChildSnapshotFromResult(output) : undefined;
+  const hasCurrentIdentity = checkpoint?.topology?.sourceOrder !== undefined
+    || checkpoint?.topology?.status !== undefined || checkpoint?.topology?.occurrenceKey !== undefined
+    || checkpoint?.topology?.boundary !== undefined;
+  const childResult = parseWorkflowChildResult(output)
+    ?? (hasCurrentIdentity ? undefined : parseLegacyWorkflowChildResult(output));
+  const workflowChild = childResult === undefined ? undefined : workflowChildSnapshotFromResult(childResult);
+  const executionOrder = checkpoint?.topology?.order ?? checkpoint?.topology?.sourceOrder;
   const snapshot: StageSnapshot = {
     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,
+    ...(executionOrder !== undefined ? { executionOrder } : {}),
     ...(checkpoint?.topology !== undefined ? { replayedFromStageId: checkpoint.topology.stageId } : {}),
     ...(workflowChild !== undefined ? { workflowChild } : {}),
     ...(checkpoint?.sessionId !== undefined ? { sessionId: checkpoint.sessionId } : {}),
@@ -446,15 +451,19 @@ export function recordCachedStageWithTracker(
   checkpoint: DurableCompletedStageCheckpoint,
   completedStageReplayKeys: Map<string, string>,
   stageFailFastScope?: ParallelFailFastScope,
+  sourceToReplayedNodeIds?: Map<string, string>,
 ): void {
-  const stageId = cachedStageId(runId, replayKey);
-  let parentIds = tracker.onSpawn(stageId, name);
-  const sourceParents = checkpoint.topology?.run?.runId === runId
-    ? checkpoint.topology.parentIds
+  const sourceStageId = checkpoint.topology?.run?.runId === runId
+    ? checkpoint.topology.stageId
     : undefined;
+  const stageId = sourceStageId ?? cachedStageId(runId, replayKey);
+  let parentIds = tracker.onSpawn(stageId, name);
+  const sourceParents = sourceStageId === undefined ? undefined : checkpoint.topology?.parentIds;
   const run = store.runs().find((candidate) => candidate.id === runId);
   const restored = sourceParents?.map((sourceId) =>
-    run?.stages.find((stage) => stage.replayedFromStageId === sourceId)?.id
+    sourceToReplayedNodeIds?.get(sourceId)
+      ?? run?.stages.find((stage) => stage.id === sourceId || stage.replayedFromStageId === sourceId)?.id
+
   );
   if (restored !== undefined && restored.every((id): id is string => id !== undefined)) {
     parentIds = restored;
@@ -463,6 +472,7 @@ export function recordCachedStageWithTracker(
     parentIds = [...(stageFailFastScope.parentIds ?? [])];
     tracker.replaceParents(stageId, parentIds);
   }
+  if (checkpoint.topology?.run?.runId === runId) sourceToReplayedNodeIds?.set(checkpoint.topology.stageId, stageId);
   recordCachedStageIntoStore(store, runId, name, replayKey, checkpoint.output, completedStageReplayKeys, parentIds, checkpoint);
   tracker.onSettle(stageId);
 }
@@ -471,16 +481,6 @@ function isWorkflowTaskResult(value: WorkflowSerializableValue): value is Workfl
   return typeof (value as Record<string, WorkflowSerializableValue>)["text"] === "string";
 }
 
-function isWorkflowChildResult(value: WorkflowSerializableValue): value is WorkflowChildResult<WorkflowOutputValues> {
-  if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
-  const objectValue = value as Record<string, WorkflowSerializableValue | undefined>;
-  return typeof objectValue["workflow"] === "string"
-    && typeof objectValue["runId"] === "string"
-    && typeof objectValue["status"] === "string"
-    && typeof objectValue["outputs"] === "object"
-    && objectValue["outputs"] !== null
-    && !Array.isArray(objectValue["outputs"]);
-}
 
 function workflowChildSnapshotFromResult(result: WorkflowChildResult<WorkflowOutputValues>): StageSnapshot["workflowChild"] {
   return {