@bastani/atomic 0.9.11-alpha.8 → 0.9.11

package/dist/builtin/workflows/src/runs/shared/prompt-callsite.ts

@@ -8,89 +8,89 @@
 import { fileURLToPath } from "node:url";
 
 export interface PromptCallsiteFrame {
-  readonly normalizedPath: string;
-  readonly lineNumber: string;
-  readonly columnNumber: string;
+	readonly normalizedPath: string;
+	readonly lineNumber: string;
+	readonly columnNumber: string;
 }
 
 const PACKAGED_WORKFLOW_RUNTIME_ROOTS = [
-  "/dist/builtin/workflows/src/",
-  "/node_modules/@bastani/workflows/src/",
+	"/dist/builtin/workflows/src/",
+	"/node_modules/@bastani/workflows/src/",
 ] as const;
 
 function normalizeSlashes(path: string): string {
-  return path.replace(/\\/g, "/");
+	return path.replace(/\\/g, "/");
 }
 
 export function normalizeStackPath(framePath: string): string {
-  let normalized = framePath;
-  if (normalized.startsWith("file://")) {
-    try {
-      normalized = fileURLToPath(normalized);
-    } catch {
-      try {
-        normalized = decodeURIComponent(new URL(normalized).pathname);
-      } catch {
-        // Keep the original string; it will only be hashed, not persisted raw.
-      }
-    }
-  }
+	let normalized = framePath;
+	if (normalized.startsWith("file://")) {
+		try {
+			normalized = fileURLToPath(normalized);
+		} catch {
+			try {
+				normalized = decodeURIComponent(new URL(normalized).pathname);
+			} catch {
+				// Keep the original string; it will only be hashed, not persisted raw.
+			}
+		}
+	}
 
-  // Keep the normalized module/file identity absolute. Relativizing against
-  // mutable process.cwd() makes the same persisted workflow callsite hash
-  // differently when a later process starts from another directory.
-  normalized = normalizeSlashes(normalized).replace(/^\/([A-Za-z]:\/)/, "$1");
+	// Keep the normalized module/file identity absolute. Relativizing against
+	// mutable process.cwd() makes the same persisted workflow callsite hash
+	// differently when a later process starts from another directory.
+	normalized = normalizeSlashes(normalized).replace(/^\/([A-Za-z]:\/)/, "$1");
 
-  return normalized;
+	return normalized;
 }
 
 function currentModuleRuntimeRoot(): string | undefined {
-  const modulePath = normalizeStackPath(fileURLToPath(import.meta.url));
-  const markers = ["packages/workflows/src/", ...PACKAGED_WORKFLOW_RUNTIME_ROOTS.map((root) => root.slice(1))];
-  for (const marker of markers) {
-    const index = modulePath.indexOf(marker);
-    if (index >= 0) return modulePath.slice(0, index + marker.length);
-  }
-  return undefined;
+	const modulePath = normalizeStackPath(fileURLToPath(import.meta.url));
+	const markers = ["packages/workflows/src/", ...PACKAGED_WORKFLOW_RUNTIME_ROOTS.map((root) => root.slice(1))];
+	for (const marker of markers) {
+		const index = modulePath.indexOf(marker);
+		if (index >= 0) return modulePath.slice(0, index + marker.length);
+	}
+	return undefined;
 }
 
 const CURRENT_WORKFLOW_RUNTIME_ROOT = currentModuleRuntimeRoot();
 
 export function isWorkflowRuntimeFrame(normalizedPath: string): boolean {
-  const path = normalizeSlashes(normalizedPath);
-  if (path.startsWith("packages/workflows/src/")) return true;
-  if (CURRENT_WORKFLOW_RUNTIME_ROOT !== undefined && path.startsWith(CURRENT_WORKFLOW_RUNTIME_ROOT)) {
-    return true;
-  }
-  const comparable = path.startsWith("/") ? path : `/${path}`;
-  return PACKAGED_WORKFLOW_RUNTIME_ROOTS.some((runtimeRoot) => comparable.includes(runtimeRoot));
+	const path = normalizeSlashes(normalizedPath);
+	if (path.startsWith("packages/workflows/src/")) return true;
+	if (CURRENT_WORKFLOW_RUNTIME_ROOT !== undefined && path.startsWith(CURRENT_WORKFLOW_RUNTIME_ROOT)) {
+		return true;
+	}
+	const comparable = path.startsWith("/") ? path : `/${path}`;
+	return PACKAGED_WORKFLOW_RUNTIME_ROOTS.some((runtimeRoot) => comparable.includes(runtimeRoot));
 }
 
 export function parsePromptStackFrame(stackLine: string): PromptCallsiteFrame | undefined {
-  const line = stackLine.trim();
-  if (line.length === 0) return undefined;
-  if (line.includes("node:internal") || line.includes("bun:") || line.includes("(native:")) return undefined;
+	const line = stackLine.trim();
+	if (line.length === 0) return undefined;
+	if (line.includes("node:internal") || line.includes("bun:") || line.includes("(native:")) return undefined;
 
-  const match = line.match(/(\S+):(\d+):(\d+)\)?$/);
-  if (!match) return undefined;
-  const [, rawFramePath, lineNumber, columnNumber] = match;
-  if (rawFramePath === undefined || lineNumber === undefined || columnNumber === undefined) return undefined;
+	const match = line.match(/(\S+):(\d+):(\d+)\)?$/);
+	if (!match) return undefined;
+	const [, rawFramePath, lineNumber, columnNumber] = match;
+	if (rawFramePath === undefined || lineNumber === undefined || columnNumber === undefined) return undefined;
 
-  const normalizedPath = normalizeStackPath(rawFramePath.replace(/^\(/, ""));
-  return { normalizedPath, lineNumber, columnNumber };
+	const normalizedPath = normalizeStackPath(rawFramePath.replace(/^\(/, ""));
+	return { normalizedPath, lineNumber, columnNumber };
 }
 
 export function normalizedPromptCallsiteFrame(stackLine: string): string | undefined {
-  const frame = parsePromptStackFrame(stackLine);
-  if (frame === undefined) return undefined;
-  if (isWorkflowRuntimeFrame(frame.normalizedPath)) return undefined;
-  return `${frame.normalizedPath}:${frame.lineNumber}:${frame.columnNumber}`;
+	const frame = parsePromptStackFrame(stackLine);
+	if (frame === undefined) return undefined;
+	if (isWorkflowRuntimeFrame(frame.normalizedPath)) return undefined;
+	return `${frame.normalizedPath}:${frame.lineNumber}:${frame.columnNumber}`;
 }
 
 export function selectPromptCallsiteFrame(stack: string): string | undefined {
-  return stack
-    .split("\n")
-    .slice(1)
-    .map(normalizedPromptCallsiteFrame)
-    .find((candidate): candidate is string => candidate !== undefined);
+	return stack
+		.split("\n")
+		.slice(1)
+		.map(normalizedPromptCallsiteFrame)
+		.find((candidate): candidate is string => candidate !== undefined);
 }

package/dist/builtin/workflows/src/runs/shared/validate-inputs.ts

@@ -20,101 +20,92 @@
  */
 
 import { Value } from "typebox/value";
-import {
-  workflowSerializableValidationError,
-  workflowSerializableTypeName,
-} from "../../shared/serializable.js";
-import {
-  schemaChoices,
-  schemaFieldKind,
-  schemaIsRequired,
-} from "../../shared/schema-introspection.js";
+import { schemaChoices, schemaFieldKind, schemaIsRequired } from "../../shared/schema-introspection.js";
+import { workflowSerializableTypeName, workflowSerializableValidationError } from "../../shared/serializable.js";
 import type { TSchema, WorkflowInputValues } from "../../shared/types.js";
 
 export interface ValidationError {
-  key: string;
-  reason: string;
+	key: string;
+	reason: string;
 }
 
 export function validateInputs(
-  schema: Readonly<Record<string, TSchema>>,
-  inputs: WorkflowInputValues,
+	schema: Readonly<Record<string, TSchema>>,
+	inputs: WorkflowInputValues,
 ): ValidationError[] {
-  const errors: ValidationError[] = [];
+	const errors: ValidationError[] = [];
 
-  for (const key of Object.keys(inputs)) {
-    if (!(key in schema)) {
-      errors.push({ key, reason: "unknown input key (not declared by this workflow)" });
-    }
-  }
+	for (const key of Object.keys(inputs)) {
+		if (!(key in schema)) {
+			errors.push({ key, reason: "unknown input key (not declared by this workflow)" });
+		}
+	}
 
-  for (const [key, def] of Object.entries(schema)) {
-    const value = inputs[key];
-    let hasTypeError = false;
+	for (const [key, def] of Object.entries(schema)) {
+		const value = inputs[key];
+		let hasTypeError = false;
 
-    if (value === undefined) {
-      if (schemaIsRequired(def)) {
-        errors.push({ key, reason: "required input is missing" });
-      }
-      continue;
-    }
+		if (value === undefined) {
+			if (schemaIsRequired(def)) {
+				errors.push({ key, reason: "required input is missing" });
+			}
+			continue;
+		}
 
-    const kind = schemaFieldKind(def);
-    switch (kind) {
-      case "text":
-        if (typeof value !== "string") {
-          errors.push({ key, reason: `expected string, got ${workflowSerializableTypeName(value)}` });
-          hasTypeError = true;
-        }
-        break;
-      case "number":
-        if (typeof value !== "number" || !Number.isFinite(value)) {
-          errors.push({ key, reason: `expected finite number, got ${workflowSerializableTypeName(value)}` });
-          hasTypeError = true;
-        }
-        break;
-      case "integer":
-        if (typeof value !== "number" || !Number.isInteger(value)) {
-          errors.push({ key, reason: `expected integer, got ${workflowSerializableTypeName(value)}` });
-          hasTypeError = true;
-        }
-        break;
-      case "boolean":
-        if (typeof value !== "boolean") {
-          errors.push({ key, reason: `expected boolean, got ${workflowSerializableTypeName(value)}` });
-          hasTypeError = true;
-        }
-        break;
-      case "select": {
-        const choices = schemaChoices(def) ?? [];
-        const allowed = choices.join(", ");
-        if (typeof value !== "string") {
-          errors.push({ key, reason: `expected one of [${allowed}], got ${workflowSerializableTypeName(value)}` });
-          hasTypeError = true;
-        } else if (!choices.includes(value)) {
-          errors.push({ key, reason: `must be one of [${allowed}]` });
-        }
-        break;
-      }
-      default:
-        // object / array / unknown: defer to the schema's own checker so a
-        // precise declared shape (Type.Object({ ... }), Type.Array(...)) is
-        // still enforced, while loose schemas accept any serializable value.
-        if (!Value.Check(def, value)) {
-          const first = [...Value.Errors(def, value)][0];
-          errors.push({ key, reason: first === undefined ? `does not match ${kind} schema` : first.message });
-          hasTypeError = true;
-        }
-        break;
-    }
+		const kind = schemaFieldKind(def);
+		switch (kind) {
+			case "text":
+				if (typeof value !== "string") {
+					errors.push({ key, reason: `expected string, got ${workflowSerializableTypeName(value)}` });
+					hasTypeError = true;
+				}
+				break;
+			case "number":
+				if (typeof value !== "number" || !Number.isFinite(value)) {
+					errors.push({ key, reason: `expected finite number, got ${workflowSerializableTypeName(value)}` });
+					hasTypeError = true;
+				}
+				break;
+			case "integer":
+				if (typeof value !== "number" || !Number.isInteger(value)) {
+					errors.push({ key, reason: `expected integer, got ${workflowSerializableTypeName(value)}` });
+					hasTypeError = true;
+				}
+				break;
+			case "boolean":
+				if (typeof value !== "boolean") {
+					errors.push({ key, reason: `expected boolean, got ${workflowSerializableTypeName(value)}` });
+					hasTypeError = true;
+				}
+				break;
+			case "select": {
+				const choices = schemaChoices(def) ?? [];
+				const allowed = choices.join(", ");
+				if (typeof value !== "string") {
+					errors.push({ key, reason: `expected one of [${allowed}], got ${workflowSerializableTypeName(value)}` });
+					hasTypeError = true;
+				} else if (!choices.includes(value)) {
+					errors.push({ key, reason: `must be one of [${allowed}]` });
+				}
+				break;
+			}
+			default:
+				// object / array / unknown: defer to the schema's own checker so a
+				// precise declared shape (Type.Object({ ... }), Type.Array(...)) is
+				// still enforced, while loose schemas accept any serializable value.
+				if (!Value.Check(def, value)) {
+					const first = [...Value.Errors(def, value)][0];
+					errors.push({ key, reason: first === undefined ? `does not match ${kind} schema` : first.message });
+					hasTypeError = true;
+				}
+				break;
+		}
 
-    const serializableError = hasTypeError
-      ? undefined
-      : workflowSerializableValidationError(value, `input "${key}"`);
-    if (serializableError !== undefined) {
-      errors.push({ key, reason: serializableError.replace(/^input "[^"]+" /, "") });
-    }
-  }
+		const serializableError = hasTypeError ? undefined : workflowSerializableValidationError(value, `input "${key}"`);
+		if (serializableError !== undefined) {
+			errors.push({ key, reason: serializableError.replace(/^input "[^"]+" /, "") });
+		}
+	}
 
-  return errors;
+	return errors;
 }

package/dist/builtin/workflows/src/runs/shared/worktree-cache-lifecycle.ts

@@ -5,9 +5,7 @@ export interface GitWorktreeSetupCacheOwner {
 	release(finalizer: () => void): void;
 }
 
-export function createGitWorktreeSetupCacheOwner(
-	suppliedCache?: GitWorktreeSetupCache,
-): GitWorktreeSetupCacheOwner {
+export function createGitWorktreeSetupCacheOwner(suppliedCache?: GitWorktreeSetupCache): GitWorktreeSetupCacheOwner {
 	const cache = suppliedCache ?? createGitWorktreeSetupCache();
 	const ownsCache = suppliedCache === undefined;
 	let released = false;

package/dist/builtin/workflows/src/runs/shared/worktree-cwd.ts

@@ -3,101 +3,114 @@ import { dirname, isAbsolute, relative, resolve, sep } from "node:path";
 import type { GitWorktreeSetupResult } from "./worktree-types.js";
 
 function relativePathWithin(root: string, candidate: string): string | undefined {
-  const path = relative(root, candidate);
-  return path === ".." || path.startsWith(`..${sep}`) || isAbsolute(path) ? undefined : path;
+	const path = relative(root, candidate);
+	return path === ".." || path.startsWith(`..${sep}`) || isAbsolute(path) ? undefined : path;
 }
 
 function existingRealPathThroughAncestor(path: string, description: string): string {
-  let existing = resolve(path);
-  const missing: string[] = [];
-  while (true) {
-    try {
-      return resolve(realpathSync.native(existing), ...missing);
-    } catch (error) {
-      let existingEntry: ReturnType<typeof lstatSync> | undefined;
-      try {
-        existingEntry = lstatSync(existing);
-      } catch {
-        // Missing components are resolved through their nearest existing ancestor.
-      }
-      const code = error && typeof error === "object" && "code" in error
-        ? String((error as { readonly code?: unknown }).code)
-        : undefined;
-      const parent = dirname(existing);
-      if (existingEntry?.isSymbolicLink() === true || (code !== "ENOENT" && code !== "ENOTDIR") || parent === existing) {
-        const message = error instanceof Error ? error.message : String(error);
-        throw new Error(`atomic-workflows: cannot resolve ${description} ${path}: ${message}`);
-      }
-      missing.unshift(existing.slice(parent.length + (parent.endsWith(sep) ? 0 : 1)));
-      existing = parent;
-    }
-  }
+	let existing = resolve(path);
+	const missing: string[] = [];
+	while (true) {
+		try {
+			return resolve(realpathSync.native(existing), ...missing);
+		} catch (error) {
+			let existingEntry: ReturnType<typeof lstatSync> | undefined;
+			try {
+				existingEntry = lstatSync(existing);
+			} catch {
+				// Missing components are resolved through their nearest existing ancestor.
+			}
+			const code =
+				error && typeof error === "object" && "code" in error
+					? String((error as { readonly code?: unknown }).code)
+					: undefined;
+			const parent = dirname(existing);
+			if (
+				existingEntry?.isSymbolicLink() === true ||
+				(code !== "ENOENT" && code !== "ENOTDIR") ||
+				parent === existing
+			) {
+				const message = error instanceof Error ? error.message : String(error);
+				throw new Error(`atomic-workflows: cannot resolve ${description} ${path}: ${message}`);
+			}
+			missing.unshift(existing.slice(parent.length + (parent.endsWith(sep) ? 0 : 1)));
+			existing = parent;
+		}
+	}
 }
 
 function existingRealPath(path: string, description: string): string {
-  try {
-    return realpathSync.native(path);
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    throw new Error(`atomic-workflows: cannot resolve ${description} ${path}: ${message}`);
-  }
+	try {
+		return realpathSync.native(path);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		throw new Error(`atomic-workflows: cannot resolve ${description} ${path}: ${message}`);
+	}
 }
 
-export function resolveWorktreeStageCwd(
-  cwd: string | undefined,
-  setup: GitWorktreeSetupResult,
-): string | undefined {
-  const worktreeRoot = existingRealPath(setup.worktreeRoot, "gitWorktreeDir");
-  const repositoryRoot = existingRealPath(setup.repositoryRoot, "invoking checkout");
-  if (cwd === undefined || cwd.length === 0) return undefined;
+export function resolveWorktreeStageCwd(cwd: string | undefined, setup: GitWorktreeSetupResult): string | undefined {
+	const worktreeRoot = existingRealPath(setup.worktreeRoot, "gitWorktreeDir");
+	const repositoryRoot = existingRealPath(setup.repositoryRoot, "invoking checkout");
+	if (cwd === undefined || cwd.length === 0) return undefined;
 
-  const absoluteInput = isAbsolute(cwd);
-  const candidate = absoluteInput ? cwd : resolve(setup.cwd, cwd);
-  if (!absoluteInput && relativePathWithin(setup.worktreeRoot, candidate) === undefined) {
-    throw new Error(`atomic-workflows: relative cwd ${cwd} escapes gitWorktreeDir ${setup.worktreeRoot}; choose a cwd inside the worktree.`);
-  }
-  const candidateRealPath = existingRealPath(candidate, "cwd");
-  const worktreeRelative = relativePathWithin(worktreeRoot, candidateRealPath);
-  if (worktreeRelative !== undefined) return resolve(setup.worktreeRoot, worktreeRelative);
-  if (!isAbsolute(cwd)) {
-    throw new Error(`atomic-workflows: relative cwd ${cwd} escapes gitWorktreeDir ${setup.worktreeRoot}; choose a path that remains inside the selected worktree.`);
-  }
-  if (relativePathWithin(setup.worktreeRoot, candidate) !== undefined) {
-    throw new Error(`atomic-workflows: cwd ${cwd} resolves outside gitWorktreeDir ${setup.worktreeRoot}; remove the escaping symlink or choose a cwd inside the worktree.`);
-  }
+	const absoluteInput = isAbsolute(cwd);
+	const candidate = absoluteInput ? cwd : resolve(setup.cwd, cwd);
+	if (!absoluteInput && relativePathWithin(setup.worktreeRoot, candidate) === undefined) {
+		throw new Error(
+			`atomic-workflows: relative cwd ${cwd} escapes gitWorktreeDir ${setup.worktreeRoot}; choose a cwd inside the worktree.`,
+		);
+	}
+	const candidateRealPath = existingRealPath(candidate, "cwd");
+	const worktreeRelative = relativePathWithin(worktreeRoot, candidateRealPath);
+	if (worktreeRelative !== undefined) return resolve(setup.worktreeRoot, worktreeRelative);
+	if (!isAbsolute(cwd)) {
+		throw new Error(
+			`atomic-workflows: relative cwd ${cwd} escapes gitWorktreeDir ${setup.worktreeRoot}; choose a path that remains inside the selected worktree.`,
+		);
+	}
+	if (relativePathWithin(setup.worktreeRoot, candidate) !== undefined) {
+		throw new Error(
+			`atomic-workflows: cwd ${cwd} resolves outside gitWorktreeDir ${setup.worktreeRoot}; remove the escaping symlink or choose a cwd inside the worktree.`,
+		);
+	}
 
-  const repositoryRelative = absoluteInput
-    ? relativePathWithin(repositoryRoot, candidateRealPath)
-    : undefined;
-  if (repositoryRelative === undefined) {
-    throw new Error(`atomic-workflows: cwd ${cwd} is outside gitWorktreeDir ${setup.worktreeRoot}; use a cwd inside the invoking repository so Atomic can remap it, or omit cwd.`);
-  }
-  const mappedCwd = resolve(setup.worktreeRoot, repositoryRelative);
-  const mappedRealPath = existingRealPath(mappedCwd, "remapped worktree cwd");
-  if (relativePathWithin(worktreeRoot, mappedRealPath) === undefined) {
-    throw new Error(`atomic-workflows: cwd ${cwd} remaps through a path that resolves outside gitWorktreeDir ${setup.worktreeRoot}; remove the escaping symlink or omit cwd.`);
-  }
-  return mappedCwd;
+	const repositoryRelative = absoluteInput ? relativePathWithin(repositoryRoot, candidateRealPath) : undefined;
+	if (repositoryRelative === undefined) {
+		throw new Error(
+			`atomic-workflows: cwd ${cwd} is outside gitWorktreeDir ${setup.worktreeRoot}; use a cwd inside the invoking repository so Atomic can remap it, or omit cwd.`,
+		);
+	}
+	const mappedCwd = resolve(setup.worktreeRoot, repositoryRelative);
+	const mappedRealPath = existingRealPath(mappedCwd, "remapped worktree cwd");
+	if (relativePathWithin(worktreeRoot, mappedRealPath) === undefined) {
+		throw new Error(
+			`atomic-workflows: cwd ${cwd} remaps through a path that resolves outside gitWorktreeDir ${setup.worktreeRoot}; remove the escaping symlink or omit cwd.`,
+		);
+	}
+	return mappedCwd;
 }
 
-
 export function resolveContainedRelativePath(
-  root: string,
-  baseDir: string,
-  relativePath: string,
-  description: string,
+	root: string,
+	baseDir: string,
+	relativePath: string,
+	description: string,
 ): string {
-  if (isAbsolute(relativePath) || relativePath.split(/[\\/]+/).includes("..")) {
-    throw new Error(`atomic-workflows: relative output ${relativePath} escapes ${description} ${root}; use a path without parent traversal.`);
-  }
-  const candidate = resolve(baseDir, relativePath);
-  if (relativePathWithin(resolve(root), candidate) === undefined) {
-    throw new Error(`atomic-workflows: relative output ${relativePath} escapes ${description} ${root}.`);
-  }
-  const realRoot = existingRealPath(root, description);
-  const realCandidate = existingRealPathThroughAncestor(candidate, "relative output");
-  if (relativePathWithin(realRoot, realCandidate) === undefined) {
-    throw new Error(`atomic-workflows: relative output ${relativePath} resolves outside ${description} ${root} through a symlink.`);
-  }
-  return candidate;
+	if (isAbsolute(relativePath) || relativePath.split(/[\\/]+/).includes("..")) {
+		throw new Error(
+			`atomic-workflows: relative output ${relativePath} escapes ${description} ${root}; use a path without parent traversal.`,
+		);
+	}
+	const candidate = resolve(baseDir, relativePath);
+	if (relativePathWithin(resolve(root), candidate) === undefined) {
+		throw new Error(`atomic-workflows: relative output ${relativePath} escapes ${description} ${root}.`);
+	}
+	const realRoot = existingRealPath(root, description);
+	const realCandidate = existingRealPathThroughAncestor(candidate, "relative output");
+	if (relativePathWithin(realRoot, realCandidate) === undefined) {
+		throw new Error(
+			`atomic-workflows: relative output ${relativePath} resolves outside ${description} ${root} through a symlink.`,
+		);
+	}
+	return candidate;
 }

package/dist/builtin/workflows/src/runs/shared/worktree-diff.ts

@@ -10,7 +10,13 @@ function safePatchAgentName(agent: string): string {
 function removeSyntheticPath(worktree: WorktreeInfo, syntheticPath: string): void {
 	const resolved = path.resolve(worktree.path, syntheticPath);
 	const relative = path.relative(worktree.path, resolved);
-	if (!relative || relative === "." || relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) {
+	if (
+		!relative ||
+		relative === "." ||
+		relative === ".." ||
+		relative.startsWith(`..${path.sep}`) ||
+		path.isAbsolute(relative)
+	) {
 		return;
 	}
 
@@ -18,7 +24,8 @@ function removeSyntheticPath(worktree: WorktreeInfo, syntheticPath: string): voi
 	try {
 		stat = fs.lstatSync(resolved);
 	} catch (error) {
-		const code = error && typeof error === "object" && "code" in error ? (error as { code?: unknown }).code : undefined;
+		const code =
+			error && typeof error === "object" && "code" in error ? (error as { code?: unknown }).code : undefined;
 		if (code === "ENOENT") return;
 		throw error;
 	}

package/dist/builtin/workflows/src/runs/shared/worktree-git-runner.ts

@@ -11,9 +11,16 @@ let gitRunnerOverride: GitRunner | undefined;
 function gitCommandArgs(args: readonly string[]): string[] {
 	return ["-c", `core.hooksPath=${DISABLED_GIT_HOOKS_PATH}`, "-c", "core.fsmonitor=false", ...args];
 }
-function gitCommandArgv(args: readonly string[]): string[] { return ["git", ...gitCommandArgs(args)]; }
+function gitCommandArgv(args: readonly string[]): string[] {
+	return ["git", ...gitCommandArgs(args)];
+}
 function withDiagnostics(result: GitResult, cwd: string, args: readonly string[]): GitResult {
-	return { ...result, argv: result.argv ?? gitCommandArgv(args), cwd: result.cwd ?? cwd, timeoutMs: result.timeoutMs ?? GIT_COMMAND_TIMEOUT_MS };
+	return {
+		...result,
+		argv: result.argv ?? gitCommandArgv(args),
+		cwd: result.cwd ?? cwd,
+		timeoutMs: result.timeoutMs ?? GIT_COMMAND_TIMEOUT_MS,
+	};
 }
 function spawnGit(cwd: string, args: readonly string[], plain: boolean): GitResult {
 	const startedAt = Date.now();
@@ -24,15 +31,22 @@ function spawnGit(cwd: string, args: readonly string[], plain: boolean): GitResu
 		timeout: GIT_COMMAND_TIMEOUT_MS,
 	});
 	return {
-		stdout: result.stdout ?? "", stderr: result.stderr ?? "", status: result.status ?? null,
-		signal: result.signal ?? null, elapsedMs: Math.max(0, Date.now() - startedAt),
+		stdout: result.stdout ?? "",
+		stderr: result.stderr ?? "",
+		status: result.status ?? null,
+		signal: result.signal ?? null,
+		elapsedMs: Math.max(0, Date.now() - startedAt),
 		...(result.error === undefined ? {} : { error: result.error }),
 	};
 }
 export function withGitRunnerForTest<T>(runner: GitRunner, callback: () => T): T {
 	const previous = gitRunnerOverride;
 	gitRunnerOverride = runner;
-	try { return callback(); } finally { gitRunnerOverride = previous; }
+	try {
+		return callback();
+	} finally {
+		gitRunnerOverride = previous;
+	}
 }
 export function runGit(cwd: string, args: readonly string[]): GitResult {
 	return withDiagnostics((gitRunnerOverride ?? ((dir, values) => spawnGit(dir, values, false)))(cwd, args), cwd, args);
@@ -73,7 +87,8 @@ function diagnosticSuffix(result: GitResult): string {
 export function gitFailureMessage(result: GitResult): string {
 	if (result.error !== undefined) {
 		const code = gitErrorCode(result.error);
-		if (isGitTimeoutResult(result)) return `git command timed out after ${result.timeoutMs ?? GIT_COMMAND_TIMEOUT_MS}ms${code === undefined ? "" : ` (${code})`}: ${result.error.message}${diagnosticSuffix(result)}`;
+		if (isGitTimeoutResult(result))
+			return `git command timed out after ${result.timeoutMs ?? GIT_COMMAND_TIMEOUT_MS}ms${code === undefined ? "" : ` (${code})`}: ${result.error.message}${diagnosticSuffix(result)}`;
 		return `${code === undefined ? result.error.message : `${code}: ${result.error.message}`}${diagnosticSuffix(result)}`;
 	}
 	return `${result.stderr.trim() || result.stdout.trim() || `git exited with status ${result.status}`}${diagnosticSuffix(result)}`;