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

package/dist/builtin/workflows/src/shared/persistence-restore.ts

@@ -1,306 +0,0 @@
-import {
-	_buildStageSnapshots,
-	findRunBlockedMetadata,
-	findRunStartMetadata,
-	restoreTerminalRuns,
-	serializableObjectOrEmpty,
-} from "./persistence-restore-helpers.js";
-/**
- * Restore: scan session entries for in-flight runs on session_start.
- * Detects run.start entries without matching run.end and marks crashed or
- * attempts resume per the `resumeInFlight` config option.
- *
- * cross-ref: spec §5.6, §5.13
- */
-
-import type { Store } from "./store.js";
-import type { RunSnapshot } from "./store-types.js";
-import type { WorkflowInputValues, WorkflowSerializableValue } from "./types.js";
-
-// ---------------------------------------------------------------------------
-// Config option
-// ---------------------------------------------------------------------------
-
-/** Controls what the extension does with in-flight runs on session_start. */
-export type ResumeInFlight = "ask" | "auto" | "never";
-
-// ---------------------------------------------------------------------------
-// Session entry types
-// ---------------------------------------------------------------------------
-
-/** Minimal shape of a pi session entry as returned by sessionManager.getEntries(). */
-export interface SessionEntry {
-	readonly id: string;
-	readonly type: string;
-	readonly payload?: Record<string, WorkflowSerializableValue>;
-	readonly customType?: string;
-	readonly data?: Record<string, WorkflowSerializableValue>;
-	/**
-	 * The payload a custom-message entry was published with. Distinct from
-	 * `data`: this is what an extension passed as `details`, so a heartbeat entry
-	 * carries its `WorkflowHeartbeatEventDetails` here. Read only to recover a
-	 * heartbeat's identity structurally rather than by parsing its rendered text.
-	 *
-	 * `unknown` deliberately: the host declares this generic and any extension
-	 * may write any shape into it, so every reader narrows. Typing it as a known
-	 * record here would be a claim about other extensions' data that nothing
-	 * enforces.
-	 */
-	readonly details?: unknown;
-}
-
-export interface NormalizedSessionEntry {
-	readonly id: string;
-	readonly type: string;
-	readonly payload: Record<string, WorkflowSerializableValue>;
-}
-
-export function normalizeSessionEntries(entries: readonly SessionEntry[]): readonly NormalizedSessionEntry[] {
-	return entries.flatMap((entry): readonly NormalizedSessionEntry[] => {
-		if (entry.type === "custom" && typeof entry.customType === "string" && entry.data !== undefined) {
-			return [{ id: entry.id, type: entry.customType, payload: entry.data }];
-		}
-		if (entry.payload !== undefined) return [{ id: entry.id, type: entry.type, payload: entry.payload }];
-		return [];
-	});
-}
-
-/** Structural type for pi's sessionManager (optional — degrades gracefully). */
-export interface SessionManager {
-	getCwd?: () => string;
-	getEntries?: () => SessionEntry[] | readonly SessionEntry[];
-	getSessionDir?: () => string;
-	usesDefaultSessionDir?: () => boolean;
-}
-
-// ---------------------------------------------------------------------------
-// In-flight run descriptor (result of scan)
-// ---------------------------------------------------------------------------
-
-export interface InFlightRun {
-	readonly runId: string;
-	readonly name: string;
-	readonly inputs: Readonly<WorkflowInputValues>;
-	readonly startTs: number;
-	/** Stage IDs that were started (in order) but may or may not have ended. */
-	readonly stageIds: readonly string[];
-}
-
-// ---------------------------------------------------------------------------
-// Scan logic
-// ---------------------------------------------------------------------------
-
-/**
- * Scans a list of session entries and returns runs that have a
- * `workflow.run.start` entry but no matching `workflow.run.end`.
- *
- * Pure function — does not mutate anything.
- */
-export function scanInFlightRuns(entries: readonly SessionEntry[]): InFlightRun[] {
-	const started = new Map<
-		string,
-		{ name: string; inputs: WorkflowInputValues; startTs: number; stageIds: string[] }
-	>();
-	const ended = new Set<string>();
-
-	for (const entry of normalizeSessionEntries(entries)) {
-		if (entry.type === "workflow.run.start") {
-			const runId = entry.payload.runId;
-			const name = entry.payload.name;
-			const inputs = entry.payload.inputs;
-			const ts = entry.payload.ts;
-			if (typeof runId === "string" && typeof name === "string" && typeof ts === "number") {
-				started.set(runId, {
-					name,
-					inputs: serializableObjectOrEmpty(inputs),
-					startTs: ts,
-					stageIds: [],
-				});
-			}
-		}
-
-		if (entry.type === "workflow.stage.start") {
-			const runId = entry.payload.runId;
-			const stageId = entry.payload.stageId;
-			if (typeof runId === "string" && typeof stageId === "string") {
-				const run = started.get(runId);
-				if (run && !run.stageIds.includes(stageId)) {
-					run.stageIds.push(stageId);
-				}
-			}
-		}
-
-		if (entry.type === "workflow.run.end") {
-			const runId = entry.payload.runId;
-			if (typeof runId === "string") {
-				ended.add(runId);
-			}
-		}
-	}
-
-	const result: InFlightRun[] = [];
-	for (const [runId, info] of started) {
-		if (!ended.has(runId)) {
-			result.push({
-				runId,
-				name: info.name,
-				inputs: Object.freeze({ ...info.inputs }),
-				startTs: info.startTs,
-				stageIds: Object.freeze([...info.stageIds]),
-			});
-		}
-	}
-	return result;
-}
-
-// ---------------------------------------------------------------------------
-// Restore callbacks
-// ---------------------------------------------------------------------------
-
-export interface RestoreCallbacks {
-	/**
-	 * Called when a run is detected as crashed (no end entry, session restarted).
-	 * Implementations typically mark the run "failed" in the store and optionally
-	 * notify the user.
-	 */
-	onCrashed?: (run: InFlightRun) => void;
-	/**
-	 * Called when a run is being resumed (resumeInFlight === "auto").
-	 * Implementations typically re-register the run in the store with status "running".
-	 */
-	onResume?: (run: InFlightRun) => void;
-}
-
-// ---------------------------------------------------------------------------
-// restoreOnSessionStart
-// ---------------------------------------------------------------------------
-
-/**
- * Entry point called on `session_start`.
- *
- * Behavior by `config.resumeInFlight`:
- *   "never" — mark all in-flight runs as crashed (failed) in the store.
- *   "auto"  — restore in-flight runs to "running" in the store and call onResume.
- *   "ask"   — same as "never" for store side-effects; onCrashed is called so
- *             the caller can prompt the user and invoke resume logic separately.
- *
- * When `config.persistRuns` is false the function returns early — no session
- * entries were written, so there is nothing to restore.
- */
-export function restoreOnSessionStart(
-	sessionManager: SessionManager,
-	config: { resumeInFlight: ResumeInFlight; persistRuns: boolean },
-	store: Store,
-	callbacks: RestoreCallbacks = {},
-): void {
-	if (!config.persistRuns) return;
-
-	const getEntries = sessionManager.getEntries;
-	if (typeof getEntries !== "function") return;
-
-	const entries = getEntries.call(sessionManager) as readonly SessionEntry[];
-	const sessionEntries = normalizeSessionEntries(entries);
-	restoreTerminalRuns(sessionEntries, store);
-	const inFlight = scanInFlightRuns(sessionEntries);
-	if (inFlight.length === 0) return;
-
-	for (const run of inFlight) {
-		const runMeta = findRunStartMetadata(sessionEntries, run.runId);
-		const blockedMeta = findRunBlockedMetadata(sessionEntries, run.runId);
-		const stages = _buildStageSnapshots(sessionEntries, run.runId, blockedMeta);
-
-		if (blockedMeta !== undefined) {
-			const runSnapshot: RunSnapshot = {
-				id: run.runId,
-				name: run.name,
-				inputs: run.inputs,
-				status: "running",
-				stages,
-				startedAt: run.startTs,
-				...(blockedMeta.endedAt !== undefined ? { endedAt: blockedMeta.endedAt } : {}),
-				...(runMeta.parentRunId !== undefined ? { parentRunId: runMeta.parentRunId } : {}),
-				...(runMeta.parentStageId !== undefined ? { parentStageId: runMeta.parentStageId } : {}),
-				...(runMeta.rootRunId !== undefined ? { rootRunId: runMeta.rootRunId } : {}),
-				...(runMeta.resumedFromRunId !== undefined ? { resumedFromRunId: runMeta.resumedFromRunId } : {}),
-				...(runMeta.origin !== undefined ? { origin: runMeta.origin } : {}),
-				...(runMeta.resumeFromStageId !== undefined ? { resumeFromStageId: runMeta.resumeFromStageId } : {}),
-				...(runMeta.accumulatedDurationMs !== undefined
-					? { accumulatedDurationMs: runMeta.accumulatedDurationMs }
-					: {}),
-				...(runMeta.budget !== undefined ? { budget: runMeta.budget } : {}),
-				...(blockedMeta.budgetState !== undefined ? { budgetState: blockedMeta.budgetState } : {}),
-			};
-			store.recordRunStart(runSnapshot);
-			store.recordRunBlocked(run.runId, blockedMeta.error, {
-				failureKind: blockedMeta.failureKind,
-				...(blockedMeta.failureCode !== undefined ? { failureCode: blockedMeta.failureCode } : {}),
-				failureRecoverability: "recoverable",
-				...(blockedMeta.failureDisposition !== undefined
-					? { failureDisposition: blockedMeta.failureDisposition }
-					: {}),
-				...(blockedMeta.failureMessage !== undefined ? { failureMessage: blockedMeta.failureMessage } : {}),
-				...(blockedMeta.failedStageId !== undefined ? { failedStageId: blockedMeta.failedStageId } : {}),
-				resumable: true,
-				...(blockedMeta.retryAfterMs !== undefined ? { retryAfterMs: blockedMeta.retryAfterMs } : {}),
-				...(blockedMeta.endedAt !== undefined ? { endedAt: blockedMeta.endedAt } : {}),
-				...(blockedMeta.result !== undefined ? { result: blockedMeta.result } : {}),
-				...(blockedMeta.budgetState !== undefined ? { budgetState: blockedMeta.budgetState } : {}),
-				blockedAt: blockedMeta.ts,
-			});
-			continue;
-		}
-
-		if (config.resumeInFlight === "auto") {
-			// Re-hydrate the run into the store as "running"
-			const runSnapshot: RunSnapshot = {
-				id: run.runId,
-				name: run.name,
-				inputs: run.inputs,
-				status: "running",
-				stages,
-				startedAt: run.startTs,
-				...(runMeta.parentRunId !== undefined ? { parentRunId: runMeta.parentRunId } : {}),
-				...(runMeta.parentStageId !== undefined ? { parentStageId: runMeta.parentStageId } : {}),
-				...(runMeta.rootRunId !== undefined ? { rootRunId: runMeta.rootRunId } : {}),
-				...(runMeta.resumedFromRunId !== undefined ? { resumedFromRunId: runMeta.resumedFromRunId } : {}),
-				...(runMeta.origin !== undefined ? { origin: runMeta.origin } : {}),
-				...(runMeta.resumeFromStageId !== undefined ? { resumeFromStageId: runMeta.resumeFromStageId } : {}),
-				...(runMeta.budget !== undefined ? { budget: runMeta.budget } : {}),
-				...(runMeta.budgetState !== undefined ? { budgetState: runMeta.budgetState } : {}),
-				...(runMeta.accumulatedDurationMs !== undefined
-					? { accumulatedDurationMs: runMeta.accumulatedDurationMs }
-					: {}),
-			};
-			store.recordRunStart(runSnapshot);
-			callbacks.onResume?.(run);
-		} else {
-			// "ask" or "never": mark as crashed in store, surface to caller
-			const runSnapshot: RunSnapshot = {
-				id: run.runId,
-				name: run.name,
-				inputs: run.inputs,
-				status: "failed",
-				stages,
-				startedAt: run.startTs,
-				endedAt: Date.now(),
-				error: "Run did not complete — process was interrupted.",
-				failureKind: "unknown",
-				resumable: false,
-				...(runMeta.parentRunId !== undefined ? { parentRunId: runMeta.parentRunId } : {}),
-				...(runMeta.parentStageId !== undefined ? { parentStageId: runMeta.parentStageId } : {}),
-				...(runMeta.rootRunId !== undefined ? { rootRunId: runMeta.rootRunId } : {}),
-				...(runMeta.resumedFromRunId !== undefined ? { resumedFromRunId: runMeta.resumedFromRunId } : {}),
-				...(runMeta.origin !== undefined ? { origin: runMeta.origin } : {}),
-				...(runMeta.resumeFromStageId !== undefined ? { resumeFromStageId: runMeta.resumeFromStageId } : {}),
-				...(runMeta.budget !== undefined ? { budget: runMeta.budget } : {}),
-				...(runMeta.budgetState !== undefined ? { budgetState: runMeta.budgetState } : {}),
-				...(runMeta.accumulatedDurationMs !== undefined
-					? { accumulatedDurationMs: runMeta.accumulatedDurationMs }
-					: {}),
-			};
-			store.recordRunStart(runSnapshot);
-			store.recordRunEnd(run.runId, "failed");
-			callbacks.onCrashed?.(run);
-		}
-	}
-}

package/dist/builtin/workflows/src/shared/persistence-session-entries.ts

@@ -1,303 +0,0 @@
-/**
- * Helpers to append workflow lifecycle entries via pi.appendEntry.
- * cross-ref: spec §5.6 Persistence via session entries
- *
- * All functions are pure helpers — they accept a PersistenceAPI and call
- * through gracefully when the runtime doesn't support the method.
- */
-
-import type {
-	ToolNodeSnapshot,
-	WorkflowActor,
-	WorkflowFailureCode,
-	WorkflowFailureDisposition,
-	WorkflowFailureKind,
-} from "./store-types.js";
-import type { WorkflowExitStatus, WorkflowInputValues, WorkflowModelAttempt, WorkflowOutputValues } from "./types.js";
-
-// ---------------------------------------------------------------------------
-// Structural API type (subset of ExtensionAPI needed here)
-// ---------------------------------------------------------------------------
-
-/** Subset of the pi runtime API required for persistence operations. */
-export interface PersistenceAPI {
-	/** Appends a typed entry to the session transcript. Returns the entry ID. */
-	appendEntry?: (type: string, payload: Record<string, unknown>) => string | undefined;
-	/** Labels an entry for /tree bookmark filtering. */
-	setLabel?: (entryId: string, label: string) => void;
-	/** Appends a synthetic system/assistant message entry. */
-	appendCustomMessageEntry?: (content: string, meta?: Record<string, unknown>) => string | undefined;
-}
-
-// ---------------------------------------------------------------------------
-// Entry payload types (spec §5.6)
-// ---------------------------------------------------------------------------
-
-export interface RunStartPayload {
-	readonly runId: string;
-	readonly name: string;
-	readonly inputs: Readonly<WorkflowInputValues>;
-	readonly parentRunId?: string;
-	readonly parentStageId?: string;
-	readonly rootRunId?: string;
-	readonly resumedFromRunId?: string;
-	/** Who launched this run, when the launcher was attributable. */
-	readonly origin?: WorkflowActor;
-	readonly resumeFromStageId?: string;
-	/** Elapsed ms inherited from prior sessions of a resumed run. */
-	readonly accumulatedDurationMs?: number;
-	readonly budget?: import("./store-types.js").RunBudgetSnapshot;
-	readonly budgetState?: import("./store-types.js").RunBudgetState;
-	readonly ts: number;
-}
-
-export interface StageStartPayload {
-	readonly runId: string;
-	readonly stageId: string;
-	readonly name: string;
-	readonly parentIds: readonly string[];
-	readonly model?: string;
-	readonly replayKey?: string;
-	readonly replayedFromStageId?: string;
-	readonly replayed?: boolean;
-	readonly ts: number;
-}
-
-export interface StageProgressPayload {
-	readonly runId: string;
-	readonly stageId: string;
-	readonly kind: string;
-	readonly payload: unknown;
-}
-
-export interface WorkflowChildReplayPayload {
-	readonly alias: string;
-	readonly workflow: string;
-	readonly runId: string;
-	readonly status: WorkflowExitStatus;
-	readonly exited?: boolean;
-	readonly outputs: WorkflowOutputValues;
-	readonly exitReason?: string;
-}
-
-export interface StageEndPayload {
-	readonly runId: string;
-	readonly stageId: string;
-	readonly status: string;
-	readonly durationMs?: number;
-	readonly summary?: string;
-	readonly error?: string;
-	readonly failureKind?: string;
-	readonly failureCode?: string;
-	readonly failureRecoverability?: string;
-	readonly failureDisposition?: string;
-	readonly failureMessage?: string;
-	readonly retryAfterMs?: number;
-	readonly skippedReason?: string;
-	readonly sessionId?: string;
-	readonly sessionFile?: string;
-	readonly modelAttempts?: readonly WorkflowModelAttempt[];
-	readonly replayKey?: string;
-	readonly replayedFromStageId?: string;
-	readonly replayed?: boolean;
-	readonly workflowChild?: WorkflowChildReplayPayload;
-}
-
-export interface RunEndPayload {
-	readonly runId: string;
-	readonly status: string;
-	readonly result?: WorkflowOutputValues;
-	readonly error?: string;
-	readonly exited?: boolean;
-	readonly exitReason?: string;
-	readonly failureKind?: string;
-	readonly failureCode?: string;
-	readonly failureRecoverability?: string;
-	readonly failureDisposition?: string;
-	readonly failureMessage?: string;
-	readonly failedStageId?: string;
-	readonly failedToolNodeId?: string;
-	readonly failedToolNode?: ToolNodeSnapshot;
-	readonly resumable?: boolean;
-	readonly retryAfterMs?: number;
-	readonly endedAt?: number;
-	readonly durationMs?: number;
-	readonly ts: number;
-}
-
-export interface RunBlockedPayload {
-	readonly runId: string;
-	readonly failedStageId?: string;
-	readonly error: string;
-	readonly failureKind: WorkflowFailureKind;
-	readonly failureCode?: WorkflowFailureCode;
-	readonly failureMessage?: string;
-	readonly failureRecoverability: "recoverable";
-	readonly failureDisposition?: WorkflowFailureDisposition;
-	readonly retryAfterMs?: number;
-	readonly resumable: true;
-	readonly endedAt?: number;
-	readonly result?: WorkflowOutputValues;
-	readonly budgetState?: import("./store-types.js").RunBudgetState;
-	readonly ts: number;
-}
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-/**
- * Appends a `workflow.run.start` entry and labels it for /tree filtering.
- * Label format: `wf:<name>:<full-run-id>`.
- */
-export function appendRunStart(api: PersistenceAPI, payload: RunStartPayload): void {
-	if (typeof api.appendEntry !== "function") return;
-	const entryId = api.appendEntry("workflow.run.start", {
-		runId: payload.runId,
-		name: payload.name,
-		inputs: payload.inputs,
-		...(payload.parentRunId !== undefined ? { parentRunId: payload.parentRunId } : {}),
-		...(payload.parentStageId !== undefined ? { parentStageId: payload.parentStageId } : {}),
-		...(payload.rootRunId !== undefined ? { rootRunId: payload.rootRunId } : {}),
-		...(payload.resumedFromRunId !== undefined ? { resumedFromRunId: payload.resumedFromRunId } : {}),
-		...(payload.origin !== undefined ? { origin: payload.origin } : {}),
-		...(payload.resumeFromStageId !== undefined ? { resumeFromStageId: payload.resumeFromStageId } : {}),
-		...(payload.accumulatedDurationMs !== undefined ? { accumulatedDurationMs: payload.accumulatedDurationMs } : {}),
-		...(payload.budget !== undefined ? { budget: payload.budget } : {}),
-		...(payload.budgetState !== undefined ? { budgetState: payload.budgetState } : {}),
-		ts: payload.ts,
-	});
-	if (entryId && typeof api.setLabel === "function") {
-		api.setLabel(entryId, `wf:${payload.name}:${payload.runId}`);
-	}
-}
-
-/** Appends a `workflow.stage.start` entry. */
-export function appendStageStart(api: PersistenceAPI, payload: StageStartPayload): void {
-	if (typeof api.appendEntry !== "function") return;
-	api.appendEntry("workflow.stage.start", {
-		runId: payload.runId,
-		stageId: payload.stageId,
-		name: payload.name,
-		parentIds: [...payload.parentIds],
-		...(payload.model !== undefined ? { model: payload.model } : {}),
-		...(payload.replayKey !== undefined ? { replayKey: payload.replayKey } : {}),
-		...(payload.replayedFromStageId !== undefined ? { replayedFromStageId: payload.replayedFromStageId } : {}),
-		...(payload.replayed !== undefined ? { replayed: payload.replayed } : {}),
-		ts: payload.ts,
-	});
-}
-
-/** Appends a `workflow.stage.progress` entry (tool calls, message deltas, etc.). */
-export function appendStageProgress(api: PersistenceAPI, payload: StageProgressPayload): void {
-	if (typeof api.appendEntry !== "function") return;
-	api.appendEntry("workflow.stage.progress", {
-		runId: payload.runId,
-		stageId: payload.stageId,
-		kind: payload.kind,
-		payload: payload.payload as Record<string, unknown>,
-	});
-}
-
-/** Appends a `workflow.stage.end` entry. Optionally emits a custom message entry. */
-export function appendStageEnd(api: PersistenceAPI, payload: StageEndPayload, opts?: { emitMessage?: boolean }): void {
-	if (typeof api.appendEntry !== "function") return;
-	api.appendEntry("workflow.stage.end", {
-		runId: payload.runId,
-		stageId: payload.stageId,
-		status: payload.status,
-		...(payload.durationMs !== undefined ? { durationMs: payload.durationMs } : {}),
-		...(payload.summary !== undefined ? { summary: payload.summary } : {}),
-		...(payload.error !== undefined ? { error: payload.error } : {}),
-		...(payload.failureKind !== undefined ? { failureKind: payload.failureKind } : {}),
-		...(payload.failureCode !== undefined ? { failureCode: payload.failureCode } : {}),
-		...(payload.failureRecoverability !== undefined ? { failureRecoverability: payload.failureRecoverability } : {}),
-		...(payload.failureDisposition !== undefined ? { failureDisposition: payload.failureDisposition } : {}),
-		...(payload.failureMessage !== undefined ? { failureMessage: payload.failureMessage } : {}),
-		...(payload.retryAfterMs !== undefined ? { retryAfterMs: payload.retryAfterMs } : {}),
-		...(payload.skippedReason !== undefined ? { skippedReason: payload.skippedReason } : {}),
-		...(payload.sessionId !== undefined ? { sessionId: payload.sessionId } : {}),
-		...(payload.sessionFile !== undefined ? { sessionFile: payload.sessionFile } : {}),
-		...(payload.modelAttempts !== undefined ? { modelAttempts: payload.modelAttempts } : {}),
-		...(payload.replayKey !== undefined ? { replayKey: payload.replayKey } : {}),
-		...(payload.replayedFromStageId !== undefined ? { replayedFromStageId: payload.replayedFromStageId } : {}),
-		...(payload.replayed !== undefined ? { replayed: payload.replayed } : {}),
-		...(payload.status === "completed" && payload.workflowChild !== undefined
-			? { workflowChild: payload.workflowChild }
-			: {}),
-	});
-	if (opts?.emitMessage === true && payload.summary && typeof api.appendCustomMessageEntry === "function") {
-		api.appendCustomMessageEntry(
-			`Workflow stage ${payload.stageId} completed (${payload.status}): ${payload.summary}`,
-			{ runId: payload.runId, stageId: payload.stageId },
-		);
-	}
-}
-
-function sanitizeTerminalRunEndPayload(payload: RunEndPayload): RunEndPayload {
-	if (payload.status === "killed") {
-		return {
-			...payload,
-			failureRecoverability: "non_recoverable",
-			failureDisposition: "terminal_killed",
-			resumable: false,
-		};
-	}
-
-	if (payload.failureDisposition !== "active_blocked") return payload;
-	const sanitized = { ...payload };
-	delete (sanitized as { failureDisposition?: string }).failureDisposition;
-	return sanitized;
-}
-
-/** Appends a `workflow.run.end` entry. */
-export function appendRunEnd(api: PersistenceAPI, payload: RunEndPayload): void {
-	if (typeof api.appendEntry !== "function") return;
-	const terminalPayload = sanitizeTerminalRunEndPayload(payload);
-	api.appendEntry("workflow.run.end", {
-		runId: terminalPayload.runId,
-		status: terminalPayload.status,
-		...(terminalPayload.result !== undefined ? { result: terminalPayload.result } : {}),
-		...(terminalPayload.error !== undefined ? { error: terminalPayload.error } : {}),
-		...(terminalPayload.exited !== undefined ? { exited: terminalPayload.exited } : {}),
-		...(terminalPayload.exitReason !== undefined ? { exitReason: terminalPayload.exitReason } : {}),
-		...(terminalPayload.failureKind !== undefined ? { failureKind: terminalPayload.failureKind } : {}),
-		...(terminalPayload.failureCode !== undefined ? { failureCode: terminalPayload.failureCode } : {}),
-		...(terminalPayload.failureRecoverability !== undefined
-			? { failureRecoverability: terminalPayload.failureRecoverability }
-			: {}),
-		...(terminalPayload.failureDisposition !== undefined
-			? { failureDisposition: terminalPayload.failureDisposition }
-			: {}),
-		...(terminalPayload.failureMessage !== undefined ? { failureMessage: terminalPayload.failureMessage } : {}),
-		...(terminalPayload.failedStageId !== undefined ? { failedStageId: terminalPayload.failedStageId } : {}),
-		...(terminalPayload.failedToolNodeId !== undefined ? { failedToolNodeId: terminalPayload.failedToolNodeId } : {}),
-		...(terminalPayload.failedToolNode !== undefined ? { failedToolNode: terminalPayload.failedToolNode } : {}),
-		...(terminalPayload.resumable !== undefined ? { resumable: terminalPayload.resumable } : {}),
-		...(terminalPayload.retryAfterMs !== undefined ? { retryAfterMs: terminalPayload.retryAfterMs } : {}),
-		...(terminalPayload.endedAt !== undefined ? { endedAt: terminalPayload.endedAt } : {}),
-		...(terminalPayload.durationMs !== undefined ? { durationMs: terminalPayload.durationMs } : {}),
-		ts: terminalPayload.ts,
-	});
-}
-
-/** Appends a `workflow.run.blocked` entry for active recoverable failures. */
-export function appendRunBlocked(api: PersistenceAPI, payload: RunBlockedPayload): void {
-	if (typeof api.appendEntry !== "function") return;
-	api.appendEntry("workflow.run.blocked", {
-		runId: payload.runId,
-		...(payload.failedStageId !== undefined ? { failedStageId: payload.failedStageId } : {}),
-		error: payload.error,
-		failureKind: payload.failureKind,
-		...(payload.failureCode !== undefined ? { failureCode: payload.failureCode } : {}),
-		...(payload.failureMessage !== undefined ? { failureMessage: payload.failureMessage } : {}),
-		failureRecoverability: payload.failureRecoverability,
-		...(payload.failureDisposition !== undefined ? { failureDisposition: payload.failureDisposition } : {}),
-		...(payload.retryAfterMs !== undefined ? { retryAfterMs: payload.retryAfterMs } : {}),
-		resumable: payload.resumable,
-		...(payload.endedAt !== undefined ? { endedAt: payload.endedAt } : {}),
-		...(payload.result !== undefined ? { result: payload.result } : {}),
-		...(payload.budgetState !== undefined ? { budgetState: payload.budgetState } : {}),
-		ts: payload.ts,
-	});
-}