@bastani/atomic 0.9.5-alpha.7 → 0.9.5-alpha.9

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

@@ -359,6 +359,10 @@ export class DbosDurableBackend implements DurableWorkflowBackend {
       ...(entry.label !== undefined ? { label: entry.label } : {}),
       ...(entry.rootWorkflowId !== undefined ? { rootWorkflowId: entry.rootWorkflowId } : {}),
       ...(entry.resumable !== undefined ? { resumable: entry.resumable } : {}),
+      ...(entry.invocationCwd !== undefined ? { invocationCwd: entry.invocationCwd } : {}),
+      ...(entry.workflowCwd !== undefined ? { workflowCwd: entry.workflowCwd } : {}),
+      ...(entry.repositoryRoot !== undefined ? { repositoryRoot: entry.repositoryRoot } : {}),
+      ...(entry.gitWorktreeRoot !== undefined ? { gitWorktreeRoot: entry.gitWorktreeRoot } : {}),
     });
   }
 }
@@ -377,7 +381,7 @@ function isMetadataStep(stepName: string): boolean {
 interface DbosMetadataEnvelope {
   readonly __atomicDurableMetadata: true;
   readonly version: 1;
-  readonly entry: DurableCheckpointEntry;
+  readonly entry: WorkflowSerializableValue;
 }
 
 function encodeMetadata(entry: DurableCheckpointEntry): WorkflowSerializableValue {
@@ -395,6 +399,10 @@ function encodeMetadata(entry: DurableCheckpointEntry): WorkflowSerializableValu
       ...(entry.label !== undefined ? { label: entry.label } : {}),
       ...(entry.rootWorkflowId !== undefined ? { rootWorkflowId: entry.rootWorkflowId } : {}),
       ...(entry.resumable !== undefined ? { resumable: entry.resumable } : {}),
+      ...(entry.invocationCwd !== undefined ? { invocationCwd: entry.invocationCwd } : {}),
+      ...(entry.workflowCwd !== undefined ? { workflowCwd: entry.workflowCwd } : {}),
+      ...(entry.repositoryRoot !== undefined ? { repositoryRoot: entry.repositoryRoot } : {}),
+      ...(entry.gitWorktreeRoot !== undefined ? { gitWorktreeRoot: entry.gitWorktreeRoot } : {}),
       ts: entry.ts,
     },
   };
@@ -404,7 +412,60 @@ function decodeMetadata(value: WorkflowSerializableValue): DurableCheckpointEntr
   if (typeof value !== "object" || value === null || Array.isArray(value)) return undefined;
   const raw = value as Partial<DbosMetadataEnvelope>;
   if (raw.__atomicDurableMetadata !== true || raw.version !== METADATA_VERSION) return undefined;
-  return raw.entry;
+  const entry = raw.entry;
+  if (entry === undefined) return undefined;
+  return parseDurableCheckpointEntry(entry);
+}
+
+function parseDurableCheckpointEntry(value: WorkflowSerializableValue): DurableCheckpointEntry | undefined {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return undefined;
+  const entry = value as Partial<DurableCheckpointEntry>;
+  if (entry.type !== "workflow.durable.checkpoint"
+    || typeof entry.workflowId !== "string"
+    || typeof entry.name !== "string"
+    || typeof entry.inputs !== "object"
+    || entry.inputs === null
+    || Array.isArray(entry.inputs)
+    || typeof entry.status !== "string"
+    || !isDurableWorkflowStatus(entry.status)
+    || typeof entry.completedCheckpoints !== "number"
+    || typeof entry.pendingPrompts !== "number"
+    || typeof entry.ts !== "number"
+    || (entry.label !== undefined && typeof entry.label !== "string")
+    || (entry.rootWorkflowId !== undefined && typeof entry.rootWorkflowId !== "string")
+    || (entry.resumable !== undefined && typeof entry.resumable !== "boolean")
+    || (entry.invocationCwd !== undefined && typeof entry.invocationCwd !== "string")
+    || (entry.workflowCwd !== undefined && typeof entry.workflowCwd !== "string")
+    || (entry.repositoryRoot !== undefined && typeof entry.repositoryRoot !== "string")
+    || (entry.gitWorktreeRoot !== undefined && typeof entry.gitWorktreeRoot !== "string")) {
+    return undefined;
+  }
+  return {
+    type: "workflow.durable.checkpoint",
+    workflowId: entry.workflowId,
+    name: entry.name,
+    inputs: entry.inputs,
+    status: entry.status,
+    completedCheckpoints: entry.completedCheckpoints,
+    pendingPrompts: entry.pendingPrompts,
+    ts: entry.ts,
+    ...(entry.label !== undefined ? { label: entry.label } : {}),
+    ...(entry.rootWorkflowId !== undefined ? { rootWorkflowId: entry.rootWorkflowId } : {}),
+    ...(entry.resumable !== undefined ? { resumable: entry.resumable } : {}),
+    ...(entry.invocationCwd !== undefined ? { invocationCwd: entry.invocationCwd } : {}),
+    ...(entry.workflowCwd !== undefined ? { workflowCwd: entry.workflowCwd } : {}),
+    ...(entry.repositoryRoot !== undefined ? { repositoryRoot: entry.repositoryRoot } : {}),
+    ...(entry.gitWorktreeRoot !== undefined ? { gitWorktreeRoot: entry.gitWorktreeRoot } : {}),
+  };
+}
+
+function isDurableWorkflowStatus(value: string): value is DurableWorkflowStatus {
+  return value === "running"
+    || value === "paused"
+    || value === "completed"
+    || value === "failed"
+    || value === "cancelled"
+    || value === "blocked";
 }
 
 function dbosStatusToDurable(status: string): DurableWorkflowStatus {

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

@@ -51,6 +51,14 @@ export interface DbosCheckpointEnvelope extends WorkflowSerializableObject {
   readonly sessionId?: string;
   readonly sessionFile?: string;
   readonly completedAt: number;
+  readonly startedAt?: number;
+  readonly endedAt?: number;
+  readonly durationMs?: number;
+  readonly result?: string;
+  readonly model?: string;
+  readonly fastMode?: boolean;
+  readonly attemptedModels?: WorkflowSerializableValue;
+  readonly modelAttempts?: WorkflowSerializableValue;
 }
 
 /**
@@ -82,6 +90,14 @@ export function encodeCheckpoint(cp: DurableCheckpoint): DbosCheckpointEnvelope
     replayKey: s.replayKey,
     ...(s.sessionId !== undefined ? { sessionId: s.sessionId } : {}),
     ...(s.sessionFile !== undefined ? { sessionFile: s.sessionFile } : {}),
+    ...(s.startedAt !== undefined ? { startedAt: s.startedAt } : {}),
+    ...(s.endedAt !== undefined ? { endedAt: s.endedAt } : {}),
+    ...(s.durationMs !== undefined ? { durationMs: s.durationMs } : {}),
+    ...(s.result !== undefined ? { result: s.result } : {}),
+    ...(s.model !== undefined ? { model: s.model } : {}),
+    ...(s.fastMode !== undefined ? { fastMode: s.fastMode } : {}),
+    ...(s.attemptedModels !== undefined ? { attemptedModels: [...s.attemptedModels] } : {}),
+    ...(s.modelAttempts !== undefined ? { modelAttempts: s.modelAttempts as WorkflowSerializableValue } : {}),
   };
 }
 
@@ -144,9 +160,21 @@ function decodeEnvelope(workflowId: string, env: DbosCheckpointEnvelope): Durabl
     ...(env.hasOutput !== false && env.output !== undefined ? { output: env.output } : {}),
     ...(env.sessionId !== undefined ? { sessionId: env.sessionId } : {}),
     ...(env.sessionFile !== undefined ? { sessionFile: env.sessionFile } : {}),
+    ...(typeof env.startedAt === "number" ? { startedAt: env.startedAt } : {}),
+    ...(typeof env.endedAt === "number" ? { endedAt: env.endedAt } : {}),
+    ...(typeof env.durationMs === "number" ? { durationMs: env.durationMs } : {}),
+    ...(typeof env.result === "string" ? { result: env.result } : {}),
+    ...(typeof env.model === "string" ? { model: env.model } : {}),
+    ...(typeof env.fastMode === "boolean" ? { fastMode: env.fastMode } : {}),
+    ...(isStringArray(env.attemptedModels) ? { attemptedModels: env.attemptedModels } : {}),
+    ...(Array.isArray(env.modelAttempts) ? { modelAttempts: env.modelAttempts as DurableStageCheckpoint["modelAttempts"] } : {}),
   } as DurableStageCheckpoint;
 }
 
+
+function isStringArray(value: WorkflowSerializableValue | undefined): value is readonly string[] {
+  return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
 function decodeLegacy(
   workflowId: string,
   stepName: string,

package/dist/builtin/workflows/src/durable/resume-catalog.ts

@@ -107,6 +107,10 @@ function parseDurableEntry(raw: Record<string, unknown>): DurableCheckpointEntry
     ...(typeof raw["label"] === "string" ? { label: raw["label"] } : {}),
     ...(typeof raw["rootWorkflowId"] === "string" ? { rootWorkflowId: raw["rootWorkflowId"] } : {}),
     ...(typeof raw["resumable"] === "boolean" ? { resumable: raw["resumable"] } : {}),
+    ...(typeof raw["invocationCwd"] === "string" ? { invocationCwd: raw["invocationCwd"] } : {}),
+    ...(typeof raw["workflowCwd"] === "string" ? { workflowCwd: raw["workflowCwd"] } : {}),
+    ...(typeof raw["repositoryRoot"] === "string" ? { repositoryRoot: raw["repositoryRoot"] } : {}),
+    ...(typeof raw["gitWorktreeRoot"] === "string" ? { gitWorktreeRoot: raw["gitWorktreeRoot"] } : {}),
     ts,
   };
 }
@@ -142,6 +146,10 @@ function entryToResumable(entry: DurableCheckpointEntry, sessionFile: string): R
     ...(entry.label !== undefined ? { label: entry.label } : {}),
     ...(entry.rootWorkflowId !== undefined ? { rootWorkflowId: entry.rootWorkflowId } : {}),
     ...(entry.resumable !== undefined ? { resumable: entry.resumable } : {}),
+    ...(entry.invocationCwd !== undefined ? { invocationCwd: entry.invocationCwd } : {}),
+    ...(entry.workflowCwd !== undefined ? { workflowCwd: entry.workflowCwd } : {}),
+    ...(entry.repositoryRoot !== undefined ? { repositoryRoot: entry.repositoryRoot } : {}),
+    ...(entry.gitWorktreeRoot !== undefined ? { gitWorktreeRoot: entry.gitWorktreeRoot } : {}),
     createdAt: entry.ts,
     updatedAt: entry.ts,
   };
@@ -197,6 +205,10 @@ export function persistDurableCacheEntry(
     ...(entry.label !== undefined ? { label: entry.label } : {}),
     ...(entry.rootWorkflowId !== undefined ? { rootWorkflowId: entry.rootWorkflowId } : {}),
     ...(entry.resumable !== undefined ? { resumable: entry.resumable } : {}),
+    ...(entry.invocationCwd !== undefined ? { invocationCwd: entry.invocationCwd } : {}),
+    ...(entry.workflowCwd !== undefined ? { workflowCwd: entry.workflowCwd } : {}),
+    ...(entry.repositoryRoot !== undefined ? { repositoryRoot: entry.repositoryRoot } : {}),
+    ...(entry.gitWorktreeRoot !== undefined ? { gitWorktreeRoot: entry.gitWorktreeRoot } : {}),
     ts: entry.ts,
   });
 }

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

@@ -167,11 +167,14 @@ export function resumeDurableWorkflow(
   // ORIGINAL workflow id as the run id so durable checkpoints replay.
   backend.setWorkflowStatus(resolved.workflowId, "running");
 
-  const accepted: DetachedAccepted = runDetached(def, inputs, {
+  const resumeRunOpts: RunOpts = {
     ...deps.baseRunOpts,
+    ...(handle.invocationCwd !== undefined ? { cwd: handle.invocationCwd } : {}),
     runId: resolved.workflowId,
     durableBackend: backend,
-  });
+  };
+
+  const accepted: DetachedAccepted = runDetached(def, inputs, resumeRunOpts);
 
   return {
     ok: true,

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

@@ -1,6 +1,6 @@
 /** Durable `ctx.stage` / `ctx.task` replay and checkpoint helpers. */
 
-import type { StageContext, StageOptions, WorkflowTaskOptions, WorkflowTaskResult } from "../shared/types.js";
+import type { StageContext, StageOptions, WorkflowChildResult, WorkflowOutputValues, WorkflowTaskOptions, WorkflowTaskResult } from "../shared/types.js";
 import type { StageSnapshot } from "../shared/store-types.js";
 import type { WorkflowSerializableValue } from "../shared/types.js";
 import type { DurableWorkflowBackend } from "./backend.js";
@@ -8,6 +8,7 @@ import type { ParallelFailFastScope } from "../runs/foreground/executor-types.js
 import { durableHash } from "./backend.js";
 import { recordCheckpointDurably } from "./tool-primitive.js";
 import type { DurableStageCheckpoint } from "./types.js";
+export type DurableCompletedStageCheckpoint = DurableStageCheckpoint & { readonly output: WorkflowSerializableValue };
 
 export interface DurableStageDeps {
   readonly workflowId: string;
@@ -20,16 +21,28 @@ export interface DurableStageDeps {
 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);
-  if (deps.backend.getStageOutput(deps.workflowId, replayKey) !== undefined) return false;
-  const checkpoint: DurableStageCheckpoint = {
-    kind: "stage",
-    workflowId: deps.workflowId,
-    checkpointId: stableCheckpointId("stage", replayKey),
-    name: stage.name,
-    replayKey,
-    output: stageOutput(stage),
-    completedAt: stage.endedAt ?? Date.now(),
-  };
+  const metadata = checkpointMetadata(stage);
+  const hasExistingOutput = deps.backend.getStageOutput(deps.workflowId, replayKey) !== undefined;
+  const checkpoint: DurableStageCheckpoint = hasExistingOutput
+    ? {
+        kind: "stage",
+        workflowId: deps.workflowId,
+        checkpointId: stageMetadataCheckpointId(replayKey, stage),
+        name: stage.name,
+        replayKey,
+        completedAt: stage.endedAt ?? Date.now(),
+        ...metadata,
+      }
+    : {
+        kind: "stage",
+        workflowId: deps.workflowId,
+        checkpointId: stableCheckpointId("stage", replayKey),
+        name: stage.name,
+        replayKey,
+        output: stageOutput(stage),
+        completedAt: stage.endedAt ?? Date.now(),
+        ...metadata,
+      };
   await recordCheckpointDurably(deps.backend, checkpoint);
   return true;
 }
@@ -79,14 +92,14 @@ export function createDurableStagePrimitive(input: {
   readonly backend: DurableWorkflowBackend;
   readonly nextReplayKey: (stageName: string) => string;
   readonly stage: (name: string, options: StageOptions | undefined, replayKey: string) => StageContext;
-  readonly recordCachedStage?: (name: string, replayKey: string, output: WorkflowSerializableValue) => void;
+  readonly recordCachedStage?: (name: string, replayKey: string, checkpoint: DurableCompletedStageCheckpoint) => void;
 }): (name: string, options?: StageOptions) => StageContext {
   return (name: string, options?: StageOptions): StageContext => {
     const replayKey = input.nextReplayKey(name);
-    const cached = input.backend.getStageOutput(input.workflowId, replayKey);
+    const cached = stageCheckpointWithOutput(input.backend, input.workflowId, replayKey);
     if (cached !== undefined) {
       input.recordCachedStage?.(name, replayKey, cached);
-      return createCachedStageContext(name, cached);
+      return createCachedStageContext(name, cached.output, cached.result);
     }
     const session = input.backend.getStageSession(input.workflowId, replayKey);
     const isMidSessionResume = session?.sessionFile !== undefined;
@@ -112,14 +125,14 @@ export function createDurableTaskPrimitive(input: {
   readonly backend: DurableWorkflowBackend;
   readonly nextReplayKey: (stageName: string) => string;
   readonly task: (name: string, options: WorkflowTaskOptions, stageFailFastScope?: ParallelFailFastScope) => Promise<WorkflowTaskResult>;
-  readonly recordCachedTask?: (name: string, replayKey: string, output: WorkflowTaskResult) => void;
+  readonly recordCachedTask?: (name: string, replayKey: string, checkpoint: DurableCompletedStageCheckpoint, stageFailFastScope?: ParallelFailFastScope) => void;
 }): (name: string, options: WorkflowTaskOptions) => Promise<WorkflowTaskResult> {
   return async (name: string, options: WorkflowTaskOptions, stageFailFastScope?: ParallelFailFastScope): Promise<WorkflowTaskResult> => {
     const replayKey = input.nextReplayKey(`task:${name}`);
-    const cached = input.backend.getStageOutput(input.workflowId, replayKey);
-    if (cached !== undefined && isWorkflowTaskResult(cached)) {
-      input.recordCachedTask?.(name, replayKey, cached);
-      return cached;
+    const cached = stageCheckpointWithOutput(input.backend, input.workflowId, replayKey, isWorkflowTaskResult);
+    if (cached !== undefined && isWorkflowTaskResult(cached.output)) {
+      input.recordCachedTask?.(name, replayKey, cached, stageFailFastScope);
+      return cached.output;
     }
     const session = input.backend.getStageSession(input.workflowId, replayKey);
     const taskOptions: WorkflowTaskOptions = {
@@ -136,6 +149,7 @@ export function createDurableTaskPrimitive(input: {
       replayKey,
       output: result,
       completedAt: Date.now(),
+      ...taskCheckpointMetadata(result),
     });
     return result;
   };
@@ -174,8 +188,8 @@ function wrapSchemaStageForDurability(input: {
   return wrapped;
 }
 
-function createCachedStageContext(name: string, output: WorkflowSerializableValue): StageContext {
-  const text = typeof output === "string" ? output : JSON.stringify(output);
+function createCachedStageContext(name: string, output: WorkflowSerializableValue, result?: string): StageContext {
+  const text = result ?? (typeof output === "string" ? output : JSON.stringify(output));
   const unsupported = async (): Promise<never> => { throw new Error(`Stage "${name}" was replayed from a durable checkpoint; live session operations are unavailable.`); };
   const cached = {
     name,
@@ -213,6 +227,82 @@ function stageOutput(stage: StageSnapshot): WorkflowSerializableValue {
   return { status: stage.status, stageId: stage.id };
 }
 
+function checkpointMetadata(stage: StageSnapshot): Partial<DurableStageCheckpoint> {
+  return {
+    ...(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 {
+    result: result.text,
+    ...(result.sessionId !== undefined ? { sessionId: result.sessionId } : {}),
+    ...(result.sessionFile !== undefined ? { sessionFile: result.sessionFile } : {}),
+    ...(result.model !== undefined ? { model: result.model } : {}),
+    ...(result.fastMode !== undefined ? { fastMode: result.fastMode } : {}),
+    ...(result.attemptedModels !== undefined ? { attemptedModels: [...result.attemptedModels] } : {}),
+    ...(result.modelAttempts !== undefined ? { modelAttempts: [...result.modelAttempts] } : {}),
+  };
+}
+
+export function stageCheckpointWithOutput(
+  backend: DurableWorkflowBackend,
+  workflowId: string,
+  replayKey: string,
+  matchesOutput?: (value: WorkflowSerializableValue) => boolean,
+): DurableCompletedStageCheckpoint | undefined {
+  const checkpoints = backend.listCheckpoints(workflowId)
+    .filter((checkpoint): checkpoint is DurableStageCheckpoint =>
+      checkpoint.kind === "stage" && checkpoint.replayKey === replayKey,
+    );
+  const outputCheckpoints = checkpoints.filter((checkpoint): checkpoint is DurableCompletedStageCheckpoint =>
+    checkpoint.output !== undefined,
+  );
+  const replayValueCheckpoint = matchesOutput === undefined
+    ? outputCheckpoints[0]
+    : outputCheckpoints.find((checkpoint) => matchesOutput(checkpoint.output));
+  if (replayValueCheckpoint === undefined) return undefined;
+  return mergeCheckpointHydrationMetadata(replayValueCheckpoint, checkpoints);
+}
+
+function mergeCheckpointHydrationMetadata(
+  replayValueCheckpoint: DurableCompletedStageCheckpoint,
+  checkpoints: readonly DurableStageCheckpoint[],
+): DurableCompletedStageCheckpoint {
+  if (checkpoints.length === 0) return replayValueCheckpoint;
+  return {
+    ...replayValueCheckpoint,
+    ...(replayValueCheckpoint.startedAt === undefined ? metadataValue(checkpoints, "startedAt") : {}),
+    ...(replayValueCheckpoint.endedAt === undefined ? metadataValue(checkpoints, "endedAt") : {}),
+    ...(replayValueCheckpoint.durationMs === undefined ? metadataValue(checkpoints, "durationMs") : {}),
+    ...(replayValueCheckpoint.result === undefined ? metadataValue(checkpoints, "result") : {}),
+    ...(replayValueCheckpoint.sessionId === undefined ? metadataValue(checkpoints, "sessionId") : {}),
+    ...(replayValueCheckpoint.sessionFile === undefined ? metadataValue(checkpoints, "sessionFile") : {}),
+    ...(replayValueCheckpoint.model === undefined ? metadataValue(checkpoints, "model") : {}),
+    ...(replayValueCheckpoint.fastMode === undefined ? metadataValue(checkpoints, "fastMode") : {}),
+    ...(replayValueCheckpoint.attemptedModels === undefined ? metadataValue(checkpoints, "attemptedModels") : {}),
+    ...(replayValueCheckpoint.modelAttempts === undefined ? metadataValue(checkpoints, "modelAttempts") : {}),
+  };
+}
+
+function metadataValue<K extends keyof DurableStageCheckpoint>(
+  checkpoints: readonly DurableStageCheckpoint[],
+  key: K,
+): Pick<DurableStageCheckpoint, K> | Record<string, never> {
+  const value = checkpoints.find((checkpoint) => checkpoint[key] !== undefined)?.[key];
+  return value === undefined ? {} : { [key]: value } as Pick<DurableStageCheckpoint, K>;
+}
+
+
 export function createStageReplayKeyGenerator(_workflowId: string): (stageName: string, stageId?: string) => string {
   const counts = new Map<string, number>();
   return (stageName: string, _stageId?: string): string => {
@@ -236,6 +326,15 @@ function stageSessionCheckpointId(replayKey: string, stage: StageSnapshot): stri
 export function cachedStageId(runId: string, replayKey: string): string {
   return `durable-${durableHash({ runId, replayKey })}`;
 }
+function stageMetadataCheckpointId(replayKey: string, stage: StageSnapshot): string {
+  return `${stableCheckpointId("stage-meta", replayKey)}:${durableHash({
+    stageId: stage.id,
+    endedAt: stage.endedAt ?? 0,
+    durationMs: stage.durationMs ?? 0,
+    result: stage.result ?? "",
+  })}`;
+}
+
 
 export function recordCachedStageIntoStore(
   store: import("../shared/store.js").Store,
@@ -245,13 +344,24 @@ export function recordCachedStageIntoStore(
   output: WorkflowSerializableValue,
   completedStageReplayKeys: Map<string, string>,
   parentIds?: readonly string[],
+  checkpoint?: DurableCompletedStageCheckpoint,
 ): void {
   const now = Date.now();
   const stageId = cachedStageId(runId, replayKey);
-  const result = typeof output === "string" ? output : JSON.stringify(output);
+  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 snapshot: StageSnapshot = {
-    id: stageId, name, status: "completed", parentIds: parentIds !== undefined ? Object.freeze([...parentIds]) : [], startedAt: now, endedAt: now, durationMs: 0, result,
+    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,
+    ...(workflowChild !== undefined ? { workflowChild } : {}),
+    ...(checkpoint?.sessionId !== undefined ? { sessionId: checkpoint.sessionId } : {}),
+    ...(checkpoint?.sessionFile !== undefined ? { sessionFile: checkpoint.sessionFile } : {}),
+    ...(checkpoint?.model !== undefined ? { model: checkpoint.model } : {}),
+    ...(checkpoint?.fastMode !== undefined ? { fastMode: checkpoint.fastMode } : {}),
+    ...(checkpoint?.attemptedModels !== undefined ? { attemptedModels: checkpoint.attemptedModels } : {}),
+    ...(checkpoint?.modelAttempts !== undefined ? { modelAttempts: checkpoint.modelAttempts } : {}),
   };
   store.recordStageStart(runId, snapshot);
   store.recordStageEnd(runId, snapshot);
@@ -269,16 +379,44 @@ export function recordCachedStageWithTracker(
   runId: string,
   name: string,
   replayKey: string,
-  output: WorkflowSerializableValue,
+  checkpoint: DurableCompletedStageCheckpoint,
   completedStageReplayKeys: Map<string, string>,
+  stageFailFastScope?: ParallelFailFastScope,
 ): void {
   const stageId = cachedStageId(runId, replayKey);
-  const parentIds = tracker.onSpawn(stageId, name);
-  recordCachedStageIntoStore(store, runId, name, replayKey, output, completedStageReplayKeys, parentIds);
+  let parentIds = tracker.onSpawn(stageId, name);
+  const scopeParentIds = stageFailFastScope?.parentIds ?? [];
+  if (stageFailFastScope !== undefined) {
+    tracker.replaceParents(stageId, scopeParentIds);
+    parentIds = [...scopeParentIds];
+  }
+  recordCachedStageIntoStore(store, runId, name, replayKey, checkpoint.output, completedStageReplayKeys, parentIds, checkpoint);
   tracker.onSettle(stageId);
 }
-
 function isWorkflowTaskResult(value: WorkflowSerializableValue): value is WorkflowTaskResult {
   if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
   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 {
+    alias: result.workflow,
+    workflow: result.workflow,
+    runId: result.runId,
+    status: result.status,
+    ...(result.exited !== undefined ? { exited: result.exited } : {}),
+    outputs: result.outputs,
+    ...(typeof result.exitReason === "string" ? { exitReason: result.exitReason } : {}),
+  };
+}

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

@@ -9,7 +9,7 @@
  * cross-ref: issue #1498
  */
 
-import type { WorkflowSerializableValue } from "../shared/types.js";
+import type { WorkflowModelAttempt, WorkflowSerializableValue } from "../shared/types.js";
 
 // ---------------------------------------------------------------------------
 // Top-level workflow identity
@@ -32,6 +32,14 @@ export interface DurableWorkflowHandle {
   readonly updatedAt: number;
   /** Current durable status. */
   readonly status: DurableWorkflowStatus;
+  /** Original invocation cwd used to resolve repo-relative workflow defaults on resume. */
+  readonly invocationCwd?: string;
+  /** Resolved workflow cwd when an input-bound reusable worktree was set up. */
+  readonly workflowCwd?: string;
+  /** Invoking repository root used for reusable worktree validation. */
+  readonly repositoryRoot?: string;
+  /** Resolved reusable git worktree root, when setup happened at workflow start. */
+  readonly gitWorktreeRoot?: string;
   /** Session file path that caches this workflow's durable metadata. */
   readonly sessionFile?: string;
   /** Number of completed durable checkpoints. */
@@ -113,6 +121,19 @@ export interface DurableStageCheckpoint {
   readonly sessionId?: string;
   readonly sessionFile?: string;
   readonly completedAt: number;
+  /** Original stage start timestamp, when available. */
+  readonly startedAt?: number;
+  /** Original stage end timestamp, when available. */
+  readonly endedAt?: number;
+  /** Original stage duration, when available. */
+  readonly durationMs?: number;
+  /** Display/result text recorded for the completed stage. */
+  readonly result?: string;
+  /** Completed stage/task model metadata used to hydrate replayed snapshots. */
+  readonly model?: string;
+  readonly fastMode?: boolean;
+  readonly attemptedModels?: readonly string[];
+  readonly modelAttempts?: readonly WorkflowModelAttempt[];
 }
 
 export type UiPromptKind = "input" | "confirm" | "select" | "editor" | "custom";
@@ -145,6 +166,10 @@ export interface DurableCheckpointEntry {
   readonly label?: string;
   readonly rootWorkflowId?: string;
   readonly resumable?: boolean;
+  readonly invocationCwd?: string;
+  readonly workflowCwd?: string;
+  readonly repositoryRoot?: string;
+  readonly gitWorktreeRoot?: string;
   readonly ts: number;
 }
 
@@ -163,6 +188,10 @@ export interface ResumableWorkflowEntry {
   readonly label?: string;
   readonly rootWorkflowId?: string;
   readonly resumable?: boolean;
+  readonly invocationCwd?: string;
+  readonly workflowCwd?: string;
+  readonly repositoryRoot?: string;
+  readonly gitWorktreeRoot?: string;
   readonly createdAt: number;
   readonly updatedAt: number;
 }

package/dist/builtin/workflows/src/engine/primitives/task.ts

@@ -41,6 +41,7 @@ function createTaskPrimitive(runtime: EngineRuntime): WorkflowTaskPrimitive {
       const resolvedTaskOptions = stageOptionsWithGitWorktree(
         stageOptionsWithInputDefaults(taskOptions, runtime.inputRuntimeDefaults),
         runtime.workflowInvocationCwd,
+        runtime.gitWorktreeSetupCache,
       ) ?? taskOptions;
       const stageOptions = taskStageOptions(resolvedTaskOptions);
       const stageHandle = runtime.spawnStage(name, {

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

@@ -38,8 +38,7 @@ export async function finalizeDurableTerminalStatus(input: DurableTerminalFinali
 
   const durableStatus = toDurableStatus(status);
   if (durableStatus !== undefined) {
-    const resumable = status === "blocked" ? false : input.runSnapshot.resumable;
-    input.durableBackend.setWorkflowStatus(input.runId, durableStatus, undefined, resumable);
+    input.durableBackend.setWorkflowStatus(input.runId, durableStatus, undefined, input.runSnapshot.resumable);
   }
   try {
     await input.durableBackend.flush?.();

package/dist/builtin/workflows/src/engine/run-returned-status.ts

@@ -1,5 +1,13 @@
 import type { RunEndMetadata } from "../shared/store-public-types.js";
 import type { WorkflowOutputValues } from "../shared/types.js";
+import type { RunSnapshot } from "../shared/store-types.js";
+import {
+  actionableReturnedStatusText,
+  isReturnedBlockedWorkflowStatus,
+  isReturnedResumableBlockedWorkflowStatus,
+  normalizeReturnedWorkflowStatus,
+  structuredRecoverableWorkflowFailure,
+} from "../shared/returned-run-status.js";
 
 export interface ReturnedRunStatus {
   readonly status: "completed" | "failed" | "blocked";
@@ -7,23 +15,44 @@ export interface ReturnedRunStatus {
   readonly metadata?: RunEndMetadata;
 }
 
-export function classifyReturnedRunStatus(result: WorkflowOutputValues | undefined): ReturnedRunStatus {
-  const returnedStatus = result?.["status"];
-  if (returnedStatus !== "failed" && returnedStatus !== "blocked") {
+export function classifyReturnedRunStatus(result: WorkflowOutputValues | undefined, runSnapshot?: RunSnapshot): ReturnedRunStatus {
+  const structuredFailure = runSnapshot !== undefined ? structuredRecoverableWorkflowFailure(runSnapshot) : undefined;
+  if (structuredFailure !== undefined) {
+    return {
+      status: "blocked",
+      error: structuredFailure.error,
+      metadata: structuredFailure.metadata,
+    };
+  }
+  const returnedStatus = normalizeReturnedWorkflowStatus(result?.["status"]);
+  if (returnedStatus === undefined || returnedStatus === "completed" || returnedStatus === "complete") {
     return { status: "completed" };
   }
 
-  const summary = result?.["summary"];
-  const error = typeof summary === "string" && summary.trim().length > 0
-    ? summary.trim()
-    : `Workflow returned status ${JSON.stringify(returnedStatus)}.`;
-  return {
-    status: returnedStatus,
-    error,
-    metadata: returnedStatus === "failed"
-      ? returnedFailureMetadata(error)
-      : returnedBlockedMetadata(),
-  };
+  const error = returnedStatusError(result, returnedStatus);
+  if (returnedStatus === "failed") {
+    return {
+      status: "failed",
+      error,
+      metadata: returnedFailureMetadata(error),
+    };
+  }
+  if (isReturnedBlockedWorkflowStatus(returnedStatus)) {
+    const metadata = isReturnedResumableBlockedWorkflowStatus(returnedStatus)
+      ? returnedRecoverableBlockedMetadata(error)
+      : { resumable: false };
+    return {
+      status: "blocked",
+      error,
+      metadata,
+    };
+  }
+
+  return { status: "completed" };
+}
+
+function returnedStatusError(result: WorkflowOutputValues | undefined, returnedStatus: string): string {
+  return actionableReturnedStatusText(result) ?? `Workflow returned status ${JSON.stringify(returnedStatus)}.`;
 }
 
 function returnedFailureMetadata(error: string): RunEndMetadata {
@@ -36,6 +65,11 @@ function returnedFailureMetadata(error: string): RunEndMetadata {
   };
 }
 
-function returnedBlockedMetadata(): RunEndMetadata {
-  return { resumable: false };
+function returnedRecoverableBlockedMetadata(error: string): RunEndMetadata {
+  return {
+    failureRecoverability: "recoverable",
+    failureDisposition: "active_blocked",
+    failureMessage: error,
+    resumable: true,
+  };
 }