@bastani/atomic 0.9.11-alpha.1 → 0.9.11-alpha.2

package/CHANGELOG.md

@@ -2,6 +2,29 @@
 
 ## [Unreleased]
 
+## [0.9.11-alpha.2] - 2026-07-21
+
+### Added
+
+- Added Qwen Token Plan and Qwen Token Plan China to Atomic's built-in provider defaults and credential guidance, inherited from `pi-ai` 0.81.1 ([#6858](https://github.com/earendil-works/pi/pull/6858)).
+- Added the `get_available_thinking_levels` RPC command and `RpcClient.getAvailableThinkingLevels()` so headless clients can discover the active model's exact supported cycle order ([#6865](https://github.com/earendil-works/pi/pull/6865)).
+- Exported message and tool-execution lifecycle event types from the Atomic package root for extension and SDK consumers ([#6772](https://github.com/earendil-works/pi/pull/6772)).
+
+### Changed
+
+- Updated `@earendil-works/pi-agent-core`, `pi-ai`, and `pi-tui` to 0.81.1, inheriting provider, transport, model-catalog, Kimi K3 thinking, OpenAI Responses retry, Codex request-ID, terminal rendering, and queue fixes from Pi 0.81.0–0.81.1 while retaining Atomic's branding, bundled packages, Verbatim Compaction, and versionless release flow.
+- Restored persisted model catalogs without network access during service creation, then moved automatic network refresh into running interactive and RPC modes. Interactive startup computes its first footer provider count from the restored snapshot and starts network refresh only after TUI initialization.
+
+### Fixed
+
+- Fixed transient provider failures aborting Verbatim Compaction planning or branch summarization. Both now honor the configured retry policy and publish `summarization_retry_scheduled`, `summarization_retry_attempt_start`, and `summarization_retry_finished` lifecycle events to interactive, JSON, RPC, and SDK consumers ([#6901](https://github.com/earendil-works/pi/pull/6901)).
+- Fixed persisted remote model catalogs overriding newer bundled catalogs after an upgrade by comparing catalog modification times and treating legacy undated overlays as stale ([upstream commit](https://github.com/earendil-works/pi/commit/54fad505b9d8cbc8922ff55d7e2938f70cbf6a3d)).
+- Fixed steering and follow-up delivery modes being lost when queued messages were flushed as compaction finished ([#6730](https://github.com/earendil-works/pi/pull/6730)).
+- Fixed read-tool errors being syntax-highlighted as though they were successful file contents ([#6731](https://github.com/earendil-works/pi/pull/6731)).
+- Fixed `${@:-default}` and `${ARGUMENTS:-default}` prompt-template defaults, while retaining Atomic's bounded default-value parser ([#6695](https://github.com/earendil-works/pi/issues/6695)).
+- Fixed persisted sessions being read and parsed twice when opened, and adopted the shared UUIDv7 generator for new session IDs ([#6793](https://github.com/earendil-works/pi/pull/6793), [#6834](https://github.com/earendil-works/pi/pull/6834)).
+- Fixed Kimi Coding usage costs being shown without the subscription estimate indicator.
+
 ## [0.9.11-alpha.1] - 2026-07-20
 
 ### Changed

package/dist/builtin/cursor/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/cursor",
-  "version": "0.9.11-alpha.1",
+  "version": "0.9.11-alpha.2",
   "private": true,
   "description": "Experimental first-party Atomic extension for Cursor OAuth, model discovery, and streaming provider registration.",
   "contributors": [
@@ -40,8 +40,8 @@
     }
   },
   "dependencies": {
-    "@bastani/atomic-natives": "0.9.11-alpha.1",
+    "@bastani/atomic-natives": "0.9.11-alpha.2",
     "@bufbuild/protobuf": "^2.12.1",
-    "@earendil-works/pi-ai": "^0.80.10"
+    "@earendil-works/pi-ai": "^0.81.1"
   }
 }

package/dist/builtin/intercom/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/intercom",
-  "version": "0.9.11-alpha.1",
+  "version": "0.9.11-alpha.2",
   "private": true,
   "description": "Atomic extension providing a private coordination channel between parent and child agent sessions. Fork of: https://github.com/nicobailon/pi-intercom",
   "contributors": [
@@ -44,7 +44,7 @@
   },
   "peerDependencies": {
     "@bastani/atomic": "*",
-    "@earendil-works/pi-tui": "^0.80.10"
+    "@earendil-works/pi-tui": "^0.81.1"
   },
   "peerDependenciesMeta": {
     "@bastani/atomic": {

package/dist/builtin/mcp/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/mcp",
-  "version": "0.9.11-alpha.1",
+  "version": "0.9.11-alpha.2",
   "private": true,
   "description": "Atomic extension that adapts MCP (Model Context Protocol) servers into the coding agent. Fork of: https://github.com/nicobailon/pi-mcp-adapter",
   "contributors": [
@@ -32,8 +32,8 @@
   },
   "peerDependencies": {
     "@bastani/atomic": "*",
-    "@earendil-works/pi-ai": "^0.80.10",
-    "@earendil-works/pi-tui": "^0.80.10",
+    "@earendil-works/pi-ai": "^0.81.1",
+    "@earendil-works/pi-tui": "^0.81.1",
     "zod": "^3.25.0 || ^4.0.0"
   },
   "peerDependenciesMeta": {

package/dist/builtin/subagents/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/subagents",
-  "version": "0.9.11-alpha.1",
+  "version": "0.9.11-alpha.2",
   "private": true,
   "description": "Atomic extension for delegating tasks to subagents with chains, parallel execution, and background runs. Fork of: https://github.com/nicobailon/pi-subagents",
   "contributors": [
@@ -38,9 +38,9 @@
   },
   "peerDependencies": {
     "@bastani/atomic": "*",
-    "@earendil-works/pi-agent-core": "^0.80.10",
-    "@earendil-works/pi-ai": "^0.80.10",
-    "@earendil-works/pi-tui": "^0.80.10"
+    "@earendil-works/pi-agent-core": "^0.81.1",
+    "@earendil-works/pi-ai": "^0.81.1",
+    "@earendil-works/pi-tui": "^0.81.1"
   },
   "peerDependenciesMeta": {
     "@bastani/atomic": {

package/dist/builtin/web-access/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/web-access",
-  "version": "0.9.11-alpha.1",
+  "version": "0.9.11-alpha.2",
   "private": true,
   "description": "Atomic extension for web search, URL fetching, GitHub repo cloning, PDF/video extraction. Fork of: https://github.com/nicobailon/pi-web-access",
   "contributors": [
@@ -31,7 +31,7 @@
   },
   "peerDependencies": {
     "@bastani/atomic": "*",
-    "@earendil-works/pi-tui": "^0.80.10"
+    "@earendil-works/pi-tui": "^0.81.1"
   },
   "peerDependenciesMeta": {
     "@bastani/atomic": {

package/dist/builtin/workflows/CHANGELOG.md

@@ -6,6 +6,12 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 
 ## [Unreleased]
 
+## [0.9.11-alpha.2] - 2026-07-21
+
+### Fixed
+
+- Fixed fresh-process workflow resume and completed-run inspection losing nested child-workflow and parallel stage hierarchy. DBOS stage checkpoints now retain owning-run and boundary topology, replay restores source parentage and child runs, graceful quit persists exact sub-30-second stage timing, completed runs persist and display accumulated run duration, and project-local workflows reloaded during a chat are rediscovered from their original invocation directory. The `/workflow resume` and `/workflows` picker rows also no longer display the redundant `N prompts` segment.
+
 ## [0.9.11-alpha.1] - 2026-07-20
 
 ### Added

package/dist/builtin/workflows/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/workflows",
-  "version": "0.9.11-alpha.1",
+  "version": "0.9.11-alpha.2",
   "private": true,
   "description": "Atomic extension for multi-stage workflow authoring and execution.",
   "contributors": [
@@ -83,7 +83,7 @@
   },
   "peerDependencies": {
     "@bastani/atomic": "*",
-    "@earendil-works/pi-tui": "^0.80.10"
+    "@earendil-works/pi-tui": "^0.81.1"
   },
   "peerDependenciesMeta": {
     "@bastani/atomic": {

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

@@ -11,6 +11,7 @@ import type { DurableWorkflowBackend } from "./backend.js";
 import type { DurableScope } from "./scoped-backend.js";
 import { recordCheckpointDurably } from "./tool-primitive.js";
 import { stageCheckpointWithOutput, type DurableCompletedStageCheckpoint } from "./stage-primitive.js";
+import type { DurableStageCheckpoint } from "./types.js";
 
 export function createDurableChildWorkflowPrimitive(input: {
   readonly workflowId: string;
@@ -18,6 +19,7 @@ export function createDurableChildWorkflowPrimitive(input: {
   readonly backend: DurableWorkflowBackend;
   readonly nextReplayKey: (name: string) => string;
   readonly recordCachedStage: (name: string, replayKey: string, checkpoint: DurableCompletedStageCheckpoint) => void;
+  readonly checkpointMetadata: (replayKey: string) => Partial<DurableStageCheckpoint>;
   /**
    * Publish the durable scope computed for the next child invocation so the
    * child runner can consume it and route its internal side-effect checkpoints
@@ -66,6 +68,7 @@ export function createDurableChildWorkflowPrimitive(input: {
       output: result as WorkflowSerializableValue,
       completedAt: Date.now(),
       result: result.status,
+      ...input.checkpointMetadata(replayKey),
     });
     return result as WorkflowChildResult<TChildOutputs>;
   };

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

@@ -1,5 +1,5 @@
 import type { RunSnapshot, StageSnapshot } from "../shared/store-types.js";
-import type { WorkflowInputValues } from "../shared/types.js";
+import type { WorkflowChildResult, WorkflowInputValues, WorkflowOutputValues, WorkflowSerializableValue } from "../shared/types.js";
 import { isReopenableSessionTranscript } from "../shared/session-transcript.js";
 import type { DurableWorkflowBackend } from "./backend.js";
 import {
@@ -9,6 +9,7 @@ import {
   type ResumableWorkflowEntry,
 } from "./types.js";
 import { resolveDurableEntry } from "./resume-runtime.js";
+import { priorRunElapsedMs } from "./run-timing.js";
 
 export type CompletedWorkflowResolution =
   | { readonly kind: "found"; readonly entry: ResumableWorkflowEntry; readonly snapshot: RunSnapshot }
@@ -76,24 +77,52 @@ export function completedWorkflowSnapshot(
   backend: DurableWorkflowBackend,
   entry: ResumableWorkflowEntry,
 ): RunSnapshot | undefined {
+  const runs = completedWorkflowRunSnapshots(backend, entry);
+  const root = runs.find((run) => run.id === entry.workflowId);
+  if (root === undefined || !runs.some((run) => run.stages.some((stage) => stage.sessionFile !== undefined))) return undefined;
+  return root;
+}
+
+/** Rebuild the root plus every nested child run required by graph expansion. */
+export function completedWorkflowRunSnapshots(
+  backend: DurableWorkflowBackend,
+  entry: ResumableWorkflowEntry,
+): readonly RunSnapshot[] {
   const handle = backend.getWorkflow(entry.workflowId);
-  if (handle === undefined || handle.status !== "completed") return undefined;
+  if (handle === undefined || handle.status !== "completed") return [];
   const checkpoints = backend.listCheckpoints(entry.workflowId);
-  if (checkpoints.length === 0) return undefined;
-  const stages = stageSnapshotsFromCheckpoints(checkpoints, handle.updatedAt).map(validatedStageTranscript);
-  if (!stages.some((stage) => stage.sessionFile !== undefined)) return undefined;
-
-  return {
-    id: handle.workflowId,
-    name: handle.name,
+  if (checkpoints.length === 0) return [];
+  const runs = runSnapshotsFromCheckpoints(checkpoints, handle.workflowId, handle.name, handle.updatedAt)
+    .map((run) => ({ ...run, stages: run.stages.map(validatedStageTranscript) }));
+  const rootIndex = runs.findIndex((run) => run.id === handle.workflowId);
+  if (rootIndex < 0) return [];
+  const rootDuration = priorRunElapsedMs(backend, handle.workflowId)
+    ?? Math.max(0, handle.updatedAt - handle.createdAt);
+  const root: RunSnapshot = {
+    ...runs[rootIndex]!,
     inputs: { ...handle.inputs } as WorkflowInputValues,
-    status: "completed",
-    stages,
     startedAt: handle.createdAt,
     endedAt: handle.updatedAt,
-    durationMs: Math.max(0, handle.updatedAt - handle.createdAt),
+    durationMs: rootDuration,
     resumable: false,
   };
+  return [root, ...runs.filter((_, index) => index !== rootIndex)];
+}
+
+/** Rebuild completed nested runs while a paused root is replaying cached boundaries. */
+export function durableNestedRunSnapshots(
+  backend: DurableWorkflowBackend,
+  rootWorkflowId: string,
+): readonly RunSnapshot[] {
+  const handle = backend.getWorkflow(rootWorkflowId);
+  if (handle === undefined) return [];
+  return runSnapshotsFromCheckpoints(
+    backend.listCheckpoints(rootWorkflowId),
+    rootWorkflowId,
+    handle.name,
+    handle.updatedAt,
+    false,
+  ).filter((run) => run.id !== rootWorkflowId);
 }
 
 function validatedStageTranscript(stage: StageSnapshot): StageSnapshot {
@@ -104,19 +133,109 @@ function validatedStageTranscript(stage: StageSnapshot): StageSnapshot {
 }
 
 
-function stageSnapshotsFromCheckpoints(
+function runSnapshotsFromCheckpoints(
   checkpoints: readonly DurableCheckpoint[],
+  rootRunId: string,
+  rootRunName: string,
   fallbackCompletedAt: number,
-): StageSnapshot[] {
+  strict = true,
+): RunSnapshot[] {
   const drafts = new Map<string, StageDraft>();
   for (const checkpoint of checkpoints) {
     if (checkpoint.kind !== "stage") continue;
     const existing = drafts.get(checkpoint.replayKey);
     drafts.set(checkpoint.replayKey, mergeStageDraft(existing, checkpoint));
   }
-  const ordered = [...drafts.values()].sort((a, b) => a.firstCompletedAt - b.firstCompletedAt);
-  if (ordered.length === 0) return [syntheticCheckpointStage(checkpoints.length, fallbackCompletedAt)];
-  return stageSnapshotsFromDrafts(ordered);
+  const ordered = [...drafts.values()]
+    .filter((draft) => !strict || draft.topology?.run === undefined || draft.endedAt !== undefined || draft.output !== undefined)
+    .sort((a, b) => a.firstCompletedAt - b.firstCompletedAt);
+  if (ordered.length === 0) return [syntheticRun(rootRunId, rootRunName, checkpoints.length, fallbackCompletedAt)];
+
+  const grouped = new Map<string, StageDraft[]>();
+  for (const draft of ordered) {
+    if (draft.topology?.version !== DURABLE_STAGE_TOPOLOGY_VERSION) {
+      if (strict) return [];
+      continue;
+    }
+    const runId = draft.topology.run?.runId ?? rootRunId;
+    const group = grouped.get(runId) ?? [];
+    group.push(draft);
+    grouped.set(runId, group);
+  }
+  retainReachableRunGroups(grouped, rootRunId);
+  const idMaps = new Map<string, Map<string, string>>();
+  for (const [runId, runDrafts] of grouped) {
+    const ids = new Map<string, string>();
+    runDrafts.forEach((draft, index) => {
+      const sourceId = draft.topology!.stageId;
+      if (!ids.has(sourceId)) ids.set(sourceId, `completed-stage-${index + 1}`);
+    });
+    if (ids.size !== runDrafts.length) {
+      if (strict) return [];
+      grouped.delete(runId);
+      continue;
+    }
+    idMaps.set(runId, ids);
+  }
+
+  const runs: RunSnapshot[] = [];
+  for (const [runId, runDrafts] of grouped) {
+    const ids = idMaps.get(runId)!;
+    if (runDrafts.some((draft) => draft.topology!.parentIds.some((parentId) => !ids.has(parentId)))) {
+      if (strict) return [];
+      continue;
+    }
+    const stages = runDrafts.map((draft) => stageSnapshotFromDraft(
+      draft,
+      ids.get(draft.topology!.stageId)!,
+      draft.topology!.parentIds.map((parentId) => ids.get(parentId)!),
+    ));
+    const run = runDrafts.find((draft) => draft.topology?.run !== undefined)?.topology?.run;
+    const startedAt = Math.min(...stages.map((stage) => stage.startedAt ?? fallbackCompletedAt));
+    const endedAt = Math.max(...stages.map((stage) => stage.endedAt ?? fallbackCompletedAt));
+    const parentRunId = run?.parentRunId ?? rootRunId;
+    const boundarySourceId = grouped.get(parentRunId)?.find((draft) =>
+      workflowChildFromOutput(draft.output)?.runId === runId
+    )?.topology?.stageId;
+    const declaredParentStageId = run?.parentStageId === undefined
+      ? undefined
+      : idMaps.get(parentRunId)?.get(run.parentStageId);
+    const parentStageId = declaredParentStageId
+      ?? (boundarySourceId === undefined ? undefined : idMaps.get(parentRunId)?.get(boundarySourceId));
+    runs.push({
+      id: runId,
+      name: run?.runName ?? rootRunName,
+      inputs: {},
+      status: "completed",
+      stages,
+      startedAt,
+      endedAt,
+      durationMs: Math.max(0, endedAt - startedAt),
+      ...(run?.parentRunId !== undefined ? { parentRunId: run.parentRunId } : {}),
+      ...(parentStageId !== undefined ? { parentStageId } : {}),
+      ...(run?.rootRunId !== undefined ? { rootRunId: run.rootRunId } : {}),
+      resumable: false,
+    });
+  }
+  return runs;
+}
+
+function retainReachableRunGroups(grouped: Map<string, StageDraft[]>, rootRunId: string): void {
+  const reachable = new Set([rootRunId]);
+  const pending = [rootRunId];
+  while (pending.length > 0) {
+    const drafts = grouped.get(pending.pop()!);
+    if (drafts === undefined) continue;
+    for (const draft of drafts) {
+      const childRunId = workflowChildFromOutput(draft.output)?.runId;
+      if (childRunId === undefined || reachable.has(childRunId) || !grouped.has(childRunId)) continue;
+      reachable.add(childRunId);
+      pending.push(childRunId);
+    }
+  }
+  for (const runId of grouped.keys()) {
+    if (!reachable.has(runId)) grouped.delete(runId);
+  }
 }
 
 function mergeStageDraft(
@@ -138,10 +257,21 @@ function mergeStageDraft(
     ...valueOrExisting("fastMode", checkpoint, existing),
     ...valueOrExisting("attemptedModels", checkpoint, existing),
     ...valueOrExisting("modelAttempts", checkpoint, existing),
-    ...valueOrExisting("topology", checkpoint, existing),
+    ...preferredTopology(checkpoint, existing),
   };
 }
 
+function preferredTopology(
+  checkpoint: DurableStageCheckpoint,
+  existing: StageDraft | undefined,
+): Pick<StageDraft, "topology"> | object {
+  const current = checkpoint.topology;
+  const prior = existing?.topology;
+  if (current?.run !== undefined) return { topology: current };
+  if (prior?.run !== undefined) return { topology: prior };
+  return current !== undefined ? { topology: current } : prior !== undefined ? { topology: prior } : {};
+}
+
 function valueOrExisting<
   K extends keyof Omit<StageDraft, "replayKey" | "name" | "firstCompletedAt">
 >(key: K, checkpoint: DurableStageCheckpoint, existing: StageDraft | undefined): Pick<StageDraft, K> | object {
@@ -151,21 +281,25 @@ function valueOrExisting<
   return existingValue === undefined ? {} : { [key]: existingValue } as Pick<StageDraft, K>;
 }
 
-function stageSnapshotsFromDrafts(drafts: readonly StageDraft[]): StageSnapshot[] {
-  const reconstructedIds = drafts.map((_, index) => `completed-stage-${index + 1}`);
-  const sourceToReconstructed = new Map<string, string>();
-  for (let index = 0; index < drafts.length; index += 1) {
-    const topology = drafts[index]!.topology;
-    if (topology?.version !== DURABLE_STAGE_TOPOLOGY_VERSION
-      || sourceToReconstructed.has(topology.stageId)) return [];
-    sourceToReconstructed.set(topology.stageId, reconstructedIds[index]!);
-  }
-  if (drafts.some((draft) => draft.topology!.parentIds.some((parentId) => !sourceToReconstructed.has(parentId)))) return [];
-  return drafts.map((draft, index) => stageSnapshotFromDraft(
-    draft,
-    reconstructedIds[index]!,
-    draft.topology!.parentIds.map((parentId) => sourceToReconstructed.get(parentId)!),
-  ));
+function workflowChildFromOutput(output: WorkflowSerializableValue | undefined): StageSnapshot["workflowChild"] | undefined {
+  if (!isWorkflowChildResult(output)) return undefined;
+  return {
+    alias: output.workflow,
+    workflow: output.workflow,
+    runId: output.runId,
+    status: output.status,
+    ...(output.exited !== undefined ? { exited: output.exited } : {}),
+    outputs: output.outputs,
+    ...(typeof output.exitReason === "string" ? { exitReason: output.exitReason } : {}),
+  };
+}
+
+function isWorkflowChildResult(value: WorkflowSerializableValue | undefined): value is WorkflowChildResult<WorkflowOutputValues> {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+  const item = value as Record<string, WorkflowSerializableValue | undefined>;
+  return typeof item["workflow"] === "string" && typeof item["runId"] === "string"
+    && typeof item["status"] === "string" && typeof item["outputs"] === "object"
+    && item["outputs"] !== null && !Array.isArray(item["outputs"]);
 }
 
 function stageSnapshotFromDraft(
@@ -187,6 +321,7 @@ function stageSnapshotFromDraft(
     replayKey: draft.replayKey,
     toolEvents: [],
     attachable: false,
+    ...(workflowChildFromOutput(draft.output) !== undefined ? { workflowChild: workflowChildFromOutput(draft.output) } : {}),
     ...(draft.sessionId !== undefined ? { sessionId: draft.sessionId } : {}),
     ...(draft.sessionFile !== undefined ? { sessionFile: draft.sessionFile } : {}),
     ...(draft.model !== undefined ? { model: draft.model } : {}),
@@ -202,6 +337,20 @@ function stageResult(draft: StageDraft): string | undefined {
   return typeof draft.output === "string" ? draft.output : JSON.stringify(draft.output);
 }
 
+function syntheticRun(runId: string, runName: string, checkpointCount: number, completedAt: number): RunSnapshot {
+  return {
+    id: runId,
+    name: runName,
+    inputs: {},
+    status: "completed",
+    stages: [syntheticCheckpointStage(checkpointCount, completedAt)],
+    startedAt: completedAt,
+    endedAt: completedAt,
+    durationMs: 0,
+    resumable: false,
+  };
+}
+
 function syntheticCheckpointStage(checkpointCount: number, completedAt: number): StageSnapshot {
   return {
     id: "completed-checkpoints",

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

@@ -10,6 +10,7 @@ import {
 import type { DurableWorkflowBackend } from "./backend.js";
 import {
   listOpenableCompletedWorkflows,
+  completedWorkflowRunSnapshots,
   resolveCompletedWorkflow,
 } from "./completed-catalog.js";
 import type { ResumableWorkflowEntry } from "./types.js";
@@ -69,10 +70,14 @@ export function openCompletedDurableWorkflow(
       `Workflow ${resolved.snapshot.id.slice(0, 8)} is already active in this session; attach with /workflow connect ${resolved.snapshot.id.slice(0, 8)} instead.`,
     );
   }
-  const snapshot = resolved.snapshot;
-  if (existing !== undefined) deps.store.removeRun(existing.id);
-  deps.store.recordRunStart(snapshot);
-  registerCompletedChatHandles(snapshot, deps);
+  const snapshots = completedWorkflowRunSnapshots(deps.durableBackend, resolved.entry);
+  const snapshot = snapshots.find((run) => run.id === resolved.snapshot.id) ?? resolved.snapshot;
+  for (const restored of snapshots) {
+    const previous = deps.store.runs().find((run) => run.id === restored.id);
+    if (previous !== undefined) deps.store.removeRun(previous.id);
+    deps.store.recordRunStart(restored);
+    registerCompletedChatHandles(restored, deps);
+  }
   return {
     ok: true,
     runId: snapshot.id,

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

@@ -62,12 +62,7 @@ export interface DbosCheckpointEnvelope extends WorkflowSerializableObject {
   readonly topology?: WorkflowSerializableValue;
 }
 
-/**
- * Stage-kind checkpoints from older session-timing writers may omit
- * topology. The current format requires it, so default at every write
- * boundary — persisted records must match the normalized in-memory mirror or
- * a fresh process would reject them as foreign.
- */
+/** Add a compatibility root topology when a legacy/output-only writer omits it. */
 export function withCurrentStageTopology(cp: DurableCheckpoint): DurableCheckpoint {
   if (cp.kind !== "stage" || cp.topology !== undefined) return cp;
   return {
@@ -104,7 +99,12 @@ export function encodeCheckpoint(checkpoint: DurableCheckpoint): DbosCheckpointE
     ...base,
     name: s.name,
     replayKey: s.replayKey,
-    ...(s.topology !== undefined ? { topology: { version: s.topology.version, stageId: s.topology.stageId, parentIds: [...s.topology.parentIds] } } : {}),
+    ...(s.topology !== undefined ? { topology: {
+      version: s.topology.version,
+      stageId: s.topology.stageId,
+      parentIds: [...s.topology.parentIds],
+      ...(s.topology.run !== undefined ? { run: { ...s.topology.run } } : {}),
+    } } : {}),
     ...(s.sessionId !== undefined ? { sessionId: s.sessionId } : {}),
     ...(s.sessionFile !== undefined ? { sessionFile: s.sessionFile } : {}),
     ...(s.startedAt !== undefined ? { startedAt: s.startedAt } : {}),
@@ -227,7 +227,30 @@ function stageTopology(value: WorkflowSerializableValue | undefined): DurableSta
   const record = value as Record<string, WorkflowSerializableValue>;
   if (record["version"] !== DURABLE_STAGE_TOPOLOGY_VERSION
     || typeof record["stageId"] !== "string" || !isStringArray(record["parentIds"])) return undefined;
-  return { version: DURABLE_STAGE_TOPOLOGY_VERSION, stageId: record["stageId"], parentIds: record["parentIds"] };
+  const run = stageRunTopology(record["run"]);
+  if (record["run"] !== undefined && run === undefined) return undefined;
+  return {
+    version: DURABLE_STAGE_TOPOLOGY_VERSION,
+    stageId: record["stageId"],
+    parentIds: record["parentIds"],
+    ...(run !== undefined ? { run } : {}),
+  };
+}
+
+function stageRunTopology(value: WorkflowSerializableValue | undefined): NonNullable<DurableStageTopology["run"]> | undefined {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return undefined;
+  const run = value as Record<string, WorkflowSerializableValue>;
+  if (typeof run["runId"] !== "string" || typeof run["runName"] !== "string") return undefined;
+  for (const key of ["parentRunId", "parentStageId", "rootRunId"] as const) {
+    if (run[key] !== undefined && typeof run[key] !== "string") return undefined;
+  }
+  return {
+    runId: run["runId"],
+    runName: run["runName"],
+    ...(typeof run["parentRunId"] === "string" ? { parentRunId: run["parentRunId"] } : {}),
+    ...(typeof run["parentStageId"] === "string" ? { parentStageId: run["parentStageId"] } : {}),
+    ...(typeof run["rootRunId"] === "string" ? { rootRunId: run["rootRunId"] } : {}),
+  };
 }
 
 function isModelAttempts(value: WorkflowSerializableValue | undefined): boolean {

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

@@ -18,7 +18,7 @@
  * top-level workflow id."
  */
 
-import type { WorkflowInputValues } from "../shared/types.js";
+import type { WorkflowDefinition, WorkflowInputValues } from "../shared/types.js";
 import type { WorkflowRegistry } from "../workflows/registry.js";
 import type { RunOpts } from "../runs/foreground/executor-types.js";
 import { launchDetachedUntilStartup, workflowStartupFailureMessage } from "../runs/background/startup-admission.js";
@@ -44,6 +44,8 @@ export interface ResumeDurableDeps {
   readonly baseRunOpts: RunOpts;
   /** Durable backend override (defaults to the global singleton). */
   readonly durableBackend?: DurableWorkflowBackend;
+  /** Resolve a definition from its original invocation directory after restart. */
+  readonly resolveDefinition?: (name: string, cwd: string | undefined) => Promise<WorkflowDefinition | undefined>;
   /** Job tracker used by the detached resume launch. */
   readonly jobs?: JobTracker;
 }
@@ -146,7 +148,9 @@ export async function resumeDurableWorkflow(
     return { ok: false, reason: "not_resumable", message: `Workflow ${resolved.workflowId.slice(0, 8)} is ${handle.status}, not resumable.` };
   }
 
-  const def = deps.registry.get(handle.name);
+  const def = handle.invocationCwd === undefined
+    ? deps.registry.get(handle.name)
+    : await deps.resolveDefinition?.(handle.name, handle.invocationCwd) ?? deps.registry.get(handle.name);
   if (def === undefined) {
     return { ok: false, reason: "workflow_not_found", message: `Workflow definition not found: ${handle.name}` };
   }