@bastani/atomic 0.9.11-alpha.9 → 0.9.12-alpha.1

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-prompts.ts

@@ -4,6 +4,7 @@ export const WORKFLOW_TOOL_DESCRIPTION =
 	"discover with list/get/inputs/models, list session runs with status (no runId; statusFilter narrows the list), inspect status/stages/stage details, " +
 	"send prompt answers or steering only while the root workflow is nonterminal, pause/resume/interrupt/quit runs, and reload workflow resources. " +
 	"For large stage handoffs, write context to files/artifacts, pass paths via reads, and prompt downstream agents to 'Read the file at <path>...' instead of injecting large previous text. " +
+	"Wrap critical parts of run inputs and steering messages in <keepContext>...</keepContext> so compaction preserves them verbatim in the stages that inherit them; tag role constraints, prohibitions, must-hold criteria, and identifiers, not background or bulk reference material. " +
 	"For transcripts, prefer status/stages/stage to get sessionFile/transcriptPath, " +
 	"quote the exact path without rewriting separators (Windows backslashes are valid), " +
 	"then search it with rg/grep and read small ranges; transcript is path-only by default when sessionFile/transcriptPath exists, explicit tail/limit returns bounded previews, and missing transcript paths fall back to a small preview. " +
@@ -37,6 +38,8 @@ export const DEFAULT_PROMPT_GUIDANCE: string[] = [
   - Only skip workflows for tiny, deterministic, low-risk answers or direct edits where stage tracking clearly costs more than it adds, typically a single-file/no-test/no-review change or a simple answer.`,
 	`**Workflow discovery and lifecycle**:
   - For unfamiliar named workflows, discover with \`action: "list"\`, inspect with \`action: "get"\` or \`action: "inputs"\`, and run with \`action: "run"\`, \`workflow\`, and validated \`inputs\`; do not invent workflow names or input keys.
+  - Wrap critical parts of the \`inputs\` you pass — objective, prompt, acceptance criteria — in \`<keepContext>\` / \`</keepContext>\`. Tagged text survives compaction verbatim regardless of the compression ratio, and stages inherit it because workflows inject your inputs into their prompts. A long stage is compacted repeatedly, and compaction ranks lines individually: a verbose restated objective outlives the one line that bounds it, so a stage can end up executing a coherent but unbounded version of what you asked for. Decide this per launch rather than tagging everything — tag role constraints, prohibitions, must-hold criteria, and identifiers such as a target branch, worktree path, or issue number; leave background, quoted issue text, and reference material untagged and pass bulk through files and \`reads\`. Protected lines count against the keep target rather than raising it, so an over-tagged input makes the evidence stages need compress harder.
+  - Tag steering the same way. A \`send\` amendment is authoritative and stages must carry it forward, but it arrives late in an already-long session and is exactly one short message competing with the whole transcript; \`<keepContext>\` around the requirement keeps it from being compacted away before the stage acts on it.
   - In interactive chat, named workflow launches run in the background. Run \`/workflow connect <run>\` to see agents working and chat with and steer each stage. Inspection and control calls (\`status\`, \`stages\`, \`stage\`, \`transcript\`, \`send\`, \`pause\`, \`resume\`, \`interrupt\`, \`quit\`) remain available while work runs.
   - \`workflow send\` is nonterminal-only: once the authoritative root run has completed, failed, skipped, been cancelled or killed, or ended terminal-blocked, start a new workflow if tracked work remains. Proceed inline only when the remaining task is small, deterministic, and low risk. Use explicit \`/workflow attach <run> <stage>\` for user-driven post-mortem chat; it does not resume or modify workflow execution.
   - Natural-language instructions to create or use a worktree do not enable runner isolation. A named workflow must declare and implement any worktree and feature-branch inputs it supports; inspect its inputs and pass a distinct path and branch for each concurrent item. Reusable \`baseBranch\` binding creates a missing target as a detached checkout from that base or reuses an existing same-repository worktree as-is; neither case checks out a separate feature-branch input.
@@ -55,6 +58,7 @@ export const DEFAULT_PROMPT_GUIDANCE: string[] = [
   - Every workflow invocation automatically receives one stable, non-default Intercom group. Intercom-capable stages inherit it, nested workflows keep the top-level invocation group, and subagents inherit their launching stage's group. Do not mint or thread group names through ordinary workflow definitions. Use an explicit \`group\` only for an intentional override: a named group or \`group: true\` creates a subgroup, while \`group: "default"\` opts into the shared default group. Stages without Intercom access receive no group, and \`contact_supervisor\` still crosses group boundaries for authorized escalation.
   - Prefer \`ctx.tool(name, args, fn)\` for workflow-owned TypeScript operations with side effects, such as filesystem writes, network mutations, and external API actions. It creates a tracked, non-attachable durable graph node before invoking \`fn\`; it may be used before, between, after, or without model stages. A completed \`ctx.tool\` call is durably checkpointed with its serializable result, so resume replays that result without rerunning \`fn\`. For checks that may fail during a bounded repair loop, opt into \`failureMode: "return"\`, branch on the typed outcome, and pass only the needed error fields to the repair stage or artifact yourself; Atomic does not inject failure evidence into later prompts. Cancellation and storage faults still throw. Keep pure computation and side-effect-free transformations as ordinary TypeScript. Do not wrap agent-stage internals or every function call indiscriminately; this rule applies to side effects orchestrated directly by the workflow definition.
   - Pass large stage context through files/artifacts and \`reads\` with an explicit \`Read the file at <path>...\` prompt rather than large \`previous\` payloads or injected session history.
+  - Wrap critical stage-prompt content in \`<keepContext>\` / \`</keepContext>\`. Tagged content survives compression verbatim regardless of the compression ratio, and every line of the span including the tag lines is protected. A long-running stage will be compacted, and compaction ranks lines individually: an objective is verbose and restated while the constraint that narrows it is usually one line, so the constraint is the cheaper deletion and what survives reads as broader permission than intended. Tag role constraints that bound a stage to part of the work, acceptance criteria and immutable contracts, explicit prohibitions, and identifiers a stage must not lose such as a target branch, worktree path, or run ID. Do not tag bulk context: protected lines count against the keep target rather than raising it, so a large protected span makes the surrounding transcript compress harder — tag the constraint, not the material it applies to.
   - Separate implementation/review acceptance from explicitly authorized final actions such as PR/MR/review creation, release tagging, deployment, or publication. Stop implementation loops once acceptance is proven and carry a remaining final action separately.
   - A model stage sees its local prompt, artifacts, tools, and reads, not the graph name or surrounding implementation. State the concrete action, evidence, and success criteria directly.`,
 ];

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";