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

package/dist/builtin/workflows/src/runs/foreground/executor-child-helpers.ts

@@ -1,79 +0,0 @@
-import { isBrandedWorkflowDefinition } from "../../authoring/workflow.js";
-import type { WorkflowChildReplaySnapshot } from "../../shared/store-types.js";
-import type {
-	WorkflowChildResult,
-	WorkflowDefinition,
-	WorkflowOutputValues,
-	WorkflowSerializableValue,
-} from "../../shared/types.js";
-
-export function cloneWorkflowChildValue<T>(value: T): T {
-	return structuredClone(value);
-}
-
-function workflowChildSerializationMessage(err: unknown): string {
-	return err instanceof Error ? err.message : String(err);
-}
-
-export function isWorkflowDefinition(value: unknown): value is WorkflowDefinition {
-	if (value === null || typeof value !== "object" || !isBrandedWorkflowDefinition(value)) return false;
-	const record = value as Partial<WorkflowDefinition>;
-	return (
-		record.__piWorkflow === true &&
-		typeof record.name === "string" &&
-		record.name.trim().length > 0 &&
-		typeof record.normalizedName === "string" &&
-		record.normalizedName.trim().length > 0 &&
-		typeof record.run === "function" &&
-		typeof record.inputs === "object" &&
-		record.inputs !== null
-	);
-}
-
-export function workflowDefinitionRequirementMessage(callSite: string, value: unknown): string {
-	if (value !== null && typeof value === "object" && (value as { __piWorkflow?: unknown }).__piWorkflow === true) {
-		return `atomic-workflows: ${callSite} requires a workflow definition produced by workflow({...}); hand-rolled __piWorkflow objects are not supported`;
-	}
-	return `atomic-workflows: ${callSite} requires a workflow definition`;
-}
-
-export function cloneWorkflowChildReplaySnapshot(snapshot: WorkflowChildReplaySnapshot): WorkflowChildReplaySnapshot {
-	return {
-		alias: snapshot.alias,
-		workflow: snapshot.workflow,
-		runId: snapshot.runId,
-		status: snapshot.status,
-		...(snapshot.exited !== undefined ? { exited: snapshot.exited } : {}),
-		outputs: cloneWorkflowChildValue(snapshot.outputs),
-		...(snapshot.exitReason !== undefined ? { exitReason: snapshot.exitReason } : {}),
-	};
-}
-
-export function workflowChildReplaySnapshot(
-	alias: string,
-	childResult: WorkflowChildResult,
-): WorkflowChildReplaySnapshot {
-	const outputs: Record<string, WorkflowSerializableValue> = {};
-	for (const [key, value] of Object.entries(childResult.outputs as WorkflowOutputValues)) {
-		if (value === undefined) continue;
-		try {
-			outputs[key] = cloneWorkflowChildValue(value);
-		} catch (err) {
-			throw new Error(
-				`atomic-workflows: child workflow "${alias}" (${childResult.workflow}) exposed output "${key}" is not serializable for continuation replay: ${workflowChildSerializationMessage(err)}`,
-				{ cause: err },
-			);
-		}
-	}
-
-	const exitReason = childResult.exited === true ? childResult.exitReason : undefined;
-	return {
-		alias,
-		workflow: childResult.workflow,
-		runId: childResult.runId,
-		status: childResult.status,
-		exited: childResult.exited,
-		outputs,
-		...(exitReason !== undefined ? { exitReason } : {}),
-	};
-}

package/dist/builtin/workflows/src/runs/foreground/executor-child-workflow.ts

@@ -1 +0,0 @@
-export { createChildWorkflowRunner } from "../../engine/primitives/workflow.js";

package/dist/builtin/workflows/src/runs/foreground/executor-continuation.ts

@@ -1,207 +0,0 @@
-import type { StageSnapshot } from "../../shared/store-types.js";
-import type { RunContinuationOpts } from "./executor-types.js";
-
-export type PromptAnswerReplaySafety = "allowed" | "unavailable" | "ambiguous";
-
-export function getPromptAnswerState(
-	hasReplayAnswer: boolean,
-	replaySourceId: string | undefined,
-	answerReplay: PromptAnswerReplaySafety,
-): StageSnapshot["promptAnswerState"] {
-	if (replaySourceId === undefined) return undefined;
-	if (hasReplayAnswer) return "available";
-	if (answerReplay === "ambiguous") return "ambiguous";
-	return "unavailable";
-}
-
-export type ContinuationReplayDecision =
-	| {
-			readonly kind: "execute";
-			readonly source?: StageSnapshot;
-			readonly parentIds: readonly string[];
-			readonly answerReplay: PromptAnswerReplaySafety;
-	  }
-	| {
-			readonly kind: "replay";
-			readonly source: StageSnapshot;
-			readonly parentIds: readonly string[];
-			readonly answerReplay: PromptAnswerReplaySafety;
-	  };
-
-interface ContinuationReplayInput {
-	readonly displayName: string;
-	readonly replayKey: string;
-	readonly parentIds: readonly string[];
-	readonly stageId: string;
-	readonly kind: "stage" | "prompt" | "workflow";
-}
-
-export interface ContinuationReplayIndex {
-	decide(input: ContinuationReplayInput): ContinuationReplayDecision;
-	markPromptAnswerReplayed(stageId: string): void;
-}
-
-export function sameStringSet(left: readonly string[], right: readonly string[]): boolean {
-	if (left.length !== right.length) return false;
-	const rightSet = new Set(right);
-	return left.every((value) => rightSet.has(value));
-}
-
-function sortedIdentity(values: readonly string[]): string {
-	return [...values].sort().join("\u0000");
-}
-
-export function createContinuationReplayIndex(continuation: RunContinuationOpts | undefined): ContinuationReplayIndex {
-	if (continuation === undefined) {
-		return {
-			decide: (input) => ({
-				kind: "execute",
-				parentIds: input.parentIds,
-				answerReplay: "unavailable",
-			}),
-			markPromptAnswerReplayed: () => {},
-		};
-	}
-	if (continuation.resumeFromStageId === undefined) {
-		if (continuation.source.stages.length > 0)
-			throw new Error(
-				`atomic-workflows: insufficient_state: continuation has no resume stage in source run ${continuation.source.id}`,
-			);
-		return {
-			decide: (input) => ({
-				kind: "execute",
-				parentIds: input.parentIds,
-				answerReplay: "unavailable",
-			}),
-			markPromptAnswerReplayed: () => {},
-		};
-	}
-	const resumeStage = continuation.source.stages.find((stage) => stage.id === continuation.resumeFromStageId);
-	if (resumeStage === undefined) {
-		throw new Error(
-			`atomic-workflows: insufficient_state: resume stage ${continuation.resumeFromStageId} was not found in source run ${continuation.source.id}`,
-		);
-	}
-
-	const stagesByReplayIdentity = new Map<string, StageSnapshot[]>();
-	const stagesByDisplayName = new Map<string, StageSnapshot[]>();
-	const promptDuplicateCounts = new Map<string, number>();
-	for (const stage of continuation.source.stages) {
-		const identity = stage.replayKey ?? stage.name;
-		const stages = stagesByReplayIdentity.get(identity);
-		if (stages === undefined) stagesByReplayIdentity.set(identity, [stage]);
-		else stages.push(stage);
-		const namedStages = stagesByDisplayName.get(stage.name);
-		if (namedStages === undefined) stagesByDisplayName.set(stage.name, [stage]);
-		else namedStages.push(stage);
-		const duplicateKeys = [
-			`${identity}\u0001${sortedIdentity(stage.parentIds)}`,
-			...(identity === stage.name ? [] : [`${stage.name}\u0001${sortedIdentity(stage.parentIds)}`]),
-		];
-		for (const duplicateKey of duplicateKeys) {
-			promptDuplicateCounts.set(duplicateKey, (promptDuplicateCounts.get(duplicateKey) ?? 0) + 1);
-		}
-	}
-
-	const consumedSourceStageIds = new Set<string>();
-	const continuationStageIdBySourceStageId = new Map<string, string>();
-	const replayablePromptContinuationStageIds = new Set<string>();
-
-	const failTopology = (displayName: string, replayKey: string, reason: "mismatch" | "ambiguous"): never => {
-		throw new Error(
-			`atomic-workflows: insufficient_state: replay topology ${reason} for stage "${displayName}" (replayKey "${replayKey}") in source run ${continuation.source.id}`,
-		);
-	};
-
-	const translateSourceParents = (source: StageSnapshot): string[] | undefined => {
-		const parentIds: string[] = [];
-		for (const sourceParentId of source.parentIds) {
-			const continuationParentId = continuationStageIdBySourceStageId.get(sourceParentId);
-			if (continuationParentId === undefined) return undefined;
-			parentIds.push(continuationParentId);
-		}
-		return parentIds;
-	};
-
-	const allSameParentSet = (candidates: readonly { readonly parentIds: readonly string[] }[]): boolean => {
-		const first = candidates[0]?.parentIds;
-		if (first === undefined) return false;
-		return candidates.every((candidate) => sameStringSet(candidate.parentIds, first));
-	};
-
-	const hasOnlyReplayablePromptParentDrift = (
-		sourceParentIds: readonly string[],
-		provisionalParentIds: readonly string[],
-	): boolean => {
-		const sourceParentSet = new Set(sourceParentIds);
-		const provisionalParentSet = new Set(provisionalParentIds);
-		const driftParentIds = [
-			...sourceParentIds.filter((parentId) => !provisionalParentSet.has(parentId)),
-			...provisionalParentIds.filter((parentId) => !sourceParentSet.has(parentId)),
-		];
-		return (
-			driftParentIds.length > 0 &&
-			driftParentIds.every((parentId) => replayablePromptContinuationStageIds.has(parentId))
-		);
-	};
-
-	return {
-		markPromptAnswerReplayed(stageId: string): void {
-			replayablePromptContinuationStageIds.add(stageId);
-		},
-
-		decide(input: ContinuationReplayInput): ContinuationReplayDecision {
-			const { displayName, replayKey, parentIds, stageId, kind } = input;
-			let identity = replayKey;
-			let candidates =
-				stagesByReplayIdentity.get(replayKey)?.filter((stage) => !consumedSourceStageIds.has(stage.id)) ?? [];
-			if (candidates.length === 0) {
-				identity = displayName;
-				const namedCandidates =
-					stagesByDisplayName.get(displayName)?.filter((stage) => !consumedSourceStageIds.has(stage.id)) ?? [];
-				candidates =
-					kind === "prompt" ? namedCandidates.filter((stage) => stage.replayKey === undefined) : namedCandidates;
-			}
-			if (candidates.length === 0) return { kind: "execute", parentIds, answerReplay: "unavailable" };
-
-			const mappedCandidates = candidates
-				.map((source) => ({ source, parentIds: translateSourceParents(source) }))
-				.filter(
-					(candidate): candidate is { readonly source: StageSnapshot; readonly parentIds: string[] } =>
-						candidate.parentIds !== undefined,
-				);
-
-			if (mappedCandidates.length === 0) failTopology(displayName, replayKey, "mismatch");
-
-			const provisionalMatches = mappedCandidates.filter((candidate) =>
-				sameStringSet(candidate.parentIds, parentIds),
-			);
-			const hasPromptDriftMatch =
-				kind === "prompt" &&
-				allSameParentSet(mappedCandidates) &&
-				hasOnlyReplayablePromptParentDrift(mappedCandidates[0]!.parentIds, parentIds);
-			let matches: typeof mappedCandidates | undefined;
-			if (provisionalMatches.length > 0) matches = provisionalMatches;
-			else if (hasPromptDriftMatch) matches = mappedCandidates;
-			if (matches === undefined) return failTopology(displayName, replayKey, "mismatch");
-			if (matches.length > 1 && (kind !== "prompt" || !allSameParentSet(matches))) {
-				failTopology(displayName, replayKey, "ambiguous");
-			}
-
-			const selected = matches[0]!;
-			const duplicateKey = `${identity}\u0001${sortedIdentity(selected.source.parentIds)}`;
-			const ambiguousPromptAnswer = kind === "prompt" && (promptDuplicateCounts.get(duplicateKey) ?? 0) > 1;
-			const answerReplay: PromptAnswerReplaySafety = ambiguousPromptAnswer
-				? "ambiguous"
-				: selected.source.status === "completed"
-					? "allowed"
-					: "unavailable";
-			consumedSourceStageIds.add(selected.source.id);
-			continuationStageIdBySourceStageId.set(selected.source.id, stageId);
-			if (selected.source.status === "completed" && answerReplay === "allowed") {
-				return { kind: "replay", source: selected.source, parentIds: selected.parentIds, answerReplay };
-			}
-			return { kind: "execute", source: selected.source, parentIds: selected.parentIds, answerReplay };
-		},
-	};
-}

package/dist/builtin/workflows/src/runs/foreground/executor-direct-helpers.ts

@@ -1,321 +0,0 @@
-import { isAbsolute, join, resolve } from "node:path";
-import { CONFIG_DIR_NAME, isCodexFastModeCandidateModelId } from "@bastani/atomic";
-import type { WorkflowActor } from "../../shared/store-types.js";
-import type { StageOptions, WorkflowArtifact, WorkflowTaskOptions, WorkflowTaskStep } from "../../shared/types.js";
-import { workflowArtifactRunPath } from "../../shared/workflow-artifacts.js";
-import { buildModelCandidatesFromCatalog, workflowModelId } from "../shared/model-fallback.js";
-import {
-	cleanupWorktrees,
-	createWorktrees,
-	diffWorktrees,
-	findWorktreeTaskCwdConflict,
-	formatWorktreeDiffSummary,
-	formatWorktreeTaskCwdConflict,
-	type GitWorktreeSetupCache,
-	type GitWorktreeSetupResult,
-	setupGitWorktreeCached,
-	type WorktreeSetup,
-} from "../shared/worktree.js";
-import { resolveWorktreeStageCwd } from "../shared/worktree-cwd.js";
-import { withoutUndefinedProperties } from "./executor-task-prompts.js";
-import type { RunOpts } from "./executor-types.js";
-
-export type { GitWorktreeSetupCache } from "../shared/worktree.js";
-export { createGitWorktreeSetupCache, createGitWorktreeSetupCacheOwner } from "../shared/worktree.js";
-
-export function positiveConcurrency(value: number | undefined): number | undefined {
-	if (typeof value !== "number" || !Number.isFinite(value) || value < 1) return undefined;
-	return Math.floor(value);
-}
-
-export async function mapParallelSteps<T>(
-	steps: readonly WorkflowTaskStep[],
-	concurrency: number | undefined,
-	failFast: boolean | undefined,
-	mapper: (step: WorkflowTaskStep) => Promise<T>,
-	onFirstFailure?: (error: unknown) => void | Promise<void>,
-	control?: {
-		readonly beforeDequeue?: () => void;
-		readonly beforeMap?: () => void;
-		readonly isControlSignal?: (error: unknown) => boolean;
-	},
-): Promise<T[]> {
-	const limit = positiveConcurrency(concurrency) ?? steps.length;
-	const failFastEnabled = failFast !== false;
-	const results = new Array<T>(steps.length);
-	const failures: Array<{ readonly index: number; readonly error: unknown }> = [];
-	let nextIndex = 0;
-	let firstFailure: unknown;
-	let controlSignal: unknown;
-	let rejectFirstFailure: (reason: unknown) => void = () => {};
-	const firstFailurePromise = new Promise<never>((_, reject) => {
-		rejectFirstFailure = reject;
-	});
-
-	const isControlSignal = (error: unknown): boolean => control?.isControlSignal?.(error) === true;
-	const selectControlSignal = (error: unknown): void => {
-		if (controlSignal !== undefined) return;
-		controlSignal = error;
-		if (failFastEnabled) rejectFirstFailure(error);
-	};
-	const recordFailure = async (index: number, error: unknown): Promise<void> => {
-		failures.push({ index, error });
-		if (firstFailure === undefined) {
-			firstFailure = error;
-			await onFirstFailure?.(error);
-			if (failFastEnabled) rejectFirstFailure(error);
-		}
-	};
-
-	async function worker(): Promise<void> {
-		while (true) {
-			if (controlSignal !== undefined || (failFastEnabled && firstFailure !== undefined)) return;
-			try {
-				control?.beforeDequeue?.();
-			} catch (error) {
-				if (isControlSignal(error)) selectControlSignal(error);
-				else await recordFailure(nextIndex, error);
-				return;
-			}
-			if (controlSignal !== undefined) return;
-			const index = nextIndex;
-			nextIndex += 1;
-			const step = steps[index];
-			if (step === undefined) return;
-			try {
-				control?.beforeMap?.();
-				results[index] = await mapper(step);
-			} catch (error) {
-				if (isControlSignal(error)) {
-					selectControlSignal(error);
-					return;
-				}
-				await recordFailure(index, error);
-				if (failFastEnabled) return;
-			}
-		}
-	}
-
-	const allWorkers = Promise.all(Array.from({ length: Math.min(limit, steps.length) }, () => worker()));
-	if (!failFastEnabled) await allWorkers;
-	else {
-		try {
-			await Promise.race([allWorkers, firstFailurePromise]);
-		} catch (error) {
-			void allWorkers.catch(() => {});
-			throw error;
-		}
-	}
-
-	if (controlSignal !== undefined) throw controlSignal;
-	if (failures.length > 0) {
-		throw new AggregateError(
-			failures.map((failure) => failure.error),
-			`atomic-workflows: ${failures.length} parallel ${failures.length === 1 ? "step" : "steps"} failed`,
-		);
-	}
-	return results;
-}
-
-export function stageOptionsWithInputDefaults<T extends StageOptions>(
-	options: T | undefined,
-	inputDefaults: Partial<StageOptions>,
-): T | undefined {
-	const defaults = withoutUndefinedProperties(inputDefaults);
-	if (Object.keys(defaults).length === 0) return options;
-	return { ...defaults, ...withoutUndefinedProperties(options ?? {}) } as T;
-}
-
-export function stageOptionsWithGitWorktree<T extends StageOptions>(
-	options: T | undefined,
-	workflowInvocationCwd: string,
-	cache?: GitWorktreeSetupCache,
-): T | undefined {
-	if (options === undefined) return undefined;
-	if (typeof options.gitWorktreeDir !== "string") return options;
-	if (options.gitWorktreeDir.trim().length === 0) {
-		throw new Error(
-			"atomic-workflows: gitWorktreeDir cannot be empty; provide a reusable worktree path or omit gitWorktreeDir for a non-worktree run.",
-		);
-	}
-	const setup = setupGitWorktreeCached(
-		{
-			gitWorktreeDir: options.gitWorktreeDir,
-			baseBranch: options.baseBranch,
-			cwd: workflowInvocationCwd,
-		},
-		cache,
-	);
-	const explicitCwd = resolveWorktreeStageCwd(options.cwd, setup);
-	return { ...options, gitWorktreeDir: undefined, baseBranch: undefined, cwd: explicitCwd ?? setup.cwd };
-}
-
-export function setupWorkflowInputGitWorktree(
-	inputDefaults: Partial<StageOptions>,
-	workflowInvocationCwd: string,
-	cache?: GitWorktreeSetupCache,
-): GitWorktreeSetupResult | undefined {
-	if (typeof inputDefaults.gitWorktreeDir !== "string" || inputDefaults.gitWorktreeDir.trim().length === 0)
-		return undefined;
-	return setupGitWorktreeCached(
-		{
-			gitWorktreeDir: inputDefaults.gitWorktreeDir,
-			baseBranch: inputDefaults.baseBranch,
-			cwd: workflowInvocationCwd,
-		},
-		cache,
-	);
-}
-
-export function workflowCwdWithInputWorktree(
-	inputDefaults: Partial<StageOptions>,
-	workflowInvocationCwd: string,
-	cache?: GitWorktreeSetupCache,
-): string {
-	return setupWorkflowInputGitWorktree(inputDefaults, workflowInvocationCwd, cache)?.cwd ?? workflowInvocationCwd;
-}
-
-export function workflowInvocationMetadata(
-	inputDefaults: Partial<StageOptions>,
-	workflowInvocationCwd: string,
-	cache?: GitWorktreeSetupCache,
-	origin?: WorkflowActor,
-): {
-	readonly invocationCwd: string;
-	readonly workflowCwd?: string;
-	readonly repositoryRoot?: string;
-	readonly gitWorktreeRoot?: string;
-	readonly origin?: WorkflowActor;
-} {
-	const setup = setupWorkflowInputGitWorktree(inputDefaults, workflowInvocationCwd, cache);
-	return {
-		invocationCwd: workflowInvocationCwd,
-		...(setup !== undefined
-			? { workflowCwd: setup.cwd, repositoryRoot: setup.repositoryRoot, gitWorktreeRoot: setup.worktreeRoot }
-			: {}),
-		...(origin !== undefined ? { origin } : {}),
-	};
-}
-
-export interface TaskOutputIsolation {
-	readonly baseDir: string;
-	readonly trustedRoot: string;
-}
-
-export interface PreparedTaskWorktrees {
-	readonly tasks: WorkflowTaskStep[];
-	readonly setup?: WorktreeSetup;
-	readonly agents: string[];
-	readonly diffsDir?: string;
-	readonly outputIsolations?: readonly TaskOutputIsolation[];
-}
-
-function resolvedTaskCwd(cwd: string | undefined, workflowInvocationCwd: string): string | undefined {
-	if (cwd === undefined) return undefined;
-	return isAbsolute(cwd) ? cwd : resolve(workflowInvocationCwd, cwd);
-}
-
-function taskWorktreeOutputsRoot(runId: string): string {
-	return join(workflowArtifactRunPath(runId), "task-outputs");
-}
-
-export function prepareTaskWorktrees(
-	tasks: readonly WorkflowTaskStep[],
-	options: WorkflowTaskOptions,
-	runId: string,
-	scope: string,
-	workflowInvocationCwd: string = process.cwd(),
-	symlinkDirectories?: readonly string[],
-): PreparedTaskWorktrees {
-	if (options.worktree !== true && !tasks.some((task) => task.worktree === true)) {
-		return { tasks: [...tasks], agents: tasks.map((task) => task.name) };
-	}
-	if (typeof options.gitWorktreeDir === "string" || tasks.some((task) => typeof task.gitWorktreeDir === "string")) {
-		throw new Error(
-			"atomic-workflows: worktree and gitWorktreeDir are mutually exclusive; use gitWorktreeDir for a reusable worktree or worktree:true for temporary isolated worktrees.",
-		);
-	}
-	const explicitCwd = tasks.find((task) => typeof task.cwd === "string")?.cwd;
-	const sharedCwd =
-		explicitCwd === undefined
-			? workflowInvocationCwd
-			: isAbsolute(explicitCwd)
-				? explicitCwd
-				: resolve(workflowInvocationCwd, explicitCwd);
-	const conflict = findWorktreeTaskCwdConflict(
-		tasks.map((task) => ({ agent: task.name, cwd: resolvedTaskCwd(task.cwd, workflowInvocationCwd) })),
-		sharedCwd,
-	);
-	if (conflict !== undefined) throw new Error(formatWorktreeTaskCwdConflict(conflict, sharedCwd));
-
-	const agents = tasks.map((task) => task.name);
-	const setup = createWorktrees(sharedCwd, runId, tasks.length, {
-		agents,
-		baseBranch: options.baseBranch,
-		symlinkDirectories,
-	});
-	const trustedRoot = taskWorktreeOutputsRoot(runId);
-	return {
-		tasks: tasks.map((task, index) => ({ ...task, cwd: setup.worktrees[index]!.agentCwd })),
-		setup,
-		agents,
-		diffsDir: join(setup.cwd, CONFIG_DIR_NAME, "workflows", "worktree-diffs", runId, scope),
-		outputIsolations: tasks.map((_, index) => ({
-			baseDir: join(trustedRoot, runId, scope, String(index)),
-			trustedRoot,
-		})),
-	};
-}
-
-export function collectWorktreeDiffs(
-	prepared: PreparedTaskWorktrees,
-	enabled = true,
-): {
-	artifacts: WorkflowArtifact[];
-	summary?: string;
-} {
-	if (!enabled || prepared.setup === undefined || prepared.diffsDir === undefined) return { artifacts: [] };
-	const diffs = diffWorktrees(prepared.setup, prepared.agents, prepared.diffsDir);
-	const artifacts = diffs.map((diff) => ({
-		kind: "diff" as const,
-		path: diff.patchPath,
-		taskName: diff.agent,
-		branch: diff.branch,
-		diffStat: diff.diffStat,
-		filesChanged: diff.filesChanged,
-		insertions: diff.insertions,
-		deletions: diff.deletions,
-	}));
-	const summary = formatWorktreeDiffSummary(diffs);
-	return { artifacts, ...(summary.length > 0 ? { summary } : {}) };
-}
-
-export function cleanupPreparedWorktrees(prepared: PreparedTaskWorktrees): void {
-	if (prepared.setup !== undefined) cleanupWorktrees(prepared.setup);
-}
-
-export async function hasExplicitFastModeCandidate(input: {
-	readonly model?: StageOptions["model"];
-	readonly fallbackModels?: readonly string[];
-	readonly models?: RunOpts["models"];
-}): Promise<boolean> {
-	const rawCandidate =
-		isCodexFastModeCandidate(input.model) ||
-		(Array.isArray(input.fallbackModels) &&
-			input.fallbackModels.some((candidate) => isCodexFastModeCandidate(candidate)));
-	if (rawCandidate) return true;
-	try {
-		const candidates = await buildModelCandidatesFromCatalog({
-			primaryModel: input.model,
-			fallbackModels: input.fallbackModels,
-			catalog: input.models,
-		});
-		return candidates.some((candidate) => isCodexFastModeCandidate(candidate.id));
-	} catch {
-		return false;
-	}
-}
-
-function isCodexFastModeCandidate(model: StageOptions["model"] | string | undefined): boolean {
-	return isCodexFastModeCandidateModelId(workflowModelId(model));
-}