@bastani/atomic 0.9.11-alpha.8 → 0.9.11

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

@@ -1,15 +1,11 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import type { GitResult, GitWorktreeSetupOptions, GitWorktreeSetupResult } from "./worktree-types.js";
-import { openGitWorktreeGenerationAnchor, type GitWorktreeGenerationAnchor } from "./worktree-generation.js";
+import { type GitWorktreeGenerationAnchor, openGitWorktreeGenerationAnchor } from "./worktree-generation.js";
+import { gitFailureMessage, isGitTimeoutResult, runGit, runGitReadOnlyProbe } from "./worktree-git-runner.js";
 import { findCanonicalGitRoot } from "./worktree-root.js";
-import {
-	gitFailureMessage,
-	isGitTimeoutResult,
-	runGit,
-	runGitReadOnlyProbe,
-} from "./worktree-git-runner.js";
+import type { GitResult, GitWorktreeSetupOptions, GitWorktreeSetupResult } from "./worktree-types.js";
 
+export type { GitRunner } from "./worktree-git-runner.js";
 export {
 	gitFailureMessage,
 	isGitTimeoutResult,
@@ -18,7 +14,6 @@ export {
 	runGitPlain,
 	withGitRunnerForTest,
 } from "./worktree-git-runner.js";
-export type { GitRunner } from "./worktree-git-runner.js";
 
 export interface GitWorktreeSetupCache {
 	get(options: GitWorktreeSetupOptions): GitWorktreeSetupResult;
@@ -73,12 +68,15 @@ export function createGitWorktreeSetupCache(): GitWorktreeSetupCache {
 	};
 }
 
-export function setupGitWorktreeCached(options: GitWorktreeSetupOptions, cache?: GitWorktreeSetupCache): GitWorktreeSetupResult {
+export function setupGitWorktreeCached(
+	options: GitWorktreeSetupOptions,
+	cache?: GitWorktreeSetupCache,
+): GitWorktreeSetupResult {
 	return cache?.get(options) ?? setupGitWorktree(options);
 }
 
 function quoteShellArg(value: string): string {
-	if (process.platform === "win32") return `"${value.replace(/"/g, "\"\"")}"`;
+	if (process.platform === "win32") return `"${value.replace(/"/g, '""')}"`;
 	return `'${value.replace(/'/g, "'\\''")}'`;
 }
 
@@ -157,10 +155,14 @@ function validateWorktreeOutsideInvokingCheckout(worktreeRoot: string, repoRoot:
 	const candidate = comparablePathThroughExistingAncestor(worktreeRoot);
 	const relativePath = path.relative(repository, candidate);
 	if (relativePath === "") {
-		throw new Error("gitWorktreeDir must not resolve to the invoking checkout; provide a separate same-repository worktree path.");
+		throw new Error(
+			"gitWorktreeDir must not resolve to the invoking checkout; provide a separate same-repository worktree path.",
+		);
 	}
 	if (!relativePath.startsWith(`..${path.sep}`) && relativePath !== ".." && !path.isAbsolute(relativePath)) {
-		throw new Error("gitWorktreeDir must be outside the invoking checkout; provide a separate same-repository worktree path.");
+		throw new Error(
+			"gitWorktreeDir must be outside the invoking checkout; provide a separate same-repository worktree path.",
+		);
 	}
 }
 
@@ -175,7 +177,8 @@ function pathExistsSync(value: string): boolean {
 		fs.statSync(value);
 		return true;
 	} 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" || code === "ENOTDIR") return false;
 		throw error;
 	}
@@ -185,13 +188,19 @@ function repositoryRootForGitWorktree(cwd: string): string {
 	const result = runGitReadOnlyProbe(cwd, ["rev-parse", "--show-toplevel"]);
 	if (result.status !== 0) {
 		if (isGitTimeoutResult(result)) {
-			throw new Error(`Timed out while checking the Git repository for gitWorktreeDir from ${cwd}. Git reported: ${gitFailureMessage(result)}`);
+			throw new Error(
+				`Timed out while checking the Git repository for gitWorktreeDir from ${cwd}. Git reported: ${gitFailureMessage(result)}`,
+			);
 		}
-		throw new Error(`gitWorktreeDir requires the workflow to be invoked from inside a Git repository. Start from a Git checkout or omit gitWorktreeDir. Git reported: ${gitFailureMessage(result)}`);
+		throw new Error(
+			`gitWorktreeDir requires the workflow to be invoked from inside a Git repository. Start from a Git checkout or omit gitWorktreeDir. Git reported: ${gitFailureMessage(result)}`,
+		);
 	}
 	const normalized = gitPathFromOutput(result.stdout, cwd);
 	if (normalized === undefined) {
-		throw new Error(`gitWorktreeDir could not resolve the repository top level from ${cwd}: git returned an empty path.`);
+		throw new Error(
+			`gitWorktreeDir could not resolve the repository top level from ${cwd}: git returned an empty path.`,
+		);
 	}
 	return normalized;
 }
@@ -207,16 +216,24 @@ export function gitTopLevelFromResult(result: GitResult, cwd: string, descriptio
 }
 
 function gitTopLevel(cwd: string): string | undefined {
-	return gitTopLevelFromResult(runGitReadOnlyProbe(cwd, ["rev-parse", "--show-toplevel"]), cwd, `gitWorktreeDir ${cwd}`);
+	return gitTopLevelFromResult(
+		runGitReadOnlyProbe(cwd, ["rev-parse", "--show-toplevel"]),
+		cwd,
+		`gitWorktreeDir ${cwd}`,
+	);
 }
 
 function gitCommonDirForWorktree(cwd: string): string {
 	const result = runGitReadOnlyProbe(cwd, ["rev-parse", "--git-common-dir"]);
 	if (result.status !== 0) {
 		if (isGitTimeoutResult(result)) {
-			throw new Error(`Timed out while validating Git common directory for gitWorktreeDir ${cwd}. Git reported: ${gitFailureMessage(result)}`);
+			throw new Error(
+				`Timed out while validating Git common directory for gitWorktreeDir ${cwd}. Git reported: ${gitFailureMessage(result)}`,
+			);
 		}
-		throw new Error(`Failed to validate Git common directory for gitWorktreeDir ${cwd}. Git reported: ${gitFailureMessage(result)}`);
+		throw new Error(
+			`Failed to validate Git common directory for gitWorktreeDir ${cwd}. Git reported: ${gitFailureMessage(result)}`,
+		);
 	}
 	const gitPath = gitPathFromOutput(result.stdout, cwd);
 	if (gitPath === undefined) throw new Error("git rev-parse --git-common-dir returned an empty path");
@@ -238,7 +255,8 @@ function cwdWithinGitRepository(cwd: string, repoRoot: string): { relativeCwd: s
 	const sourceCwd = fs.realpathSync.native(cwd);
 	const sourceRepoRoot = fs.realpathSync.native(repoRoot);
 	const relativeCwd = path.relative(sourceRepoRoot, sourceCwd);
-	const safeRelativeCwd = relativeCwd === "" || relativeCwd.startsWith("..") || path.isAbsolute(relativeCwd) ? "" : relativeCwd;
+	const safeRelativeCwd =
+		relativeCwd === "" || relativeCwd.startsWith("..") || path.isAbsolute(relativeCwd) ? "" : relativeCwd;
 	const logicalCwd = canonicalizePreservingSymlinks(cwd);
 	return {
 		relativeCwd: safeRelativeCwd,
@@ -256,10 +274,16 @@ function validateExistingGitWorktreeRoot(worktreeRoot: string, repoRoot: string)
 		throw new Error(`gitWorktreeDir already exists but is not a Git worktree: ${worktreeRoot}`);
 	}
 	if (comparableRealPath(worktreeRoot) !== comparableRealPath(topLevel)) {
-		throw new Error(`gitWorktreeDir already exists but is not a Git worktree root: ${worktreeRoot}. Git top-level checkout is ${topLevel}`);
+		throw new Error(
+			`gitWorktreeDir already exists but is not a Git worktree root: ${worktreeRoot}. Git top-level checkout is ${topLevel}`,
+		);
 	}
-	if (comparableRealPath(gitCommonDirForWorktree(repoRoot)) !== comparableRealPath(gitCommonDirForWorktree(topLevel))) {
-		throw new Error(`gitWorktreeDir already exists but does not belong to the invoking Git repository: ${worktreeRoot}`);
+	if (
+		comparableRealPath(gitCommonDirForWorktree(repoRoot)) !== comparableRealPath(gitCommonDirForWorktree(topLevel))
+	) {
+		throw new Error(
+			`gitWorktreeDir already exists but does not belong to the invoking Git repository: ${worktreeRoot}`,
+		);
 	}
 }
 
@@ -279,7 +303,9 @@ interface GitWorktreeIdentity extends GitWorktreeIdentitySnapshot {
 function gitDirectoryForWorktree(cwd: string): string {
 	const result = runGitReadOnlyProbe(cwd, ["rev-parse", "--absolute-git-dir"]);
 	if (result.status !== 0) {
-		throw new Error(`Failed to validate Git directory for gitWorktreeDir ${cwd}. Git reported: ${gitFailureMessage(result)}`);
+		throw new Error(
+			`Failed to validate Git directory for gitWorktreeDir ${cwd}. Git reported: ${gitFailureMessage(result)}`,
+		);
 	}
 	const gitDir = gitPathFromOutput(result.stdout, cwd);
 	if (gitDir === undefined) throw new Error("git rev-parse --absolute-git-dir returned an empty path");
@@ -322,7 +348,9 @@ function assertCachedGitWorktreeIdentity(cached: CachedGitWorktreeSetup, options
 		current.device !== expected.device ||
 		current.inode !== expected.inode
 	) {
-		throw new Error(`Cached gitWorktreeDir changed before reuse: ${options.gitWorktreeDir}. Start a new run with the intended same-repository worktree.`);
+		throw new Error(
+			`Cached gitWorktreeDir changed before reuse: ${options.gitWorktreeDir}. Start a new run with the intended same-repository worktree.`,
+		);
 	}
 }
 
@@ -354,10 +382,12 @@ export function setupGitWorktree(options: GitWorktreeSetupOptions): GitWorktreeS
 	const baseRef = options.baseBranch?.trim() || "HEAD";
 	const result = runGit(mainRoot, ["worktree", "add", "--detach", worktreeRoot, baseRef]);
 	if (result.status !== 0) {
-		throw new Error([
-			`Failed to create git worktree at requested gitWorktreeDir ${worktreeRoot} from ${baseRef}. Git reported: ${gitFailureMessage(result)}`,
-			`If another process just created this same-repository worktree, rerun the workflow to resume it. If this is an orphaned worktree from an interrupted run, recover or remove it with: ${worktreeRecoveryCommand(mainRoot, worktreeRoot)}`,
-		].join("\n"));
+		throw new Error(
+			[
+				`Failed to create git worktree at requested gitWorktreeDir ${worktreeRoot} from ${baseRef}. Git reported: ${gitFailureMessage(result)}`,
+				`If another process just created this same-repository worktree, rerun the workflow to resume it. If this is an orphaned worktree from an interrupted run, recover or remove it with: ${worktreeRecoveryCommand(mainRoot, worktreeRoot)}`,
+			].join("\n"),
+		);
 	}
 	try {
 		validateWorktreeOutsideInvokingCheckout(worktreeRoot, repoRoot);

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

@@ -23,7 +23,8 @@ function hasTrackedPathComponent(repo: string, relativePath: string): boolean {
 function copyUntrackedFile(mainRoot: string, worktreeRoot: string, relativePath: string): boolean {
 	const source = path.join(mainRoot, relativePath);
 	const destination = path.join(worktreeRoot, relativePath);
-	if (!fs.existsSync(source) || fs.existsSync(destination) || hasTrackedPathComponent(worktreeRoot, relativePath)) return false;
+	if (!fs.existsSync(source) || fs.existsSync(destination) || hasTrackedPathComponent(worktreeRoot, relativePath))
+		return false;
 	fs.mkdirSync(path.dirname(destination), { recursive: true });
 	fs.copyFileSync(source, destination);
 	return true;
@@ -31,8 +32,12 @@ function copyUntrackedFile(mainRoot: string, worktreeRoot: string, relativePath:
 
 function propagateLocalSettings(mainRoot: string, worktreeRoot: string): string[] {
 	const copied: string[] = [];
-	if (copyUntrackedFile(mainRoot, worktreeRoot, ".atomic/settings.local.json")) copied.push(".atomic/settings.local.json");
-	if (!tracked(mainRoot, ".atomic/settings.json") && copyUntrackedFile(mainRoot, worktreeRoot, ".atomic/settings.json")) {
+	if (copyUntrackedFile(mainRoot, worktreeRoot, ".atomic/settings.local.json"))
+		copied.push(".atomic/settings.local.json");
+	if (
+		!tracked(mainRoot, ".atomic/settings.json") &&
+		copyUntrackedFile(mainRoot, worktreeRoot, ".atomic/settings.json")
+	) {
 		copied.push(".atomic/settings.json");
 	}
 	return copied;
@@ -47,7 +52,8 @@ function populatedHooksDirectory(mainRoot: string): string | undefined {
 	}
 	const hooks = path.join(mainRoot, ".git", "hooks");
 	try {
-		const populated = fs.readdirSync(hooks, { withFileTypes: true })
+		const populated = fs
+			.readdirSync(hooks, { withFileTypes: true })
 			.some((entry) => entry.isFile() && !entry.name.endsWith(".sample"));
 		return populated ? hooks : undefined;
 	} catch {
@@ -85,7 +91,8 @@ function symlinkConfiguredDirectories(
 		if (relativePath === undefined || synthetic.includes(relativePath)) continue;
 		const source = path.join(mainRoot, relativePath);
 		const destination = path.join(worktreeRoot, relativePath);
-		if (!fs.existsSync(source) || fs.existsSync(destination) || hasTrackedPathComponent(worktreeRoot, relativePath)) continue;
+		if (!fs.existsSync(source) || fs.existsSync(destination) || hasTrackedPathComponent(worktreeRoot, relativePath))
+			continue;
 		fs.mkdirSync(path.dirname(destination), { recursive: true });
 		try {
 			fs.symlinkSync(source, destination, process.platform === "win32" ? "junction" : undefined);

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

@@ -21,9 +21,10 @@ const DEFAULT_WORKTREE_SETUP_HOOK_TIMEOUT_MS = 30000;
 
 function originDefaultBranch(mainRoot: string): string | undefined {
 	const symbolic = runGit(mainRoot, ["symbolic-ref", "--short", "refs/remotes/origin/HEAD"]);
-	let branch = symbolic.status === 0 && symbolic.stdout.trim().startsWith("origin/")
-		? symbolic.stdout.trim().slice("origin/".length)
-		: undefined;
+	let branch =
+		symbolic.status === 0 && symbolic.stdout.trim().startsWith("origin/")
+			? symbolic.stdout.trim().slice("origin/".length)
+			: undefined;
 	if (!branch) {
 		const remote = runGit(mainRoot, ["remote", "show", "origin"]);
 		branch = remote.status === 0 ? remote.stdout.match(/^\s*HEAD branch:\s*(\S+)\s*$/m)?.[1] : undefined;
@@ -77,10 +78,7 @@ export function findWorktreeTaskCwdConflict(
 	return undefined;
 }
 
-export function formatWorktreeTaskCwdConflict(
-	conflict: WorktreeTaskCwdConflict,
-	sharedCwd: string,
-): string {
+export function formatWorktreeTaskCwdConflict(conflict: WorktreeTaskCwdConflict, sharedCwd: string): string {
 	return `worktree isolation uses the shared cwd (${sharedCwd}); task ${conflict.index + 1} (${conflict.agent}) sets cwd to ${conflict.cwd}. Remove task-level cwd overrides or disable worktree.`;
 }
 
@@ -108,9 +106,7 @@ function resolveRepoCwdRelative(cwd: string): string {
 		throw new Error("worktree isolation requires a git repository");
 	}
 	const rawPrefix = runGitChecked(cwd, ["rev-parse", "--show-prefix"]).trim();
-	const normalizedPrefix = rawPrefix
-		? path.normalize(rawPrefix.replace(/[\\/]+$/, ""))
-		: "";
+	const normalizedPrefix = rawPrefix ? path.normalize(rawPrefix.replace(/[\\/]+$/, "")) : "";
 	return normalizedPrefix === "." ? "" : normalizedPrefix;
 }
 
@@ -203,10 +199,22 @@ function parseWorktreeSetupHookOutput(rawStdout: string): WorktreeSetupHookOutpu
 	return parsed as WorktreeSetupHookOutput;
 }
 
-function runWorktreeSetupHook(
-	hook: ResolvedWorktreeSetupHook,
-	input: WorktreeSetupHookInput,
-): string[] {
+/**
+ * Whether a `spawnSync` error is only the parent's stdin write losing its reader.
+ *
+ * A setup hook is handed its JSON input on stdin, but nothing requires a hook to
+ * read it and most do not. When such a hook exits before that write is flushed,
+ * the write fails with EPIPE even though the hook itself ran to completion — a
+ * race a loaded machine loses far more often than an idle one. Node still
+ * reports the child's real exit status and full stdout in that case, so the
+ * spawn result stays authoritative and only a spawn that never produced a status
+ * is a genuine failure.
+ */
+export function isSpuriousHookStdinWriteFailure(code: string | undefined, status: number | null): boolean {
+	return code === "EPIPE" && status !== null;
+}
+
+function runWorktreeSetupHook(hook: ResolvedWorktreeSetupHook, input: WorktreeSetupHookInput): string[] {
 	const result = spawnSync(hook.hookPath, [], {
 		cwd: input.worktreePath,
 		encoding: "utf-8",
@@ -216,11 +224,13 @@ function runWorktreeSetupHook(
 	});
 
 	if (result.error) {
-		const code = "code" in result.error ? result.error.code : undefined;
+		const code = "code" in result.error && typeof result.error.code === "string" ? result.error.code : undefined;
 		if (code === "ETIMEDOUT") {
 			throw new Error(`worktree setup hook timed out after ${hook.timeoutMs}ms`);
 		}
-		throw new Error(`worktree setup hook failed: ${result.error.message}`);
+		if (!isSpuriousHookStdinWriteFailure(code, result.status)) {
+			throw new Error(`worktree setup hook failed: ${result.error.message}`);
+		}
 	}
 
 	if (result.status !== 0) {
@@ -253,11 +263,15 @@ function waitForGitLockRelease(): void {
 }
 
 function cleanupSingleWorktree(repoCwd: string, worktree: Pick<WorktreeInfo, "path" | "branch">): void {
-	try { runGitChecked(repoCwd, ["worktree", "remove", "--force", worktree.path]); } catch {
+	try {
+		runGitChecked(repoCwd, ["worktree", "remove", "--force", worktree.path]);
+	} catch {
 		// Cleanup is idempotent and best-effort.
 	}
 	waitForGitLockRelease();
-	try { runGitChecked(repoCwd, ["branch", "-D", worktree.branch]); } catch {
+	try {
+		runGitChecked(repoCwd, ["branch", "-D", worktree.branch]);
+	} catch {
 		// Cleanup is idempotent and best-effort.
 	}
 }
@@ -313,7 +327,12 @@ function createSingleWorktree(
 	}
 }
 
-export function createWorktrees(cwd: string, runId: string, count: number, options?: CreateWorktreesOptions): WorktreeSetup {
+export function createWorktrees(
+	cwd: string,
+	runId: string,
+	count: number,
+	options?: CreateWorktreesOptions,
+): WorktreeSetup {
 	const repo = resolveRepoState(cwd, options?.baseBranch);
 	ensureWorktreeIgnore(repo.mainRoot);
 	const setupHook = resolveWorktreeSetupHook(repo.mainRoot, options?.setupHook);
@@ -322,17 +341,19 @@ export function createWorktrees(cwd: string, runId: string, count: number, optio
 
 	try {
 		for (let index = 0; index < count; index++) {
-			worktrees.push(createSingleWorktree(
-				repo.mainRoot,
-				repo.cwdRelative,
-				runId,
-				index,
-				repo.baseRef,
-				repo.baseCommit,
-				symlinkDirectories,
-				setupHook,
-				options?.agents?.[index],
-			));
+			worktrees.push(
+				createSingleWorktree(
+					repo.mainRoot,
+					repo.cwdRelative,
+					runId,
+					index,
+					repo.baseRef,
+					repo.baseCommit,
+					symlinkDirectories,
+					setupHook,
+					options?.agents?.[index],
+				),
+			);
 		}
 	} catch (error) {
 		cleanupWorktrees({ cwd: repo.mainRoot, worktrees, baseCommit: repo.baseCommit });

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

@@ -1,6 +1,8 @@
-export { createGitWorktreeSetupCache, setupGitWorktree, setupGitWorktreeCached } from "./worktree-git.js";
-export { createGitWorktreeSetupCacheOwner } from "./worktree-cache-lifecycle.js";
 export type { GitWorktreeSetupCacheOwner } from "./worktree-cache-lifecycle.js";
+export { createGitWorktreeSetupCacheOwner } from "./worktree-cache-lifecycle.js";
+export { diffWorktrees, formatWorktreeDiffSummary } from "./worktree-diff.js";
+export type { GitWorktreeSetupCache } from "./worktree-git.js";
+export { createGitWorktreeSetupCache, setupGitWorktree, setupGitWorktreeCached } from "./worktree-git.js";
 export {
 	cleanupWorktrees,
 	createWorktrees,
@@ -8,7 +10,6 @@ export {
 	formatWorktreeTaskCwdConflict,
 	resolveExpectedWorktreeAgentCwd,
 } from "./worktree-setup.js";
-export { diffWorktrees, formatWorktreeDiffSummary } from "./worktree-diff.js";
 export type {
 	CreateWorktreesOptions,
 	GitWorktreeSetupOptions,
@@ -18,4 +19,3 @@ export type {
 	WorktreeSetup,
 	WorktreeTaskCwdConflict,
 } from "./worktree-types.js";
-export type { GitWorktreeSetupCache } from "./worktree-git.js";

package/dist/builtin/workflows/src/sdk-surface.ts

@@ -5,37 +5,56 @@
  * discovery. The package root re-exports this module directly.
  */
 
-export { workflow } from "./authoring/workflow.js";
 export type { Static, TSchema } from "typebox";
+export { workflow } from "./authoring/workflow.js";
 
 const REMOVED_RUN_WORKFLOW_MESSAGE =
-  "@bastani/workflows no longer exports runWorkflow; author workflows with workflow({...})";
+	"@bastani/workflows no longer exports runWorkflow; author workflows with workflow({...})";
 
 /**
  * @deprecated Removed imperative workflow API. Kept as a runtime migration
  * stub so older workflow modules fail at the call site with a clear message.
  */
 export const runWorkflow: never = (() => {
-  throw new Error(REMOVED_RUN_WORKFLOW_MESSAGE);
+	throw new Error(REMOVED_RUN_WORKFLOW_MESSAGE);
 }) as never;
 
-export { createRegistry } from "./workflows/registry.js";
-export { normalizeWorkflowName, workflowNamesEqual } from "./workflows/identity.js";
-export type * from "./shared/types.js";
-export { INTERACTIVE_WORKFLOW_POLICY, NON_INTERACTIVE_WORKFLOW_POLICY } from "./shared/types.js";
-export type { AuthoredWorkflowDefinition, AuthoredWorkflowSpec, WorkflowInputsFromSchemas, WorkflowOutputsFromSchemas, WorkflowProvidedInputsFromSchemas } from "./authoring/workflow.js";
-export type { WorkflowRegistry } from "./workflows/registry.js";
+export type {
+	AuthoredWorkflowDefinition,
+	AuthoredWorkflowSpec,
+	WorkflowInputsFromSchemas,
+	WorkflowOutputsFromSchemas,
+	WorkflowProvidedInputsFromSchemas,
+} from "./authoring/workflow.js";
+export type { StageNode } from "./engine/graph-inference.js";
+export { GraphFrontierTracker } from "./engine/graph-inference.js";
+export type { ActiveRunEntry, CancellationRegistry } from "./runs/background/cancellation-registry.js";
+// Phase D — cancellation registry
+export { cancellationRegistry, createCancellationRegistry } from "./runs/background/cancellation-registry.js";
+export type { ResolvedInputs, RunOpts, RunResult } from "./runs/foreground/executor.js";
 
-export { run, resolveInputs } from "./runs/foreground/executor.js";
-export type { RunOpts, RunResult, ResolvedInputs } from "./runs/foreground/executor.js";
+export { resolveInputs, run } from "./runs/foreground/executor.js";
 export type { AgentSessionAdapter, StageAdapters } from "./runs/foreground/stage-runner.js";
-export { GraphFrontierTracker } from "./engine/graph-inference.js";
-export type { StageNode } from "./engine/graph-inference.js";
-export { setupGitWorktree } from "./runs/shared/worktree.js";
 export type { GitWorktreeSetupOptions, GitWorktreeSetupResult } from "./runs/shared/worktree.js";
+export { setupGitWorktree } from "./runs/shared/worktree.js";
 export { createStore, store } from "./shared/store.js";
-export type { RunStatus, StageStatus, ToolEvent, ToolNodeSnapshot, StageSnapshot, RunSnapshot, StoreSnapshot, WorkflowNotice, NoticeLevel, WorkflowOverlayAdapter, PromptKind, CustomPromptIdentitySource, PendingPrompt } from "./shared/store-types.js";
-
-// Phase D — cancellation registry
-export { createCancellationRegistry, cancellationRegistry } from "./runs/background/cancellation-registry.js";
-export type { CancellationRegistry, ActiveRunEntry } from "./runs/background/cancellation-registry.js";
+export type {
+	CustomPromptIdentitySource,
+	NoticeLevel,
+	PendingPrompt,
+	PromptKind,
+	RunSnapshot,
+	RunStatus,
+	StageSnapshot,
+	StageStatus,
+	StoreSnapshot,
+	ToolEvent,
+	ToolNodeSnapshot,
+	WorkflowNotice,
+	WorkflowOverlayAdapter,
+} from "./shared/store-types.js";
+export type * from "./shared/types.js";
+export { INTERACTIVE_WORKFLOW_POLICY, NON_INTERACTIVE_WORKFLOW_POLICY } from "./shared/types.js";
+export { normalizeWorkflowName, workflowNamesEqual } from "./workflows/identity.js";
+export type { WorkflowRegistry } from "./workflows/registry.js";
+export { createRegistry } from "./workflows/registry.js";

package/dist/builtin/workflows/src/shared/authoring-contract-stage.d.ts

@@ -27,7 +27,9 @@ export type RunStatus = "pending" | "running" | "paused" | WorkflowExitStatus |
 export type WorkflowDetailsMode = "named" | "inspection" | "control";
 export type WorkflowDetailsStatus = "accepted" | "running" | WorkflowExitStatus | "failed" | "killed" | "noop";
 export type WorkflowAction = "list" | "get" | "inputs" | "run" | "status" | "interrupt" | "resume";
-type WorkflowExitOutputValues<TOutputs extends WorkflowOutputValues = WorkflowOutputValues> = [keyof TOutputs] extends [never] ? Readonly<Record<string, never>> : Partial<TOutputs>;
+type WorkflowExitOutputValues<TOutputs extends WorkflowOutputValues = WorkflowOutputValues> = [keyof TOutputs] extends [
+    never
+] ? Readonly<Record<string, never>> : Partial<TOutputs>;
 export interface WorkflowExitOptions<TOutputs extends WorkflowOutputValues = WorkflowOutputValues> {
     readonly status?: WorkflowExitStatus;
     readonly reason?: string;
@@ -194,7 +196,7 @@ export type StageSessionEvent = {
     readonly messages?: readonly WorkflowSerializableValue[];
 };
 export interface StageSessionRuntime {
-    prompt(text: string, options?: PromptOptions): Promise<string | void>;
+    prompt(text: string, options?: PromptOptions): Promise<string | undefined>;
     sendUserMessage?(content: StageUserMessageContent, options?: StageSendUserMessageOptions): Promise<void>;
     steer(text: string): Promise<void>;
     followUp(text: string): Promise<void>;
@@ -365,12 +367,16 @@ export interface WorkflowRunChildOptions<TInputs extends WorkflowInputValues = W
     readonly stageName?: string;
 }
 type WorkflowRequiredKeys<T extends object> = {
-    [K in keyof T]-?: {} extends Pick<T, K> ? never : K;
+    [K in keyof T]-?: Record<never, never> extends Pick<T, K> ? never : K;
 }[keyof T];
-export type WorkflowRunChildOptionsArgument<TInputs extends WorkflowInputValues = WorkflowInputValues> = [WorkflowRequiredKeys<TInputs>] extends [never] ? WorkflowRunChildOptions<TInputs> : WorkflowRunChildOptions<TInputs> & {
+export type WorkflowRunChildOptionsArgument<TInputs extends WorkflowInputValues = WorkflowInputValues> = [
+    WorkflowRequiredKeys<TInputs>
+] extends [never] ? WorkflowRunChildOptions<TInputs> : WorkflowRunChildOptions<TInputs> & {
     readonly inputs: TInputs;
 };
-export type WorkflowRunChildArgs<TInputs extends WorkflowInputValues = WorkflowInputValues> = [WorkflowRequiredKeys<TInputs>] extends [never] ? readonly [options?: WorkflowRunChildOptionsArgument<NoInfer<TInputs>>] : readonly [options: WorkflowRunChildOptionsArgument<NoInfer<TInputs>>];
+export type WorkflowRunChildArgs<TInputs extends WorkflowInputValues = WorkflowInputValues> = [
+    WorkflowRequiredKeys<TInputs>
+] extends [never] ? readonly [options?: WorkflowRunChildOptionsArgument<NoInfer<TInputs>>] : readonly [options: WorkflowRunChildOptionsArgument<NoInfer<TInputs>>];
 export interface WorkflowCompletedChildResult<TOutputs extends WorkflowOutputValues = WorkflowOutputValues> extends WorkflowSerializableObject {
     readonly workflow: string;
     readonly runId: string;