@bastani/atomic 0.9.11-alpha.9 → 0.9.11

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

@@ -26,6 +26,7 @@ import {
 } from "../runs/foreground/executor-child-helpers.js";
 import { resolveAndValidateInputs } from "../runs/foreground/executor-inputs.js";
 import type { RunOpts } from "../runs/foreground/executor-types.js";
+import { isFullRunId, malformedRunIdMessage } from "../shared/run-id.js";
 import type { RunSnapshot } from "../shared/store-types.js";
 import type { WorkflowDefinition, WorkflowInputValues } from "../shared/types.js";
 import type { WorkflowRegistry } from "../workflows/registry.js";
@@ -63,7 +64,7 @@ export interface ResumeDurableDeps {
 
 /** Hydrate current DBOS metadata and checkpoints before synchronous replay reads. */
 export async function prepareDurableResume(
-	workflowIdOrPrefix: string | undefined,
+	workflowId: string | undefined,
 	deps: ResumeDurableDeps,
 ): Promise<readonly ResumableWorkflowEntry[]> {
 	const backend = deps.durableBackend ?? getDurableBackend();
@@ -71,8 +72,8 @@ export async function prepareDurableResume(
 	const catalog = backend.listResumableWorkflows();
 	// If a specific target was requested, hydrate that workflow too (it might
 	// be resumable but not yet in the resumable filter — e.g. recently failed).
-	if (workflowIdOrPrefix !== undefined) {
-		const resolved = resolveDurableEntry(workflowIdOrPrefix, catalog);
+	if (workflowId !== undefined) {
+		const resolved = resolveDurableEntry(workflowId, catalog);
 		if (resolved !== undefined && !("kind" in resolved)) {
 			await backend.hydrateWorkflow(resolved.workflowId);
 		}
@@ -80,30 +81,32 @@ export async function prepareDurableResume(
 	return backend.listResumableWorkflows();
 }
 
-/** Resolve a current DBOS catalog entry by full id or unique prefix. */
+/**
+ * Resolve a current DBOS catalog entry by its full run id.
+ *
+ * The durable `workflowId` is the live run id, so it takes the same strict
+ * contract: a full UUID or nothing. A malformed target is reported separately
+ * from an absent one.
+ */
 export function resolveDurableEntry(
-	workflowIdOrPrefix: string,
+	workflowId: string,
 	catalog: readonly ResumableWorkflowEntry[],
-): ResumableWorkflowEntry | { kind: "ambiguous"; matches: readonly ResumableWorkflowEntry[] } | undefined {
-	const exact = catalog.find((entry) => entry.workflowId === workflowIdOrPrefix);
-	if (exact !== undefined) return exact;
-	const prefixMatches = catalog.filter((entry) => entry.workflowId.startsWith(workflowIdOrPrefix));
-	if (prefixMatches.length === 0) return undefined;
-	if (prefixMatches.length === 1) return prefixMatches[0];
-	return { kind: "ambiguous", matches: prefixMatches };
+): ResumableWorkflowEntry | { kind: "malformed"; message: string } | undefined {
+	if (!isFullRunId(workflowId)) return { kind: "malformed", message: malformedRunIdMessage(workflowId) };
+	return catalog.find((entry) => entry.workflowId === workflowId);
 }
 
 /** Resume by DBOS workflow id and replay current persisted checkpoints. */
 export async function resumeDurableWorkflow(
-	workflowIdOrPrefix: string,
+	workflowId: string,
 	deps: ResumeDurableDeps,
 	catalog?: readonly ResumableWorkflowEntry[],
 ): Promise<ResumeDurableResult> {
 	const backend = deps.durableBackend ?? getDurableBackend();
 	const resolvedCatalog = catalog ?? backend.listResumableWorkflows();
-	const resolved = resolveDurableEntry(workflowIdOrPrefix, resolvedCatalog);
+	const resolved = resolveDurableEntry(workflowId, resolvedCatalog);
 	if (resolved === undefined) {
-		const direct = backend.getWorkflow(workflowIdOrPrefix);
+		const direct = backend.getWorkflow(workflowId);
 		if (direct !== undefined && direct.status === "running") {
 			if (hasActiveLiveRun(deps.baseRunOpts.store, direct.workflowId)) {
 				return alreadyRunningResult(direct.name, direct.workflowId, deps.baseRunOpts.store);
@@ -112,31 +115,27 @@ export async function resumeDurableWorkflow(
 				return foreignRunningResult(direct.name, direct.workflowId);
 			}
 		}
-		if (!backend.isWorkflowLoadable(workflowIdOrPrefix)) {
+		if (!backend.isWorkflowLoadable(workflowId)) {
 			return {
 				ok: false,
 				reason: "not_registered",
-				message: `Workflow ${workflowIdOrPrefix.slice(0, 8)} has no valid current DBOS state.`,
+				message: `Workflow ${workflowId} has no valid current DBOS state.`,
 			};
 		}
 		return {
 			ok: false,
 			reason: "not_registered",
-			message: `No resumable workflow found for id/prefix: ${workflowIdOrPrefix}`,
+			message: `No resumable workflow found for id: ${workflowId}`,
 		};
 	}
 	if ("kind" in resolved) {
-		return {
-			ok: false,
-			reason: "not_registered",
-			message: `Ambiguous workflow prefix "${workflowIdOrPrefix}" matches: ${resolved.matches.map((m) => `${m.name} (${m.workflowId.slice(0, 8)})`).join(", ")}`,
-		};
+		return { ok: false, reason: "not_registered", message: resolved.message };
 	}
 	if (!backend.isWorkflowLoadable(resolved.workflowId)) {
 		return {
 			ok: false,
 			reason: "not_registered",
-			message: `Workflow ${resolved.workflowId.slice(0, 8)} has no valid current DBOS state.`,
+			message: `Workflow ${resolved.workflowId} has no valid current DBOS state.`,
 		};
 	}
 	// Revalidate the authoritative DBOS handle before resume. A running handle
@@ -147,7 +146,7 @@ export async function resumeDurableWorkflow(
 		return {
 			ok: false,
 			reason: "stale",
-			message: `Workflow ${resolved.workflowId.slice(0, 8)} has no current DBOS checkpoint state; re-run the workflow to start fresh.`,
+			message: `Workflow ${resolved.workflowId} has no current DBOS checkpoint state; re-run the workflow to start fresh.`,
 		};
 	}
 
@@ -163,7 +162,7 @@ export async function resumeDurableWorkflow(
 		return {
 			ok: false,
 			reason: "not_resumable",
-			message: `Workflow ${resolved.workflowId.slice(0, 8)} is ${handle.status}, not resumable.`,
+			message: `Workflow ${resolved.workflowId} is ${handle.status}, not resumable.`,
 		};
 	}
 
@@ -200,7 +199,7 @@ export async function resumeDurableWorkflow(
 		return {
 			ok: false,
 			reason: "stale",
-			message: `Workflow ${resolved.workflowId.slice(0, 8)} changed while resume was pending; refresh the workflow list and try again.`,
+			message: `Workflow ${resolved.workflowId} changed while resume was pending; refresh the workflow list and try again.`,
 		};
 	}
 
@@ -223,7 +222,7 @@ export async function resumeDurableWorkflow(
 		return {
 			ok: false,
 			reason: "startup_failed",
-			message: `Failed to resume durable workflow ${resolved.workflowId.slice(0, 8)}: ${error instanceof Error ? error.message : String(error)}`,
+			message: `Failed to resume durable workflow ${resolved.workflowId}: ${error instanceof Error ? error.message : String(error)}`,
 		};
 	}
 	const { accepted } = launch;
@@ -233,7 +232,7 @@ export async function resumeDurableWorkflow(
 		const error = workflowStartupFailureMessage(
 			admission,
 			snapshot?.error,
-			`Workflow ${resolved.workflowId.slice(0, 8)} ended before startup admission`,
+			`Workflow ${resolved.workflowId} ended before startup admission`,
 		);
 		deps.baseRunOpts.store?.removeRun(accepted.runId);
 		backend.setWorkflowStatus(resolved.workflowId, handle.status, handle.pendingPrompts, handle.resumable);
@@ -241,7 +240,7 @@ export async function resumeDurableWorkflow(
 		return {
 			ok: false,
 			reason: "startup_failed",
-			message: `Failed to resume durable workflow ${resolved.workflowId.slice(0, 8)}: ${error}`,
+			message: `Failed to resume durable workflow ${resolved.workflowId}: ${error}`,
 		};
 	}
 
@@ -250,7 +249,7 @@ export async function resumeDurableWorkflow(
 		runId: accepted.runId,
 		workflowId: resolved.workflowId,
 		name: handle.name,
-		message: `Resuming durable workflow "${handle.name}" (${resolved.workflowId.slice(0, 8)}) — completed checkpoints will be replayed.`,
+		message: `Resuming durable workflow "${handle.name}" (${resolved.workflowId}) — completed checkpoints will be replayed.`,
 	};
 }
 
@@ -271,7 +270,7 @@ function foreignRunningResult(name: string, workflowId: string): ResumeDurableRe
 		ok: false,
 		reason: "not_resumable",
 		message:
-			`Workflow "${name}" (${workflowId.slice(0, 8)}) is actively running in another Atomic session. ` +
+			`Workflow "${name}" (${workflowId}) is actively running in another Atomic session. ` +
 			"Control it from that session; it becomes resumable here only after that session pauses, quits, or crashes.",
 	};
 }
@@ -281,9 +280,9 @@ function alreadyRunningResult(name: string, workflowId: string, store: RunOpts["
 	return {
 		ok: false,
 		reason: "not_resumable",
-		message: `Workflow "${name}" (${workflowId.slice(0, 8)}) is already running${
+		message: `Workflow "${name}" (${workflowId}) is already running${
 			here ? " in this session" : " in another session"
-		}. See agents working and chat with or steer each stage using \`/workflow connect ${workflowId.slice(0, 8)}\`; use \`/workflow quit ${workflowId.slice(0, 8)}\` to pause the run for later resume.`,
+		}. See agents working and chat with or steer each stage using \`/workflow connect ${workflowId}\`; use \`/workflow quit ${workflowId}\` to pause the run for later resume.`,
 	};
 }
 
@@ -332,12 +331,12 @@ export async function prepareTargetedDurableResumable(
 
 export async function prepareRuntimeDurableResumable(
 	getBackend: () => DurableWorkflowBackend,
-	workflowIdOrPrefix?: string,
+	workflowId?: string,
 ): Promise<readonly ResumableWorkflowEntry[]> {
 	const backend = getBackend();
 	await backend.hydrateResumableWorkflows();
-	if (workflowIdOrPrefix !== undefined) {
-		const resolved = resolveDurableEntry(workflowIdOrPrefix, backend.listResumableWorkflows());
+	if (workflowId !== undefined) {
+		const resolved = resolveDurableEntry(workflowId, backend.listResumableWorkflows());
 		if (resolved !== undefined && !("kind" in resolved)) await backend.hydrateWorkflow(resolved.workflowId);
 	}
 	return backend.listResumableWorkflows();

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

@@ -16,6 +16,7 @@
  */
 
 import { runCallback } from "@bastani/atomic";
+import { flattenTruncatedString } from "../shared/flat-string.js";
 import type { ToolNodeSnapshot } from "../shared/store-types.js";
 import type {
 	WorkflowSerializableValue,
@@ -609,10 +610,17 @@ async function recordReplayedToolTopology(
 	});
 	input.throwIfCancelled();
 }
+/**
+ * Summaries are written into durable checkpoints and read back by status and
+ * graph inspection, so they outlive the value they came from. Flatten the
+ * truncation: a bare `slice` leaves a SlicedString pointing at the whole
+ * serialized payload, and the 240-character bound would cap what you can read
+ * without capping what is retained.
+ */
 function summarizeToolResult(value: WorkflowSerializableValue): string {
 	const serialized = JSON.stringify(value);
-	if (serialized === undefined) return String(value).slice(0, 240);
-	return serialized.length <= 240 ? serialized : `${serialized.slice(0, 237)}...`;
+	if (serialized === undefined) return flattenTruncatedString(String(value).slice(0, 240));
+	return serialized.length <= 240 ? serialized : `${flattenTruncatedString(serialized.slice(0, 237))}...`;
 }
 
 export async function recordCheckpointDurably(

package/dist/builtin/workflows/src/engine/run.ts

@@ -495,6 +495,7 @@ export async function run<TInputs extends WorkflowInputValues, TRunInputs extend
 	});
 	const ctx: WorkflowRunContext<TInputs> = {
 		inputs: resolvedInputs as TInputs,
+		runId,
 		get cwd() {
 			return resolveWorkflowCwd();
 		},

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

@@ -3,6 +3,7 @@ import type { StageAdapters } from "../runs/foreground/stage-runner.js";
 import type { SessionManager } from "../shared/persistence-restore.js";
 import { stageUiBroker } from "../shared/stage-ui-broker.js";
 import { store } from "../shared/store.js";
+import { readGraphStoreSnapshot } from "../shared/store-observation.js";
 import type { RunSnapshot } from "../shared/store-types.js";
 import type {
 	WorkflowExecutionPolicy,
@@ -87,7 +88,10 @@ export function createWorkflowExtensionRuntimeState(
 	const lifecycleNotificationState = createWorkflowLifecycleNotificationState();
 	const hilAnswerNotificationState = createWorkflowHilAnswerNotificationState();
 	const beforeRestoreCompleted = (snapshots: readonly RunSnapshot[]): void => {
-		seedWorkflowLifecycleNotificationState(lifecycleNotificationState, { ...store.snapshot(), runs: snapshots });
+		seedWorkflowLifecycleNotificationState(lifecycleNotificationState, {
+			...readGraphStoreSnapshot(store),
+			runs: snapshots,
+		});
 	};
 	const lifecycleNotificationConfigRef: { current: WorkflowLifecycleNotificationConfig } = {
 		current: WORKFLOW_CONFIG_DEFAULTS.workflowNotifications,
@@ -152,14 +156,14 @@ export function createWorkflowExtensionRuntimeState(
 		resumeFailedRun(sourceRunId, stageId, options) {
 			return runtimeRef.current.resumeFailedRun(sourceRunId, stageId, options);
 		},
-		resumeDurableWorkflow(workflowIdOrPrefix, options) {
-			return runtimeRef.current.resumeDurableWorkflow(workflowIdOrPrefix, options);
+		resumeDurableWorkflow(workflowId, options) {
+			return runtimeRef.current.resumeDurableWorkflow(workflowId, options);
 		},
 		listDurableResumable() {
 			return runtimeRef.current.listDurableResumable();
 		},
-		prepareDurableResumable(workflowIdOrPrefix) {
-			return runtimeRef.current.prepareDurableResumable(workflowIdOrPrefix);
+		prepareDurableResumable(workflowId) {
+			return runtimeRef.current.prepareDurableResumable(workflowId);
 		},
 		prepareDurableResumableForIds(workflowIds) {
 			const targeted = runtimeRef.current.prepareDurableResumableForIds;
@@ -169,16 +173,16 @@ export function createWorkflowExtensionRuntimeState(
 		prepareCompletedDurable() {
 			return runtimeRef.current.prepareCompletedDurable?.() ?? Promise.resolve([]);
 		},
-		openCompletedDurableWorkflow(workflowIdOrPrefix, catalog) {
+		openCompletedDurableWorkflow(workflowId, catalog) {
 			const open = runtimeRef.current.openCompletedDurableWorkflow;
 			if (open === undefined) {
 				return {
 					ok: false,
 					reason: "not_found",
-					message: `No completed durable workflow found for id/prefix: ${workflowIdOrPrefix}`,
+					message: `No completed durable workflow found for id: ${workflowId}`,
 				};
 			}
-			return open(workflowIdOrPrefix, catalog);
+			return open(workflowId, catalog);
 		},
 	};
 

package/dist/builtin/workflows/src/extension/hil-answer-notifications.ts

@@ -1,5 +1,6 @@
 import type { StageUiBroker } from "../shared/stage-ui-broker.js";
 import type { Store } from "../shared/store.js";
+import { readGraphStoreSnapshot, subscribeStoreInvalidation } from "../shared/store-observation.js";
 import type {
 	PendingPrompt,
 	PromptKind,
@@ -99,10 +100,12 @@ export function installWorkflowHilAnswerNotifications(options: WorkflowHilAnswer
 		}
 	};
 
-	const unsubscribeStore = options.store.subscribe(inspectWorkflowPromptAnswers);
+	const unsubscribeStore = subscribeStoreInvalidation(options.store, () =>
+		inspectWorkflowPromptAnswers(readGraphStoreSnapshot(options.store)),
+	);
 	const unsubscribeBroker = options.stageUiBroker?.onStagePromptResolved((event) => {
 		if (event.answerSource === "workflow_tool") return;
-		const answeredStage = findStageSnapshot(options.store.snapshot(), event.runId, event.stageId);
+		const answeredStage = findStageSnapshot(readGraphStoreSnapshot(options.store), event.runId, event.stageId);
 		if (answeredStage === undefined) return;
 
 		emitOnce(