@bastani/atomic 0.9.13-alpha.2 → 0.9.13-alpha.3

package/dist/builtin/workflows/src/extension/index.bundle.mjs

@@ -37555,6 +37555,8 @@ function summaryRows(detail, now) {
     rows.push(["error", detail.error.split(`
 `)[0] ?? ""]);
   }
+  if (detail.resumeGuidance)
+    rows.push(["guidance", detail.resumeGuidance]);
   return rows;
 }
 function artifactRowsFor(detail) {
@@ -37668,6 +37670,8 @@ function stateBadges(detail, theme) {
   switch (detail.status) {
     case "running":
       return [{ text: "● running", fg: theme.warning }];
+    case "crashed":
+      return [{ text: detail.resumable === true ? "✗ crashed · resumable" : "✗ crashed", fg: theme.error }];
     case "paused":
       return [{ text: "❚❚ paused", fg: theme.warning }];
     case "completed":
@@ -37690,6 +37694,8 @@ function stateLabel(detail) {
   switch (detail.status) {
     case "running":
       return "● running";
+    case "crashed":
+      return detail.resumable === true ? "✗ crashed · resumable" : "✗ crashed";
     case "paused":
       return "❚❚ paused";
     case "completed":
@@ -37729,8 +37735,10 @@ function renderIdentifierRows2(id, width, theme) {
   });
 }
 function renderDetailHintRows(detail, width, theme) {
-  const prefix = detail.endedAt === undefined ? detail.status === "paused" ? " ▸ workflow resume id=" : " ▸ workflow interrupt   id=" : " ▸ workflow resume id=";
-  const suffix = detail.endedAt === undefined ? detail.status === "paused" ? "    continue workflow " : "    cancel " : "    reopen graph ";
+  const resumable = detail.status === "paused" && detail.resumable !== false || detail.resumable === true && (detail.status === "crashed" || detail.status === "failed" || detail.status === "blocked");
+  const inspectOnly = detail.ownerActiveElsewhere === true || detail.status === "crashed" && !resumable || detail.endedAt !== undefined && !resumable;
+  const prefix = inspectOnly ? " ▸ workflow status id=" : resumable ? " ▸ workflow resume id=" : " ▸ workflow interrupt   id=";
+  const suffix = inspectOnly ? detail.ownerActiveElsewhere === true ? "    inspect; owner active elsewhere " : "    inspect retained state " : resumable ? "    continue workflow " : "    cancel ";
   const continuation = "    ";
   const rows = wrapIdentifierLines(detail.runId, width, prefix, continuation);
   const last = rows[rows.length - 1];
@@ -47839,7 +47847,7 @@ function isModelUsage(value2) {
   if (typeof value2 !== "object" || value2 === null || Array.isArray(value2))
     return false;
   const usage = value2;
-  return ["input", "output", "cacheRead", "cacheWrite", "cost", "turns"].every((key2) => usage[key2] === undefined || typeof usage[key2] === "number" && Number.isFinite(usage[key2]));
+  return ["input", "output", "cacheRead", "cacheWrite", "cost", "turns"].every((key2) => usage[key2] === undefined || typeof usage[key2] === "number" && Number.isFinite(usage[key2]) && usage[key2] >= 0);
 }
 function isUiPromptKind(value2) {
   return value2 === "input" || value2 === "confirm" || value2 === "select" || value2 === "editor" || value2 === "custom";
@@ -48165,6 +48173,12 @@ class InMemoryDurableBackend {
     return this.getWorkflow(workflowId);
   }
   async hydrateWorkflow(_workflowId) {}
+  async hydrateWorkflowForInspection(workflowId) {
+    const handle = this.getLoadableWorkflow(workflowId);
+    if (handle !== undefined)
+      return { kind: "current", handle };
+    return { kind: this.deletedWorkflowIds.has(workflowId) ? "deleted" : "absent" };
+  }
   async hydrateResumableWorkflows() {}
   async prepareWorkflowCatalog() {
     return { resumable: this.listResumableWorkflows(), completed: this.listCompletedWorkflows() };
@@ -50300,17 +50314,24 @@ class DbosDurableBackend {
     throw first;
   }
   async hydrateWorkflow(workflowId) {
-    if (this.locallyRegistered.has(workflowId))
-      return;
-    const info = await this.sdk.retrieveWorkflow(workflowId);
-    if (info !== undefined) {
-      await this.hydrateInfo(info);
-      return;
+    await this.hydrateWorkflowForInspection(workflowId);
+  }
+  async hydrateWorkflowForInspection(workflowId) {
+    if (this.locallyRegistered.has(workflowId)) {
+      const handle = this.getLoadableWorkflow(workflowId);
+      return handle === undefined ? { kind: "malformed" } : { kind: "current", handle };
     }
+    const info = await this.sdk.retrieveWorkflow(workflowId);
+    if (info !== undefined)
+      return await this.hydrateInfo(info);
     const records = await this.sdk.listStepRecords(workflowId);
     const deletion = classifyDbosDeletionTombstone(records, workflowId);
-    if (deletion !== "absent")
-      await this.suppressWorkflow(workflowId);
+    if (deletion === "absent" && records.length === 0)
+      return { kind: "absent" };
+    await this.suppressWorkflow(workflowId);
+    if (deletion === "absent")
+      return { kind: "malformed" };
+    return { kind: deletion === "current" ? "deleted" : "malformed" };
   }
   async hydrateResumableWorkflows() {
     const all = await this.sdk.listAllWorkflows();
@@ -50322,10 +50343,15 @@ class DbosDurableBackend {
   }
   async hydrateInfo(info) {
     const records = await this.sdk.listStepRecords(info.workflowId);
+    const deletion = classifyDbosDeletionTombstone(records, info.workflowId);
+    if (deletion !== "absent") {
+      await this.suppressWorkflow(info.workflowId);
+      return { kind: deletion === "current" ? "deleted" : "malformed" };
+    }
     const metadata = classifyLatestMetadata(records, info.workflowId);
     if (metadata.kind !== "current") {
       await this.suppressWorkflow(info.workflowId);
-      return;
+      return { kind: "malformed" };
     }
     const checkpoints = [];
     for (const record of records) {
@@ -50334,7 +50360,7 @@ class DbosDurableBackend {
       const classified = classifyCheckpointPayload(info.workflowId, record.stepName, record.output);
       if (classified.kind === "unknown") {
         await this.suppressWorkflow(info.workflowId);
-        return;
+        return { kind: "malformed" };
       }
       checkpoints.push(classified.checkpoint);
     }
@@ -50345,14 +50371,21 @@ class DbosDurableBackend {
     for (const checkpoint of checkpoints)
       this.mem.recordCheckpoint(checkpoint);
     const current = this.mem.getWorkflow(info.workflowId);
-    if (current !== undefined) {
-      const pendingPrompts2 = this.promptReservations.hydrate(info.workflowId, metadata.metadata.pendingPrompts, records, metadata.metadata.promptReservationEpoch);
-      this.applyMetadata(info.workflowId, {
-        ...metadata.metadata,
-        pendingPrompts: pendingPrompts2,
-        completedCheckpoints: current.completedCheckpoints
-      });
+    if (current === undefined) {
+      await this.suppressWorkflow(info.workflowId);
+      return { kind: "malformed" };
     }
+    const pendingPrompts2 = this.promptReservations.hydrate(info.workflowId, metadata.metadata.pendingPrompts, records, metadata.metadata.promptReservationEpoch);
+    this.applyMetadata(info.workflowId, {
+      ...metadata.metadata,
+      pendingPrompts: pendingPrompts2,
+      completedCheckpoints: current.completedCheckpoints
+    });
+    const handle = this.getLoadableWorkflow(info.workflowId);
+    if (handle !== undefined)
+      return { kind: "current", handle };
+    await this.suppressWorkflow(info.workflowId);
+    return { kind: "malformed" };
   }
   async suppressWorkflow(workflowId) {
     this.invalid.add(workflowId);
@@ -51066,20 +51099,34 @@ function priorRunElapsedMs(backend, workflowId) {
   return elapsedMs;
 }
 function recordRunTimingCheckpoint(backend, run, options) {
+  const checkpoint = runTimingCheckpoint(backend, run, options);
+  if (checkpoint === undefined)
+    return false;
+  backend.recordCheckpoint(checkpoint);
+  return true;
+}
+async function recordRunTimingCheckpointAsync(backend, run, options) {
+  const checkpoint = runTimingCheckpoint(backend, run, options);
+  if (checkpoint === undefined)
+    return false;
+  await backend.recordCheckpointAsync(checkpoint);
+  return true;
+}
+function runTimingCheckpoint(backend, run, options) {
   const now = options?.now ?? Date.now();
   const elapsedMs = elapsedRunMs(run, now);
   if (elapsedMs <= 0)
-    return false;
+    return;
   if (backend.listCheckpoints(run.id).length === 0)
-    return false;
+    return;
   const recorded = priorRunElapsedMs(backend, run.id);
   if (recorded !== undefined) {
     if (elapsedMs <= recorded)
-      return false;
+      return;
     if (options?.debounce === true && timingBucket(elapsedMs) === timingBucket(recorded))
-      return false;
+      return;
   }
-  const checkpoint = {
+  return {
     kind: "tool",
     workflowId: run.id,
     checkpointId: `run-timing:${elapsedMs}`,
@@ -51088,8 +51135,6 @@ function recordRunTimingCheckpoint(backend, run, options) {
     output: { elapsedMs },
     completedAt: now
   };
-  backend.recordCheckpoint(checkpoint);
-  return true;
 }
 function inheritedRunElapsedMs(input) {
   const now = input.now ?? Date.now();
@@ -52992,33 +53037,33 @@ function isRunStatus(value2) {
       return false;
   }
 }
-function resolveRunId(target) {
+function resolveRunId(target, activeStore = store) {
   if (!isFullRunId(target))
     return { kind: "malformed", message: malformedRunIdMessage(target) };
-  const exact = store.runs().find((r) => r.id === target);
+  const exact = activeStore.runs().find((r) => r.id === target);
   if (exact)
     return { kind: "exact", runId: exact.id };
   return { kind: "not_found" };
 }
-function resolveToolRunTarget(args, emptyMessage) {
+function resolveToolRunTarget(args, emptyMessage, activeStore = store) {
   const rawTarget = args.runId?.trim() ?? "";
   if (args.all === true || rawTarget === "--all")
     return { kind: "all" };
-  const target = rawTarget || store.activeRunId() || "";
+  const target = rawTarget || activeStore.activeRunId() || "";
   if (!target)
     return { kind: "not_found", target: rawTarget, message: emptyMessage };
-  const resolved = resolveRunId(target);
+  const resolved = resolveRunId(target, activeStore);
   if (resolved.kind === "exact")
     return { kind: "run", runId: resolved.runId };
   if (resolved.kind === "malformed")
     return { kind: "malformed", target, message: resolved.message };
   return { kind: "not_found", target, message: `Run not found: ${target}` };
 }
-function resolveStageTarget(runId, stageTarget) {
+function resolveStageTarget(runId, stageTarget, activeStore = store) {
   const target = stageTarget?.trim();
   if (!target)
     return { ok: true, runId };
-  const graph = expandWorkflowGraph(readGraphStoreSnapshot(store), runId);
+  const graph = expandWorkflowGraph(readGraphStoreSnapshot(activeStore), runId);
   const exactVirtualIds = graph.stages.filter((stage) => stage.id === target);
   if (exactVirtualIds.length === 1)
     return resolvedStageTarget(exactVirtualIds[0]);
@@ -53054,8 +53099,8 @@ function ambiguousStageTarget(target, stages) {
     message: `Ambiguous stage identifier "${target}" matches: ${stages.map(expandedStageLabel).join(", ")}`
   };
 }
-function resolveToolStageTarget(runId, stageTarget) {
-  return resolveStageTarget(runId, stageTarget);
+function resolveToolStageTarget(runId, stageTarget, activeStore = store) {
+  return resolveStageTarget(runId, stageTarget, activeStore);
 }
 function resolveControlNodeTarget(runId, stageTarget) {
   const target = stageTarget?.trim();
@@ -61101,6 +61146,9 @@ class ScopedDurableBackend {
   hydrateWorkflow(_workflowId) {
     return Promise.resolve();
   }
+  hydrateWorkflowForInspection(_workflowId) {
+    return Promise.resolve({ kind: "absent" });
+  }
   hydrateResumableWorkflows() {
     return Promise.resolve();
   }
@@ -64784,7 +64832,7 @@ function createDurableStageSessionRecorder(input) {
     if (stageRunId === input.runId) {
       await recordStageSessionCheckpoint(input.deps, snapshot, { force: options?.forceDurable === true });
       if (input.runSnapshot !== undefined) {
-        recordRunTimingCheckpoint(input.deps.backend, input.runSnapshot, {
+        await recordRunTimingCheckpointAsync(input.deps.backend, input.runSnapshot, {
           debounce: options?.forceDurable !== true
         });
       }
@@ -64833,7 +64881,7 @@ function hasUsableContentBlock(block) {
 }
 
 // dist/builtin/workflows/src/durable/completed-catalog-stage-groups.ts
-function validBoundaryRecordSet(checkpoints, strict) {
+function validBoundaryRecordSet(checkpoints, strict, requireActiveFingerprint = false) {
   const stages = checkpoints.filter((item) => item.kind === "stage");
   const boundaries = stages.filter((item) => item.topology?.boundary !== undefined);
   const startsByReplay = new Map;
@@ -64848,42 +64896,59 @@ function validBoundaryRecordSet(checkpoints, strict) {
     return false;
   if (boundaries.some((checkpoint) => checkpoint.topology.boundary.event === "terminal" && startsByReplay.get(checkpoint.replayKey)?.length !== 1))
     return false;
-  return [...startsByReplay.values()].every((starts) => boundaryTransitionError(starts[0], stages, strict) === undefined);
+  return [...startsByReplay.values()].every((starts) => {
+    const start = starts[0];
+    if (boundaryTransitionError(start, stages, strict) !== undefined)
+      return false;
+    if (!requireActiveFingerprint || start.topology.boundary.invocationFingerprint !== undefined)
+      return true;
+    return stages.some((stage) => stage.replayKey === start.replayKey && stage.topology?.boundary?.event === "terminal" && stage.topology.boundary.status === "completed") && boundaryTransitionError(start, stages, true) === undefined;
+  });
 }
-function validStageGroup(drafts, runId, allowedNodeIds = new Set) {
+function validStageGroup(drafts, runId, rootRunId, tools = []) {
   if (drafts.some((draft) => draft.topology.stageId.length === 0))
     return false;
-  const stageIds = new Set(drafts.map((draft) => draft.topology.stageId));
-  if (stageIds.size !== drafts.length)
+  if (tools.some((tool) => tool.topology !== undefined && (tool.topology.version !== DURABLE_TOOL_TOPOLOGY_VERSION || tool.topology.nodeId.length === 0)))
     return false;
-  const ids = new Set([...allowedNodeIds, ...stageIds]);
-  if (ids.size !== allowedNodeIds.size + stageIds.size)
+  const stageIds = drafts.map((draft) => draft.topology.stageId);
+  const toolIds = tools.map((tool) => tool.topology?.nodeId ?? tool.checkpointId);
+  const ids = new Set([...stageIds, ...toolIds]);
+  if (ids.size !== stageIds.length + toolIds.length)
     return false;
   const orders = drafts.flatMap((draft) => draft.topology.sourceOrder === undefined ? [] : [draft.topology.sourceOrder]);
   if (new Set(orders).size !== orders.length)
     return false;
-  if (drafts.some((draft) => draft.topology.parentIds.some((parentId) => !ids.has(parentId))))
+  const parentEntries = [
+    ...drafts.map((draft) => [draft.topology.stageId, draft.topology.parentIds]),
+    ...tools.map((tool) => [tool.topology?.nodeId ?? tool.checkpointId, tool.topology?.parentIds ?? []])
+  ];
+  if (parentEntries.some(([, parentIds]) => parentIds.some((parentId) => !ids.has(parentId))))
     return false;
-  const runs = drafts.flatMap((draft) => draft.topology?.run === undefined ? [] : [draft.topology.run]);
+  const runs = [
+    ...drafts.flatMap((draft) => draft.topology?.run === undefined ? [] : [draft.topology.run]),
+    ...tools.flatMap((tool) => tool.topology?.run === undefined ? [] : [tool.topology.run])
+  ];
   const first = runs[0];
   if (runs.some((run) => run.runId !== runId || first !== undefined && (run.runName !== first.runName || run.parentRunId !== first.parentRunId || run.parentStageId !== first.parentStageId || run.rootRunId !== first.rootRunId)))
     return false;
-  const parents = new Map(drafts.map((draft) => [draft.topology.stageId, draft.topology.parentIds]));
+  if (runId === rootRunId && runs.some((run) => run.parentRunId !== undefined || run.parentStageId !== undefined || run.rootRunId !== undefined))
+    return false;
+  const parents = new Map(parentEntries);
   const visiting = new Set;
   const visited = new Set;
-  const cyclic = (stageId) => {
-    if (visiting.has(stageId))
+  const cyclic = (nodeId) => {
+    if (visiting.has(nodeId))
       return true;
-    if (visited.has(stageId))
+    if (visited.has(nodeId))
       return false;
-    visiting.add(stageId);
-    if ((parents.get(stageId) ?? []).some(cyclic))
+    visiting.add(nodeId);
+    if ((parents.get(nodeId) ?? []).some(cyclic))
       return true;
-    visiting.delete(stageId);
-    visited.add(stageId);
+    visiting.delete(nodeId);
+    visited.add(nodeId);
     return false;
   };
-  return ![...stageIds].some(cyclic);
+  return ![...ids].some(cyclic);
 }
 function compareDraftSourceOrder(left, right) {
   const leftOrder = left.topology?.sourceOrder;
@@ -65425,7 +65490,7 @@ function completedWorkflowRunSnapshots(backend, entry) {
   const checkpoints = backend.listCheckpoints(entry.workflowId);
   if (checkpoints.length === 0)
     return [];
-  const runs = runSnapshotsFromCheckpoints(checkpoints, handle.workflowId, handle.name, handle.updatedAt).map((run2) => ({ ...run2, stages: run2.stages.map(validatedStageTranscript) }));
+  const runs = runSnapshotsFromCheckpoints(checkpoints, handle.workflowId, handle.name, handle.updatedAt, COMPLETED_RECONSTRUCTION).map((run2) => ({ ...run2, stages: run2.stages.map(validatedStageTranscript) }));
   const rootIndex = runs.findIndex((run2) => run2.id === handle.workflowId);
   if (rootIndex < 0)
     return [];
@@ -65449,11 +65514,45 @@ function completedWorkflowRunSnapshots(backend, entry) {
   };
   return [root, ...runs.filter((_, index) => index !== rootIndex)];
 }
+function durableWorkflowRunSnapshots(backend, handle) {
+  const checkpoints = backend.listCheckpoints(handle.workflowId);
+  if (checkpoints.length === 0) {
+    return [rootSnapshot(backend, handle, { stages: [], toolNodes: [] })];
+  }
+  const requiresTerminalTopology = handle.status === "completed" || handle.status === "failed";
+  const runs = runSnapshotsFromCheckpoints(checkpoints, handle.workflowId, handle.name, handle.updatedAt, requiresTerminalTopology ? COMPLETED_RECONSTRUCTION : ACTIVE_INSPECTION_RECONSTRUCTION);
+  const rootIndex = runs.findIndex((run2) => run2.id === handle.workflowId);
+  if (rootIndex < 0)
+    return [];
+  return [rootSnapshot(backend, handle, runs[rootIndex]), ...runs.filter((_, index) => index !== rootIndex)];
+}
+function rootSnapshot(backend, handle, graph) {
+  const terminal = handle.status === "completed" || handle.status === "failed" || handle.status === "cancelled";
+  const priorDurationMs = priorRunElapsedMs(backend, handle.workflowId);
+  const terminalDurationMs = priorDurationMs ?? Math.max(0, handle.updatedAt - handle.createdAt);
+  return {
+    id: handle.workflowId,
+    name: handle.name,
+    inputs: { ...handle.inputs },
+    status: handle.status,
+    stages: graph.stages,
+    toolNodes: graph.toolNodes,
+    startedAt: handle.createdAt,
+    ...terminal ? { endedAt: handle.updatedAt, durationMs: terminalDurationMs } : priorDurationMs === undefined ? {} : { accumulatedDurationMs: priorDurationMs },
+    ...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: isDurableWorkflowResumable(handle)
+  };
+}
 function durableNestedRunSnapshots(backend, rootWorkflowId) {
   const handle = backend.getWorkflow(rootWorkflowId);
   if (handle === undefined)
     return [];
-  return runSnapshotsFromCheckpoints(backend.listCheckpoints(rootWorkflowId), rootWorkflowId, handle.name, handle.updatedAt, false).filter((run2) => run2.id !== rootWorkflowId);
+  return runSnapshotsFromCheckpoints(backend.listCheckpoints(rootWorkflowId), rootWorkflowId, handle.name, handle.updatedAt, LEGACY_ACTIVE_RECONSTRUCTION).filter((run2) => run2.id !== rootWorkflowId);
 }
 function validatedStageTranscript(stage) {
   if (stage.sessionFile === undefined || isReopenableSessionTranscript(stage.sessionFile))
@@ -65523,15 +65622,36 @@ function summarizeCompletedToolResult(value2) {
     return flattenTruncatedString(String(value2).slice(0, 240));
   return serialized.length <= 240 ? serialized : `${flattenTruncatedString(serialized.slice(0, 237))}...`;
 }
-function runSnapshotsFromCheckpoints(checkpoints, rootRunId, rootRunName, fallbackCompletedAt, strict = true) {
-  if (!validBoundaryRecordSet(checkpoints, strict))
+var COMPLETED_RECONSTRUCTION = {
+  requireTerminal: true,
+  failClosed: true,
+  retainActive: false,
+  failOnUnreachable: false,
+  requireActiveBoundaryFingerprint: false
+};
+var ACTIVE_INSPECTION_RECONSTRUCTION = {
+  requireTerminal: false,
+  failClosed: true,
+  retainActive: true,
+  failOnUnreachable: true,
+  requireActiveBoundaryFingerprint: true
+};
+var LEGACY_ACTIVE_RECONSTRUCTION = {
+  requireTerminal: false,
+  failClosed: false,
+  retainActive: true,
+  failOnUnreachable: false,
+  requireActiveBoundaryFingerprint: false
+};
+function runSnapshotsFromCheckpoints(checkpoints, rootRunId, rootRunName, fallbackCompletedAt, policy = COMPLETED_RECONSTRUCTION) {
+  if (!validBoundaryRecordSet(checkpoints, policy.requireTerminal, policy.requireActiveBoundaryFingerprint))
     return [];
   const stageRecords = checkpoints.filter((checkpoint) => 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) => draft.topology !== undefined ? draft : {
+  const candidates = [...recordsByGroup.values()].map((records) => mergeStageGroup(records, stageRecords, checkpoints)).filter((draft) => policy.retainActive || draft.topology?.run === undefined || draft.endedAt !== undefined || draft.output !== undefined).map((draft) => draft.topology !== undefined ? draft : {
     ...draft,
     topology: {
       version: DURABLE_STAGE_TOPOLOGY_VERSION,
@@ -65542,13 +65662,36 @@ function runSnapshotsFromCheckpoints(checkpoints, rootRunId, rootRunName, fallba
   }).sort(compareDraftSourceOrder);
   const drafts = checkpointDrafts(checkpoints);
   const toolCheckpoints = drafts.tools;
+  if (policy.failClosed) {
+    for (const draft of candidates) {
+      const boundary = draft.topology?.boundary;
+      if (boundary === undefined || childRunIdFromDraft(draft) === undefined)
+        continue;
+      if (boundary.replayScope !== draft.replayKey)
+        return [];
+      const expectedChildRun = {
+        runId: boundary.child.runId,
+        runName: boundary.child.runName,
+        parentRunId: boundary.child.parentRunId,
+        parentStageId: boundary.child.parentStageId,
+        rootRunId: boundary.child.rootRunId
+      };
+      const childToolIds = new Set(toolCheckpoints.flatMap((checkpoint) => checkpoint.topology?.run?.runId === expectedChildRun.runId ? [checkpoint.topology.nodeId] : []));
+      if (directChildTopologyError(stageRecords, boundary.replayScope, expectedChildRun, true, childToolIds) !== undefined)
+        return [];
+    }
+  }
   if (candidates.length === 0 && toolCheckpoints.length === 0) {
-    return strict ? [] : [syntheticRun(rootRunId, rootRunName, checkpoints.length, fallbackCompletedAt)];
+    const supportedNonGraphState = checkpoints.every((checkpoint) => checkpoint.kind === "ui" || checkpoint.kind === "tool" && checkpoint.argsHash === RUN_TIMING_CHECKPOINT_NAME);
+    if (policy.failClosed && supportedNonGraphState) {
+      return [emptyGraphRun(rootRunId, rootRunName, fallbackCompletedAt)];
+    }
+    return policy.failClosed ? [] : [syntheticRun(rootRunId, rootRunName, checkpoints.length, fallbackCompletedAt)];
   }
   const grouped = new Map;
   for (const draft of candidates) {
     if (draft.topology?.version !== DURABLE_STAGE_TOPOLOGY_VERSION) {
-      if (strict)
+      if (policy.failClosed)
         return [];
       continue;
     }
@@ -65564,7 +65707,10 @@ function runSnapshotsFromCheckpoints(checkpoints, rootRunId, rootRunName, fallba
   }
   for (const group of grouped.values())
     group.sort(compareDraftSourceOrder);
+  const groupedCount = grouped.size;
   retainReachableRunGroups(grouped, rootRunId);
+  if (policy.failOnUnreachable && grouped.size !== groupedCount)
+    return [];
   if (!validateRunGroups(grouped, rootRunId, toolCheckpoints, checkpoints))
     return [];
   const syntheticChildren = [];
@@ -65574,7 +65720,7 @@ function runSnapshotsFromCheckpoints(checkpoints, rootRunId, rootRunName, fallba
       if (child?.exited !== true || grouped.has(child.runId))
         continue;
       if (!isSyntheticExitedChild(draft, parentRunId, child.runId, rootRunId) || childScopedEvidenceExists(checkpoints, draft.replayKey, child.runId)) {
-        if (strict)
+        if (policy.failClosed)
           return [];
         continue;
       }
@@ -65583,8 +65729,8 @@ function runSnapshotsFromCheckpoints(checkpoints, rootRunId, rootRunName, fallba
   }
   const idMaps = new Map;
   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))
+    const ownedTools = toolCheckpoints.filter((checkpoint) => (checkpoint.topology?.run?.runId ?? rootRunId) === runId);
+    if (!validStageGroup(runDrafts, runId, rootRunId, ownedTools))
       return [];
     const ids = new Map;
     let hasIdentityConflict = false;
@@ -65600,7 +65746,7 @@ function runSnapshotsFromCheckpoints(checkpoints, rootRunId, rootRunName, fallba
       }
     });
     if (hasIdentityConflict) {
-      if (strict)
+      if (policy.failClosed)
         return [];
       grouped.delete(runId);
       continue;
@@ -65620,7 +65766,7 @@ function runSnapshotsFromCheckpoints(checkpoints, rootRunId, rootRunName, fallba
     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)
+      if (policy.failClosed)
         return [];
       continue;
     }
@@ -65630,6 +65776,8 @@ function runSnapshotsFromCheckpoints(checkpoints, rootRunId, rootRunName, fallba
     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 status = owner === undefined ? "completed" : childRunStatus(owner);
+    const terminal = status !== "running" && status !== "pending" && status !== "paused" && status !== "blocked";
     const parentRunId = run2?.parentRunId ?? rootRunId;
     const boundarySourceId = grouped.get(parentRunId)?.find((draft) => childRunIdFromDraft(draft) === runId)?.topology?.stageId;
     const declaredParentStageId = run2?.parentStageId === undefined ? undefined : idMaps.get(parentRunId)?.get(run2.parentStageId);
@@ -65639,12 +65787,11 @@ function runSnapshotsFromCheckpoints(checkpoints, rootRunId, rootRunName, fallba
       id: runId,
       name: run2?.runName ?? rootRunName,
       inputs: {},
-      status: owner === undefined ? "completed" : childRunStatus(owner),
+      status,
       stages,
       toolNodes,
       startedAt,
-      endedAt,
-      durationMs: Math.max(0, endedAt - startedAt),
+      ...terminal ? { endedAt, durationMs: Math.max(0, endedAt - startedAt) } : {},
       ...run2?.parentRunId !== undefined ? { parentRunId: run2.parentRunId } : {},
       ...parentStageId !== undefined ? { parentStageId } : {},
       ...run2?.rootRunId !== undefined ? { rootRunId: run2.rootRunId } : {},
@@ -65659,7 +65806,7 @@ function runSnapshotsFromCheckpoints(checkpoints, rootRunId, rootRunName, fallba
   }
   for (const { parentRunId, owner, child } of syntheticChildren) {
     if (!emittedRunIds.has(parentRunId)) {
-      if (strict)
+      if (policy.failClosed)
         return [];
       continue;
     }
@@ -65667,7 +65814,7 @@ function runSnapshotsFromCheckpoints(checkpoints, rootRunId, rootRunName, fallba
     const boundary = topology.boundary;
     const parentStageId = idMaps.get(parentRunId)?.get(topology.stageId);
     if (parentStageId === undefined) {
-      if (strict)
+      if (policy.failClosed)
         return [];
       continue;
     }
@@ -65736,6 +65883,20 @@ function stageResult(draft) {
     return;
   return typeof draft.output === "string" ? draft.output : JSON.stringify(draft.output);
 }
+function emptyGraphRun(runId, runName, completedAt) {
+  return {
+    id: runId,
+    name: runName,
+    inputs: {},
+    status: "completed",
+    stages: [],
+    toolNodes: [],
+    startedAt: completedAt,
+    endedAt: completedAt,
+    durationMs: 0,
+    resumable: false
+  };
+}
 function syntheticRun(runId, runName, checkpointCount, completedAt) {
   return {
     id: runId,
@@ -66619,7 +66780,7 @@ function createTrackedStageCaller(input) {
       if (suppressQueuedContinuation)
         runtime.state.suppressQueuedUserMessageContinuation = true;
       try {
-        result = await raceAbort(runtime.innerCtx.prompt(RESUME_CONTINUATION_PROMPT), runtime.signal);
+        result = await runtime.raceStageSessionHeartbeat(raceAbort(runtime.innerCtx.prompt(RESUME_CONTINUATION_PROMPT), runtime.signal));
       } finally {
         if (suppressQueuedContinuation)
           runtime.state.suppressQueuedUserMessageContinuation = false;
@@ -66646,46 +66807,51 @@ function createTrackedStageCaller(input) {
       throw err;
     }
     const trackStageLifecycle = !runtime.state.stageFinalized;
-    let refreshedParentIds;
-    if (trackStageLifecycle && !input.hasContinuation && runtime.stageSnapshot.startedAt === undefined && !input.hasScopedParents) {
-      const actualParentIds = runtime.scheduler.tracker.currentParents();
-      const sameParents = actualParentIds.length === runtime.stageSnapshot.parentIds.length && actualParentIds.every((value2) => runtime.stageSnapshot.parentIds.includes(value2));
-      if (!sameParents) {
-        runtime.scheduler.tracker.replaceParents(runtime.stageId, actualParentIds);
-        refreshedParentIds = actualParentIds;
-      }
-    }
-    if (trackStageLifecycle) {
-      const now = Date.now();
-      const hasNoExplicitModelConfig = input.options?.model === undefined && input.options?.fallbackModels === undefined;
-      const promptAdapterHandlesInitialPrompt = input.adapters.prompt !== undefined;
-      if (callOptions.eagerSession && !promptAdapterHandlesInitialPrompt && (hasNoExplicitModelConfig || await hasExplicitFastModeCandidate({
-        model: input.options?.model,
-        fallbackModels: input.options?.fallbackModels,
-        models: runtime.opts.models
-      }))) {
-        try {
-          await runtime.innerCtx.__ensureSession();
-          runtime.captureStageSessionMeta();
-        } catch (err) {
-          if (!(err instanceof Error && err.message.includes("prompt adapter not configured")))
-            throw err;
+    let applyTerminalStageState;
+    let terminalStateIsSuccess = false;
+    try {
+      let refreshedParentIds;
+      if (trackStageLifecycle && !input.hasContinuation && runtime.stageSnapshot.startedAt === undefined && !input.hasScopedParents) {
+        const actualParentIds = runtime.scheduler.tracker.currentParents();
+        const sameParents = actualParentIds.length === runtime.stageSnapshot.parentIds.length && actualParentIds.every((value2) => runtime.stageSnapshot.parentIds.includes(value2));
+        if (!sameParents) {
+          runtime.scheduler.tracker.replaceParents(runtime.stageId, actualParentIds);
+          refreshedParentIds = actualParentIds;
         }
       }
-      if (refreshedParentIds !== undefined) {
-        runtime.scheduler.setStageParentIds(runtime.stageSnapshot, refreshedParentIds);
+      if (trackStageLifecycle) {
+        const now = Date.now();
+        const hasNoExplicitModelConfig = input.options?.model === undefined && input.options?.fallbackModels === undefined;
+        const promptAdapterHandlesInitialPrompt = input.adapters.prompt !== undefined;
+        if (callOptions.eagerSession && !promptAdapterHandlesInitialPrompt && (hasNoExplicitModelConfig || await hasExplicitFastModeCandidate({
+          model: input.options?.model,
+          fallbackModels: input.options?.fallbackModels,
+          models: runtime.opts.models
+        }))) {
+          try {
+            await runtime.innerCtx.__ensureSession();
+          } catch (err) {
+            if (!(err instanceof Error && err.message.includes("prompt adapter not configured")))
+              throw err;
+          }
+        }
+        if (refreshedParentIds !== undefined) {
+          runtime.scheduler.setStageParentIds(runtime.stageSnapshot, refreshedParentIds);
+        }
+        runtime.stageSnapshot.status = "running";
+        runtime.stageSnapshot.startedAt ??= rebasedStageStartedAt(input.options?.durableAccumulatedDurationMs, now);
+        runtime.applyModelFallbackMeta(runtime.innerCtx.__modelFallbackMeta());
+        runtime.activeStore.recordStageStart(runtime.runId, runtime.stageSnapshot);
+        runtime.appendStageStartOnce();
+        const sessionMeta = runtime.innerCtx.__sessionMeta();
+        if (sessionMeta.sessionId !== undefined || sessionMeta.sessionFile !== undefined) {
+          await runtime.captureStageSessionMeta({ awaitDurable: true });
+        }
+        runtime.startStageSessionHeartbeat();
+      } else {
+        runtime.applyModelFallbackMeta(runtime.innerCtx.__modelFallbackMeta());
       }
-      runtime.stageSnapshot.status = "running";
-      runtime.stageSnapshot.startedAt ??= rebasedStageStartedAt(input.options?.durableAccumulatedDurationMs, now);
-      runtime.applyModelFallbackMeta(runtime.innerCtx.__modelFallbackMeta());
-      runtime.activeStore.recordStageStart(runtime.runId, runtime.stageSnapshot);
-      runtime.appendStageStartOnce();
-    } else {
-      runtime.applyModelFallbackMeta(runtime.innerCtx.__modelFallbackMeta());
-    }
-    runtime.mcpScope.apply();
-    let applyTerminalStageState;
-    try {
+      runtime.mcpScope.apply();
       const abortSession = () => {
         runtime.innerCtx.abort().catch(() => {});
       };
@@ -66697,7 +66863,7 @@ function createTrackedStageCaller(input) {
       try {
         runtime.state.askUserQuestionObservedThisTurn = false;
         runtime.state.chatAnswerObservedThisTurn = false;
-        result = await raceAbort(call(), runtime.signal);
+        result = await runtime.raceStageSessionHeartbeat(raceAbort(call(), runtime.signal));
         const initialDrain = await drainResumeContinuations(result);
         result = initialDrain.result;
         let repeatReadinessAfterChatTurn = initialDrain.chatAnswerObserved;
@@ -66721,10 +66887,10 @@ function createTrackedStageCaller(input) {
               runtime.state.chatAnswerObservedThisTurn = false;
               runtime.state.waitingForStageChatTurn = true;
               try {
-                await raceAbort(new Promise((resolve12) => {
+                await runtime.raceStageSessionHeartbeat(raceAbort(new Promise((resolve12) => {
                   resolveNextTurnEnd = resolve12;
                   runtime.state.wakeWaitingForStageChatTurn = resolve12;
-                }), runtime.signal);
+                }), runtime.signal));
               } finally {
                 runtime.state.wakeWaitingForStageChatTurn = undefined;
                 runtime.state.waitingForStageChatTurn = false;
@@ -66748,7 +66914,7 @@ function createTrackedStageCaller(input) {
         runtime.signal.removeEventListener("abort", abortSession);
       }
       await runtime.innerCtx.__closeGeneration();
-      runtime.captureStageSessionMeta();
+      await runtime.captureStageSessionMeta({ awaitDurable: true });
       runtime.applyModelFallbackMeta(runtime.innerCtx.__modelFallbackMeta());
       if (trackStageLifecycle && runtime.stageFailFastScope?.failed === true && runtime.stageFailFastScope.activeStages.has(runtime.stageId)) {
         runtime.markSkippedForParallelFailFast();
@@ -66758,6 +66924,7 @@ function createTrackedStageCaller(input) {
         throw runtime.parallelFailFastError();
       if (trackStageLifecycle) {
         const assistantText = runtime.innerCtx.__getLastAssistantText();
+        terminalStateIsSuccess = true;
         applyTerminalStageState = () => {
           runtime.stageSnapshot.status = "completed";
           if (assistantText !== undefined)
@@ -66782,15 +66949,30 @@ function createTrackedStageCaller(input) {
       }
       throw err;
     } finally {
-      runtime.mcpScope.clear();
       let finalizationError;
+      let durableCheckpointError;
       try {
-        await runtime.innerCtx.__closeGeneration();
-        runtime.captureStageSessionMeta();
+        runtime.mcpScope.clear();
       } catch (err) {
         finalizationError = { thrown: true, error: err };
       }
+      try {
+        await runtime.drainStageSessionHeartbeat();
+      } catch (err) {
+        durableCheckpointError = { thrown: true, error: err };
+      }
+      try {
+        await runtime.innerCtx.__closeGeneration();
+        await runtime.captureStageSessionMeta({ awaitDurable: true });
+      } catch (err) {
+        durableCheckpointError ??= { thrown: true, error: err };
+      }
+      finalizationError ??= durableCheckpointError;
       if (trackStageLifecycle) {
+        if (durableCheckpointError !== undefined && terminalStateIsSuccess) {
+          const failure3 = runtime.classifyExecutorFailure(durableCheckpointError.error);
+          applyTerminalStageState = () => applyFailureToStage(runtime.stageSnapshot, failure3);
+        }
         if (!runtime.state.stageFinalized)
           applyTerminalStageState?.();
         try {
@@ -67027,7 +67209,7 @@ function createStageControlHandle(runtime) {
     if (sessionFile === undefined)
       return;
     await runtime.innerCtx.__ensureSessionFromFile(sessionFile);
-    runtime.captureStageSessionMeta();
+    await runtime.captureStageSessionMeta({ awaitDurable: true });
   };
   const toolExecutions = new StageToolExecutionBuffer;
   const queuedUserMessages = new StageQueuedUserMessageBuffer;
@@ -67071,7 +67253,7 @@ function createStageControlHandle(runtime) {
       await ensureMessagingSession();
       await runtime.innerCtx.__ensureSession();
       runtime.throwIfStageMutationBlocked();
-      runtime.captureStageSessionMeta();
+      await runtime.captureStageSessionMeta({ awaitDurable: true });
     },
     async sendUserMessage(text, options, beforeDelivery) {
       runtime.throwIfStageMutationBlocked();
@@ -68229,6 +68411,28 @@ function terminatingToolCallId(event) {
 }
 
 // dist/builtin/workflows/src/runs/foreground/stage-runner-controller.ts
+function hasMeaningfulUsage(usage) {
+  if (usage === undefined)
+    return false;
+  const values = [usage.input, usage.output, usage.cacheRead, usage.cacheWrite, usage.totalTokens, usage.cost.total];
+  return values.every((value2) => Number.isFinite(value2) && value2 >= 0) && values.some((value2) => value2 > 0);
+}
+function usageForAttempt(messages, start, discarded) {
+  const totals = { ...discarded };
+  let meaningful = totals.turns > 0;
+  for (const message of messages.slice(start)) {
+    if (message.role !== "assistant" || !hasMeaningfulUsage(message.usage))
+      continue;
+    totals.input += message.usage.input;
+    totals.output += message.usage.output;
+    totals.cacheRead += message.usage.cacheRead;
+    totals.cacheWrite += message.usage.cacheWrite;
+    totals.cost += message.usage.cost.total;
+    totals.turns += 1;
+    meaningful = true;
+  }
+  return meaningful ? totals : undefined;
+}
 function isSessionCreationPauseResult(value2) {
   return "kind" in value2 && value2.kind === "paused";
 }
@@ -68291,6 +68495,15 @@ class StageSessionController {
   sessionPromise;
   reattachSessionFile;
   lastPromptStartIndex;
+  attemptUsageStartIndex;
+  discardedAttemptUsage = {
+    input: 0,
+    output: 0,
+    cacheRead: 0,
+    cacheWrite: 0,
+    cost: 0,
+    turns: 0
+  };
   terminatingToolCallIds = new Set;
   latestStructuredOutputToolErrorValue;
   unsubscribeTerminateWatcher;
@@ -68490,6 +68703,7 @@ class StageSessionController {
         this.activeCandidateIndex = index;
         this.selectedModel = candidate.id;
         this.notifyModelFallbackMetaChange();
+        this.beginAttemptUsage(activeSession);
         const { terminalScanStartIndex } = await this.promptWithThrownErrorRetry(activeSession, promptText, sdkOptions);
         const terminalFailure = latestTerminalAssistantFailureSince(activeSession.messages, terminalScanStartIndex);
         if (terminalFailure !== undefined) {
@@ -68628,9 +68842,38 @@ class StageSessionController {
     }
     return;
   }
+  beginAttemptUsage(session) {
+    this.attemptUsageStartIndex = session.messages.length;
+    this.discardedAttemptUsage = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0 };
+  }
+  takeAttemptUsage(session) {
+    const start = this.attemptUsageStartIndex;
+    const usage = session === undefined || start === undefined ? undefined : usageForAttempt(session.messages, start, this.discardedAttemptUsage);
+    this.clearAttemptUsage();
+    return usage;
+  }
+  clearAttemptUsage() {
+    this.attemptUsageStartIndex = undefined;
+    this.discardedAttemptUsage = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0 };
+  }
+  accrueDiscardedAttemptUsage(message) {
+    if (!hasMeaningfulUsage(message.usage))
+      return;
+    this.discardedAttemptUsage.input += message.usage.input;
+    this.discardedAttemptUsage.output += message.usage.output;
+    this.discardedAttemptUsage.cacheRead += message.usage.cacheRead;
+    this.discardedAttemptUsage.cacheWrite += message.usage.cacheWrite;
+    this.discardedAttemptUsage.cost += message.usage.cost.total;
+    this.discardedAttemptUsage.turns += 1;
+  }
   restoreSessionMessages(session, snapshot, promptText, keepPrompt) {
     const snapshotMessages = new Set(snapshot);
     const admitted = session.messages.filter((message) => !snapshotMessages.has(message));
+    for (const message of admitted) {
+      if (message.role !== "assistant" || message.stopReason !== "error")
+        continue;
+      this.accrueDiscardedAttemptUsage(message);
+    }
     const failedAssistantIndex = admitted.findLastIndex((message) => message.role === "assistant" && message.stopReason === "error");
     const promptUser = admitted.slice(0, failedAssistantIndex < 0 ? admitted.length : failedAssistantIndex).findLast((message) => message.role === "user" && stageUserMessageText(message) === promptText);
     const retainedMessages = admitted.filter((message) => {
@@ -68979,7 +69222,11 @@ class StageSessionController {
         throw new Error(`atomic-workflows: stage "${this.opts.stageName}" session has been disposed`);
       throw this.staleCreationReason(startGeneration);
     }
-    return attachCreatedStageSession(created, this.disposed, this.opts.stageName, (result) => this.attachSession(result));
+    const session = attachCreatedStageSession(created, this.disposed, this.opts.stageName, (result) => this.attachSession(result));
+    if (session instanceof Promise)
+      return await session;
+    await this.opts.onSessionReady?.();
+    return session;
   }
   attachSession(created) {
     const result = normalizeSessionCreateResult(created);
@@ -69087,11 +69334,17 @@ class StageSessionController {
     const resumedSession = this.session;
     const resumedLabel = this.selectedModel ?? workflowModelId(resumedSession.model) ?? candidates[0].id;
     this.notifyModelFallbackMetaChange();
+    this.beginAttemptUsage(resumedSession);
     try {
       const { terminalScanStartIndex } = await this.promptWithThrownErrorRetry(resumedSession, text, sdkOptions);
       const terminalFailure = latestTerminalAssistantFailureSince(resumedSession.messages, terminalScanStartIndex);
       if (terminalFailure === undefined || this.capturedStructuredOutputForAttempt()) {
-        this.modelAttempts.push({ model: resumedLabel, success: true });
+        const usage = this.takeAttemptUsage(resumedSession);
+        this.modelAttempts.push({
+          model: resumedLabel,
+          success: true,
+          ...usage === undefined ? {} : { usage }
+        });
         this.pendingFallbackWarnings.length = 0;
         this.resumeCurrentSession = true;
         return true;
@@ -69099,13 +69352,24 @@ class StageSessionController {
       throw new WorkflowPromptModelFailure(terminalFailure);
     } catch (err) {
       if (this.capturedStructuredOutputForAttempt() && isRetryableModelFailure(err)) {
-        this.modelAttempts.push({ model: resumedLabel, success: true });
+        const usage2 = this.takeAttemptUsage(resumedSession);
+        this.modelAttempts.push({
+          model: resumedLabel,
+          success: true,
+          ...usage2 === undefined ? {} : { usage: usage2 }
+        });
         this.pendingFallbackWarnings.length = 0;
         this.resumeCurrentSession = true;
         return true;
       }
       const message = errorMessage3(err);
-      this.modelAttempts.push({ model: resumedLabel, success: false, error: message });
+      const usage = this.takeAttemptUsage(resumedSession);
+      this.modelAttempts.push({
+        model: resumedLabel,
+        success: false,
+        ...usage === undefined ? {} : { usage },
+        error: message
+      });
       if (this.opts.signal?.aborted || !isRetryableModelFailure(err)) {
         this.modelWarnings.push(...this.pendingFallbackWarnings);
         this.pendingFallbackWarnings.length = 0;
@@ -69131,10 +69395,12 @@ class StageSessionController {
       this.recordSuccessfulAttempt(candidate);
       return "handled";
     }
+    const usage = this.takeAttemptUsage(this.session);
     this.modelAttempts.push({
       model: candidate.id,
       success: false,
       ...modelAttemptReasoning(candidate, this.effectiveStageOptions?.thinkingLevel),
+      ...usage === undefined ? {} : { usage },
       error: message
     });
     if (this.opts.signal?.aborted || !isRetryableModelFailure(err) || index === candidates.length - 1) {
@@ -69152,10 +69418,12 @@ class StageSessionController {
     return this.structuredOutputCapture?.called === true && this.opts.signal?.aborted !== true;
   }
   recordSuccessfulAttempt(candidate) {
+    const usage = this.takeAttemptUsage(this.session);
     this.modelAttempts.push({
       model: candidate.id,
       success: true,
-      ...modelAttemptReasoning(candidate, this.effectiveStageOptions?.thinkingLevel)
+      ...modelAttemptReasoning(candidate, this.effectiveStageOptions?.thinkingLevel),
+      ...usage === undefined ? {} : { usage }
     });
     this.pendingFallbackWarnings.length = 0;
     this.resumeCurrentSession = true;
@@ -69592,6 +69860,81 @@ function createStageContext2(opts) {
     }
   };
 }
+// dist/builtin/workflows/src/runs/foreground/stage-session-heartbeat.ts
+var STAGE_SESSION_HEARTBEAT_INTERVAL_MS = 30000;
+function createStageSessionHeartbeat(checkpoint, intervalMs = STAGE_SESSION_HEARTBEAT_INTERVAL_MS) {
+  let active2 = false;
+  let timer;
+  let generation = 0;
+  let nextDeadline = 0;
+  let failure3;
+  let inFlight;
+  let rejectFailure;
+  const failureSignal = new Promise((_resolve, reject) => {
+    rejectFailure = reject;
+  });
+  failureSignal.catch(() => {
+    return;
+  });
+  const stopScheduling = () => {
+    active2 = false;
+    generation += 1;
+    if (timer !== undefined)
+      clearTimeout(timer);
+    timer = undefined;
+  };
+  const fail = (error) => {
+    if (failure3 !== undefined)
+      return;
+    failure3 = error;
+    stopScheduling();
+    rejectFailure(error);
+  };
+  const schedule = (scheduledGeneration) => {
+    if (!active2 || failure3 !== undefined || scheduledGeneration !== generation)
+      return;
+    const delayMs = Math.max(0, nextDeadline - Date.now());
+    timer = setTimeout(() => {
+      timer = undefined;
+      const startedAt = Date.now();
+      do
+        nextDeadline += intervalMs;
+      while (nextDeadline <= startedAt);
+      const running = checkpoint().catch(fail).finally(() => {
+        if (inFlight === running)
+          inFlight = undefined;
+        schedule(scheduledGeneration);
+      });
+      inFlight = running;
+    }, delayMs);
+    timer.unref?.();
+  };
+  const drain = async () => {
+    stopScheduling();
+    await inFlight;
+    if (failure3 !== undefined)
+      throw failure3;
+  };
+  return {
+    start() {
+      if (active2 || failure3 !== undefined)
+        return;
+      active2 = true;
+      generation += 1;
+      nextDeadline = Date.now() + intervalMs;
+      schedule(generation);
+    },
+    stop: stopScheduling,
+    drain,
+    fail,
+    race(work) {
+      if (failure3 !== undefined)
+        return Promise.reject(failure3);
+      return Promise.race([work, failureSignal]);
+    }
+  };
+}
+
 // dist/builtin/workflows/src/runs/foreground/executor-stage-factory.ts
 function createWorkflowStageFactory(input) {
   return (name, options, stageFailFastScope) => {
@@ -69672,6 +70015,15 @@ function createWorkflowStageFactory(input) {
       if (meta2.modelAttempts !== undefined)
         stageSnapshot.modelAttempts = meta2.modelAttempts;
     };
+    let runtime;
+    const stageSessionHeartbeat = createStageSessionHeartbeat(async () => {
+      try {
+        await runtime.captureStageSessionMeta({ awaitDurable: true });
+      } catch (error) {
+        await runtime.innerCtx.abort().catch(() => {});
+        throw error;
+      }
+    });
     const innerCtx = createStageContext2({
       stageId,
       stageName: name,
@@ -69687,6 +70039,12 @@ function createWorkflowStageFactory(input) {
         applyModelFallbackMeta(meta2);
         if (stageSnapshot.status === "running")
           input.activeStore.recordStageStart(input.runId, stageSnapshot);
+      },
+      async onSessionReady() {
+        if (stageSnapshot.status !== "running")
+          return;
+        await runtime.captureStageSessionMeta({ awaitDurable: true });
+        runtime.startStageSessionHeartbeat();
       }
     });
     const state2 = {
@@ -69749,8 +70107,7 @@ function createWorkflowStageFactory(input) {
       stageUiBroker.clearStagePrompt(input.runId, stageId);
       await innerCtx.__dispose();
     };
-    let runtime;
-    const captureStageSessionMeta = (checkpointOptions) => {
+    const captureStageSessionMeta = async (checkpointOptions) => {
       const meta2 = innerCtx.__sessionMeta();
       if (meta2.sessionId !== undefined)
         stageSnapshot.sessionId = meta2.sessionId;
@@ -69759,15 +70116,17 @@ function createWorkflowStageFactory(input) {
       if (meta2.sessionId !== undefined || meta2.sessionFile !== undefined)
         input.activeStore.recordStageSession(input.runId, stageId, meta2);
       const pending = input.opts.onStageSession?.(input.runId, stageSnapshot, checkpointOptions);
-      if (checkpointOptions?.forceDurable === true)
-        return pending;
+      if (checkpointOptions?.forceDurable === true || checkpointOptions?.awaitDurable === true) {
+        await pending;
+        return;
+      }
       Promise.resolve(pending).catch(() => {});
-      return;
     };
     const releaseLiveHandle = async () => {
       if (state2.liveHandleReleased)
         return;
       state2.liveHandleReleased = true;
+      stageSessionHeartbeat.stop();
       runtime.dropStageControlHandle();
       runtime.unregisterStageHandle();
       await disposeInnerContext();
@@ -69800,6 +70159,7 @@ function createWorkflowStageFactory(input) {
       });
     };
     const finalizeStageSnapshot = async () => {
+      stageSessionHeartbeat.stop();
       if (state2.stageFinalized)
         return false;
       if (stageSnapshot.endedAt !== undefined && isTerminalStage(stageSnapshot)) {
@@ -69872,6 +70232,9 @@ function createWorkflowStageFactory(input) {
       dropStageControlHandle: () => {},
       unregisterWorkflowExitCleanup: () => {},
       captureStageSessionMeta,
+      startStageSessionHeartbeat: stageSessionHeartbeat.start,
+      drainStageSessionHeartbeat: stageSessionHeartbeat.drain,
+      raceStageSessionHeartbeat: stageSessionHeartbeat.race,
       applyModelFallbackMeta,
       appendStageStartOnce,
       finalizeStageSnapshot,
@@ -70024,9 +70387,22 @@ class EngineRuntime {
       apply: () => {
         if (!this.childRunOptions.mcp || !hasScope)
           return;
-        if (depth === 0)
+        if (depth > 0) {
+          depth += 1;
+          return;
+        }
+        depth = 1;
+        try {
           this.childRunOptions.mcp.setScope(stageId, allow, deny);
-        depth += 1;
+        } catch (error) {
+          depth = 0;
+          try {
+            this.childRunOptions.mcp.clearScope(stageId);
+          } catch (cleanupError) {
+            throw new AggregateError([error, cleanupError], "MCP scope setup failed and compensating cleanup failed");
+          }
+          throw error;
+        }
       },
       clear: () => {
         if (!this.childRunOptions.mcp || !hasScope)
@@ -71369,6 +71745,72 @@ function disposeCompletedChatHandle(handle) {
   });
 }
 
+// dist/builtin/workflows/src/durable/targeted-inspection.ts
+async function inspectTargetedDurableWorkflow(backend, workflowId, now = Date.now()) {
+  const hydrated = backend.hydrateWorkflowForInspection ? await backend.hydrateWorkflowForInspection(workflowId) : await hydrateWithoutClassification(backend, workflowId);
+  if (hydrated.kind !== "current")
+    return hydrationFailure(workflowId, hydrated.kind);
+  const handle = hydrated.handle;
+  if (handle.rootWorkflowId !== undefined && handle.rootWorkflowId !== handle.workflowId) {
+    return malformed(workflowId, "the requested id belongs to a nested workflow rather than a durable root");
+  }
+  const reconstructed = durableWorkflowRunSnapshots(backend, handle);
+  if (reconstructed.length === 0)
+    return malformed(workflowId, "durable checkpoint topology is malformed or incomplete");
+  const runs = structuredClone(reconstructed);
+  const inspectionStore = createStore();
+  for (const run2 of runs)
+    inspectionStore.recordRunStart(structuredClone(run2));
+  const inspected = inspectRun(workflowId, { store: inspectionStore });
+  if (!inspected.ok)
+    return malformed(workflowId, "the durable checkpoint graph has no reciprocal root");
+  const foreignLive = isForeignLiveWorkflow(handle, getAtomicExecutorId(), now);
+  const live = isLiveRunningWorkflow(handle, now);
+  const crashed = handle.status === "running" && !live;
+  const resumeGuidance = crashed ? inspected.detail.resumable === true ? `This workflow appears to have crashed and is resumable. Resume it explicitly with /workflow resume ${workflowId}.` : "This workflow appears to have crashed, but its retained state is not resumable." : foreignLive ? "This workflow is actively running in another Atomic session. Inspect it here, but control it from its owner session." : live ? "This workflow still has a fresh durable heartbeat. Inspect it here without starting another executor." : terminalGuidance(handle.status, workflowId, inspected.detail.resumable === true);
+  return {
+    kind: "found",
+    runs,
+    store: inspectionStore,
+    detail: {
+      ...inspected.detail,
+      ...crashed ? { status: "crashed" } : {},
+      ...live ? { resumable: false } : {},
+      ...foreignLive ? { ownerActiveElsewhere: true } : {},
+      resumeGuidance
+    }
+  };
+}
+function terminalGuidance(status, workflowId, resumable) {
+  if (resumable)
+    return `This retained workflow is ${status} and resumable. Resume it explicitly with /workflow resume ${workflowId}.`;
+  return `This retained workflow is ${status} and available for read-only inspection.`;
+}
+async function hydrateWithoutClassification(backend, workflowId) {
+  await backend.hydrateWorkflow(workflowId);
+  const handle = backend.getLoadableWorkflow(workflowId);
+  return handle === undefined ? { kind: "absent" } : { kind: "current", handle };
+}
+function hydrationFailure(workflowId, kind) {
+  switch (kind) {
+    case "absent":
+      return {
+        kind,
+        message: `Run not found: ${workflowId} (not present in the current session or durable store).`
+      };
+    case "deleted":
+      return { kind, message: `Durable workflow was deleted: ${workflowId}` };
+    case "malformed":
+      return malformed(workflowId, "current DBOS metadata or checkpoints are malformed");
+  }
+}
+function malformed(workflowId, reason) {
+  return {
+    kind: "malformed",
+    message: `Durable workflow ${workflowId} cannot be inspected safely: ${reason}.`
+  };
+}
+
 // dist/builtin/workflows/src/extension/runtime-durable-resume.ts
 function createDurableResumeRuntime(deps) {
   const hydrateStoredWorkflowCandidates = async (backend, target) => {
@@ -71378,6 +71820,10 @@ function createDurableResumeRuntime(deps) {
   };
   let preparedCatalog = [];
   return {
+    async inspectDurableWorkflow(workflowId) {
+      await deps.ensureReady();
+      return await inspectTargetedDurableWorkflow(getDurableBackend(), workflowId);
+    },
     async resumeDurableWorkflow(workflowId, options) {
       await deps.ensureReady();
       const backend = getDurableBackend();
@@ -72052,6 +72498,9 @@ function createWorkflowExtensionRuntimeState(pi, adapters, resolveCwd = () => pi
     resumeDurableWorkflow(workflowId, options) {
       return runtimeRef.current.resumeDurableWorkflow(workflowId, options);
     },
+    inspectDurableWorkflow(workflowId) {
+      return runtimeRef.current.inspectDurableWorkflow(workflowId);
+    },
     listDurableResumable() {
       return runtimeRef.current.listDurableResumable();
     },
@@ -73721,6 +74170,7 @@ function toPickerRow(session) {
     modifiedAt: session.modified.getTime(),
     messageCount: session.messageCount,
     firstMessage: session.firstMessage,
+    ...session.summary !== undefined ? { summary: session.summary } : {},
     allMessagesText: session.allMessagesText,
     ...session.name !== undefined ? { name: session.name } : {},
     ...session.messageColor !== undefined ? { messageColor: session.messageColor } : {}
@@ -74570,8 +75020,13 @@ Available: ${formatAvailableWorkflowNames(deps.runtimeProxy.registry.names())}`)
       const resolved = resolveRunId(target);
       if (resolved.kind === "malformed")
         return fail(resolved.message);
-      if (resolved.kind === "not_found")
-        return fail(`Run not found: ${target}`);
+      if (resolved.kind === "not_found") {
+        const durable = await deps.runtimeForContext(ctx).inspectDurableWorkflow(target);
+        if (durable.kind !== "found")
+          return fail(durable.message);
+        emitChatSurface(pi, { kind: "detail", detail: durable.detail });
+        return;
+      }
       const inspected = inspectRun(resolved.runId);
       if (!inspected.ok)
         return fail(`Run not found: ${target}`);
@@ -75645,8 +76100,9 @@ function snapshotTranscriptEntryCount(snapshot) {
 }
 
 // dist/builtin/workflows/src/extension/workflow-tool-inspection.ts
-function workflowStagesResult(args) {
-  const target = resolveToolRunTarget(args, "No active run to inspect.");
+function workflowStagesResult(args, source) {
+  const activeStore = source?.store ?? store;
+  const target = resolveToolRunTarget(args, "No active run to inspect.", activeStore);
   const filter = args.statusFilter ?? "all";
   if (target.kind === "all") {
     return {
@@ -75666,19 +76122,20 @@ function workflowStagesResult(args) {
       error: target.message
     };
   }
-  const run2 = store.runs().find((r) => r.id === target.runId);
-  const stages = (run2?.stages ?? []).filter((stage) => filter === "all" || stage.status === filter).map(summarizeStage);
+  const stageSnapshots = source?.store === undefined ? activeStore.runs().find((run2) => run2.id === target.runId)?.stages ?? [] : expandWorkflowGraph(readGraphStoreSnapshot(activeStore), target.runId).stages;
+  const stages = stageSnapshots.filter((stage) => filter === "all" || stage.status === filter).map(summarizeStage);
   return { action: "stages", runId: target.runId, filter, stages };
 }
-function workflowStageResult(args) {
-  const target = resolveToolRunTarget(args, "No active run to inspect.");
+function workflowStageResult(args, source) {
+  const activeStore = source?.store ?? store;
+  const target = resolveToolRunTarget(args, "No active run to inspect.", activeStore);
   if (target.kind === "all") {
     return { action: "stage", runId: "--all", error: "Stage inspection requires a single run." };
   }
   if (target.kind === "malformed" || target.kind === "not_found") {
     return { action: "stage", runId: target.target, error: target.message };
   }
-  const stage = resolveToolStageTarget(target.runId, args.stageId);
+  const stage = resolveToolStageTarget(target.runId, args.stageId, activeStore);
   if (!stage.ok || stage.stageId === undefined) {
     return {
       action: "stage",
@@ -75687,7 +76144,7 @@ function workflowStageResult(args) {
     };
   }
   const stageRunId = stage.runId ?? target.runId;
-  const run2 = store.runs().find((r) => r.id === stageRunId);
+  const run2 = activeStore.runs().find((r) => r.id === stageRunId);
   const snapshot = run2?.stages.find((s) => s.id === stage.stageId);
   return snapshot ? { action: "stage", runId: stageRunId, stage: cloneStage(snapshot) } : {
     action: "stage",
@@ -75695,8 +76152,9 @@ function workflowStageResult(args) {
     error: `Stage not found in run ${stageRunId}: ${stage.stageId}`
   };
 }
-function workflowTranscriptResult(args) {
-  const target = resolveToolRunTarget(args, "No active run to inspect.");
+function workflowTranscriptResult(args, source) {
+  const activeStore = source?.store ?? store;
+  const target = resolveToolRunTarget(args, "No active run to inspect.", activeStore);
   if (target.kind === "all") {
     return {
       action: "transcript",
@@ -75717,7 +76175,7 @@ function workflowTranscriptResult(args) {
       truncated: false
     };
   }
-  const stage = resolveToolStageTarget(target.runId, args.stageId);
+  const stage = resolveToolStageTarget(target.runId, args.stageId, activeStore);
   if (!stage.ok || stage.stageId === undefined) {
     return {
       action: "transcript",
@@ -75729,9 +76187,9 @@ function workflowTranscriptResult(args) {
     };
   }
   const stageRunId = stage.runId ?? target.runId;
-  const run2 = store.runs().find((r) => r.id === stageRunId);
+  const run2 = activeStore.runs().find((r) => r.id === stageRunId);
   const snapshot = run2?.stages.find((s) => s.id === stage.stageId);
-  const liveHandle2 = stageControlRegistry.get(stageRunId, stage.stageId);
+  const liveHandle2 = source?.allowLiveHandles === false ? undefined : stageControlRegistry.get(stageRunId, stage.stageId);
   if (liveHandle2 !== undefined) {
     const sessionFile = liveHandle2.sessionFile ?? snapshot?.sessionFile;
     const sessionId = liveHandle2.sessionId ?? snapshot?.sessionId;
@@ -75791,6 +76249,41 @@ function brokerAnswerFromArgs(args) {
   const text = textPayloadFromArgs(args);
   return text !== undefined ? { text } : {};
 }
+function answersPendingPrompt(delivery, promptId) {
+  return delivery === "answer" || delivery === "auto" || promptId !== undefined;
+}
+function answerablePromptIds(stage) {
+  const target = stage.workflowGraphTarget;
+  const ids = [];
+  const brokered = stageUiBroker.peekStagePrompt(target.runId, target.stageId);
+  if (brokered !== undefined)
+    ids.push(brokered.id);
+  if (stage.pendingPrompt !== undefined)
+    ids.push(stage.pendingPrompt.id);
+  if (stage.status === "awaiting_input" && stage.promptFootprint?.kind === "custom") {
+    ids.push(stage.promptFootprint.id);
+  }
+  return ids;
+}
+function inferPromptStageTarget(runId, delivery, promptId) {
+  if (!answersPendingPrompt(delivery, promptId))
+    return { ok: true, runId };
+  const pending = expandWorkflowGraph(readGraphStoreSnapshot(store), runId).stages.filter((stage) => {
+    const ids = answerablePromptIds(stage);
+    return promptId === undefined ? ids.length > 0 : ids.includes(promptId);
+  });
+  const only = pending[0];
+  if (pending.length === 1 && only !== undefined) {
+    return { ok: true, runId: only.workflowGraphTarget.runId, stageId: only.workflowGraphTarget.stageId };
+  }
+  if (pending.length === 0) {
+    return promptId === undefined ? { ok: true, runId } : { ok: false, message: `No pending prompt ${promptId} in run ${runId}.` };
+  }
+  return {
+    ok: false,
+    message: `${pending.length} prompts pending; pass stageId: ${pending.map(expandedStageLabel).join(", ")}`
+  };
+}
 function workflowSendResult(runId, stageId, delivery, status, message) {
   return { action: "send", runId, stageId, delivery, status, message };
 }
@@ -75851,7 +76344,8 @@ async function workflowSendAction(args, deps = {}) {
   if (rootRun !== undefined && isTerminalRunStatus(rootRun.status)) {
     return terminalWorkflowSendResult(rootRun.id, args.stageId?.trim() ?? "", rootRun.status);
   }
-  const stage = resolveToolStageTarget(target.runId, args.stageId);
+  const requested = resolveToolStageTarget(target.runId, args.stageId);
+  const stage = requested.ok && requested.stageId === undefined ? inferPromptStageTarget(target.runId, requestedDelivery, args.promptId) : requested;
   if (!stage.ok || stage.stageId === undefined) {
     return workflowSendResult(target.runId, "", requestedDelivery, "noop", stage.ok ? "Stage id or name is required." : stage.message);
   }
@@ -75992,6 +76486,32 @@ async function workflowSendAction(args, deps = {}) {
 }
 
 // dist/builtin/workflows/src/extension/workflow-tool.ts
+async function resolveDurableInspectionSource(args, runtime) {
+  const target = args.runId?.trim();
+  if (args.all === true || target === undefined || target.length === 0 || target === "--all")
+    return { kind: "local" };
+  const local = resolveRunId(target);
+  if (local.kind !== "not_found")
+    return { kind: "local" };
+  const durable = await runtime.inspectDurableWorkflow(target);
+  if (durable.kind !== "found")
+    return { kind: "error", message: durable.message };
+  return { kind: "durable", source: { store: durable.store, allowLiveHandles: false } };
+}
+function durableInspectionError(action, runId, message) {
+  if (action === "stages")
+    return { action, runId, filter: "all", stages: [], error: message };
+  if (action === "stage")
+    return { action, runId, error: message };
+  return {
+    action,
+    runId,
+    stageId: "",
+    source: "error",
+    entries: [{ role: "notice", text: message }],
+    truncated: false
+  };
+}
 function makeExecuteWorkflowTool(runtime, reloadWorkflowResources, ensureWorkflowResourcesLoaded = () => {}, sendDeps = {}) {
   return async function executeWorkflowTool(args, ctx) {
     const action = args.action ?? "run";
@@ -76047,7 +76567,8 @@ function makeExecuteWorkflowTool(runtime, reloadWorkflowResources, ensureWorkflo
             return { action: "statusDetail", runId: target, error: resolved.message };
           }
           if (resolved.kind === "not_found") {
-            return { action: "statusDetail", runId: target, error: `run not found: ${target}` };
+            const durable = await getRuntime().inspectDurableWorkflow(target);
+            return durable.kind === "found" ? { action: "statusDetail", runId: target, detail: durable.detail } : { action: "statusDetail", runId: target, error: durable.message };
           }
           const result2 = inspectRun(resolved.runId);
           return result2.ok ? { action: "statusDetail", runId: result2.runId, detail: result2.detail } : { action: "statusDetail", runId: target, error: `run not found: ${target}` };
@@ -76063,11 +76584,18 @@ function makeExecuteWorkflowTool(runtime, reloadWorkflowResources, ensureWorkflo
         return result;
       }
       case "stages":
-        return workflowStagesResult(args);
       case "stage":
-        return workflowStageResult(args);
-      case "transcript":
-        return workflowTranscriptResult(args);
+      case "transcript": {
+        const resolved = await resolveDurableInspectionSource(args, getRuntime());
+        if (resolved.kind === "error")
+          return durableInspectionError(action, args.runId ?? "", resolved.message);
+        const source = resolved.kind === "durable" ? resolved.source : undefined;
+        if (action === "stages")
+          return workflowStagesResult(args, source);
+        if (action === "stage")
+          return workflowStageResult(args, source);
+        return workflowTranscriptResult(args, source);
+      }
       case "send":
         return workflowSendAction(args, sendDeps);
       case "pause":