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

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

@@ -1,15 +1,33 @@
-import type { RunSnapshot, StageSnapshot } from "../shared/store-types.js";
-import type { WorkflowChildResult, WorkflowInputValues, WorkflowOutputValues, WorkflowSerializableValue } from "../shared/types.js";
+import type { RunSnapshot, StageSnapshot, ToolNodeSnapshot } from "../shared/store-types.js";
+import type { WorkflowInputValues, WorkflowSerializableValue } from "../shared/types.js";
 import { isReopenableSessionTranscript } from "../shared/session-transcript.js";
 import type { DurableWorkflowBackend } from "./backend.js";
+import { workflowToolOutcomeFromValue } from "./tool-outcome.js";
 import {
   DURABLE_STAGE_TOPOLOGY_VERSION,
   type DurableCheckpoint,
   type DurableStageCheckpoint,
+  type DurableToolCheckpoint,
   type ResumableWorkflowEntry,
 } from "./types.js";
 import { resolveDurableEntry } from "./resume-runtime.js";
-import { priorRunElapsedMs } from "./run-timing.js";
+import { priorRunElapsedMs, RUN_TIMING_CHECKPOINT_NAME } from "./run-timing.js";
+import {
+  boundaryOwner,
+  childRunIdFromDraft,
+  childRunStatus,
+  compareDraftSourceOrder,
+  mergeStageDraft,
+  mergeStageGroup,
+  retainReachableRunGroups,
+  runTopologyFor,
+  type StageDraft,
+  validBoundaryRecordSet,
+  validStageGroup,
+  validateRunGroups,
+  workflowChildFromDraft,
+} from "./completed-catalog-stage-groups.js";
+import { groupByDurableStageKey, immutableStageGroupError } from "./stage-topology-validation.js";
 
 export type CompletedWorkflowResolution =
   | { readonly kind: "found"; readonly entry: ResumableWorkflowEntry; readonly snapshot: RunSnapshot }
@@ -18,22 +36,11 @@ export type CompletedWorkflowResolution =
   | { readonly kind: "stale"; readonly entry: ResumableWorkflowEntry };
 
 
-interface StageDraft {
-  readonly replayKey: string;
-  readonly name: string;
-  readonly firstCompletedAt: number;
-  readonly output?: DurableStageCheckpoint["output"];
-  readonly result?: string;
-  readonly sessionId?: string;
-  readonly sessionFile?: string;
-  readonly startedAt?: number;
-  readonly endedAt?: number;
-  readonly durationMs?: number;
-  readonly model?: string;
-  readonly fastMode?: boolean;
-  readonly attemptedModels?: readonly string[];
-  readonly modelAttempts?: DurableStageCheckpoint["modelAttempts"];
-  readonly topology?: DurableStageCheckpoint["topology"];
+
+interface ReconstructionDrafts {
+  readonly stages: readonly StageDraft[];
+  readonly tools: readonly DurableToolCheckpoint[];
+  readonly firstToolSequenceByHash: ReadonlyMap<string, number>;
 }
 
 /** Authoritative completed rows. This path is deliberately separate from resumability. */
@@ -43,7 +50,7 @@ export function listCompletedFromBackend(
   return backend.listCompletedWorkflows();
 }
 
-/** Completed rows whose authoritative checkpoints and referenced transcripts still exist. */
+/** Completed rows whose authoritative stage topology reconstructs safely. */
 export function listOpenableCompletedWorkflows(
   backend: DurableWorkflowBackend,
 ): readonly ResumableWorkflowEntry[] {
@@ -78,9 +85,7 @@ export function completedWorkflowSnapshot(
   entry: ResumableWorkflowEntry,
 ): RunSnapshot | undefined {
   const runs = completedWorkflowRunSnapshots(backend, entry);
-  const root = runs.find((run) => run.id === entry.workflowId);
-  if (root === undefined || !runs.some((run) => run.stages.some((stage) => stage.sessionFile !== undefined))) return undefined;
-  return root;
+  return runs.find((run) => run.id === entry.workflowId);
 }
 
 /** Rebuild the root plus every nested child run required by graph expansion. */
@@ -89,7 +94,7 @@ export function completedWorkflowRunSnapshots(
   entry: ResumableWorkflowEntry,
 ): readonly RunSnapshot[] {
   const handle = backend.getWorkflow(entry.workflowId);
-  if (handle === undefined || handle.status !== "completed") return [];
+  if (handle === undefined || (handle.status !== "completed" && handle.status !== "failed")) return [];
   const checkpoints = backend.listCheckpoints(entry.workflowId);
   if (checkpoints.length === 0) return [];
   const runs = runSnapshotsFromCheckpoints(checkpoints, handle.workflowId, handle.name, handle.updatedAt)
@@ -101,10 +106,17 @@ export function completedWorkflowRunSnapshots(
   const root: RunSnapshot = {
     ...runs[rootIndex]!,
     inputs: { ...handle.inputs } as WorkflowInputValues,
+    status: handle.status,
     startedAt: handle.createdAt,
     endedAt: handle.updatedAt,
     durationMs: rootDuration,
-    resumable: false,
+    ...(handle.error !== undefined ? { error: handle.error } : {}),
+    ...(handle.failureKind !== undefined ? { failureKind: handle.failureKind } : {}),
+    ...(handle.failureCode !== undefined ? { failureCode: handle.failureCode } : {}),
+    ...(handle.failureRecoverability !== undefined ? { failureRecoverability: handle.failureRecoverability } : {}),
+    ...(handle.failureDisposition !== undefined ? { failureDisposition: handle.failureDisposition } : {}),
+    ...(handle.failedToolNodeId !== undefined ? { failedToolNodeId: handle.failedToolNodeId } : {}),
+    resumable: handle.resumable ?? false,
   };
   return [root, ...runs.filter((_, index) => index !== rootIndex)];
 }
@@ -132,6 +144,78 @@ function validatedStageTranscript(stage: StageSnapshot): StageSnapshot {
   return withoutSessionFile;
 }
 
+/** Enumerate the backend sequence once so legacy stages and tools share one order domain. */
+function checkpointDrafts(checkpoints: readonly DurableCheckpoint[]): ReconstructionDrafts {
+  const stageByReplayKey = new Map<string, StageDraft>();
+  const toolByHash = new Map<string, DurableToolCheckpoint>();
+  const firstToolSequenceByHash = new Map<string, number>();
+  checkpoints.forEach((checkpoint, index) => {
+    const sequence = index + 1;
+    if (checkpoint.kind === "stage") {
+      const existing = stageByReplayKey.get(checkpoint.replayKey);
+      stageByReplayKey.set(checkpoint.replayKey, mergeStageDraft(existing, checkpoint, sequence));
+      return;
+    }
+    if (checkpoint.kind !== "tool" || checkpoint.argsHash === RUN_TIMING_CHECKPOINT_NAME) return;
+    if (!firstToolSequenceByHash.has(checkpoint.argsHash)) {
+      firstToolSequenceByHash.set(checkpoint.argsHash, sequence);
+    }
+    const existing = toolByHash.get(checkpoint.argsHash);
+    if (existing === undefined || checkpoint.completedAt >= existing.completedAt) {
+      toolByHash.set(checkpoint.argsHash, checkpoint);
+    }
+  });
+  return {
+    stages: [...stageByReplayKey.values()],
+    tools: [...toolByHash.values()],
+    firstToolSequenceByHash,
+  };
+}
+
+function completedToolNodes(
+  checkpoints: readonly DurableToolCheckpoint[],
+  runId: string,
+  rootRunId: string,
+  sourceIds: ReadonlyMap<string, string>,
+  firstSequenceByHash: ReadonlyMap<string, number>,
+): ToolNodeSnapshot[] {
+  return checkpoints.flatMap((checkpoint, index) => {
+    const topologyRunId = checkpoint.topology?.run?.runId ?? rootRunId;
+    if (topologyRunId !== runId) return [];
+    const topology = checkpoint.topology;
+    const outcome = checkpoint.outcomeKind === undefined
+      ? undefined
+      : workflowToolOutcomeFromValue(checkpoint.output);
+    const failed = checkpoint.outcomeKind === "return_failure" || checkpoint.throwingFailureError !== undefined;
+    const failureError = checkpoint.throwingFailureError
+      ?? (outcome?.ok === false ? outcome.error.message : undefined);
+    return [{
+      kind: "tool" as const,
+      id: topology?.nodeId ?? checkpoint.checkpointId,
+      name: checkpoint.name,
+      argsHash: checkpoint.argsHash,
+      ordinal: topology?.ordinal ?? index + 1,
+      parentIds: Object.freeze([...(topology?.parentIds ?? [])].map((parentId) => sourceIds.get(parentId) ?? parentId)),
+      replayed: true,
+      ...(topology === undefined ? { topologyState: "unavailable" as const } : {}),
+      status: failed ? "failed" as const : "cached" as const,
+      executionOrder: topology?.order ?? firstSequenceByHash.get(checkpoint.argsHash)!,
+      ...(topology?.startedAt !== undefined ? { startedAt: topology.startedAt } : {}),
+      endedAt: topology?.endedAt ?? checkpoint.completedAt,
+      ...(failed
+        ? { error: failureError ?? "Invalid durable ctx.tool failure outcome" }
+        : { resultSummary: summarizeCompletedToolResult(checkpoint.output) }),
+      attachable: false as const,
+    }];
+  });
+}
+
+function summarizeCompletedToolResult(value: WorkflowSerializableValue): string {
+  const serialized = JSON.stringify(value);
+  if (serialized === undefined) return String(value).slice(0, 240);
+  return serialized.length <= 240 ? serialized : `${serialized.slice(0, 237)}...`;
+}
+
 
 function runSnapshotsFromCheckpoints(
   checkpoints: readonly DurableCheckpoint[],
@@ -140,19 +224,37 @@ function runSnapshotsFromCheckpoints(
   fallbackCompletedAt: number,
   strict = true,
 ): RunSnapshot[] {
-  const drafts = new Map<string, StageDraft>();
-  for (const checkpoint of checkpoints) {
-    if (checkpoint.kind !== "stage") continue;
-    const existing = drafts.get(checkpoint.replayKey);
-    drafts.set(checkpoint.replayKey, mergeStageDraft(existing, checkpoint));
+  if (!validBoundaryRecordSet(checkpoints, strict)) return [];
+  const stageRecords = checkpoints.filter(
+    (checkpoint): checkpoint is DurableStageCheckpoint => checkpoint.kind === "stage",
+  );
+  const identityRecords = stageRecords.filter((stage) => stage.topology?.sourceOrder !== undefined
+    || stage.topology?.status !== undefined || stage.topology?.occurrenceKey !== undefined
+    || stage.topology?.boundary !== undefined);
+  if (immutableStageGroupError(identityRecords) !== undefined) return [];
+  const recordsByGroup = groupByDurableStageKey(stageRecords);
+  const candidates = [...recordsByGroup.values()]
+    .map((records) => mergeStageGroup(records, stageRecords, checkpoints))
+    .filter((draft) => !strict || draft.topology?.run === undefined
+      || draft.endedAt !== undefined || draft.output !== undefined)
+    .map((draft): StageDraft => draft.topology !== undefined ? draft : {
+      ...draft,
+      topology: {
+        version: DURABLE_STAGE_TOPOLOGY_VERSION,
+        stageId: `completed-stage-${draft.firstSequence}`,
+        parentIds: [],
+        order: draft.firstSequence,
+      },
+    })
+    .sort(compareDraftSourceOrder);
+  const drafts = checkpointDrafts(checkpoints);
+  const toolCheckpoints = drafts.tools;
+  if (candidates.length === 0 && toolCheckpoints.length === 0) {
+    return strict ? [] : [syntheticRun(rootRunId, rootRunName, checkpoints.length, fallbackCompletedAt)];
   }
-  const ordered = [...drafts.values()]
-    .filter((draft) => !strict || draft.topology?.run === undefined || draft.endedAt !== undefined || draft.output !== undefined)
-    .sort((a, b) => a.firstCompletedAt - b.firstCompletedAt);
-  if (ordered.length === 0) return [syntheticRun(rootRunId, rootRunName, checkpoints.length, fallbackCompletedAt)];
 
   const grouped = new Map<string, StageDraft[]>();
-  for (const draft of ordered) {
+  for (const draft of candidates) {
     if (draft.topology?.version !== DURABLE_STAGE_TOPOLOGY_VERSION) {
       if (strict) return [];
       continue;
@@ -162,26 +264,58 @@ function runSnapshotsFromCheckpoints(
     group.push(draft);
     grouped.set(runId, group);
   }
+  for (const checkpoint of toolCheckpoints) {
+    const runId = checkpoint.topology?.run?.runId ?? rootRunId;
+    if (!grouped.has(runId)) grouped.set(runId, []);
+  }
+  for (const group of grouped.values()) group.sort(compareDraftSourceOrder);
   retainReachableRunGroups(grouped, rootRunId);
+  if (!validateRunGroups(grouped, rootRunId, toolCheckpoints)) return [];
+
   const idMaps = new Map<string, Map<string, string>>();
   for (const [runId, runDrafts] of grouped) {
+    const ownedToolIds = new Set(toolCheckpoints.flatMap((checkpoint) =>
+      (checkpoint.topology?.run?.runId ?? rootRunId) === runId
+        ? [checkpoint.topology?.nodeId ?? checkpoint.checkpointId]
+        : []
+    ));
+    if (!validStageGroup(runDrafts, runId, ownedToolIds)) return [];
     const ids = new Map<string, string>();
-    runDrafts.forEach((draft, index) => {
-      const sourceId = draft.topology!.stageId;
-      if (!ids.has(sourceId)) ids.set(sourceId, `completed-stage-${index + 1}`);
+    let hasIdentityConflict = false;
+    runDrafts.forEach((draft) => {
+      const completedId = draft.topology!.stageId;
+      ids.set(draft.topology!.stageId, completedId);
+      for (const sourceId of draft.sourceIds) {
+        const existing = ids.get(sourceId);
+        if (existing !== undefined && existing !== completedId) hasIdentityConflict = true;
+        else ids.set(sourceId, completedId);
+      }
     });
-    if (ids.size !== runDrafts.length) {
+    if (hasIdentityConflict) {
       if (strict) return [];
       grouped.delete(runId);
       continue;
     }
+    for (const checkpoint of toolCheckpoints) {
+      const ownerRunId = checkpoint.topology?.run?.runId ?? rootRunId;
+      const sourceId = checkpoint.topology?.nodeId ?? checkpoint.checkpointId;
+      if (ownerRunId === runId) ids.set(sourceId, sourceId);
+    }
     idMaps.set(runId, ids);
   }
 
   const runs: RunSnapshot[] = [];
   for (const [runId, runDrafts] of grouped) {
     const ids = idMaps.get(runId)!;
-    if (runDrafts.some((draft) => draft.topology!.parentIds.some((parentId) => !ids.has(parentId)))) {
+    const ownedTools = toolCheckpoints.filter((checkpoint) =>
+      (checkpoint.topology?.run?.runId ?? rootRunId) === runId
+    );
+    const hasUnknownParents = runDrafts.some((draft) =>
+      draft.topology!.parentIds.some((parentId) => !ids.has(parentId))
+    ) || ownedTools.some((checkpoint) =>
+      checkpoint.topology?.parentIds.some((parentId) => !ids.has(parentId)) === true
+    );
+    if (hasUnknownParents) {
       if (strict) return [];
       continue;
     }
@@ -190,12 +324,22 @@ function runSnapshotsFromCheckpoints(
       ids.get(draft.topology!.stageId)!,
       draft.topology!.parentIds.map((parentId) => ids.get(parentId)!),
     ));
-    const run = runDrafts.find((draft) => draft.topology?.run !== undefined)?.topology?.run;
-    const startedAt = Math.min(...stages.map((stage) => stage.startedAt ?? fallbackCompletedAt));
-    const endedAt = Math.max(...stages.map((stage) => stage.endedAt ?? fallbackCompletedAt));
+    const toolNodes = completedToolNodes(
+      toolCheckpoints, runId, rootRunId, ids, drafts.firstToolSequenceByHash,
+    );
+    const run = runTopologyFor(runDrafts, ownedTools);
+    const startedAt = Math.min(
+      ...stages.map((stage) => stage.startedAt ?? fallbackCompletedAt),
+      ...toolNodes.map((tool) => tool.startedAt ?? tool.endedAt ?? fallbackCompletedAt),
+    );
+    const endedAt = Math.max(
+      ...stages.map((stage) => stage.endedAt ?? fallbackCompletedAt),
+      ...toolNodes.map((tool) => tool.endedAt ?? fallbackCompletedAt),
+    );
+    const owner = runId === rootRunId ? undefined : boundaryOwner(grouped, runId);
     const parentRunId = run?.parentRunId ?? rootRunId;
     const boundarySourceId = grouped.get(parentRunId)?.find((draft) =>
-      workflowChildFromOutput(draft.output)?.runId === runId
+      childRunIdFromDraft(draft) === runId
     )?.topology?.stageId;
     const declaredParentStageId = run?.parentStageId === undefined
       ? undefined
@@ -206,8 +350,9 @@ function runSnapshotsFromCheckpoints(
       id: runId,
       name: run?.runName ?? rootRunName,
       inputs: {},
-      status: "completed",
+      status: owner === undefined ? "completed" : childRunStatus(owner),
       stages,
+      toolNodes,
       startedAt,
       endedAt,
       durationMs: Math.max(0, endedAt - startedAt),
@@ -220,108 +365,37 @@ function runSnapshotsFromCheckpoints(
   return runs;
 }
 
-function retainReachableRunGroups(grouped: Map<string, StageDraft[]>, rootRunId: string): void {
-  const reachable = new Set([rootRunId]);
-  const pending = [rootRunId];
-  while (pending.length > 0) {
-    const drafts = grouped.get(pending.pop()!);
-    if (drafts === undefined) continue;
-    for (const draft of drafts) {
-      const childRunId = workflowChildFromOutput(draft.output)?.runId;
-      if (childRunId === undefined || reachable.has(childRunId) || !grouped.has(childRunId)) continue;
-      reachable.add(childRunId);
-      pending.push(childRunId);
-    }
-  }
-  for (const runId of grouped.keys()) {
-    if (!reachable.has(runId)) grouped.delete(runId);
-  }
-}
-
-function mergeStageDraft(
-  existing: StageDraft | undefined,
-  checkpoint: DurableStageCheckpoint,
-): StageDraft {
-  return {
-    replayKey: checkpoint.replayKey,
-    name: existing?.name ?? checkpoint.name,
-    firstCompletedAt: Math.min(existing?.firstCompletedAt ?? checkpoint.completedAt, checkpoint.completedAt),
-    ...valueOrExisting("output", checkpoint, existing),
-    ...valueOrExisting("result", checkpoint, existing),
-    ...valueOrExisting("sessionId", checkpoint, existing),
-    ...valueOrExisting("sessionFile", checkpoint, existing),
-    ...valueOrExisting("startedAt", checkpoint, existing),
-    ...valueOrExisting("endedAt", checkpoint, existing),
-    ...valueOrExisting("durationMs", checkpoint, existing),
-    ...valueOrExisting("model", checkpoint, existing),
-    ...valueOrExisting("fastMode", checkpoint, existing),
-    ...valueOrExisting("attemptedModels", checkpoint, existing),
-    ...valueOrExisting("modelAttempts", checkpoint, existing),
-    ...preferredTopology(checkpoint, existing),
-  };
-}
-
-function preferredTopology(
-  checkpoint: DurableStageCheckpoint,
-  existing: StageDraft | undefined,
-): Pick<StageDraft, "topology"> | object {
-  const current = checkpoint.topology;
-  const prior = existing?.topology;
-  if (current?.run !== undefined) return { topology: current };
-  if (prior?.run !== undefined) return { topology: prior };
-  return current !== undefined ? { topology: current } : prior !== undefined ? { topology: prior } : {};
-}
-
-function valueOrExisting<
-  K extends keyof Omit<StageDraft, "replayKey" | "name" | "firstCompletedAt">
->(key: K, checkpoint: DurableStageCheckpoint, existing: StageDraft | undefined): Pick<StageDraft, K> | object {
-  const checkpointValue = checkpoint[key];
-  if (checkpointValue !== undefined) return { [key]: checkpointValue } as Pick<StageDraft, K>;
-  const existingValue = existing?.[key];
-  return existingValue === undefined ? {} : { [key]: existingValue } as Pick<StageDraft, K>;
-}
-
-function workflowChildFromOutput(output: WorkflowSerializableValue | undefined): StageSnapshot["workflowChild"] | undefined {
-  if (!isWorkflowChildResult(output)) return undefined;
-  return {
-    alias: output.workflow,
-    workflow: output.workflow,
-    runId: output.runId,
-    status: output.status,
-    ...(output.exited !== undefined ? { exited: output.exited } : {}),
-    outputs: output.outputs,
-    ...(typeof output.exitReason === "string" ? { exitReason: output.exitReason } : {}),
-  };
-}
-
-function isWorkflowChildResult(value: WorkflowSerializableValue | undefined): value is WorkflowChildResult<WorkflowOutputValues> {
-  if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
-  const item = value as Record<string, WorkflowSerializableValue | undefined>;
-  return typeof item["workflow"] === "string" && typeof item["runId"] === "string"
-    && typeof item["status"] === "string" && typeof item["outputs"] === "object"
-    && item["outputs"] !== null && !Array.isArray(item["outputs"]);
-}
 
 function stageSnapshotFromDraft(
   draft: StageDraft,
   id: string,
   parentIds: readonly string[],
 ): StageSnapshot {
+  const status = draft.topology?.status ?? "completed";
   const startedAt = draft.startedAt ?? draft.firstCompletedAt;
-  const endedAt = draft.endedAt ?? draft.firstCompletedAt;
+  const endedAt = draft.endedAt ?? (status === "running" ? undefined : draft.firstCompletedAt);
+  const workflowChild = workflowChildFromDraft(draft);
+  const boundary = draft.topology?.boundary;
   return {
     id,
     name: draft.name,
-    status: "completed",
+    status,
     parentIds,
+    executionOrder: draft.topology?.order ?? draft.topology?.sourceOrder ?? draft.firstSequence,
     startedAt,
-    endedAt,
-    durationMs: draft.durationMs ?? Math.max(0, endedAt - startedAt),
+    ...(endedAt !== undefined ? { endedAt } : {}),
+    ...(endedAt !== undefined ? { durationMs: draft.durationMs ?? Math.max(0, endedAt - startedAt) } : {}),
     ...(stageResult(draft) !== undefined ? { result: stageResult(draft) } : {}),
     replayKey: draft.replayKey,
     toolEvents: [],
     attachable: false,
-    ...(workflowChildFromOutput(draft.output) !== undefined ? { workflowChild: workflowChildFromOutput(draft.output) } : {}),
+    ...(workflowChild !== undefined ? { workflowChild } : {}),
+    ...(workflowChild === undefined && boundary !== undefined
+      && status !== "failed" && status !== "skipped" ? { workflowChildRun: {
+        alias: boundary.alias,
+        workflow: boundary.workflow,
+        runId: boundary.child.runId,
+      } } : {}),
     ...(draft.sessionId !== undefined ? { sessionId: draft.sessionId } : {}),
     ...(draft.sessionFile !== undefined ? { sessionFile: draft.sessionFile } : {}),
     ...(draft.model !== undefined ? { model: draft.model } : {}),

package/dist/builtin/workflows/src/durable/completed-inspection.ts

@@ -26,6 +26,8 @@ export interface OpenCompletedDurableDeps {
   readonly stageControlRegistry?: StageControlRegistry;
   readonly cwd?: string;
   readonly defaultSessionDir?: string;
+  /** Seed lifecycle dedupe state before historical snapshots become observable. */
+  readonly beforeRestore?: (snapshots: readonly RunSnapshot[]) => void;
 }
 
 interface CompletedChatRegistration {
@@ -72,18 +74,22 @@ export function openCompletedDurableWorkflow(
   }
   const snapshots = completedWorkflowRunSnapshots(deps.durableBackend, resolved.entry);
   const snapshot = snapshots.find((run) => run.id === resolved.snapshot.id) ?? resolved.snapshot;
+  deps.beforeRestore?.(snapshots);
   for (const restored of snapshots) {
     const previous = deps.store.runs().find((run) => run.id === restored.id);
     if (previous !== undefined) deps.store.removeRun(previous.id);
     deps.store.recordRunStart(restored);
     registerCompletedChatHandles(restored, deps);
   }
+  const hasReopenableStage = snapshots.some((run) =>
+    run.stages.some((stage) => stage.sessionFile !== undefined)
+  );
   return {
     ok: true,
     runId: snapshot.id,
     workflowId: snapshot.id,
     name: snapshot.name,
-    message: `Opened completed durable workflow "${snapshot.name}" (${snapshot.id.slice(0, 8)}) for read-only inspection and follow-up chat.`,
+    message: `Opened completed durable workflow "${snapshot.name}" (${snapshot.id.slice(0, 8)}) for read-only inspection${hasReopenableStage ? " and follow-up chat" : ""}.`,
   };
 }
 
@@ -115,7 +121,7 @@ function registerCompletedChatHandles(
     if (stage.sessionFile === undefined) continue;
     const key = completedChatKey(snapshot.id, stage.id);
     const registration = registrations.get(key);
-    const existing = registry.get(snapshot.id, stage.id);
+    const existing = registry.claim(snapshot.id, stage.id);
     if (existing?.sessionFile === stage.sessionFile && !existing.isDisposed) continue;
     if (registration !== undefined) {
       removeCompletedChatRegistration(registrations, key, registration);

package/dist/builtin/workflows/src/durable/completed-subtree.ts

@@ -0,0 +1,31 @@
+import type { RunSnapshot } from "../shared/store-types.js";
+import type { DurableWorkflowBackend } from "./backend.js";
+import { durableNestedRunSnapshots } from "./completed-catalog.js";
+
+/** Return one cached boundary's exact subtree only when every selected node is fully terminal. */
+export function durableCompletedNestedRunSubtree(
+  backend: DurableWorkflowBackend,
+  rootWorkflowId: string,
+  childRunId: string,
+): readonly RunSnapshot[] | undefined {
+  const nested = durableNestedRunSnapshots(backend, rootWorkflowId);
+  if (!nested.some((run) => run.id === childRunId)) return undefined;
+  const included = new Set([childRunId]);
+  let priorSize = -1;
+  while (priorSize !== included.size) {
+    priorSize = included.size;
+    for (const run of nested) {
+      if (run.parentRunId !== undefined && included.has(run.parentRunId)) included.add(run.id);
+    }
+  }
+  const subtree = nested.filter((run) => included.has(run.id));
+  const complete = subtree.length === included.size && subtree.every((run) =>
+    run.status === "completed" && run.endedAt !== undefined
+    && run.stages.every((stage) => isTerminalStage(stage.status) && stage.endedAt !== undefined)
+  );
+  return complete ? subtree : undefined;
+}
+
+function isTerminalStage(status: RunSnapshot["stages"][number]["status"]): boolean {
+  return status === "completed" || status === "failed" || status === "skipped";
+}

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

@@ -1,10 +1,10 @@
 /** DBOS-backed durable backend adapter. */
-
-import type { DurableCheckpoint, DurableWorkflowHandle, DurableWorkflowStatus, ResumableWorkflowEntry } from "./types.js";
+import type { DurableCheckpoint, DurableWorkflowFailureMetadata, DurableWorkflowHandle, DurableWorkflowStatus, ResumableWorkflowEntry } from "./types.js";
 import type { WorkflowSerializableValue } from "../shared/types.js";
 import type { WorkflowSerializableObject as DurableInputs } from "./types.js";
 import { InMemoryDurableBackend, type DurableInactiveDeleteResult, type DurableWorkflowBackend, type DurableWorkflowCatalogEntries, type WorkflowRegistrationInput } from "./backend.js";
 import { encodeCheckpoint, classifyCheckpointPayload } from "./dbos-envelope.js";
+import { DurableNestedTopologyError } from "./boundary-topology.js";
 import { transitionDbosWorkflowStatus } from "./dbos-status-transition.js";
 import { claimMetadataStepName, classifyLatestMetadata, encodeMetadata, isMetadataStep, metadataStepName, parseCurrentMetadataRecord } from "./dbos-metadata.js";
 import { inactivePromptReservationToken, type PromptReservationToken } from "./prompt-reservation-state.js";
@@ -163,6 +163,9 @@ export class DbosDurableBackend implements DurableWorkflowBackend {
   }
 
   registerWorkflow(handle: WorkflowRegistrationInput): void {
+    if (this.invalid.has(handle.workflowId)) {
+      throw new DurableNestedTopologyError(`workflow ${handle.workflowId} contains malformed current DBOS records`);
+    }
     this.invalid.delete(handle.workflowId);
     this.current.add(handle.workflowId);
     this.locallyRegistered.add(handle.workflowId);
@@ -192,6 +195,18 @@ export class DbosDurableBackend implements DurableWorkflowBackend {
     });
   }
 
+  async recordAdditiveCheckpointBestEffort(checkpoint: DurableCheckpoint): Promise<boolean> {
+    if (!this.isWorkflowLoadable(checkpoint.workflowId)) return true;
+    // Encode before the best-effort storage boundary: malformed topology or
+    // serialization must remain authoritative errors rather than be ignored.
+    const encoded = encodeCheckpoint(checkpoint);
+    return await this.enqueueBestEffortWrite(async () => {
+      if (!this.isWorkflowLoadable(checkpoint.workflowId)) return;
+      await this.sdk.recordStepOutput(checkpoint.workflowId, checkpoint.checkpointId, encoded);
+      this.mem.recordCheckpoint(checkpoint);
+    });
+  }
+
   private async persistCheckpoint(checkpoint: DurableCheckpoint): Promise<void> {
     await this.persistCheckpointRecord(checkpoint);
     await this.writeMetadata(checkpoint.workflowId);
@@ -202,6 +217,7 @@ export class DbosDurableBackend implements DurableWorkflowBackend {
   }
 
   getToolOutput(workflowId: string, argsHash: string): WorkflowSerializableValue | undefined { return this.mem.getToolOutput(workflowId, argsHash); }
+  getToolCheckpoint(workflowId: string, argsHash: string) { return this.mem.getToolCheckpoint(workflowId, argsHash); }
   getUiResponse(workflowId: string, promptHash: string): WorkflowSerializableValue | undefined { return this.mem.getUiResponse(workflowId, promptHash); }
   getStageOutput(workflowId: string, replayKey: string): WorkflowSerializableValue | undefined { return this.mem.getStageOutput(workflowId, replayKey); }
   getStageSession(workflowId: string, replayKey: string) { return this.mem.getStageSession(workflowId, replayKey); }
@@ -209,12 +225,12 @@ export class DbosDurableBackend implements DurableWorkflowBackend {
   getWorkflow(workflowId: string): DurableWorkflowHandle | undefined { return this.mem.getWorkflow(workflowId); }
   getLoadableWorkflow(workflowId: string): DurableWorkflowHandle | undefined { return this.isWorkflowLoadable(workflowId) ? this.mem.getWorkflow(workflowId) : undefined; }
 
-  setWorkflowStatus(workflowId: string, status: DurableWorkflowStatus, pendingPrompts?: number, resumable?: boolean): void {
+  setWorkflowStatus(workflowId: string, status: DurableWorkflowStatus, pendingPrompts?: number, resumable?: boolean, failure?: DurableWorkflowFailureMetadata): void {
     if (!this.isWorkflowLoadable(workflowId)) return;
     if (pendingPrompts !== undefined) {
       this.promptReservations.setBaseline(workflowId, pendingPrompts);
     }
-    this.mem.setWorkflowStatus(workflowId, status, pendingPrompts, resumable);
+    this.mem.setWorkflowStatus(workflowId, status, pendingPrompts, resumable, failure);
     this.enqueueWrite(async () => {
       if (!this.isWorkflowLoadable(workflowId)) return;
       if (status === "cancelled") await this.sdk.cancelWorkflow(workflowId);
@@ -434,6 +450,12 @@ export class DbosDurableBackend implements DurableWorkflowBackend {
     return next;
   }
 
+  private async enqueueBestEffortWrite(fn: () => Promise<void>): Promise<boolean> {
+    const next = this.writeQueue.then(fn, fn);
+    this.writeQueue = next.catch(() => undefined);
+    return await next.then(() => true, () => false);
+  }
+
   private async writeMetadata(workflowId: string): Promise<void> {
     const value = this.mem.toMetadata(workflowId);
     if (value === undefined) return;
@@ -454,26 +476,8 @@ export class DbosDurableBackend implements DurableWorkflowBackend {
     workflowId: string,
     metadata: import("./types.js").DurableWorkflowMetadata,
   ): void {
-    this.mem.registerWorkflow({
-      workflowId,
-      name: metadata.name,
-      inputs: metadata.inputs,
-      createdAt: metadata.createdAt,
-      updatedAt: metadata.updatedAt,
-      status: metadata.status,
-      completedCheckpoints: metadata.completedCheckpoints,
-      pendingPrompts: metadata.pendingPrompts,
-      ...(metadata.ownerExecutorId !== undefined ? { ownerExecutorId: metadata.ownerExecutorId } : {}),
-      ...(metadata.sessionFile !== undefined ? { sessionFile: metadata.sessionFile } : {}),
-      ...(metadata.label !== undefined ? { label: metadata.label } : {}),
-      ...(metadata.rootWorkflowId !== undefined ? { rootWorkflowId: metadata.rootWorkflowId } : {}),
-      ...(metadata.resumable !== undefined ? { resumable: metadata.resumable } : {}),
-      ...(metadata.invocationCwd !== undefined ? { invocationCwd: metadata.invocationCwd } : {}),
-      ...(metadata.workflowCwd !== undefined ? { workflowCwd: metadata.workflowCwd } : {}),
-      ...(metadata.repositoryRoot !== undefined ? { repositoryRoot: metadata.repositoryRoot } : {}),
-      ...(metadata.gitWorktreeRoot !== undefined ? { gitWorktreeRoot: metadata.gitWorktreeRoot } : {}),
-    });
+    if (metadata.workflowId !== workflowId) return;
+    this.mem.registerWorkflow(metadata);
   }
 }
-
 // Metadata encoding/classification lives in dbos-metadata.ts to keep this adapter focused.