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

package/CHANGELOG.md

@@ -2,6 +2,58 @@
 
 ## [Unreleased]
 
+## [0.9.11-alpha.3] - 2026-07-21
+
+### Added
+
+- Added a built-in, hidden llama.cpp router provider with `/login llama.cpp`, `LLAMA_BASE_URL`/`LLAMA_API_KEY` configuration, loaded-model discovery, and the `/llama` manager for load, unload, cancellation, reconnect, and Hugging Face GGUF download workflows.
+- Added provider-metadata-driven `/login` choices, direct `/login <provider>` routing and autocomplete, provider-owned login information links, API-key login for Qwen Token Plan, Radius, and GitHub Copilot, plus preferred defaults for Radius, NVIDIA, and ZAI Coding Plan China.
+- Added global `httpProxy`, duration-string and `"disabled"` HTTP idle timeouts, package `autoload: false` project deltas, Kimi deferred-tool compatibility, `oauth: "radius"` custom gateways, and global/project scope switching in `atomic config` (`-l` starts in project scope).
+- Added extension lifecycle hooks `before_provider_headers` and `agent_settled`, durable `entry_appended` events and `registerEntryRenderer()`, complete native `Provider` registration, and named/hidden `InlineExtension` descriptors.
+- Added the public `ModelRuntime` facade and associated option types, `readStoredCredential`, `InlineExtension`, entry-renderer/event types, and session context conversion helpers to the SDK/package-root surface. Atomic intentionally continues to expose Search rather than adding obsolete grep compatibility aliases.
+- Added Ctrl+X copy-last-message, clipboard text fallback when image paste finds no image, restored footer branch/session/experimental/extension-status segments, Output padding and Cache miss notices settings, and clear-on-shrink idle placeholders.
+- Added durable cache-miss attribution and waste totals, complete per-model session usage/cost breakdowns including tool and summary work, and optional live/resumed cache-miss transcript notices.
+- Added Atomic's first-run theme preview and explicit analytics opt-in. Analytics settings and a local tracking identifier are persisted only when selected; this change does not transmit analytics data.
+
+### Changed
+
+- Login provider discovery now follows registered provider authentication capabilities instead of using display names as an allowlist, so newly installed native providers automatically expose their supported OAuth and API-key methods.
+- Dynamic provider catalogs, including Radius `pi-messages`, are restored and refreshed through the provider-owned model store; documentation now distinguishes generic custom-provider APIs from the broader installed native API surface.
+- Package self-update now honors advisory release notes, pins the exact advertised package and version, reports version transitions, and cleans stale Windows native-dependency quarantine data during ordinary startup.
+- Interactive session diagnostics now show cache hit rate, wasted cache cost, and provider/model usage costs; the footer includes usage spent by tool results and summaries.
+
+### Fixed
+
+- Fixed Qwen Token Plan global/China, Radius API-key, and GitHub Copilot token methods being hidden from first-time `/login`, which kept otherwise installed models out of `/model` and `--list-models`.
+- Fixed package-manager self-update helpers rejecting the legacy string target form while retaining exact-version install targets.
+- Fixed `/login` omitting extension-registered custom-auth providers in isolated interactive mode. Provider metadata now synchronizes from the engine child, and provider-owned login prompts, credential persistence, cancellation, and post-login model refresh execute across the existing isolated-engine bridge.
+- Fixed project package overrides being unable to selectively subtract or include resources from a matching global package without replacing the complete declaration.
+- Fixed Ctrl+V reporting an image error when the clipboard contained usable text, and made Ctrl+X invoke the same copy-last-assistant behavior as `/copy`.
+- Fixed a single Ctrl+C not dismissing the `/login` popups (auth-method selector, provider selector, and login dialogs), even though Escape worked and the on-screen hint promised `esc/ctrl+c cancel`. The global Ctrl+C clear/exit handler consumed the key before the focused popup could see it, so the first press silently cleared the hidden editor and a second press within the double-press window exited the entire CLI. The global handler now defers whenever an inline popup owns input (and its overlay/custom-UI guards are evaluated live instead of once at startup), so Ctrl+C reaches the focused component and cancels exactly like Escape while editor clearing and double-press exit continue to work when the editor has focus.
+
+## [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.3",
   "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.3",
     "@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.3",
   "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.3",
   "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/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 ## [Unreleased]
 
+## [0.9.11-alpha.3] - 2026-07-21
+
+### Fixed
+
+- Fixed foreground subagent runs that detached for intercom coordination completing silently. When a foreground single, chain, or parallel child detaches (for example after asking its supervisor a question) and later exits, the parent session now receives a "Detached subagent task" completion/failure/paused notice through the same deduplicated, turn-triggering delivery pipeline used for background completion notifications, including per-child `(n/m)` attribution for parallel groups. Previously the detached child's final result was only recorded in remembered run state, so the orchestrating session had to poll `subagent status` to discover that a detached run had finished.
+
 ## [0.9.11-alpha.1] - 2026-07-20
 
 ### Changed

package/dist/builtin/subagents/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/subagents",
-  "version": "0.9.11-alpha.1",
+  "version": "0.9.11-alpha.3",
   "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/subagents/src/runs/background/notify.ts

@@ -44,6 +44,7 @@ interface SubagentResult {
 	results?: ChainStepResult[];
 	taskIndex?: number;
 	totalTasks?: number;
+	noticeLabel?: string;
 }
 
 interface TerminalPreludeMessage {
@@ -194,8 +195,9 @@ export default function registerSubagentNotify(pi: ExtensionAPI): () => void {
 					: undefined;
 
 		const displaySummary = summary.trim() ? summary : "(no output)";
+		const noticeLabel = typeof result.noticeLabel === "string" && result.noticeLabel.trim() ? result.noticeLabel.trim() : "Background task";
 		const content = [
-			`Background task ${status}: **${agent}**${taskInfo}`,
+			`${noticeLabel} ${status}: **${agent}**${taskInfo}`,
 			"",
 			displaySummary,
 			sessionLine ? "" : undefined,

package/dist/builtin/subagents/src/runs/foreground/subagent-executor-chain.ts

@@ -7,7 +7,7 @@ import { resolveSubagentDepthPolicy } from "../../shared/types.ts";
 import type { ChainStep } from "../../shared/settings.ts";
 import type { ExecutionContextData, ResolvedExecutorDeps } from "./subagent-executor-types.ts";
 import { wrapChainTasksForFork } from "./subagent-executor-input.ts";
-import { createForegroundControlNotifier, maybeBuildForegroundIntercomReceipt, rememberForegroundRun, replaceForegroundRunChild } from "./subagent-executor-status.ts";
+import { createForegroundControlNotifier, maybeBuildForegroundIntercomReceipt, notifyDetachedForegroundChildExit, rememberForegroundRun, replaceForegroundRunChild } from "./subagent-executor-status.ts";
 
 export async function runChainPath(data: ExecutionContextData, deps: ResolvedExecutorDeps): Promise<import("../../shared/types.ts").SubagentToolResult> {
 	const {
@@ -64,7 +64,10 @@ export async function runChainPath(data: ExecutionContextData, deps: ResolvedExe
 		worktreeSetupHook: deps.config.worktreeSetupHook,
 		worktreeSetupHookTimeoutMs: deps.config.worktreeSetupHookTimeoutMs,
 		runSync: deps.runtime.runSync,
-		onDetachedExit: (index, result) => replaceForegroundRunChild(deps.state, runId, index, result),
+		onDetachedExit: (index, result) => {
+			replaceForegroundRunChild(deps.state, runId, index, result);
+			notifyDetachedForegroundChildExit({ pi: deps.pi, runId, mode: "chain", index, result });
+		},
 	});
 
 	const chainDetails = chainResult.details ? compactForegroundDetails({ ...chainResult.details, runId }) : undefined;

package/dist/builtin/subagents/src/runs/foreground/subagent-executor-parallel.ts

@@ -43,7 +43,7 @@ import {
 	findDuplicateParallelOutputPath,
 	resolveParallelTaskCwd,
 } from "./subagent-executor-worktree.ts";
-import { createForegroundControlNotifier, maybeBuildForegroundIntercomReceipt, rememberForegroundRun, replaceForegroundRunChild } from "./subagent-executor-status.ts";
+import { createForegroundControlNotifier, maybeBuildForegroundIntercomReceipt, notifyDetachedForegroundChildExit, rememberForegroundRun, replaceForegroundRunChild } from "./subagent-executor-status.ts";
 import { createDetachedCleanupBarrier } from "./detached-cleanup-barrier.ts";
 
 export async function runParallelPath(data: ExecutionContextData, deps: ResolvedExecutorDeps): Promise<SubagentToolResult> {
@@ -171,6 +171,7 @@ export async function runParallelPath(data: ExecutionContextData, deps: Resolved
 			onDetachedExit: (index, result) => {
 				try {
 					replaceForegroundRunChild(deps.state, runId, index, result);
+					notifyDetachedForegroundChildExit({ pi: deps.pi, runId, mode: "parallel", index, totalTasks: tasks.length, result });
 				} finally {
 					detachedCleanup.recover(index);
 				}

package/dist/builtin/subagents/src/runs/foreground/subagent-executor-single.ts

@@ -30,7 +30,7 @@ import {
 	type SubagentToolResult,
 } from "../../shared/types.ts";
 import type { ExecutionContextData, ResolvedExecutorDeps } from "./subagent-executor-types.ts";
-import { createForegroundControlNotifier, maybeBuildForegroundIntercomReceipt, rememberForegroundRun, replaceForegroundRunChild } from "./subagent-executor-status.ts";
+import { createForegroundControlNotifier, maybeBuildForegroundIntercomReceipt, notifyDetachedForegroundChildExit, rememberForegroundRun, replaceForegroundRunChild } from "./subagent-executor-status.ts";
 
 function formatFailedSingleRunOutput(result: SingleResult, displayOutput: string): string {
 	const error = result.error || "Failed";
@@ -191,7 +191,10 @@ export async function runSinglePath(data: ExecutionContextData, deps: ResolvedEx
 			nestedRoute: foregroundControl?.nestedRoute,
 			onDetachedExit: (result) => {
 				cleanupTransientProgress(progressDir, artifactConfig.enabled);
-				if (result) replaceForegroundRunChild(deps.state, runId, 0, result);
+				if (result) {
+					replaceForegroundRunChild(deps.state, runId, 0, result);
+					notifyDetachedForegroundChildExit({ pi: deps.pi, runId, mode: "single", index: 0, result });
+				}
 			},
 			index: 0,
 			modelOverride,

package/dist/builtin/subagents/src/runs/foreground/subagent-executor-status.ts

@@ -10,6 +10,7 @@ import {
 } from "../../intercom/result-intercom.ts";
 import { formatNestedRunStatusLines } from "../shared/nested-render.ts";
 import { formatControlIntercomMessage, formatControlNoticeMessage, shouldNotifyControlEvent } from "../shared/subagent-control.ts";
+import { deliverLocalCompletionNotification } from "../background/completion-notification.ts";
 import { updateForegroundNestedProjection } from "../shared/nested-events.ts";
 import {
 	SUBAGENT_CONTROL_EVENT,
@@ -215,6 +216,39 @@ function resultSummaryForIntercom(result: SingleResult): string {
 	return output || result.error || "(no output)";
 }
 
+/**
+ * Deliver a completion notice to the parent session for a foreground child
+ * that detached for intercom coordination and later exited. Foreground runs
+ * normally return their results inline in the tool result, but a detached
+ * child outlives that tool call, so without this the parent never learns the
+ * child finished (see run history: detached parallel runs completed silently).
+ * Reuses the async completion pipeline (dedupe, ordering barrier, triggerTurn).
+ */
+export function notifyDetachedForegroundChildExit(input: {
+	pi: ExtensionAPI;
+	runId: string;
+	mode: SubagentRunMode;
+	index: number;
+	totalTasks?: number;
+	result: SingleResult;
+}): void {
+	const { pi, runId, index, result } = input;
+	void deliverLocalCompletionNotification(pi.events, {
+		id: runId,
+		runId,
+		agent: result.agent,
+		success: result.exitCode === 0 && !result.interrupted && !result.error,
+		summary: resultSummaryForIntercom(result),
+		exitCode: result.exitCode,
+		...(result.interrupted ? { state: "paused" } : {}),
+		timestamp: Date.now(),
+		...(result.progressSummary?.durationMs !== undefined ? { durationMs: result.progressSummary.durationMs } : {}),
+		...(result.sessionFile ? { sessionFile: result.sessionFile } : {}),
+		...(input.totalTasks !== undefined && input.totalTasks > 1 ? { taskIndex: index, totalTasks: input.totalTasks } : {}),
+		noticeLabel: "Detached subagent task",
+	}, `foreground-detach-${runId}-${index}`);
+}
+
 async function emitForegroundResultIntercom(input: {
 	pi: ExtensionAPI;
 	intercomBridge: IntercomBridgeState;

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.3",
   "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.3",
   "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",