@bastani/atomic 0.9.16-alpha.2 → 0.9.16-alpha.4

package/dist/builtin/workflows/src/durable/workflow-heartbeat-anchor.ts

@@ -1,153 +0,0 @@
-/**
- * Durable workflow-heartbeat cadence anchor.
- *
- * The heartbeat cadence is `anchorAt + n × interval`. Every input to that is
- * already persisted except one: the *original* run start time. A durable resume
- * re-dispatches under the original workflow id but mints a fresh
- * `RunSnapshot.startedAt` (`engine/run.ts`), and that fresh value is passed to
- * `registerWorkflow` as `createdAt`, which the backend overwrites
- * unconditionally (`durable/backend.ts`). Checkpoints are the only per-run state
- * that survives re-registration, so this record is the sole surviving carrier of
- * the original start — which is what keeps a resumed run on its original
- * cadence rather than starting a fresh series.
- *
- * Storage shape: a reserved tool-kind checkpoint (name/argsHash
- * `workflow-heartbeat-anchor`), following `run-timing.ts`. Its `checkpointId` is
- * that same constant with no suffix, so `recordCheckpoint`'s duplicate-key early
- * return makes the record **write-once and exactly one row per run** rather than
- * one row per boundary.
- *
- * Three properties this shape is chosen for:
- *
- * - **It cannot manufacture resumability.** `recordCheckpoint` sets
- *   `completedCheckpoints = checkpoints.size`, and `isDurableWorkflowResumable`
- *   gates a running or paused run on `completedCheckpoints > 0`. Writing for a
- *   run with no durable progress of its own would make it look resumable, so the
- *   write is skipped until the run has at least one other checkpoint — the same
- *   guard, and the same reason, as `run-timing.ts`.
- * - **It cannot walk liveness backwards.** `recordCheckpoint` copies
- *   `completedAt` onto the handle as `updatedAt`, which the foreign-liveness
- *   window reads, so `completedAt` is the write time and never a cadence
- *   boundary.
- * - **It cannot move a boundary forward.** It is read as
- *   `min(run.startedAt, anchorAt)`, so it can only restore the original anchor,
- *   never advance it. Recovery still floors at `now`, so no missed boundary is
- *   ever replayed.
- *
- * The record has no per-checkpoint deletion — `DurableWorkflowBackend` removes
- * whole workflows only — so terminal cleanup (issue #1975) invalidates it on the
- * read side instead: the scheduler neither reads nor writes an anchor for a run
- * it observes as terminal, and drops the in-memory memo of it. A leftover row is
- * therefore inert, and cannot put a finished run back on a cadence.
- *
- * cross-ref: packages/workflows/src/extension/workflow-heartbeat-scheduler.ts
- */
-
-import type { DurableWorkflowBackend } from "./backend.js";
-import type { DurableToolCheckpoint } from "./types.js";
-
-/** Reserved checkpoint name, args-hash, AND checkpoint id for cadence anchors. */
-export const WORKFLOW_HEARTBEAT_ANCHOR_CHECKPOINT_NAME = "workflow-heartbeat-anchor";
-
-/**
- * What a run launched with: its original start time, and the cadence its own
- * definition declared.
- *
- * `intervalMinutes` is absent on records written before it was added, so a
- * reader must treat that as "unknown" and fall back to the live definition —
- * never as `0`.
- */
-export interface WorkflowHeartbeatAnchorRecord {
-	readonly anchorAt: number;
-	readonly intervalMinutes?: number;
-}
-
-/**
- * The stored checkpoint payload, before validation.
- *
- * `getToolOutput` returns whatever a previous process wrote, so the fields are
- * declared optional and validated below rather than trusted. Naming the shape
- * keeps the decode free of inline casts while leaving the trust boundary
- * explicit.
- */
-interface PersistedAnchorOutput {
-	readonly anchorAt?: number;
-	readonly intervalMinutes?: number;
-}
-
-function asPersistedAnchorOutput(output: unknown): PersistedAnchorOutput | undefined {
-	if (typeof output !== "object" || output === null || Array.isArray(output)) return undefined;
-	const { anchorAt, intervalMinutes } = output as Partial<Record<keyof PersistedAnchorOutput, unknown>>;
-	return {
-		...(typeof anchorAt === "number" ? { anchorAt } : {}),
-		...(typeof intervalMinutes === "number" ? { intervalMinutes } : {}),
-	};
-}
-
-/** The persisted launch anchor for a run, or undefined when absent or malformed. */
-export function readWorkflowHeartbeatAnchor(
-	backend: DurableWorkflowBackend,
-	workflowId: string,
-): WorkflowHeartbeatAnchorRecord | undefined {
-	const record = asPersistedAnchorOutput(backend.getToolOutput(workflowId, WORKFLOW_HEARTBEAT_ANCHOR_CHECKPOINT_NAME));
-	if (record === undefined) return undefined;
-	const { anchorAt, intervalMinutes } = record;
-	if (anchorAt === undefined || !Number.isFinite(anchorAt)) return undefined;
-	// Only a positive finite cadence is carried: a disabled run never writes a
-	// record at all, so a non-positive value here is corrupt rather than meaningful.
-	return intervalMinutes !== undefined && Number.isFinite(intervalMinutes) && intervalMinutes > 0
-		? { anchorAt, intervalMinutes }
-		: { anchorAt };
-}
-
-/**
- * Persist what a run launched with, once.
- *
- * Uses `recordAdditiveCheckpointBestEffort` rather than the synchronous
- * `recordCheckpoint`, because the DBOS backend updates its in-memory mirror
- * *before* the real write is queued: a synchronous read-back therefore proves
- * only that the mirror holds the row, and would let a rejected storage write be
- * remembered as a success that is never retried. The best-effort path awaits
- * `recordStepOutput` and updates the mirror only after it resolves, and turns a
- * storage rejection into `false` instead of a fatal flush error.
- *
- * Returns `true` only when the record is durably written *and* readable — the
- * backend silently drops a checkpoint for a workflow it has never registered,
- * so the read-back stays as well.
- */
-export async function recordWorkflowHeartbeatAnchor(
-	backend: DurableWorkflowBackend,
-	record: {
-		readonly runId: string;
-		readonly anchorAt: number;
-		readonly intervalMinutes: number;
-		readonly now: number;
-	},
-): Promise<boolean> {
-	if (!Number.isFinite(record.anchorAt)) return false;
-	// A run launched with heartbeats disabled writes no record at all, so this
-	// path is never reached for a non-positive cadence. Guarding it here keeps
-	// that invariant local to the writer as well as to its caller.
-	if (!Number.isFinite(record.intervalMinutes) || record.intervalMinutes <= 0) return false;
-	const existing = readWorkflowHeartbeatAnchor(backend, record.runId);
-	// Write-once: the first record stands. A later write cannot move the anchor
-	// forward, and it cannot retro-fit an edited cadence onto a run in flight.
-	if (existing !== undefined) return true;
-	// A record for a run with no durable progress of its own would make that run
-	// look resumable; the anchor is worth nothing on a run that cannot resume.
-	if (backend.listCheckpoints(record.runId).length === 0) return false;
-	const checkpoint: DurableToolCheckpoint = {
-		kind: "tool",
-		workflowId: record.runId,
-		checkpointId: WORKFLOW_HEARTBEAT_ANCHOR_CHECKPOINT_NAME,
-		name: WORKFLOW_HEARTBEAT_ANCHOR_CHECKPOINT_NAME,
-		argsHash: WORKFLOW_HEARTBEAT_ANCHOR_CHECKPOINT_NAME,
-		output: { anchorAt: record.anchorAt, intervalMinutes: record.intervalMinutes },
-		// Write time, never the boundary: this lands on the handle as `updatedAt`,
-		// which the foreign-liveness window reads.
-		completedAt: record.now,
-	};
-	const stored = await backend.recordAdditiveCheckpointBestEffort(checkpoint);
-	if (!stored) return false;
-	return readWorkflowHeartbeatAnchor(backend, record.runId) !== undefined;
-}

package/dist/builtin/workflows/src/durable/workflow-status-transition.ts

@@ -1,31 +0,0 @@
-import type { DurableWorkflowBackend } from "./backend.js";
-import type { DurableWorkflowHandle, DurableWorkflowStatus } from "./types.js";
-
-/** Read one loadable handle without combining objects from different generations. */
-export function getLoadableDurableWorkflow(
-	backend: DurableWorkflowBackend,
-	workflowId: string,
-): DurableWorkflowHandle | undefined {
-	return backend.getLoadableWorkflow(workflowId);
-}
-
-/** Terminal durable generations cannot be reopened by stale nonterminal writers. */
-export function isAbsorbingDurableStatus(status: DurableWorkflowStatus, resumable?: boolean): boolean {
-	return (
-		status === "completed" ||
-		status === "cancelled" ||
-		((status === "failed" || status === "blocked") && resumable === false)
-	);
-}
-
-/** Perform a required conditional status transition. */
-export async function transitionDurableWorkflowStatus(
-	backend: DurableWorkflowBackend,
-	workflowId: string,
-	expectedStatuses: readonly DurableWorkflowStatus[],
-	status: DurableWorkflowStatus,
-	pendingPrompts?: number,
-	resumable?: boolean,
-): Promise<boolean> {
-	return await backend.transitionWorkflowStatus(workflowId, expectedStatuses, status, pendingPrompts, resumable);
-}

package/dist/builtin/workflows/src/engine/graph-inference.ts

@@ -1,100 +0,0 @@
-/**
- * GraphFrontierTracker — infers DAG parents from JavaScript execution order.
- *
- * Algorithm:
- * - Maintain `frontier: Set<string>` — settled stage IDs not yet consumed as parents
- * - At onSpawn(stageId): snapshot current frontier as parents, store in stageParents
- * - At onSettle(stageId): remove stage's parents from frontier, add stageId to frontier
- * - getParents(stageId): return recorded parents
- */
-
-export interface StageNode {
-	readonly id: string;
-	readonly name: string;
-	readonly parentIds: readonly string[];
-}
-
-export class GraphFrontierTracker {
-	private frontier: Set<string> = new Set();
-	private stageParents: Map<string, string[]> = new Map();
-	private nodes: Map<string, StageNode> = new Map();
-
-	/**
-	 * Call when ctx.stage(name) is invoked.
-	 * Returns the inferred parent IDs (snapshot of current frontier).
-	 */
-	onSpawn(stageId: string, stageName: string): string[] {
-		const parents = Array.from(this.frontier);
-		this.stageParents.set(stageId, parents);
-
-		this.nodes.set(stageId, {
-			id: stageId,
-			name: stageName,
-			parentIds: Object.freeze(parents),
-		});
-
-		return parents;
-	}
-
-	/**
-	 * Snapshot the current frontier without registering or mutating a stage.
-	 *
-	 * Use this when an already-spawned stage needs its parents refreshed before
-	 * it starts; `onSpawn` must only be called for the initial `ctx.stage()`
-	 * invocation that creates the graph node.
-	 */
-	currentParents(): string[] {
-		return Array.from(this.frontier);
-	}
-
-	/**
-	 * Replace the recorded parents for a stage before it settles.
-	 *
-	 * Continuation replay uses source-run topology as authoritative: a replayed
-	 * stage may spawn with provisional parents inferred from the continuation's
-	 * current frontier, then install the translated source parents before the
-	 * stage is recorded or settled.
-	 */
-	replaceParents(stageId: string, parentIds: readonly string[]): void {
-		const parents = Array.from(parentIds);
-		this.stageParents.set(stageId, parents);
-		const node = this.nodes.get(stageId);
-		if (node !== undefined) {
-			this.nodes.set(stageId, {
-				...node,
-				parentIds: Object.freeze(parents),
-			});
-		}
-	}
-
-	/**
-	 * Call when the stage's Promise settles.
-	 * Removes the stage's parents from the frontier and adds stageId to frontier.
-	 */
-	onSettle(stageId: string): void {
-		const parents = this.stageParents.get(stageId) ?? [];
-		// Remove parents from frontier (they are now consumed)
-		for (const parentId of parents) {
-			this.frontier.delete(parentId);
-		}
-		// Add this stage to the frontier
-		this.frontier.add(stageId);
-	}
-
-	/** Get all recorded nodes as an array. */
-	getNodes(): StageNode[] {
-		return Array.from(this.nodes.values());
-	}
-
-	/** Get parent IDs for a stage. */
-	getParents(stageId: string): string[] {
-		return this.stageParents.get(stageId) ?? [];
-	}
-
-	/** Reset to initial state. */
-	reset(): void {
-		this.frontier.clear();
-		this.stageParents.clear();
-		this.nodes.clear();
-	}
-}

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

@@ -1,44 +0,0 @@
-import type { RunOpts } from "../runs/foreground/executor-types.js";
-
-export type EngineStageRuntimeOptions = Pick<
-	RunOpts,
-	| "continuation"
-	| "models"
-	| "executionMode"
-	| "defaultSessionDir"
-	| "persistence"
-	| "onStageStart"
-	| "onStageEnd"
-	| "onStageSession"
-	| "confirmStageReadiness"
-	| "usePromptNodesForUi"
->;
-
-export type EngineWorkflowBoundaryOptions = Pick<RunOpts, "persistence" | "onStageStart" | "onStageEnd">;
-
-export type EngineChildRunOptions = Pick<
-	RunOpts,
-	| "adapters"
-	| "ui"
-	| "executionMode"
-	| "defaultSessionDir"
-	| "usePromptNodesForUi"
-	| "confirmStageReadiness"
-	| "store"
-	| "persistence"
-	| "mcp"
-	| "cancellation"
-	| "overlay"
-	| "config"
-	| "models"
-	| "registry"
-	| "stageControlRegistry"
-	| "toolControlRegistry"
-	| "toolAdmissionBoundary"
-	| "onStageStart"
-	| "onStageEnd"
-	| "onStageSession"
-	| "durableBackend"
-	| "durableRootBackend"
-	| "rootBudget"
->;

package/dist/builtin/workflows/src/engine/primitives/chain.ts

@@ -1,34 +0,0 @@
-import {
-	chainStepPrompt,
-	replaceTaskPlaceholder,
-	taskOptionsFromStep,
-	taskPrevious,
-	taskWithSharedDefaults,
-} from "../../runs/foreground/executor-task-prompts.js";
-import type { WorkflowChainOptions, WorkflowTaskResult, WorkflowTaskStep } from "../../shared/types.js";
-import type { EngineRuntime } from "../runtime.js";
-import type { WorkflowTaskPrimitive } from "./task.js";
-
-export function createChainPrimitive(input: {
-	readonly runtime: EngineRuntime;
-	readonly task: WorkflowTaskPrimitive;
-}): (steps: readonly WorkflowTaskStep[], options?: WorkflowChainOptions) => Promise<WorkflowTaskResult[]> {
-	return async (
-		steps: readonly WorkflowTaskStep[],
-		options: WorkflowChainOptions = {},
-	): Promise<WorkflowTaskResult[]> => {
-		input.runtime.exit.throwIfWorkflowExitSelected();
-		const results: WorkflowTaskResult[] = [];
-		for (let index = 0; index < steps.length; index += 1) {
-			input.runtime.exit.throwIfWorkflowExitSelected();
-			const step = steps[index]!;
-			const explicitPrevious = taskPrevious(step);
-			const previous = explicitPrevious ?? (index > 0 ? results[index - 1] : undefined);
-			const prompt = replaceTaskPlaceholder(chainStepPrompt(step, index), options.task ?? "");
-			results.push(
-				await input.task(step.name, taskWithSharedDefaults(taskOptionsFromStep(step, prompt, previous), options)),
-			);
-		}
-		return results;
-	};
-}

package/dist/builtin/workflows/src/engine/primitives/exit.ts

@@ -1,2 +0,0 @@
-export type { WorkflowExitManager } from "../../runs/foreground/executor-exit-manager.js";
-export { createWorkflowExitManager } from "../../runs/foreground/executor-exit-manager.js";

package/dist/builtin/workflows/src/engine/primitives/parallel.ts

@@ -1,74 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { findWorkflowExitSignal } from "../../runs/foreground/executor-abort.js";
-import { mapParallelSteps } from "../../runs/foreground/executor-direct-helpers.js";
-import {
-	parallelFallbackTask,
-	replaceTaskPlaceholder,
-	taskOptionsFromStep,
-	taskPrevious,
-	taskWithSharedDefaults,
-} from "../../runs/foreground/executor-task-prompts.js";
-import type { ParallelFailFastScope, ParallelFailFastStage } from "../../runs/foreground/executor-types.js";
-import { normalizeAutoGroupSentinel } from "../../shared/intercom-group.js";
-import type { WorkflowParallelOptions, WorkflowTaskResult, WorkflowTaskStep } from "../../shared/types.js";
-import type { EngineRuntime } from "../runtime.js";
-import type { WorkflowTaskPrimitive } from "./task.js";
-
-export function createParallelPrimitive(input: {
-	readonly runtime: EngineRuntime;
-	readonly task: WorkflowTaskPrimitive;
-}): (steps: readonly WorkflowTaskStep[], options?: WorkflowParallelOptions) => Promise<WorkflowTaskResult[]> {
-	return async (
-		steps: readonly WorkflowTaskStep[],
-		options: WorkflowParallelOptions = {},
-	): Promise<WorkflowTaskResult[]> => {
-		input.runtime.exit.throwIfWorkflowExitSelected();
-		// Normalize both authored and agent-serialized sentinels before deciding
-		// whether this invocation needs one shared auto-group UUID.
-		const normalizeGroup = <T extends { group?: string | true }>(value: T): T =>
-			value.group === undefined ? value : { ...value, group: normalizeAutoGroupSentinel(value.group) };
-		const normalizedOptions = normalizeGroup(options);
-		const normalizedSteps = steps.map(normalizeGroup);
-		const needsAutoGroup = normalizedOptions.group === true || normalizedSteps.some((step) => step.group === true);
-		const autoGroup = needsAutoGroup ? randomUUID() : undefined;
-		const resolveAutoGroup = <T extends { group?: string | true }>(value: T): T =>
-			value.group === true && autoGroup ? { ...value, group: autoGroup } : value;
-		const resolvedOptions = resolveAutoGroup(normalizedOptions);
-		const resolvedSteps = normalizedSteps.map(resolveAutoGroup);
-		const fallback = parallelFallbackTask(resolvedSteps, resolvedOptions);
-		const failFastEnabled = resolvedOptions.failFast !== false;
-		const parallelScope: ParallelFailFastScope = {
-			failed: false,
-			activeStages: new Map<string, ParallelFailFastStage>(),
-			parentIds: Object.freeze(input.runtime.tracker.currentParents()),
-		};
-		return mapParallelSteps(
-			resolvedSteps,
-			resolvedOptions.concurrency,
-			resolvedOptions.failFast,
-			async (step) => {
-				input.runtime.exit.throwIfWorkflowExitSelected();
-				const prompt = replaceTaskPlaceholder(
-					step.prompt ?? step.task ?? fallback,
-					resolvedOptions.task ?? fallback,
-				);
-				return await input.task(
-					step.name,
-					taskWithSharedDefaults(taskOptionsFromStep(step, prompt, taskPrevious(step)), resolvedOptions),
-					parallelScope,
-				);
-			},
-			async (error) => {
-				if (!failFastEnabled) return;
-				parallelScope.failed = true;
-				parallelScope.firstFailure = error;
-				await Promise.all([...parallelScope.activeStages.values()].map((stage) => stage.skip()));
-			},
-			{
-				beforeDequeue: input.runtime.exit.throwIfWorkflowExitSelected,
-				beforeMap: input.runtime.exit.throwIfWorkflowExitSelected,
-				isControlSignal: (error) => findWorkflowExitSignal(error, input.runtime.exit.exitScope) !== undefined,
-			},
-		);
-	};
-}

package/dist/builtin/workflows/src/engine/primitives/task.ts

@@ -1,127 +0,0 @@
-import {
-	cleanupPreparedWorktrees,
-	collectWorktreeDiffs,
-	prepareTaskWorktrees,
-	stageOptionsWithGitWorktree,
-	stageOptionsWithInputDefaults,
-} from "../../runs/foreground/executor-direct-helpers.js";
-import {
-	applyTaskContext,
-	structuredTaskOutputText,
-	taskPrevious,
-	taskPrompt,
-	taskPromptOptions,
-	taskReadInstruction,
-	taskStageOptions,
-	truncateTaskOutput,
-} from "../../runs/foreground/executor-task-prompts.js";
-import type { ParallelFailFastScope } from "../../runs/foreground/executor-types.js";
-import { RESUME_CONTINUATION_PROMPT } from "../../shared/resume-continuation.js";
-import type {
-	WorkflowChainOptions,
-	WorkflowParallelOptions,
-	WorkflowTaskOptions,
-	WorkflowTaskResult,
-	WorkflowTaskStep,
-} from "../../shared/types.js";
-import type { EngineRuntime } from "../runtime.js";
-import { createChainPrimitive } from "./chain.js";
-import { createParallelPrimitive } from "./parallel.js";
-
-export type WorkflowTaskPrimitive = (
-	name: string,
-	options: WorkflowTaskOptions,
-	stageFailFastScope?: ParallelFailFastScope,
-) => Promise<WorkflowTaskResult>;
-
-export interface WorkflowTaskRunners {
-	task: WorkflowTaskPrimitive;
-	chain(steps: readonly WorkflowTaskStep[], options?: WorkflowChainOptions): Promise<WorkflowTaskResult[]>;
-	parallel(steps: readonly WorkflowTaskStep[], options?: WorkflowParallelOptions): Promise<WorkflowTaskResult[]>;
-}
-
-function createTaskPrimitive(runtime: EngineRuntime): WorkflowTaskPrimitive {
-	return async (
-		name: string,
-		options: WorkflowTaskOptions,
-		stageFailFastScope?: ParallelFailFastScope,
-	): Promise<WorkflowTaskResult> => {
-		runtime.exit.throwIfWorkflowExitSelected();
-		const runTaskOnce = async (taskOptions: WorkflowTaskOptions): Promise<WorkflowTaskResult> => {
-			runtime.exit.throwIfWorkflowExitSelected();
-			const resolvedTaskOptions =
-				stageOptionsWithGitWorktree(
-					stageOptionsWithInputDefaults(taskOptions, runtime.inputRuntimeDefaults),
-					runtime.workflowInvocationCwd,
-					runtime.gitWorktreeSetupCache,
-				) ?? taskOptions;
-			const stageOptions = taskStageOptions(resolvedTaskOptions);
-			const stageHandle = runtime.spawnStage(name, {
-				kind: "agent",
-				...(stageOptions !== undefined ? { options: stageOptions } : {}),
-				...(stageFailFastScope !== undefined ? { failFastScope: stageFailFastScope } : {}),
-			});
-			const stage = stageHandle.context;
-			const promptText =
-				resolvedTaskOptions.resumeFromSessionFile !== undefined
-					? RESUME_CONTINUATION_PROMPT
-					: applyTaskContext(
-							`${taskReadInstruction(resolvedTaskOptions)}${taskPrompt(resolvedTaskOptions)}`,
-							taskPrevious(resolvedTaskOptions),
-						);
-			const rawOutput = await stage.prompt(promptText, taskPromptOptions(resolvedTaskOptions));
-			const structured = typeof rawOutput === "string" ? undefined : rawOutput;
-			const text = truncateTaskOutput(structuredTaskOutputText(rawOutput), resolvedTaskOptions.maxOutput);
-			const sessionId = (() => {
-				try {
-					return stage.sessionId;
-				} catch {
-					return undefined;
-				}
-			})();
-			const stageMeta = stage.__modelFallbackMeta();
-			return {
-				name,
-				stageName: name,
-				text,
-				...(structured !== undefined ? { structured } : {}),
-				...(sessionId !== undefined ? { sessionId } : {}),
-				...(stage.sessionFile !== undefined ? { sessionFile: stage.sessionFile } : {}),
-				...(stageMeta.model !== undefined ? { model: stageMeta.model } : {}),
-				...(stageMeta.fastMode === true ? { fastMode: stageMeta.fastMode } : {}),
-				...(stageMeta.attemptedModels !== undefined ? { attemptedModels: stageMeta.attemptedModels } : {}),
-				...(stageMeta.modelAttempts !== undefined ? { modelAttempts: stageMeta.modelAttempts } : {}),
-				...(stageMeta.warnings !== undefined ? { warnings: stageMeta.warnings } : {}),
-			};
-		};
-
-		if (options.worktree !== true) return runTaskOnce(options);
-		const prepared = prepareTaskWorktrees(
-			[{ ...options, name }],
-			{ ...options, worktree: true },
-			`${runtime.runId}-${name}-${crypto.randomUUID()}`,
-			name,
-			runtime.workflowInvocationCwd,
-			runtime.worktreeSymlinkDirectories,
-		);
-		const preparedTask = prepared.tasks[0]!;
-		try {
-			const result = await runTaskOnce(preparedTask);
-			const worktreeDiffs = collectWorktreeDiffs(prepared, options.artifacts !== false);
-			return worktreeDiffs.artifacts.length === 0
-				? result
-				: { ...result, artifacts: [...(result.artifacts ?? []), ...worktreeDiffs.artifacts] };
-		} finally {
-			cleanupPreparedWorktrees(prepared);
-		}
-	};
-}
-
-export function createWorkflowTaskRunners(input: { readonly runtime: EngineRuntime }): WorkflowTaskRunners {
-	const task = createTaskPrimitive(input.runtime);
-	return {
-		task,
-		chain: createChainPrimitive({ runtime: input.runtime, task }),
-		parallel: createParallelPrimitive({ runtime: input.runtime, task }),
-	};
-}

package/dist/builtin/workflows/src/engine/primitives/ui.ts

@@ -1,54 +0,0 @@
-import { type DurableUiDeps, wrapUiWithDurable } from "../../durable/ui-primitive.js";
-import { makeHeadlessUnavailableUIContext, normalizeUIContext } from "../../runs/foreground/executor-hil.js";
-import type { RunOpts } from "../../runs/foreground/executor-types.js";
-import type { WorkflowUIContext as AuthoringWorkflowUIContext } from "../../shared/authoring-contract-ui.js";
-import type { WorkflowCustomUiFactory, WorkflowCustomUiOptions, WorkflowUIContext } from "../../shared/types.js";
-
-export interface BuildExitGatedUiContextInput {
-	readonly opts: RunOpts;
-	readonly baseFromPromptNodes: () => AuthoringWorkflowUIContext;
-	readonly throwIfWorkflowExitSelected: () => void;
-	/**
-	 * Optional durable UI deps. When provided, completed ctx.ui responses are
-	 * cached durably and replayed on resume instead of re-asking the user.
-	 *
-	 * cross-ref: issue #1498 — durable ctx.ui response/pending prompt state.
-	 */
-	readonly durableUi?: DurableUiDeps;
-}
-
-export function buildExitGatedUiContext(input: BuildExitGatedUiContextInput): WorkflowUIContext {
-	const base =
-		input.opts.usePromptNodesForUi === true
-			? input.baseFromPromptNodes()
-			: input.opts.executionMode === "non_interactive" && input.opts.ui === undefined
-				? makeHeadlessUnavailableUIContext()
-				: normalizeUIContext(input.opts.ui);
-	// Prompt-node continuation owns replay so its stage remains observable;
-	// durable response replay is for non-node UI and fresh redispatches.
-	const promptNodeReplay = input.opts.usePromptNodesForUi === true && input.opts.continuation !== undefined;
-	const durableBase =
-		input.durableUi !== undefined && !promptNodeReplay ? wrapUiWithDurable(base, input.durableUi) : base;
-	return {
-		async input(promptText: string): Promise<string> {
-			input.throwIfWorkflowExitSelected();
-			return await durableBase.input(promptText);
-		},
-		async confirm(message: string): Promise<boolean> {
-			input.throwIfWorkflowExitSelected();
-			return await durableBase.confirm(message);
-		},
-		async select<T extends string>(message: string, options: readonly T[]): Promise<T> {
-			input.throwIfWorkflowExitSelected();
-			return await durableBase.select(message, options);
-		},
-		async editor(initial?: string): Promise<string> {
-			input.throwIfWorkflowExitSelected();
-			return await durableBase.editor(initial);
-		},
-		async custom<T>(factory: WorkflowCustomUiFactory<T>, options?: WorkflowCustomUiOptions): Promise<T> {
-			input.throwIfWorkflowExitSelected();
-			return await durableBase.custom(factory, options);
-		},
-	};
-}