@bastani/atomic 0.9.9 → 0.9.10-alpha.1

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

@@ -1,10 +1,5 @@
 /**
- * Cross-session durable workflow resume adapter.
- *
- * Resumes a workflow whose durable checkpoints live in the durable backend
- * (and are mirrored to the session JSONL cache) but whose in-process run is no
- * longer live. This is the production path behind `/workflow resume <id>` when
- * the id names a durable workflow that is not present in the live run store.
+ * Cross-process workflow resume using DBOS as the sole source of state.
  *
  * Resume semantics (DBOS-aligned):
  *   1. Look up the durable catalog entry (workflow name + cached inputs).
@@ -26,19 +21,22 @@
 import type { WorkflowInputValues } from "../shared/types.js";
 import type { WorkflowRegistry } from "../workflows/registry.js";
 import type { RunOpts } from "../runs/foreground/executor-types.js";
-import { runDetached, type DetachedAccepted } from "../runs/background/runner.js";
+import { launchDetachedUntilStartup, workflowStartupFailureMessage } from "../runs/background/startup-admission.js";
+import type { JobTracker } from "../runs/background/job-tracker.js";
 import { resolveAndValidateInputs } from "../runs/foreground/executor-inputs.js";
 import { getDurableBackend } from "./factory.js";
-import type { DurableWorkflowBackend } from "./backend.js";
+
+import { resumableEntryFromHandle, type DurableWorkflowBackend } from "./backend.js";
 import type { ResumableWorkflowEntry } from "./types.js";
-import { isDurableWorkflowResumable } from "./resume-eligibility.js";
+import { isDurableWorkflowResumable, isForeignLiveWorkflow } from "./resume-eligibility.js";
+import { getAtomicExecutorId } from "./dbos-sdk-handle.js";
 import { workflowDefinitionRequirementMessage } from "../runs/foreground/executor-child-helpers.js";
 import { isWorkflowDefinition } from "../runs/foreground/executor-child-helpers.js";
 import type { RunSnapshot } from "../shared/store-types.js";
 
 export type ResumeDurableResult =
   | { ok: true; runId: string; workflowId: string; name: string; message: string }
-  | { ok: false; reason: "workflow_not_found" | "not_resumable" | "invalid_inputs" | "not_registered" | "stale"; message: string };
+  | { ok: false; reason: "workflow_not_found" | "not_resumable" | "invalid_inputs" | "not_registered" | "stale" | "startup_failed"; message: string };
 
 export interface ResumeDurableDeps {
   readonly registry: WorkflowRegistry;
@@ -46,44 +44,30 @@ export interface ResumeDurableDeps {
   readonly baseRunOpts: RunOpts;
   /** Durable backend override (defaults to the global singleton). */
   readonly durableBackend?: DurableWorkflowBackend;
+  /** Job tracker used by the detached resume launch. */
+  readonly jobs?: JobTracker;
 }
 
-/**
- * Prepare a durable resume: hydrate the backend's in-memory mirror from the
- * persistent store (DBOS) so synchronous reads in {@link resumeDurableWorkflow}
- * find the workflow and its checkpoints. No-op for backends without hydration.
- *
- * Must be awaited before calling {@link resumeDurableWorkflow} when the backend
- * might be a fresh DBOS process.
- */
+/** Hydrate current DBOS metadata and checkpoints before synchronous replay reads. */
 export async function prepareDurableResume(
   workflowIdOrPrefix: string | undefined,
   deps: ResumeDurableDeps,
 ): Promise<readonly ResumableWorkflowEntry[]> {
   const backend = deps.durableBackend ?? getDurableBackend();
-  // Hydrate all resumable workflows first so the catalog is complete.
-  if (backend.hydrateResumableWorkflows !== undefined) {
-    await backend.hydrateResumableWorkflows();
-  }
+  await backend.hydrateResumableWorkflows();
   const catalog = backend.listResumableWorkflows();
   // If a specific target was requested, hydrate that workflow too (it might
   // be resumable but not yet in the resumable filter — e.g. recently failed).
   if (workflowIdOrPrefix !== undefined) {
     const resolved = resolveDurableEntry(workflowIdOrPrefix, catalog);
     if (resolved !== undefined && !("kind" in resolved)) {
-      if (backend.hydrateWorkflow !== undefined) {
-        await backend.hydrateWorkflow(resolved.workflowId);
-      }
+      await backend.hydrateWorkflow(resolved.workflowId);
     }
   }
   return backend.listResumableWorkflows();
 }
 
-/**
- * Resolve a durable catalog entry for a workflow id (full or prefix match).
- * Prefers the durable backend's resumable list; falls back to an explicit
- * session-scan catalog when provided by the caller.
- */
+/** Resolve a current DBOS catalog entry by full id or unique prefix. */
 export function resolveDurableEntry(
   workflowIdOrPrefix: string,
   catalog: readonly ResumableWorkflowEntry[],
@@ -96,32 +80,33 @@ export function resolveDurableEntry(
   return { kind: "ambiguous", matches: prefixMatches };
 }
 
-/**
- * Resume a durable workflow by top-level workflow id. Re-dispatches the workflow
- * with the cached inputs and the original workflow id so durable checkpoints
- * replay (skipping completed side effects).
- */
-export function resumeDurableWorkflow(
+/** Resume by DBOS workflow id and replay current persisted checkpoints. */
+export async function resumeDurableWorkflow(
   workflowIdOrPrefix: string,
   deps: ResumeDurableDeps,
   catalog?: readonly ResumableWorkflowEntry[],
-): ResumeDurableResult {
+): Promise<ResumeDurableResult> {
   const backend = deps.durableBackend ?? getDurableBackend();
   const resolvedCatalog = catalog ?? backend.listResumableWorkflows();
   const resolved = resolveDurableEntry(workflowIdOrPrefix, resolvedCatalog);
   if (resolved === undefined) {
-    if (!backend.isWorkflowLoadable(workflowIdOrPrefix)) {
-      return { ok: false, reason: "not_registered", message: `Durable workflow ${workflowIdOrPrefix.slice(0, 8)} uses an incompatible or unavailable persisted format and cannot be resumed.` };
-    }
-    // Not in the (filtered) resumable catalog. It may still be a workflow the
-    // backend knows about. Only surface "already running" when there is a live,
-    // actively-executing run for it in this session; otherwise a `running`
-    // durable handle is a crashed process and falls through to not-found.
     const direct = backend.getWorkflow(workflowIdOrPrefix);
-    if (direct !== undefined && direct.status === "running" && hasActiveLiveRun(deps.baseRunOpts.store, direct.workflowId)) {
-      return alreadyRunningResult(direct.name, direct.workflowId, deps.baseRunOpts.store);
+    if (direct !== undefined && direct.status === "running") {
+      if (hasActiveLiveRun(deps.baseRunOpts.store, direct.workflowId)) {
+        return alreadyRunningResult(direct.name, direct.workflowId, deps.baseRunOpts.store);
+      }
+      if (isForeignLiveWorkflow(direct, getAtomicExecutorId())) {
+        return foreignRunningResult(direct.name, direct.workflowId);
+      }
+    }
+    if (!backend.isWorkflowLoadable(workflowIdOrPrefix)) {
+      return {
+        ok: false,
+        reason: "not_registered",
+        message: `Workflow ${workflowIdOrPrefix.slice(0, 8)} has no valid current DBOS state.`,
+      };
     }
-    return { ok: false, reason: "not_registered", message: `No durable workflow found for id/prefix: ${workflowIdOrPrefix}` };
+    return { ok: false, reason: "not_registered", message: `No resumable workflow found for id/prefix: ${workflowIdOrPrefix}` };
   }
   if ("kind" in resolved) {
     return {
@@ -131,23 +116,31 @@ export function resumeDurableWorkflow(
     };
   }
   if (!backend.isWorkflowLoadable(resolved.workflowId)) {
-    return { ok: false, reason: "not_registered", message: `Durable workflow ${resolved.workflowId.slice(0, 8)} uses an incompatible or unavailable persisted format and cannot be resumed.` };
+    return {
+      ok: false,
+      reason: "not_registered",
+      message: `Workflow ${resolved.workflowId.slice(0, 8)} has no valid current DBOS state.`,
+    };
   }
-  // Authoritative backend-handle check: a cache-only entry (no handle) is
-  // "stale" regardless of its cached status. A `running` handle is only
-  // refused when there is a live, actively-executing run for it in THIS
-  // session — otherwise it is a crashed process and cross-session crash
-  // recovery should proceed.
+  // Revalidate the authoritative DBOS handle before resume. A running handle
+  // is refused when this process still has an actively executing run, or when
+  // fresh ownership metadata shows another Atomic session is executing it.
   const handle = backend.getWorkflow(resolved.workflowId);
   if (handle === undefined) {
     return {
       ok: false,
       reason: "stale",
-      message: `Workflow ${resolved.workflowId.slice(0, 8)} has only session-cache metadata and no durable checkpoint state; resume would re-run from scratch. Re-run the workflow to start fresh.`,
+      message: `Workflow ${resolved.workflowId.slice(0, 8)} has no current DBOS checkpoint state; re-run the workflow to start fresh.`,
     };
   }
-  if (handle.status === "running" && hasActiveLiveRun(deps.baseRunOpts.store, resolved.workflowId)) {
-    return alreadyRunningResult(handle.name, resolved.workflowId, deps.baseRunOpts.store);
+
+  if (handle.status === "running") {
+    if (hasActiveLiveRun(deps.baseRunOpts.store, resolved.workflowId)) {
+      return alreadyRunningResult(handle.name, resolved.workflowId, deps.baseRunOpts.store);
+    }
+    if (isForeignLiveWorkflow(handle, getAtomicExecutorId())) {
+      return foreignRunningResult(handle.name, resolved.workflowId);
+    }
   }
   if (!isDurableWorkflowResumable(handle)) {
     return { ok: false, reason: "not_resumable", message: `Workflow ${resolved.workflowId.slice(0, 8)} is ${handle.status}, not resumable.` };
@@ -169,10 +162,19 @@ export function resumeDurableWorkflow(
   }
   removeDurableResumeShadowRuns(deps.baseRunOpts.store, resolved.workflowId);
 
-
-  // Mark the workflow as resuming in the backend, then re-dispatch with the
-  // ORIGINAL workflow id as the run id so durable checkpoints replay.
-  backend.setWorkflowStatus(resolved.workflowId, "running");
+  // Claim resume against concurrent deletion through the required transition seam.
+  const claimed = await backend.transitionWorkflowStatus(
+    resolved.workflowId,
+    [handle.status],
+    "running",
+  );
+  if (!claimed) {
+    return {
+      ok: false,
+      reason: "stale",
+      message: `Workflow ${resolved.workflowId.slice(0, 8)} changed while resume was pending; refresh the workflow list and try again.`,
+    };
+  }
 
   const resumeRunOpts: RunOpts = {
     ...deps.baseRunOpts,
@@ -181,7 +183,31 @@ export function resumeDurableWorkflow(
     durableBackend: backend,
   };
 
-  const accepted: DetachedAccepted = runDetached(def, inputs, resumeRunOpts);
+  let launch: ReturnType<typeof launchDetachedUntilStartup>;
+  try {
+    launch = launchDetachedUntilStartup(def, inputs, {
+      ...resumeRunOpts,
+      ...(deps.jobs !== undefined ? { jobs: deps.jobs } : {}),
+    });
+  } catch (error) {
+    backend.setWorkflowStatus(resolved.workflowId, handle.status, handle.pendingPrompts, handle.resumable);
+    await backend.flush();
+    return { ok: false, reason: "startup_failed", message: `Failed to resume durable workflow ${resolved.workflowId.slice(0, 8)}: ${error instanceof Error ? error.message : String(error)}` };
+  }
+  const { accepted } = launch;
+  const admission = await launch.wait;
+  if (!admission.started) {
+    const snapshot = deps.baseRunOpts.store?.runs().find((run) => run.id === accepted.runId);
+    const error = workflowStartupFailureMessage(
+      admission,
+      snapshot?.error,
+      `Workflow ${resolved.workflowId.slice(0, 8)} ended before startup admission`,
+    );
+    deps.baseRunOpts.store?.removeRun(accepted.runId);
+    backend.setWorkflowStatus(resolved.workflowId, handle.status, handle.pendingPrompts, handle.resumable);
+    await backend.flush();
+    return { ok: false, reason: "startup_failed", message: `Failed to resume durable workflow ${resolved.workflowId.slice(0, 8)}: ${error}` };
+  }
 
   return {
     ok: true,
@@ -204,6 +230,15 @@ function removeDurableResumeShadowRuns(store: RunOpts["store"], workflowId: stri
     if (!store.removeRun(workflowId)) return;
   }
 }
+function foreignRunningResult(name: string, workflowId: string): ResumeDurableResult {
+  return {
+    ok: false,
+    reason: "not_resumable",
+    message: `Workflow "${name}" (${workflowId.slice(0, 8)}) is actively running in another Atomic session. `
+      + "Control it from that session; it becomes resumable here only after that session pauses, quits, or crashes.",
+  };
+}
+
 
 function alreadyRunningResult(name: string, workflowId: string, store: RunOpts["store"]): ResumeDurableResult {
   const here = store?.runs().some((r) => r.id === workflowId && r.endedAt === undefined) === true;
@@ -212,7 +247,7 @@ function alreadyRunningResult(name: string, workflowId: string, store: RunOpts["
     reason: "not_resumable",
     message: `Workflow "${name}" (${workflowId.slice(0, 8)}) is already running${
       here ? " in this session" : " in another session"
-    }. Attach with \`/workflow connect ${workflowId.slice(0, 8)}\`, or if that session has ended, clear it with \`/workflow kill ${workflowId.slice(0, 8)}\` and re-run.`,
+    }. See agents working and chat with or steer each stage using \`/workflow connect ${workflowId.slice(0, 8)}\`; use \`/workflow quit ${workflowId.slice(0, 8)}\` to pause the run for later resume.`,
   };
 }
 
@@ -227,36 +262,7 @@ function hasActiveLiveRun(store: RunOpts["store"] | undefined, workflowId: strin
   return store.runs().some((r) => r.id === workflowId && r.endedAt === undefined && r.exitReason !== "quit");
 }
 
-/**
- * Check whether the durable backend records a TERMINAL (non-resumable) status
- * for the given workflow id. Terminal status suppresses stale session-cache
- * entries so a completed/cancelled workflow is not resurrected as resumable.
- *
- * Returns true only when the backend has a registered handle whose status is
- * definitively terminal (completed, cancelled, or failed-and-non-resumable).
- */
-export function isBackendTerminal(backend: DurableWorkflowBackend, workflowId: string): boolean {
-  const handle = backend.getWorkflow(workflowId);
-  if (handle === undefined) return false;
-  const status = handle.status;
-  if (status === "completed" || status === "cancelled") return true;
-  if (status === "failed" || status === "blocked") return handle.resumable === false;
-  return false;
-}
-
-
-/**
- * Runtime-facing async preparation: hydrate the durable backend from DBOS
- * (when supported) then list resumable workflows with optional session-dir
- * scan merge. Used by the ExtensionRuntime's `prepareDurableResumable`.
- *
- * Stale-cache suppression: when a session JSONL cache entry has no matching
- * durable backend handle, it came from an older/non-checkpointed workflow
- * engine and is hidden from selectors. When the backend knows a workflow is
- * terminal (completed/cancelled/non-resumable), stale cache rows for that id
- * are also suppressed. cross-ref: issue #1498.
- */
-/** Remove restored/live snapshots whose authoritative durable format is non-loadable. */
+/** Remove local snapshots that do not exist as valid current DBOS workflows. */
 export function purgeSuppressedWorkflowRuns(backend: DurableWorkflowBackend, store: RunOpts["store"]): readonly string[] {
   if (store === undefined) return [];
   const removed: string[] = [];
@@ -267,36 +273,33 @@ export function purgeSuppressedWorkflowRuns(backend: DurableWorkflowBackend, sto
   return removed;
 }
 
+/** Hydrate a bounded set of known DBOS workflow ids. */
+export async function prepareTargetedDurableResumable(
+  backend: DurableWorkflowBackend,
+  workflowIds: readonly string[],
+): Promise<readonly ResumableWorkflowEntry[]> {
+  const entries: ResumableWorkflowEntry[] = [];
+  const seen = new Set<string>();
+  for (const workflowId of workflowIds) {
+    if (seen.has(workflowId)) continue;
+    seen.add(workflowId);
+    await backend.hydrateWorkflow(workflowId);
+    const handle = backend.getLoadableWorkflow(workflowId);
+    if (handle === undefined || !isDurableWorkflowResumable(handle)) continue;
+    entries.push(resumableEntryFromHandle(handle));
+  }
+  return entries;
+}
+
 export async function prepareRuntimeDurableResumable(
   getBackend: () => DurableWorkflowBackend,
-  resolveSessionDir: () => string | undefined,
   workflowIdOrPrefix?: string,
-  sessionDir?: string,
 ): Promise<readonly ResumableWorkflowEntry[]> {
   const backend = getBackend();
-  if (backend.hydrateResumableWorkflows !== undefined) {
-    await backend.hydrateResumableWorkflows();
-  }
-  if (workflowIdOrPrefix !== undefined && backend.hydrateWorkflow !== undefined) {
-    const catalog = backend.listResumableWorkflows();
-    const resolved = resolveDurableEntry(workflowIdOrPrefix, catalog);
-    if (resolved !== undefined && !("kind" in resolved)) {
-      await backend.hydrateWorkflow(resolved.workflowId);
-    }
+  await backend.hydrateResumableWorkflows();
+  if (workflowIdOrPrefix !== undefined) {
+    const resolved = resolveDurableEntry(workflowIdOrPrefix, backend.listResumableWorkflows());
+    if (resolved !== undefined && !("kind" in resolved)) await backend.hydrateWorkflow(resolved.workflowId);
   }
-  const live = backend.listResumableWorkflows();
-  const effectiveSessionDir = sessionDir ?? resolveSessionDir();
-  if (effectiveSessionDir === undefined) return live;
-  const { scanResumableWorkflows } = await import("./resume-catalog.js");
-  const scanned = scanResumableWorkflows(effectiveSessionDir);
-  const liveIds = new Set(live.map((e) => e.workflowId));
-  // Suppress cache-only entries from older workflow engines. Without a
-  // durable backend handle/checkpoint state, selecting the row can only fail
-  // as stale (or risk re-running from scratch), so it should not clutter the
-  // resume selector.
-  const suppressed = scanned.filter((entry) => {
-    const handle = backend.getWorkflow(entry.workflowId);
-    return !liveIds.has(entry.workflowId) && handle !== undefined && isDurableWorkflowResumable(handle);
-  });
-  return [...live, ...suppressed];
+  return backend.listResumableWorkflows();
 }

package/dist/builtin/workflows/src/durable/retention-policy.ts

@@ -0,0 +1,42 @@
+import type { DurableWorkflowBackend } from "./backend.js";
+
+export type DurableWorkflowDeleteOutcome =
+  | { readonly ok: true; readonly message: string }
+  | { readonly ok: false; readonly message: string };
+
+/**
+ * `/resume` parity keeps every eligible run regardless of age/count and only
+ * removes history after an explicit confirmed action. This helper is the
+ * workflow-aware deletion gate used after selector confirmation.
+ */
+export async function deleteDurableWorkflowIfSafe(
+  backend: DurableWorkflowBackend,
+  workflowId: string,
+  isInFlight: (workflowId: string) => boolean,
+): Promise<DurableWorkflowDeleteOutcome> {
+  if (isInFlight(workflowId)) {
+    return { ok: false, message: "Cannot delete an in-flight workflow run." };
+  }
+  try {
+    const handle = backend.getLoadableWorkflow(workflowId);
+    if (handle === undefined) {
+      return { ok: false, message: "Workflow durable state is stale or no longer available." };
+    }
+    if (handle.status === "running") {
+      return { ok: false, message: "Cannot delete a workflow marked running; it may be active in another process." };
+    }
+    const result = await backend.deleteWorkflowIfInactive(workflowId);
+    if (!result.ok) {
+      return {
+        ok: false,
+        message: result.reason === "running"
+          ? "Cannot delete a workflow that became active while deletion was pending."
+          : "Workflow durable state is stale or no longer available.",
+      };
+    }
+    return { ok: true, message: "Workflow durable history deleted; retained session transcripts were not removed." };
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    return { ok: false, message: `Failed to delete workflow durable history: ${detail}` };
+  }
+}

package/dist/builtin/workflows/src/durable/run-timing.ts

@@ -0,0 +1,98 @@
+/**
+ * Durable run-level elapsed-time checkpoints.
+ *
+ * Persists the total accumulated elapsed time of a top-level workflow run so a
+ * durable `/workflow resume` can seed the new `RunSnapshot` with the prior
+ * elapsed time — the main-chat dashboard total then reports prior + current
+ * elapsed instead of restarting at zero.
+ *
+ * Storage shape: a reserved tool-kind checkpoint (name/argsHash
+ * `workflow-run-timing`). Tool checkpoints round-trip through the DBOS
+ * envelope untouched and are ignored by stage-graph reconstruction, so no
+ * phantom stages appear in durable inspection. Repeated updates use distinct
+ * checkpoint ids; the latest record (by `completedAt`) wins on hydration
+ * because the in-memory mirror replays checkpoints in completion order.
+ *
+ * cross-ref: packages/workflows/src/shared/timing.ts elapsedRunMs
+ */
+
+import type { DurableWorkflowBackend } from "./backend.js";
+import type { DurableToolCheckpoint } from "./types.js";
+import type { RunSnapshot } from "../shared/store-types.js";
+import { elapsedRunMs } from "../shared/timing.js";
+
+/** Reserved checkpoint name AND args-hash for run-level timing records. */
+export const RUN_TIMING_CHECKPOINT_NAME = "workflow-run-timing";
+
+/**
+ * Debounce granularity for run-timing updates, matching the stage-session
+ * duration bucket so piggybacked writes never outpace stage checkpoints.
+ */
+export const RUN_TIMING_DURATION_BUCKET_MS = 30_000;
+
+function timingBucket(elapsedMs: number): number {
+  return Math.floor(elapsedMs / RUN_TIMING_DURATION_BUCKET_MS);
+}
+
+/** Prior accumulated run elapsed recorded durably, or undefined when absent. */
+export function priorRunElapsedMs(backend: DurableWorkflowBackend, workflowId: string): number | undefined {
+  const output = backend.getToolOutput(workflowId, RUN_TIMING_CHECKPOINT_NAME);
+  if (typeof output !== "object" || output === null || Array.isArray(output)) return undefined;
+  const elapsedMs = (output as Record<string, unknown>)["elapsedMs"];
+  if (typeof elapsedMs !== "number" || !Number.isFinite(elapsedMs) || elapsedMs <= 0) return undefined;
+  return elapsedMs;
+}
+
+/**
+ * Record the run's current total elapsed time (prior + this session) durably.
+ *
+ * Skipped when the workflow has no durable progress yet (a timing record with
+ * nothing to resume would only manufacture resumability), when the elapsed
+ * value did not grow past the last record, or — with `debounce` — while the
+ * value stays inside the last 30 s bucket.
+ */
+export function recordRunTimingCheckpoint(
+  backend: DurableWorkflowBackend,
+  run: RunSnapshot,
+  options?: { readonly debounce?: boolean; readonly now?: number },
+): boolean {
+  const now = options?.now ?? Date.now();
+  const elapsedMs = elapsedRunMs(run, now);
+  if (elapsedMs <= 0) return false;
+  if (backend.listCheckpoints(run.id).length === 0) return false;
+  const recorded = priorRunElapsedMs(backend, run.id);
+  if (recorded !== undefined) {
+    if (elapsedMs <= recorded) return false;
+    if (options?.debounce === true && timingBucket(elapsedMs) === timingBucket(recorded)) return false;
+  }
+  const checkpoint: DurableToolCheckpoint = {
+    kind: "tool",
+    workflowId: run.id,
+    checkpointId: `run-timing:${elapsedMs}`,
+    name: RUN_TIMING_CHECKPOINT_NAME,
+    argsHash: RUN_TIMING_CHECKPOINT_NAME,
+    output: { elapsedMs },
+    completedAt: now,
+  };
+  backend.recordCheckpoint(checkpoint);
+  return true;
+}
+
+/**
+ * Elapsed time a freshly-created run inherits from its predecessor:
+ * continuation resumes measure the live source snapshot; durable re-dispatch
+ * resumes (same run id, no continuation) read the persisted timing record.
+ */
+export function inheritedRunElapsedMs(input: {
+  readonly backend: DurableWorkflowBackend;
+  readonly runId: string;
+  readonly continuationSource?: RunSnapshot;
+  readonly now?: number;
+}): number | undefined {
+  const now = input.now ?? Date.now();
+  const source = input.continuationSource;
+  const inherited = source !== undefined
+    ? elapsedRunMs(source, source.endedAt ?? now)
+    : priorRunElapsedMs(input.backend, input.runId);
+  return inherited !== undefined && inherited > 0 ? inherited : undefined;
+}

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

@@ -12,17 +12,17 @@
  * remaps every checkpoint identity to the root workflow id, prefixed by a stable
  * child boundary key, so the same side effects are recovered on resume.
  *
- * Only checkpoint read/write methods are scoped. Lifecycle methods
- * (`registerWorkflow`, `setWorkflowStatus`, completed/resumable listing,
- * `toCacheEntry`, `getWorkflow`) are no-ops for scoped children because child
- * runs are never independently addressable — only the root workflow is.
+ * Only checkpoint read/write methods are scoped. Root lifecycle, catalog,
+ * metadata, and deletion methods are no-ops because child runs are not
+ * independently addressable.
  *
  * cross-ref: issue #1498 — child side effects under the root durable workflow.
  */
 
 import type { DurableCheckpoint, DurableWorkflowStatus, ResumableWorkflowEntry } from "./types.js";
 import type { WorkflowSerializableValue } from "../shared/types.js";
-import type { DurableWorkflowBackend, WorkflowRegistrationInput } from "./backend.js";
+import type { DurableInactiveDeleteResult, DurableWorkflowBackend, DurableWorkflowCatalogEntries, WorkflowRegistrationInput } from "./backend.js";
+import { claimDurablePromptToken, durablePromptScope, releaseDurablePrompt, reserveDurablePrompt, type PromptReservationToken } from "./prompt-reservations.js";
 
 /**
  * Durable scope for a child workflow run.
@@ -62,16 +62,11 @@ export class ScopedDurableBackend implements DurableWorkflowBackend {
   }
 
   async recordCheckpointAsync(checkpoint: DurableCheckpoint): Promise<void> {
-    if (this.inner.recordCheckpointAsync !== undefined) {
-      await this.inner.recordCheckpointAsync(this.remap(checkpoint));
-      return;
-    }
-    this.inner.recordCheckpoint(this.remap(checkpoint));
-    await this.inner.flush?.();
+    await this.inner.recordCheckpointAsync(this.remap(checkpoint));
   }
 
   flush(): Promise<void> {
-    return this.inner.flush?.() ?? Promise.resolve();
+    return this.inner.flush();
   }
 
   getToolOutput(_workflowId: string, argsHash: string): WorkflowSerializableValue | undefined {
@@ -97,7 +92,7 @@ export class ScopedDurableBackend implements DurableWorkflowBackend {
 
   listCheckpoints(_workflowId: string): readonly DurableCheckpoint[] {
     const all = this.inner.listCheckpoints(this.scope.rootWorkflowId);
-    const prefix = `${this.scope.scopePrefix}:`;
+    const prefix = `${this.effectivePromptScope().scope}:`;
     // Checkpoints are stored with their scope prefix already embedded in their
     // ids (see remap()). Filter by the stored id directly — NOT by re-prefixing
     // — so sibling scopes (e.g. "workflow:child:1") are excluded when the
@@ -111,10 +106,44 @@ export class ScopedDurableBackend implements DurableWorkflowBackend {
     return undefined;
   }
 
+  getLoadableWorkflow(_workflowId: string): undefined {
+    return undefined;
+  }
+
   setWorkflowStatus(_workflowId: string, _status: DurableWorkflowStatus, _pendingPrompts?: number, _resumable?: boolean): void {
     // No-op: child status is reflected via the root workflow boundary.
   }
 
+  async transitionWorkflowStatus(
+    _workflowId: string,
+    _expectedStatuses: readonly DurableWorkflowStatus[],
+    _status: DurableWorkflowStatus,
+    _pendingPrompts?: number,
+    _resumable?: boolean,
+  ): Promise<boolean> {
+    return false;
+  }
+
+  adjustPendingPrompts(_workflowId: string, delta: number): void {
+    this.inner.adjustPendingPrompts(this.scope.rootWorkflowId, delta);
+  }
+
+  promptReservationScope(_workflowId: string): { readonly rootWorkflowId: string; readonly scope: string } {
+    return this.effectivePromptScope();
+  }
+
+  pendingPromptToken(_workflowId: string, reservationId: string): PromptReservationToken | undefined {
+    return claimDurablePromptToken(this.inner, this.scope.rootWorkflowId, reservationId);
+  }
+
+  reservePendingPrompt(_workflowId: string, reservationId: string): PromptReservationToken {
+    return reserveDurablePrompt(this.inner, this.scope.rootWorkflowId, reservationId);
+  }
+
+  releasePendingPrompt(_workflowId: string, reservationId: string, token: PromptReservationToken): void {
+    releaseDurablePrompt(this.inner, this.scope.rootWorkflowId, reservationId, token);
+  }
+
   listResumableWorkflows(): readonly ResumableWorkflowEntry[] {
     return [];
   }
@@ -123,7 +152,11 @@ export class ScopedDurableBackend implements DurableWorkflowBackend {
     return [];
   }
 
-  toCacheEntry(_workflowId: string): undefined {
+  async prepareWorkflowCatalog(): Promise<DurableWorkflowCatalogEntries> {
+    return { resumable: [], completed: [] };
+  }
+
+  toMetadata(_workflowId: string): undefined {
     return undefined;
   }
 
@@ -131,6 +164,10 @@ export class ScopedDurableBackend implements DurableWorkflowBackend {
     // No-op: scoped children never own or delete root durable state.
   }
 
+  async deleteWorkflowIfInactive(_workflowId: string): Promise<DurableInactiveDeleteResult> {
+    return { ok: false, reason: "not_found" };
+  }
+
   isWorkflowLoadable(_workflowId: string): boolean {
     return false;
   }
@@ -147,6 +184,17 @@ export class ScopedDurableBackend implements DurableWorkflowBackend {
     return Promise.resolve();
   }
 
+  private effectivePromptScope(): { readonly rootWorkflowId: string; readonly scope: string } {
+    const parent = durablePromptScope(this.inner, this.scope.rootWorkflowId);
+    const scope = parent.scope === "root"
+      ? this.scope.scopePrefix
+      : `${parent.scope}:${this.scope.scopePrefix}`;
+    return {
+      rootWorkflowId: parent.rootWorkflowId,
+      scope,
+    };
+  }
+
   private scopeKey(key: string): string {
     return `${this.scope.scopePrefix}:${key}`;
   }