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

package/dist/builtin/subagents/src/tui/render-event-formatting.ts

@@ -1,257 +1,7 @@
-import { formatNestedAggregate } from "../runs/inprocess/runtime-support/nested-rendering.ts";
-import { formatDuration, formatModelThinking, shortenPath } from "../shared/formatters.ts";
-import { formatAgentRunningLabel } from "../shared/status-format.ts";
-import {
-	type AsyncJobState,
-	type AsyncJobStep,
-	MAX_SUBAGENT_NESTING_DEPTH,
-	type NestedRunSummary,
-	type NestedStepSummary,
-} from "../shared/types.ts";
-import { runningGlyph, runningPulseGlyph, type Theme, truncLine } from "./render-layout.ts";
-import {
-	buildLiveStatusLine,
-	formatCurrentToolLine,
-	formatTokenStat,
-	formatToolUseStat,
-	statJoin,
-} from "./render-status-progress.ts";
-
-export function formatWidgetAgents(agents: string[]): string {
-	const distinct = [...new Set(agents)];
-	if (distinct.length === 1 && agents.length > 1) return `${distinct[0]} ×${agents.length}`;
-	if (agents.length > 3) return `${agents.slice(0, 2).join(", ")} +${agents.length - 2} more`;
-	return agents.join(", ");
-}
-
-export function widgetJobName(job: AsyncJobState): string {
-	if (job.mode === "parallel") return "parallel";
-	if (job.mode === "single" && job.agents?.length === 1) return job.agents[0]!;
-	if (job.agents?.length) return formatWidgetAgents(job.agents);
-	return job.mode ?? "subagent";
-}
-
-export function widgetActivity(job: AsyncJobState): string {
-	const facts: string[] = [];
-	if (job.currentTool && job.currentToolStartedAt !== undefined && job.updatedAt !== undefined)
-		facts.push(`${job.currentTool} ${formatDuration(Math.max(0, job.updatedAt - job.currentToolStartedAt))}`);
-	else if (job.currentTool) facts.push(job.currentTool);
-	if (job.currentPath) facts.push(shortenPath(job.currentPath));
-	if (job.turnCount !== undefined) facts.push(`${job.turnCount} turns`);
-	if (job.toolCount !== undefined) facts.push(`${job.toolCount} tools`);
-	const activity = buildLiveStatusLine(job, job.updatedAt);
-	if (activity && facts.length) return `${activity} · ${facts.join(" · ")}`;
-	if (activity) return activity;
-	if (facts.length) return facts.join(" · ");
-	if (job.status === "running") return "thinking…";
-	if (job.status === "queued") return "queued…";
-	if (job.status === "paused") return "Paused";
-	if (job.status === "failed") return "Failed";
-	return "Done";
-}
-
-export function widgetStatusGlyph(job: AsyncJobState, theme: Theme, pulseFrame?: number): string {
-	if (job.status === "running") return theme.fg("accent", runningPulseGlyph(pulseFrame));
-	if (job.status === "queued") return theme.fg("muted", "◦");
-	if (job.status === "complete") return theme.fg("success", "✓");
-	if (job.status === "paused") return theme.fg("warning", "■");
-	return theme.fg("error", "✗");
-}
-
-export function widgetStepGlyph(status: AsyncJobStep["status"], theme: Theme, seed?: number, now?: number): string {
-	if (status === "running") return theme.fg("accent", runningGlyph(seed, now));
-	if (status === "complete" || status === "completed") return theme.fg("success", "✓");
-	if (status === "failed") return theme.fg("error", "✗");
-	if (status === "paused") return theme.fg("warning", "■");
-	return theme.fg("muted", "◦");
-}
-
-export function widgetStepPulseGlyph(status: AsyncJobStep["status"], theme: Theme, pulseFrame?: number): string {
-	if (status === "running") return theme.fg("accent", runningPulseGlyph(pulseFrame));
-	if (status === "complete" || status === "completed") return theme.fg("success", "✓");
-	if (status === "failed") return theme.fg("error", "✗");
-	if (status === "paused") return theme.fg("warning", "■");
-	return theme.fg("muted", "◦");
-}
-
-export function widgetStepStatus(status: AsyncJobStep["status"], theme: Theme): string {
-	if (status === "running") return theme.fg("accent", "running");
-	if (status === "complete" || status === "completed") return theme.fg("success", "complete");
-	if (status === "failed") return theme.fg("error", "failed");
-	if (status === "paused") return theme.fg("warning", "paused");
-	return theme.fg("dim", status);
-}
-
-export function widgetStepActivity(step: NonNullable<AsyncJobState["steps"]>[number], snapshotNow?: number): string {
-	const facts: string[] = [];
-	if (step.currentTool && step.currentToolStartedAt !== undefined && snapshotNow !== undefined)
-		facts.push(`${step.currentTool} ${formatDuration(Math.max(0, snapshotNow - step.currentToolStartedAt))}`);
-	else if (step.currentTool) facts.push(step.currentTool);
-	if (step.currentPath) facts.push(shortenPath(step.currentPath));
-	if (step.turnCount !== undefined) facts.push(`${step.turnCount} turns`);
-	if (step.toolCount !== undefined) facts.push(`${step.toolCount} tools`);
-	if (step.tokens?.total) facts.push(formatTokenStat(step.tokens.total));
-	const activity = buildLiveStatusLine(step, snapshotNow);
-	if (activity && facts.length) return `${activity} · ${facts.join(" · ")}`;
-	if (activity) return activity;
-	return facts.join(" · ");
-}
-
-export function widgetStats(job: AsyncJobState, theme: Theme): string {
-	const parts: string[] = [];
-	const stepsTotal = job.stepsTotal ?? job.agents?.length ?? 1;
-	if (job.activeParallelGroup) {
-		const running = job.runningSteps ?? (job.status === "running" ? 1 : 0);
-		const done = job.completedSteps ?? (job.status === "complete" ? stepsTotal : 0);
-		if (job.status === "running" && running > 0) parts.push(formatAgentRunningLabel(running));
-		if (stepsTotal > 0) parts.push(`${done}/${stepsTotal} done`);
-	} else if (stepsTotal > 1) {
-		parts.push(`steps ${stepsTotal}`);
-	}
-	if (job.toolCount !== undefined) parts.push(formatToolUseStat(job.toolCount));
-	if (job.totalTokens?.total) parts.push(formatTokenStat(job.totalTokens.total));
-	if (job.startedAt !== undefined && job.updatedAt !== undefined)
-		parts.push(formatDuration(Math.max(0, job.updatedAt - job.startedAt)));
-	return statJoin(theme, parts);
-}
-
-export function widgetStepStats(theme: Theme, step: NonNullable<AsyncJobState["steps"]>[number]): string {
-	return statJoin(theme, [
-		step.turnCount !== undefined ? `${step.turnCount} turns` : "",
-		step.toolCount !== undefined ? formatToolUseStat(step.toolCount) : "",
-		step.tokens?.total ? formatTokenStat(step.tokens.total) : "",
-		step.durationMs !== undefined ? formatDuration(step.durationMs) : "",
-	]);
-}
+import { formatModelThinking } from "../shared/formatters.ts";
+import type { Theme } from "./render-layout.ts";
 
 export function modelThinkingBadge(theme: Theme, model?: string, thinking?: string, fastMode?: boolean): string {
 	const label = formatModelThinking(model, thinking, fastMode);
 	return label ? theme.fg("dim", ` (${label})`) : "";
 }
-
-export function widgetStepActivityLine(
-	step: NonNullable<AsyncJobState["steps"]>[number],
-	width: number,
-	expanded: boolean,
-	snapshotNow?: number,
-): string {
-	const toolLine = formatCurrentToolLine(step, width, expanded, snapshotNow);
-	if (toolLine) return toolLine;
-	const activity = buildLiveStatusLine(step, snapshotNow);
-	if (activity) return activity;
-	if (step.status === "running") return "thinking…";
-	return "";
-}
-
-export function nestedRunName(run: NestedRunSummary): string {
-	if (run.agent) return run.agent;
-	if (run.agents?.length) return formatWidgetAgents(run.agents);
-	return run.id;
-}
-
-export function nestedStatusGlyph(
-	state: NestedRunSummary["state"] | NestedStepSummary["status"],
-	theme: Theme,
-	pulseFrame?: number,
-): string {
-	if (state === "running") return theme.fg("accent", runningPulseGlyph(pulseFrame));
-	if (state === "complete" || state === "completed") return theme.fg("success", "✓");
-	if (state === "failed") return theme.fg("error", "✗");
-	if (state === "paused") return theme.fg("warning", "■");
-	return theme.fg("muted", "◦");
-}
-
-export function nestedActivity(
-	input: Pick<
-		NestedRunSummary | NestedStepSummary,
-		| "activityState"
-		| "lastActivityAt"
-		| "currentTool"
-		| "currentToolStartedAt"
-		| "currentPath"
-		| "turnCount"
-		| "toolCount"
-	>,
-	state: NestedRunSummary["state"] | NestedStepSummary["status"],
-	snapshotNow?: number,
-): string {
-	const facts: string[] = [];
-	if (input.currentTool && input.currentToolStartedAt !== undefined && snapshotNow !== undefined)
-		facts.push(`${input.currentTool} ${formatDuration(Math.max(0, snapshotNow - input.currentToolStartedAt))}`);
-	else if (input.currentTool) facts.push(input.currentTool);
-	if (input.currentPath) facts.push(shortenPath(input.currentPath));
-	if (input.turnCount !== undefined) facts.push(`${input.turnCount} turns`);
-	if (input.toolCount !== undefined) facts.push(`${input.toolCount} tools`);
-	const activity = buildLiveStatusLine(input, snapshotNow);
-	if (activity && facts.length) return `${activity} · ${facts.join(" · ")}`;
-	if (activity) return activity;
-	if (facts.length) return facts.join(" · ");
-	if (state === "running") return "thinking…";
-	if (state === "queued" || state === "pending") return "queued…";
-	if (state === "paused") return "Paused";
-	if (state === "failed") return "Failed";
-	return "Done";
-}
-
-export function formatNestedWidgetLines(
-	children: NestedRunSummary[] | undefined,
-	theme: Theme,
-	width: number,
-	expanded: boolean,
-	snapshotNow?: number,
-	lineBudget = expanded ? 12 : 1,
-	now?: number,
-): string[] {
-	if (!children?.length || lineBudget <= 0) return [];
-	if (!expanded) {
-		const aggregate = formatNestedAggregate(children);
-		return aggregate ? [theme.fg("dim", `↳ ${aggregate}`)] : [];
-	}
-	const lines: string[] = [];
-	const maxDepth = MAX_SUBAGENT_NESTING_DEPTH;
-	const append = (items: NestedRunSummary[] | undefined, depth: number, prefix: string): void => {
-		if (!items?.length || lines.length >= lineBudget) return;
-		if (depth > maxDepth) {
-			const aggregate = formatNestedAggregate(items);
-			if (aggregate && lines.length < lineBudget) lines.push(theme.fg("dim", `${prefix}↳ ${aggregate}`));
-			return;
-		}
-		for (let index = 0; index < items.length; index++) {
-			const child = items[index]!;
-			if (lines.length >= lineBudget) {
-				const aggregate = formatNestedAggregate(items.slice(index));
-				if (aggregate) lines[lines.length - 1] = theme.fg("dim", `${prefix}↳ ${aggregate}`);
-				return;
-			}
-			const activity = nestedActivity(child, child.state, snapshotNow ?? child.lastUpdate);
-			const error = child.error ? ` · ${child.error}` : "";
-			lines.push(
-				theme.fg(
-					"dim",
-					`${prefix}↳ ${nestedStatusGlyph(child.state, theme, now)} ${nestedRunName(child)} · ${child.state} · ${activity}${error}`,
-				),
-			);
-			if (depth === maxDepth) {
-				const aggregate = formatNestedAggregate([
-					...(child.steps?.flatMap((step) => step.children ?? []) ?? []),
-					...(child.children ?? []),
-				]);
-				if (aggregate && lines.length < lineBudget) lines.push(theme.fg("dim", `${prefix}  ↳ ${aggregate}`));
-				continue;
-			}
-			for (const step of child.steps ?? []) {
-				if (lines.length >= lineBudget) return;
-				lines.push(
-					theme.fg(
-						"dim",
-						`${prefix}  ↳ ${nestedStatusGlyph(step.status, theme, now)} ${step.agent} · ${step.status} · ${nestedActivity(step, step.status, snapshotNow ?? child.lastUpdate)}`,
-					),
-				);
-				append(step.children, depth + 1, `${prefix}    `);
-			}
-			append(child.children, depth + 1, `${prefix}  `);
-		}
-	};
-	append(children, 0, "");
-	return lines.map((line) => truncLine(line, width));
-}

package/dist/builtin/subagents/src/tui/render-layout.ts

@@ -76,7 +76,7 @@ export const RUNNING_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦",
  * the clock. This fixes the frozen/stuttering spinner from issue #1084.
  *
  * IMPORTANT: a wall-clock spinner only stays flicker-free for widgets pinned to
- * the bottom of the buffer (e.g. the below-editor async widget), where every
+ * the bottom of the buffer (e.g. a below-editor widget), where every
  * tick stays inside the viewport. Content rendered into chat scrollback (live
  * foreground subagent results) can scroll above the viewport fold; there, even
  * a single-cell spinner diff forces pi-tui into a destructive full-screen +
@@ -135,9 +135,9 @@ export function pulseGlyph(frame?: number): string {
 }
 
 /**
- * Running async/background subagent pulse. It reuses the exact foreground pulse
- * glyph frames while accepting an explicit frame advanced by the widget only on
- * real async progress/status updates, matching foreground result semantics.
+ * Running subagent pulse. It reuses the exact foreground pulse glyph frames
+ * while accepting an explicit frame advanced by the renderer on real progress
+ * updates, matching foreground result semantics.
  */
 export function runningPulseGlyph(frame?: number): string {
 	return pulseGlyph(frame);

package/dist/builtin/subagents/src/tui/render-result.ts

@@ -69,15 +69,6 @@ export function renderSubagentResult(
 	theme: Theme,
 ): Component {
 	const d = result.details;
-	if (d?.asyncId && d.results.length === 0) {
-		const contextPrefix = d.context === "fork" ? `${theme.fg("warning", "[fork]")} ` : "";
-		const container = new Container();
-		container.addChild(new Text(`${contextPrefix}${theme.fg("success", "launched")} · async run ${d.asyncId}`, 0, 0));
-		container.addChild(
-			new Text(theme.fg("dim", "completion pending; the detached result will be delivered when it finishes"), 0, 0),
-		);
-		return container;
-	}
 	const liveMultiProgress = d?.mode === "parallel" && (d?.progress?.length ?? 0) > 0;
 	if (!d?.results.length && !liveMultiProgress) {
 		const t = result.content[0];

package/dist/builtin/subagents/src/tui/render-stable-output.ts

@@ -1,29 +1,5 @@
 import type { AgentToolResult } from "@earendil-works/pi-agent-core";
-import type { AgentProgress, AsyncJobState, Details } from "../shared/types.ts";
-
-export function widgetRenderKey(job: AsyncJobState): string {
-	return JSON.stringify({
-		asyncDir: job.asyncDir,
-		status: job.status,
-		activityState: job.activityState,
-		lastActivityAt: job.lastActivityAt,
-		currentTool: job.currentTool,
-		currentToolStartedAt: job.currentToolStartedAt,
-		currentPath: job.currentPath,
-		turnCount: job.turnCount,
-		toolCount: job.toolCount,
-		mode: job.mode,
-		agents: job.agents,
-		steps: job.steps,
-		nestedChildren: job.nestedChildren,
-		stepsTotal: job.stepsTotal,
-		runningSteps: job.runningSteps,
-		completedSteps: job.completedSteps,
-		startedAt: job.startedAt,
-		updatedAt: job.updatedAt,
-		totalTokens: job.totalTokens,
-	});
-}
+import type { AgentProgress, Details } from "../shared/types.ts";
 
 export function progressRenderKey(progress: Partial<AgentProgress> | undefined): string {
 	if (!progress) return "";
@@ -42,14 +18,6 @@ export function progressRenderKey(progress: Partial<AgentProgress> | undefined):
 	].join(":");
 }
 
-export function isRunningSubagentResult(result: AgentToolResult<Details>): boolean {
-	return (
-		result.details?.progress?.some((entry) => entry.status === "running") ||
-		result.details?.results.some((entry) => entry.progress?.status === "running") ||
-		false
-	);
-}
-
 export function subagentResultRenderKey(
 	result: AgentToolResult<Details>,
 	options: { expanded: boolean; isPartial: boolean },
@@ -75,7 +43,6 @@ export function subagentResultRenderKey(
 		options.isPartial ? "partial" : "final",
 		options.expanded ? "expanded" : "compact",
 		details.mode,
-		details.asyncId ?? "",
 		details.totalSteps ?? "",
 		progressRenderKey(details.progressSummary),
 		progressKeys.join("|"),

package/dist/builtin/subagents/src/tui/render.ts

@@ -21,5 +21,3 @@ export {
 	clearResultAnimationTimer,
 	stopResultAnimations,
 } from "./render-result-animation.ts";
-export { widgetRenderKey } from "./render-stable-output.ts";
-export { buildWidgetLines, renderWidget, stopWidgetAnimation } from "./render-widget.ts";

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

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/web-access",
-  "version": "0.9.13-alpha.2",
+  "version": "0.9.13-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": [

package/dist/builtin/workflows/CHANGELOG.md

@@ -6,6 +6,18 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 
 ## [Unreleased]
 
+## [0.9.13-alpha.3] - 2026-08-13
+
+### Changed
+
+- Workflow model fallback attempt metadata now includes per-attempt input/output tokens, cache reads/writes, provider-reported total cost, and meaningful assistant-turn counts when usage is available ([#2197](https://github.com/bastani-inc/atomic/issues/2197)).
+
+### Fixed
+
+- Corrected stale README claims that `workflow` tool `runId`/`stageId` targets and expanded-graph stage identifiers accept prefixes; run ids require the full 36-character UUID and stage ids/names match whole, matching `resolveRunId` and `stageMatchesExpandedIdentifier` behavior.
+- Fixed exact workflow inspection returning `Run not found` after process loss even when DBOS retained a stale running, resumable root. `workflow` status/stages/stage/transcript actions with an explicit full run id and `/workflow status <id>` now hydrate only that DBOS root on a local miss, reconstruct its authoritative checkpoint DAG as read-only state, report stale owners as `crashed` with explicit resume guidance, protect fresh foreign owners, distinguish absent/deleted/malformed records, and reject cyclic or nonreciprocal topology without claiming, transitioning, dispatching, or auto-resuming the run. Status without an id remains current-session-only.
+- Fixed long model turns losing their active stage session identity and root liveness when the process died between turn boundaries. Atomic now records stage start before the first session checkpoint, waits for that identity to persist before the first model use, and runs serialized, unref'd 30-second checkpoints for root and nested scoped stages. Heartbeats stop on every exit, refresh root metadata without status transitions, and surface persistent storage or MCP cleanup faults instead of dropping them in detached promise handlers. A checkpoint still in flight when the stage shuts down is drained rather than abandoned, so a late durability failure is never silently discarded, and a stage whose final durability checkpoint fails is recorded as failed instead of completed while its caller still receives the error and its concurrency slot is still released; explicit resume still replays completed effects exactly once.
+
 ## [0.9.13-alpha.2] - 2026-08-12
 
 ### Breaking Changes

package/dist/builtin/workflows/README.md

@@ -246,7 +246,7 @@ The child executes as a nested workflow behind a parent boundary stage named `wo
 
 For durable runs, Atomic writes and awaits a versioned boundary-start identity before child code can run. That record fixes the boundary id, child run id, owning root/parent, source order and parents, replay scope, alias, workflow, and a deterministic fingerprint of the child definition plus exact validated inputs across pause, process restart, cached replay, and completed inspection. Distinct-input parallel calls therefore keep their own cache even when restart reverses dispatch order; repeated identical calls share the fingerprint but retain a per-invocation ordinal. A completed child boundary and its `ctx.tool` side effects replay exactly once from the root's scoped checkpoints; only incomplete work continues.
 
-If no valid child graph can stand in for the boundary—including a failed or skipped boundary, a missing or empty child graph, stale or mismatched ownership metadata, or a recursive link that cannot produce a valid expansion—the expanded graph keeps the boundary summary instead of flattening an unrelated or invalid child. Exact expanded ids resolve first; a local id, prefix, or stage name is accepted only when it identifies one visible stage. Inputs are strictly validated against the child workflow before it starts: unknown keys, missing required values, type mismatches, and invalid `select` choices fail before the child body runs. The parent receives the child's declared `outputs` on `child.outputs` after those outputs pass their declared runtime type checks.
+If no valid child graph can stand in for the boundary—including a failed or skipped boundary, a missing or empty child graph, stale or mismatched ownership metadata, or a recursive link that cannot produce a valid expansion—the expanded graph keeps the boundary summary instead of flattening an unrelated or invalid child. Exact expanded ids resolve first; a local id or stage name is accepted only when it identifies one visible stage, and identifiers always match whole—a stage id is never truncated, so a prefix never selects a stage. Inputs are strictly validated against the child workflow before it starts: unknown keys, missing required values, type mismatches, and invalid `select` choices fail before the child body runs. The parent receives the child's declared `outputs` on `child.outputs` after those outputs pass their declared runtime type checks.
 
 For workflows intended to be called as children, declare an `outputs` entry for every non-default field a parent should rely on. `outputs` is only the schema/contract: use normal TypeScript in `run()` to gather values from any stage/task/child workflow and return those keys.
 
@@ -663,8 +663,8 @@ Raw stage-chat prompt answer replay is live-memory only. `StageSnapshot.promptAn
     "workflow": "string (optional) — workflow ID or normalized name",
     "inputs": "object (optional) — key/value map of workflow inputs",
     "action": "'run' | 'list' | 'get' | 'inputs' | 'models' | 'status' | 'stages' | 'stage' | 'transcript' | 'send' | 'pause' | 'interrupt' | 'quit' | 'resume' | 'reload'",
-    "runId": "optional run id or unique prefix; control actions default to the active run where safe; use '--all' or all:true for pause/interrupt/quit all",
-    "stageId": "optional stage id, prefix, or name for stage-scoped actions; cannot be combined with all:true",
+    "runId": "optional full 36-character run id; prefixes are rejected; control actions default to the active run where safe; use '--all' or all:true for pause/interrupt/quit all",
+    "stageId": "optional exact stage id or exact stage name for stage-scoped actions; prefixes and partial names are rejected; cannot be combined with all:true",
     "statusFilter": "optional filter for stages or the no-runId status run listing: pending/running/awaiting_input/paused/blocked/completed/failed/skipped/cancelled/killed/all; for the status listing, run statuses match directly and awaiting_input selects runs with a pending human prompt",
     "format": "optional agent-facing output format: text or json",
     "limit": "transcript-only explicit maximum number of recent entries; omitted with tail omitted uses the path-only default when sessionFile/transcriptPath exists",

package/dist/builtin/workflows/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/workflows",
-  "version": "0.9.13-alpha.2",
+  "version": "0.9.13-alpha.3",
   "private": true,
   "description": "Atomic extension for multi-stage workflow authoring and execution.",
   "contributors": [

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

@@ -44,6 +44,10 @@ export type DurableInactiveDeleteResult =
 	| { readonly ok: true }
 	| { readonly ok: false; readonly reason: "not_found" | "running" };
 
+export type DurableWorkflowHydrationResult =
+	| { readonly kind: "current"; readonly handle: DurableWorkflowHandle }
+	| { readonly kind: "absent" | "deleted" | "malformed" };
+
 /** DBOS is the sole persistent implementation. In-memory is a test seam and the non-durable last-resort fallback. */
 export interface DurableWorkflowBackend {
 	/** Whether state survives the current process. */
@@ -154,6 +158,8 @@ export interface DurableWorkflowBackend {
 
 	/** Hydrate one workflow from persistent storage. */
 	hydrateWorkflow(workflowId: string): Promise<void>;
+	/** Optional exact, read-only hydration classification for targeted inspection. */
+	hydrateWorkflowForInspection?(workflowId: string): Promise<DurableWorkflowHydrationResult>;
 	/** Hydrate all catalog candidates from persistent storage. */
 	hydrateResumableWorkflows(): Promise<void>;
 	promptReservationScope(workflowId: string): { readonly rootWorkflowId: string; readonly scope: string };
@@ -352,6 +358,11 @@ export class InMemoryDurableBackend implements DurableWorkflowBackend {
 	}
 
 	async hydrateWorkflow(_workflowId: string): Promise<void> {}
+	async hydrateWorkflowForInspection(workflowId: string): Promise<DurableWorkflowHydrationResult> {
+		const handle = this.getLoadableWorkflow(workflowId);
+		if (handle !== undefined) return { kind: "current", handle };
+		return { kind: this.deletedWorkflowIds.has(workflowId) ? "deleted" : "absent" };
+	}
 
 	async hydrateResumableWorkflows(): Promise<void> {}
 

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

@@ -1,10 +1,11 @@
 import type { RunSnapshot, StageSnapshot } from "../shared/store-types.js";
 import { boundaryTransitionError, resolveBoundaryLifecycle } from "./boundary-lifecycle.js";
-import type {
-	DurableCheckpoint,
-	DurableStageCheckpoint,
-	DurableStageRunTopology,
-	DurableToolCheckpoint,
+import {
+	DURABLE_TOOL_TOPOLOGY_VERSION,
+	type DurableCheckpoint,
+	type DurableStageCheckpoint,
+	type DurableStageRunTopology,
+	type DurableToolCheckpoint,
 } from "./types.js";
 import { parseLegacyWorkflowChildResult, parseWorkflowChildResult } from "./workflow-child-result.js";
 
@@ -28,7 +29,11 @@ export interface StageDraft {
 	readonly topology?: DurableStageCheckpoint["topology"];
 }
 
-export function validBoundaryRecordSet(checkpoints: readonly DurableCheckpoint[], strict: boolean): boolean {
+export function validBoundaryRecordSet(
+	checkpoints: readonly DurableCheckpoint[],
+	strict: boolean,
+	requireActiveFingerprint = false,
+): boolean {
 	const stages = checkpoints.filter((item): item is DurableStageCheckpoint => item.kind === "stage");
 	const boundaries = stages.filter((item) => item.topology?.boundary !== undefined);
 	const startsByReplay = new Map<string, DurableStageCheckpoint[]>();
@@ -47,27 +52,53 @@ export function validBoundaryRecordSet(checkpoints: readonly DurableCheckpoint[]
 		)
 	)
 		return false;
-	return [...startsByReplay.values()].every(
-		(starts) => boundaryTransitionError(starts[0]!, stages, strict) === undefined,
-	);
+	return [...startsByReplay.values()].every((starts) => {
+		const start = starts[0]!;
+		if (boundaryTransitionError(start, stages, strict) !== undefined) return false;
+		if (!requireActiveFingerprint || start.topology!.boundary!.invocationFingerprint !== undefined) return true;
+		return (
+			stages.some(
+				(stage) =>
+					stage.replayKey === start.replayKey &&
+					stage.topology?.boundary?.event === "terminal" &&
+					stage.topology.boundary.status === "completed",
+			) && boundaryTransitionError(start, stages, true) === undefined
+		);
+	});
 }
 
 export function validStageGroup(
 	drafts: readonly StageDraft[],
 	runId: string,
-	allowedNodeIds: ReadonlySet<string> = new Set(),
+	rootRunId: string,
+	tools: readonly DurableToolCheckpoint[] = [],
 ): boolean {
 	if (drafts.some((draft) => draft.topology!.stageId.length === 0)) return false;
-	const stageIds = new Set(drafts.map((draft) => draft.topology!.stageId));
-	if (stageIds.size !== drafts.length) return false;
-	const ids = new Set([...allowedNodeIds, ...stageIds]);
-	if (ids.size !== allowedNodeIds.size + stageIds.size) return false;
+	if (
+		tools.some(
+			(tool) =>
+				tool.topology !== undefined &&
+				(tool.topology.version !== DURABLE_TOOL_TOPOLOGY_VERSION || tool.topology.nodeId.length === 0),
+		)
+	)
+		return false;
+	const stageIds = drafts.map((draft) => draft.topology!.stageId);
+	const toolIds = tools.map((tool) => tool.topology?.nodeId ?? tool.checkpointId);
+	const ids = new Set([...stageIds, ...toolIds]);
+	if (ids.size !== stageIds.length + toolIds.length) return false;
 	const orders = drafts.flatMap((draft) =>
 		draft.topology!.sourceOrder === undefined ? [] : [draft.topology!.sourceOrder],
 	);
 	if (new Set(orders).size !== orders.length) return false;
-	if (drafts.some((draft) => draft.topology!.parentIds.some((parentId) => !ids.has(parentId)))) return false;
-	const runs = drafts.flatMap((draft) => (draft.topology?.run === undefined ? [] : [draft.topology.run]));
+	const parentEntries: ReadonlyArray<readonly [string, readonly string[]]> = [
+		...drafts.map((draft) => [draft.topology!.stageId, draft.topology!.parentIds] as const),
+		...tools.map((tool) => [tool.topology?.nodeId ?? tool.checkpointId, tool.topology?.parentIds ?? []] as const),
+	];
+	if (parentEntries.some(([, parentIds]) => parentIds.some((parentId) => !ids.has(parentId)))) return false;
+	const runs = [
+		...drafts.flatMap((draft) => (draft.topology?.run === undefined ? [] : [draft.topology.run])),
+		...tools.flatMap((tool) => (tool.topology?.run === undefined ? [] : [tool.topology.run])),
+	];
 	const first = runs[0];
 	if (
 		runs.some(
@@ -81,19 +112,26 @@ export function validStageGroup(
 		)
 	)
 		return false;
-	const parents = new Map(drafts.map((draft) => [draft.topology!.stageId, draft.topology!.parentIds]));
+	if (
+		runId === rootRunId &&
+		runs.some(
+			(run) => run.parentRunId !== undefined || run.parentStageId !== undefined || run.rootRunId !== undefined,
+		)
+	)
+		return false;
+	const parents = new Map(parentEntries);
 	const visiting = new Set<string>();
 	const visited = new Set<string>();
-	const cyclic = (stageId: string): boolean => {
-		if (visiting.has(stageId)) return true;
-		if (visited.has(stageId)) return false;
-		visiting.add(stageId);
-		if ((parents.get(stageId) ?? []).some(cyclic)) return true;
-		visiting.delete(stageId);
-		visited.add(stageId);
+	const cyclic = (nodeId: string): boolean => {
+		if (visiting.has(nodeId)) return true;
+		if (visited.has(nodeId)) return false;
+		visiting.add(nodeId);
+		if ((parents.get(nodeId) ?? []).some(cyclic)) return true;
+		visiting.delete(nodeId);
+		visited.add(nodeId);
 		return false;
 	};
-	return ![...stageIds].some(cyclic);
+	return ![...ids].some(cyclic);
 }
 
 export function compareDraftSourceOrder(left: StageDraft, right: StageDraft): number {