@bastani/atomic 0.9.11-alpha.9 → 0.9.11

package/dist/builtin/workflows/src/extension/lifecycle-notifications.ts

@@ -7,6 +7,7 @@ import {
 } from "../shared/returned-run-status.js";
 import { isTopLevelWorkflowRun } from "../shared/run-visibility.js";
 import type { Store } from "../shared/store.js";
+import { readGraphStoreSnapshot, subscribeStoreInvalidation } from "../shared/store-observation.js";
 import type {
 	PendingPrompt,
 	PromptKind,
@@ -175,7 +176,9 @@ export function installWorkflowLifecycleNotifications(options: WorkflowLifecycle
 	const notifyOn = new Set<WorkflowLifecycleNoticeKind>(options.config.notifyOn);
 	const state = options.state ?? createWorkflowLifecycleNotificationState();
 	let delivery!: ReturnType<typeof createLifecycleNoticeDelivery>;
-	if (options.seedExisting !== false) seedWorkflowLifecycleNotificationState(state, options.store.snapshot());
+	if (options.seedExisting !== false) {
+		seedWorkflowLifecycleNotificationState(state, readGraphStoreSnapshot(options.store));
+	}
 
 	const emit = (details: WorkflowLifecycleNoticeDetails): boolean | Promise<boolean> => {
 		try {
@@ -266,8 +269,8 @@ export function installWorkflowLifecycleNotifications(options: WorkflowLifecycle
 		if (notifyOn.has(details.kind)) delivery.deliver(key, details);
 	}
 
-	const unsubscribe = options.store.subscribe(inspect);
-	inspect(options.store.snapshot());
+	const unsubscribe = subscribeStoreInvalidation(options.store, () => inspect(readGraphStoreSnapshot(options.store)));
+	inspect(readGraphStoreSnapshot(options.store));
 	return () => {
 		unsubscribe();
 		delivery.dispose();

package/dist/builtin/workflows/src/extension/postmortem-deps.ts

@@ -22,6 +22,7 @@ import {
 import { stageControlRegistry } from "../runs/foreground/stage-control-registry.js";
 import type { StageAdapters } from "../runs/foreground/stage-runner.js";
 import { store } from "../shared/store.js";
+import { readGraphStoreSnapshot } from "../shared/store-observation.js";
 
 export interface PostMortemResolverDeps {
 	readonly adapters: StageAdapters;
@@ -33,7 +34,7 @@ function resolveStageCwd(runId: string): string | undefined {
 	try {
 		const backend = getDurableBackend();
 		const owningHandle = backend.getWorkflow(runId);
-		const run = store.snapshot().runs.find((candidate) => candidate.id === runId);
+		const run = readGraphStoreSnapshot(store).runs.find((candidate) => candidate.id === runId);
 		const rootRunId = run?.rootRunId ?? owningHandle?.rootWorkflowId;
 		const cwdHandle = rootRunId === undefined ? owningHandle : (backend.getWorkflow(rootRunId) ?? owningHandle);
 		return cwdHandle?.workflowCwd ?? cwdHandle?.invocationCwd ?? undefined;
@@ -61,7 +62,7 @@ export function createPostMortemHandleResolver(
 	deps: PostMortemResolverDeps,
 ): (runId: string, stageId: string) => EnsurePostMortemStageHandleResult | undefined {
 	return (runId, stageId) => {
-		const run = store.snapshot().runs.find((candidate) => candidate.id === runId);
+		const run = readGraphStoreSnapshot(store).runs.find((candidate) => candidate.id === runId);
 		const stage = run?.stages.find((candidate) => candidate.id === stageId);
 		if (stage === undefined) return undefined;
 		return ensurePostMortemStageHandle(runId, stage, postMortemDepsForRun(runId, deps));

package/dist/builtin/workflows/src/extension/render-result.ts

@@ -442,9 +442,7 @@ export function renderResult(result: WorkflowToolResult, opts?: RenderResultOpts
 			const r = result as StageListResult;
 			if (r.error) return renderNotice("WORKFLOW STAGES", `${r.runId || "(none)"}: ${r.error}`, opts, themed);
 			const counts = r.stages
-				.map(
-					(s) => `${s.name} (${s.id.slice(0, 12)}): ${s.status}${s.skippedReason ? ` — ${s.skippedReason}` : ""}`,
-				)
+				.map((s) => `${s.name} (${s.id}): ${s.status}${s.skippedReason ? ` — ${s.skippedReason}` : ""}`)
 				.join("; ");
 			return renderNotice("WORKFLOW STAGES", `${r.runId}: ${r.filter} — ${counts || "no stages"}`, opts, themed);
 		}
@@ -456,7 +454,7 @@ export function renderResult(result: WorkflowToolResult, opts?: RenderResultOpts
 			const extra = r.stage.error ? ` — ${r.stage.error}` : r.stage.result ? ` — ${r.stage.result}` : "";
 			return renderNotice(
 				"WORKFLOW STAGE",
-				`${r.runId}: ${r.stage.name} (${r.stage.id.slice(0, 12)}) ${r.stage.status}${extra}`,
+				`${r.runId}: ${r.stage.name} (${r.stage.id}) ${r.stage.status}${extra}`,
 				opts,
 				themed,
 			);
@@ -468,7 +466,7 @@ export function renderResult(result: WorkflowToolResult, opts?: RenderResultOpts
 			const suffix = r.truncated ? " (truncated)" : "";
 			return renderNotice(
 				"WORKFLOW TRANSCRIPT",
-				`${r.runId}/${r.stageId.slice(0, 12)} ${r.source}: ${text}${suffix}`,
+				`${r.runId}/${r.stageId} ${r.source}: ${text}${suffix}`,
 				opts,
 				themed,
 			);
@@ -476,12 +474,7 @@ export function renderResult(result: WorkflowToolResult, opts?: RenderResultOpts
 
 		case "send": {
 			const r = result as SendResult;
-			return renderNotice(
-				"WORKFLOW SEND",
-				`${r.runId}/${r.stageId.slice(0, 12)} ${r.delivery}: ${r.message}`,
-				opts,
-				themed,
-			);
+			return renderNotice("WORKFLOW SEND", `${r.runId}/${r.stageId} ${r.delivery}: ${r.message}`, opts, themed);
 		}
 
 		case "pause": {

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

@@ -25,17 +25,17 @@ import { discoverWorkflows } from "./discovery.js";
 
 export interface DurableResumeRuntime {
 	resumeDurableWorkflow(
-		workflowIdOrPrefix: string,
+		workflowId: string,
 		options?: { readonly policy?: WorkflowExecutionPolicy },
 	): Promise<ResumeDurableResult>;
 	listDurableResumable(): readonly ResumableWorkflowEntry[];
-	prepareDurableResumable(workflowIdOrPrefix?: string): Promise<readonly ResumableWorkflowEntry[]>;
+	prepareDurableResumable(workflowId?: string): Promise<readonly ResumableWorkflowEntry[]>;
 	prepareDurableCatalog?(): Promise<DurableWorkflowCatalogEntries>;
 	/** Hydrate a bounded set of known DBOS workflow ids. */
 	prepareDurableResumableForIds?(workflowIds: readonly string[]): Promise<readonly ResumableWorkflowEntry[]>;
 	prepareCompletedDurable?(): Promise<readonly ResumableWorkflowEntry[]>;
 	openCompletedDurableWorkflow?(
-		workflowIdOrPrefix: string,
+		workflowId: string,
 		catalog?: readonly ResumableWorkflowEntry[],
 	): OpenCompletedDurableResult;
 }
@@ -60,18 +60,18 @@ export function createDurableResumeRuntime(deps: DurableResumeRuntimeDeps): Dura
 		const ids = deps.store
 			.runs()
 			.map((run) => run.id)
-			.filter((id) => target === undefined || id === target || id.startsWith(target));
+			.filter((id) => target === undefined || id === target);
 		for (const id of ids) await backend.hydrateWorkflow(id);
 	};
 	let preparedCatalog: readonly ResumableWorkflowEntry[] = [];
 	return {
-		async resumeDurableWorkflow(workflowIdOrPrefix, options): Promise<ResumeDurableResult> {
+		async resumeDurableWorkflow(workflowId, options): Promise<ResumeDurableResult> {
 			await deps.ensureReady();
 			const backend = getDurableBackend();
 			if (preparedCatalog.length === 0) {
-				preparedCatalog = await prepareRuntimeDurableResumable(() => backend, workflowIdOrPrefix);
+				preparedCatalog = await prepareRuntimeDurableResumable(() => backend, workflowId);
 			}
-			const resolved = resolveCatalogEntry(workflowIdOrPrefix, preparedCatalog);
+			const resolved = resolveCatalogEntry(workflowId, preparedCatalog);
 			if (resolved !== undefined) await backend.hydrateWorkflow(resolved.workflowId);
 			const adapterDeps: ResumeDurableDeps = {
 				registry: deps.registry,
@@ -81,17 +81,17 @@ export function createDurableResumeRuntime(deps: DurableResumeRuntimeDeps): Dura
 					(await discoverWorkflows({ cwd: cwd ?? deps.runtimeCwd })).registry.get(name),
 				...(deps.jobs !== undefined ? { jobs: deps.jobs } : {}),
 			};
-			return await resumeDurableWorkflowAdapter(workflowIdOrPrefix, adapterDeps, preparedCatalog);
+			return await resumeDurableWorkflowAdapter(workflowId, adapterDeps, preparedCatalog);
 		},
 		listDurableResumable(): readonly ResumableWorkflowEntry[] {
 			return getDurableBackend().listResumableWorkflows();
 		},
-		async prepareDurableResumable(workflowIdOrPrefix) {
+		async prepareDurableResumable(workflowId) {
 			await deps.ensureReady();
 			const backend = getDurableBackend();
 			try {
-				await hydrateStoredWorkflowCandidates(backend, workflowIdOrPrefix);
-				preparedCatalog = await prepareRuntimeDurableResumable(() => backend, workflowIdOrPrefix);
+				await hydrateStoredWorkflowCandidates(backend, workflowId);
+				preparedCatalog = await prepareRuntimeDurableResumable(() => backend, workflowId);
 				return preparedCatalog;
 			} finally {
 				purgeSuppressedWorkflowRuns(backend, deps.store);
@@ -131,12 +131,12 @@ export function createDurableResumeRuntime(deps: DurableResumeRuntimeDeps): Dura
 				purgeSuppressedWorkflowRuns(backend, deps.store);
 			}
 		},
-		openCompletedDurableWorkflow(workflowIdOrPrefix, catalog) {
+		openCompletedDurableWorkflow(workflowId, catalog) {
 			const backend = getDurableBackend();
-			const entry = resolveCatalogEntry(workflowIdOrPrefix, catalog ?? []);
-			const handle = backend.getWorkflow(entry?.workflowId ?? workflowIdOrPrefix);
+			const entry = resolveCatalogEntry(workflowId, catalog ?? []);
+			const handle = backend.getWorkflow(entry?.workflowId ?? workflowId);
 			return openCompletedSnapshot(
-				workflowIdOrPrefix,
+				workflowId,
 				{
 					durableBackend: backend,
 					store: deps.store,
@@ -152,11 +152,8 @@ export function createDurableResumeRuntime(deps: DurableResumeRuntimeDeps): Dura
 }
 
 function resolveCatalogEntry(
-	workflowIdOrPrefix: string,
+	workflowId: string,
 	catalog: readonly ResumableWorkflowEntry[],
 ): ResumableWorkflowEntry | undefined {
-	const exact = catalog.find((entry) => entry.workflowId === workflowIdOrPrefix);
-	if (exact !== undefined) return exact;
-	const matches = catalog.filter((entry) => entry.workflowId.startsWith(workflowIdOrPrefix));
-	return matches.length === 1 ? matches[0] : undefined;
+	return catalog.find((entry) => entry.workflowId === workflowId);
 }

package/dist/builtin/workflows/src/extension/runtime.ts

@@ -172,11 +172,11 @@ export function createExtensionRuntime(opts: ExtensionRuntimeOpts = {}): Extensi
 	}
 
 	function matchesResumeStageIdentifier(stage: RunSnapshot["stages"][number], identifier: string): boolean {
-		return stage.id === identifier || stage.name === identifier || stage.id.startsWith(identifier);
+		return stage.id === identifier || stage.name === identifier;
 	}
 
 	function stageLabel(stage: RunSnapshot["stages"][number]): string {
-		return `${stage.name} (${stage.id.slice(0, 12)})`;
+		return `${stage.name} (${stage.id})`;
 	}
 
 	function resolveUniqueResumeStage(
@@ -261,7 +261,7 @@ export function createExtensionRuntime(opts: ExtensionRuntimeOpts = {}): Extensi
 			};
 		}
 		const stageMessage = (verb: string, runId: string): string =>
-			`${verb} workflow "${def.name}" from run ${source.id.slice(0, 8)} at stage ${resolvedStage.stageId.slice(0, 8)} (run ${runId.slice(0, 8)}).`;
+			`${verb} workflow "${def.name}" from run ${source.id} at stage ${resolvedStage.stageId} (run ${runId}).`;
 		const launchContinuation = () =>
 			launchDetachedUntilStartup(def, sourceInputs, {
 				...runOptions(options?.policy),

package/dist/builtin/workflows/src/extension/workflow-command-completions.ts

@@ -43,7 +43,7 @@ function workflowNameItems(runtime: ExtensionRuntime): PiArgumentCompletion[] {
 function runIdItems(): PiArgumentCompletion[] {
 	return topLevelWorkflowRuns(store.runs()).map((run) => ({
 		value: `${run.id} `,
-		label: run.id.slice(0, 8),
+		label: run.id,
 		description: `${run.name} — ${run.status}`,
 	}));
 }

package/dist/builtin/workflows/src/extension/workflow-command-registration.ts

@@ -35,7 +35,7 @@ import {
 import { workflowPolicyFromContext } from "./workflow-policy.js";
 import { normalizeWorkflowReloadReport, type WorkflowReloadReport } from "./workflow-reload-report.js";
 import { handleRunControlCommand, type WorkflowRunControlDeps } from "./workflow-run-control-command.js";
-import { overlaySurfaceFromContext, reloadFailureMessage, resolveRunIdPrefix } from "./workflow-targets.js";
+import { overlaySurfaceFromContext, reloadFailureMessage, resolveRunId } from "./workflow-targets.js";
 
 export interface WorkflowSlashCommandDeps {
 	runtimeProxy: ExtensionRuntime;
@@ -150,13 +150,9 @@ async function workflowSlashHandler(
 	if (subcommand === "status") {
 		const target = parts[1];
 		if (target && !target.startsWith("--")) {
-			const resolved = resolveRunIdPrefix(target);
+			const resolved = resolveRunId(target);
+			if (resolved.kind === "malformed") return fail(resolved.message);
 			if (resolved.kind === "not_found") return fail(`Run not found: ${target}`);
-			if (resolved.kind === "ambiguous") {
-				return fail(
-					`Ambiguous run prefix "${target}" matches: ${resolved.matches.map((id) => id.slice(0, 12)).join(", ")}`,
-				);
-			}
 			const inspected = inspectRun(resolved.runId);
 			if (!inspected.ok) return fail(`Run not found: ${target}`);
 			emitChatSurface(pi, { kind: "detail", detail: inspected.detail });

package/dist/builtin/workflows/src/extension/workflow-durable-resume-command.ts

@@ -2,10 +2,13 @@ import { listOpenableCompletedWorkflows } from "../durable/completed-catalog.js"
 import { openCompletedDurableWorkflow } from "../durable/completed-inspection.js";
 import { getDurableBackend } from "../durable/factory.js";
 import { formatResumableWorkflowList } from "../durable/resume-catalog.js";
+import { isWorkflowRunResumable } from "../durable/resume-eligibility.js";
 import { type DurableWorkflowDeleteOutcome, deleteDurableWorkflowIfSafe } from "../durable/retention-policy.js";
 import type { ResumableWorkflowEntry } from "../durable/types.js";
+import { isFullRunId, malformedRunIdMessage } from "../shared/run-id.js";
 import { store } from "../shared/store.js";
 import type { RunSnapshot } from "../shared/store-types.js";
+import { workflowRunResumeCandidate } from "../shared/workflow-artifacts.js";
 import type { GraphOverlayPort } from "../tui/overlay-adapter.js";
 import { openWorkflowResumeSelector } from "../tui/workflow-resume-selector.js";
 import type { ExtensionAPI, PiCommandContext } from "./public-types.js";
@@ -37,12 +40,12 @@ export interface WorkflowResumeTarget {
 
 export type WorkflowResumeTargetResolution =
 	| WorkflowResumeTarget
-	| { readonly kind: "ambiguous"; readonly matches: readonly WorkflowResumeTarget[] }
+	| { readonly kind: "malformed"; readonly message: string }
 	| { readonly kind: "not_found" };
 
 export async function prepareWorkflowResumeCatalog(
 	runtime: ExtensionRuntime,
-	activeLiveIds: ReadonlySet<string>,
+	suppressedLiveIds: ReadonlySet<string>,
 	target?: string,
 ): Promise<WorkflowResumeCatalog> {
 	const shared = await runtime.prepareDurableCatalog?.();
@@ -50,8 +53,11 @@ export async function prepareWorkflowResumeCatalog(
 	const backend = getDurableBackend();
 	const isDisplayLoadable = (entry: ResumableWorkflowEntry): boolean =>
 		shared !== undefined || backend.isWorkflowLoadable(entry.workflowId);
+	// The durable catalog is already produced by `listResumableWorkflows()`, which
+	// applies `isDurableWorkflowResumable`; re-filtering here would only drop rows
+	// a hydrating backend has not yet materialized.
 	const resumable = filterSelectorDurableEntries(runtime, prepared).filter(
-		(entry) => !activeLiveIds.has(entry.workflowId) && isDisplayLoadable(entry),
+		(entry) => !suppressedLiveIds.has(entry.workflowId) && isDisplayLoadable(entry),
 	);
 	const completed =
 		shared?.completed ??
@@ -60,7 +66,7 @@ export async function prepareWorkflowResumeCatalog(
 			: listOpenableCompletedWorkflows(backend));
 	return {
 		resumable,
-		completed: completed.filter((entry) => !activeLiveIds.has(entry.workflowId) && isDisplayLoadable(entry)),
+		completed: completed.filter((entry) => isDisplayLoadable(entry)),
 	};
 }
 
@@ -99,8 +105,8 @@ export async function handleDurableResume(
 			// directory a second time for the same command invocation.
 			catalog.completed,
 		);
-		if (resolved.kind === "ambiguous") {
-			fail(`Ambiguous workflow prefix "${target}" matches: ${formatMatches(resolved.matches)}`);
+		if (resolved.kind === "malformed") {
+			fail(resolved.message);
 			return true;
 		}
 		if (resolved.kind === "completed") {
@@ -191,21 +197,16 @@ export function resolveWorkflowResumeTarget(
 			name: run.name,
 		});
 	}
+	if (!isFullRunId(target)) return { kind: "malformed", message: malformedRunIdMessage(target) };
 	const exact = targets.get(target);
-	if (exact !== undefined) return exact;
-	const matches = [...targets.values()].filter((candidate) => candidate.workflowId.startsWith(target));
-	if (matches.length === 0) return { kind: "not_found" };
-	if (matches.length === 1) return matches[0]!;
-	return { kind: "ambiguous", matches };
+	return exact ?? { kind: "not_found" };
 }
 
 function isExplicitResumeCandidate(run: RunSnapshot): boolean {
-	if (run.status === "completed" || run.status === "paused" || run.exitReason === "quit") return true;
-	if (run.stages.some((stage) => stage.status === "paused")) return true;
-	if (run.status === "failed") return run.resumable !== false;
-	if (run.endedAt !== undefined) return false;
-	if (run.status === "running") return true;
-	return run.resumable === true && run.failureRecoverability === "recoverable";
+	if (run.status === "completed") return true;
+	return (
+		isWorkflowRunResumable(workflowRunResumeCandidate(run)) || (run.endedAt === undefined && run.status === "running")
+	);
 }
 
 async function resumeDurableTarget(
@@ -247,14 +248,14 @@ function openCompletedTarget(
 
 function openCompleted(
 	runtime: ExtensionRuntime,
-	workflowIdOrPrefix: string,
+	workflowId: string,
 	catalog: readonly ResumableWorkflowEntry[],
 	beforeRestoreCompleted?: (snapshots: readonly RunSnapshot[]) => void,
 ) {
 	return (
-		runtime.openCompletedDurableWorkflow?.(workflowIdOrPrefix, catalog) ??
+		runtime.openCompletedDurableWorkflow?.(workflowId, catalog) ??
 		openCompletedDurableWorkflow(
-			workflowIdOrPrefix,
+			workflowId,
 			{
 				durableBackend: getDurableBackend(),
 				store,
@@ -264,7 +265,3 @@ function openCompleted(
 		)
 	);
 }
-
-function formatMatches(entries: readonly WorkflowResumeTarget[]): string {
-	return entries.map((entry) => `${entry.name} (${entry.workflowId.slice(0, 8)})`).join(", ");
-}

package/dist/builtin/workflows/src/extension/workflow-resume-picker-rows.ts

@@ -9,51 +9,63 @@
  */
 
 import { getDurableBackend } from "../durable/factory.js";
+import { isWorkflowRunResumable } from "../durable/resume-eligibility.js";
 import type { ResumableWorkflowEntry } from "../durable/types.js";
 import { topLevelWorkflowRuns } from "../shared/run-visibility.js";
 import type { Store } from "../shared/store.js";
+import { subscribeStoreInvalidation } from "../shared/store-observation.js";
 import type { RunSnapshot } from "../shared/store-types.js";
+import { workflowRunResumeCandidate } from "../shared/workflow-artifacts.js";
 import type { WorkflowResumeRefresh } from "../tui/workflow-resume-selector.js";
 import type { ExtensionRuntime } from "./runtime.js";
 import { prepareWorkflowResumeCatalog } from "./workflow-durable-resume-command.js";
-import { reconcileDurableResumeShadow } from "./workflow-resume-shadow.js";
+import { classifyDurableResumeShadow } from "./workflow-resume-shadow.js";
 
 export interface ResumePickerLiveSource {
 	readonly liveRuns: readonly RunSnapshot[];
-	readonly activeLiveIds: ReadonlySet<string>;
+	/** Live ids whose resumable durable duplicates must be suppressed. */
+	readonly suppressedLiveIds: ReadonlySet<string>;
 }
 
-function isActiveRecoverableBlock(run: RunSnapshot): boolean {
-	return run.endedAt === undefined && run.resumable === true && run.failureRecoverability === "recoverable";
+/** A live run is resumable when the shared predicate accepts it and the durable
+ * backend has not explicitly deleted it. A live paused/quit run resumes through
+ * its live stage controls, so it must NOT require a durable checkpoint here;
+ * a restored snapshot that depends on durable state is filtered by its shadow
+ * classification instead.
+ */
+function isResumableLiveRun(run: RunSnapshot): boolean {
+	if (!getDurableBackend().isWorkflowLoadable(run.id)) return false;
+	return isWorkflowRunResumable(workflowRunResumeCandidate(run));
 }
 
 export function collectResumePickerLiveRuns(runStore: Store): ResumePickerLiveSource {
-	const durableResumeShadows = new Set(
-		topLevelWorkflowRuns(runStore.runs())
-			.filter((run) => reconcileDurableResumeShadow(run, runStore))
-			.map((run) => run.id),
-	);
-	const liveRuns = topLevelWorkflowRuns(runStore.runs()).filter(
-		(run) =>
-			!durableResumeShadows.has(run.id) &&
-			(run.status === "paused" ||
-				(run.status === "failed" && run.resumable !== false) ||
-				isActiveRecoverableBlock(run)) &&
-			getDurableBackend().isWorkflowLoadable(run.id),
-	);
+	// `eligible` rows are re-listed from the durable catalog, and `ineligible`
+	// rows have no durable checkpoint or pending prompt progress, so the resume
+	// path would refuse them. Only `not_shadow` runs can actually be resumed here.
+	const runs = topLevelWorkflowRuns(runStore.runs());
+	const shadowClassification = new Map(runs.map((run) => [run.id, classifyDurableResumeShadow(run, runStore)]));
+	const isOfferable = (run: RunSnapshot): boolean => shadowClassification.get(run.id) === "not_shadow";
+	const resumableById = new Map(runs.map((run) => [run.id, isResumableLiveRun(run)]));
+	const liveRuns = runs.filter((run) => isOfferable(run) && resumableById.get(run.id) === true);
+	const isCurrentlyRunning = (run: RunSnapshot): boolean =>
+		run.endedAt === undefined && run.status === "running" && run.exitReason !== "quit";
 	const activeLiveIds = new Set(
-		topLevelWorkflowRuns(runStore.runs())
+		runs
 			.filter(
 				(run) =>
-					!durableResumeShadows.has(run.id) &&
-					run.endedAt === undefined &&
-					run.status === "running" &&
-					!isActiveRecoverableBlock(run) &&
-					run.exitReason !== "quit",
+					shadowClassification.get(run.id) !== "eligible" &&
+					isCurrentlyRunning(run) &&
+					resumableById.get(run.id) !== true,
 			)
 			.map((run) => run.id),
 	);
-	return { liveRuns, activeLiveIds };
+	// A non-running snapshot rejected by the shared predicate must not reappear as
+	// a resumable durable row. Completed inspection rows remain visible separately.
+	const rejectedLiveIds = new Set(
+		runs.filter((run) => !isCurrentlyRunning(run) && resumableById.get(run.id) !== true).map((run) => run.id),
+	);
+	const suppressedLiveIds = new Set([...activeLiveIds, ...rejectedLiveIds]);
+	return { liveRuns, suppressedLiveIds };
 }
 
 export interface ResumePickerLiveUpdateOptions {
@@ -66,10 +78,10 @@ export function resumePickerLiveUpdateOptions(
 	runtime: ExtensionRuntime,
 ): ResumePickerLiveUpdateOptions {
 	return {
-		watch: (onChange) => runStore.subscribe(() => onChange()),
+		watch: (onChange) => subscribeStoreInvalidation(runStore, onChange),
 		refresh: async () => {
 			const current = collectResumePickerLiveRuns(runStore);
-			const catalog = await prepareWorkflowResumeCatalog(runtime, current.activeLiveIds);
+			const catalog = await prepareWorkflowResumeCatalog(runtime, current.suppressedLiveIds);
 			return {
 				liveRuns: current.liveRuns,
 				catalog: { durable: catalog.resumable, completed: catalog.completed },

package/dist/builtin/workflows/src/extension/workflow-resume-shadow.ts

@@ -5,6 +5,7 @@ import { getLoadableDurableWorkflow } from "../durable/workflow-status-transitio
 import { type JobTracker, jobTracker } from "../runs/background/job-tracker.js";
 import { type StageControlRegistry, stageControlRegistry } from "../runs/foreground/stage-control-registry.js";
 import { expandWorkflowGraph } from "../shared/expanded-workflow-graph.js";
+import { readGraphStoreSnapshot } from "../shared/store-observation.js";
 import type { Store } from "../shared/store-public-types.js";
 import type { RunSnapshot } from "../shared/store-types.js";
 
@@ -28,7 +29,7 @@ export function classifyDurableResumeShadow(
 	const jobs = deps.jobs ?? jobTracker;
 	if (jobs.has(run.id)) return "not_shadow";
 	const controls = deps.stageControls ?? stageControlRegistry;
-	const graph = expandWorkflowGraph(store.snapshot(), run.id);
+	const graph = expandWorkflowGraph(readGraphStoreSnapshot(store), run.id);
 	const controlRunIds = new Set<string>([run.id]);
 	for (const stage of graph.stages) controlRunIds.add(stage.workflowGraphTarget.runId);
 	if ([...controlRunIds].some((runId) => controls.run(runId).stages().length > 0)) return "not_shadow";