@keystrokehq/cli 0.0.1

package/dist/workflow-build-DBQaBfnn.mjs

@@ -0,0 +1,1819 @@
+#!/usr/bin/env node
+
+import { i as __toESM, n as __exportAll } from "./chunk-CH6r78ws.mjs";
+import { a as originalConsole, h as toErrorMessage, i as logger, o as ANSI, s as style, t as ui } from "./keystroke.mjs";
+import { a as getKeystrokeTmpDir } from "./dist-CUK7yBM0.mjs";
+import { t as assertWorkflowProjectRoot } from "./project-config-D1qsQlO7.mjs";
+import { c as FlowGraphSchema, s as WorkflowManifestSchema } from "./_manifest-JSRE3H8k.mjs";
+import { t as AgentVersionManifestSchema } from "./agent-manifest-CDnbkR2f.mjs";
+import { r as RelativeFilePathSchema } from "./file-metadata-D1vm-XY2.mjs";
+import { c as createArtifactOutputFiles, l as createMetadataOutputFile, o as METADATA_ROOT_DIR_NAME, p as getWorkflowArtifactPaths, t as BUILD_DIR_NAME } from "./layout-CbMtQ2tm.mjs";
+import { t as resolveConfiguredBuildOutputDir } from "./utils-CywxCDM7.mjs";
+import { a as readAgentSandboxPackage, r as AGENT_VM_TOOLS_RUNTIME_RELATIVE_PATH } from "./agent-bundle-package-DWV6B_5q-BtV7Xycc.mjs";
+import { a as prewarmFileContentCache, c as typedEntries, i as createFileContentCache, l as require_out, n as computeBuilderFingerprint, o as resetFileContentCache, r as computeWorkflowFingerprint, s as sha256String } from "./metadata-layout-GUYIUo0i-_aG2zjue.mjs";
+import { a as getAgentArtifactPaths, c as hashWorkflowManifestForDisk, d as resolveOutputDir, i as createAgentOutputFiles, l as removeAgentArtifacts, n as BUILD_CACHE_FILE_NAME, o as hashAgentManifestForDisk, r as allOutputFilesExist, s as hashWorkflowFlowForDisk, t as AGENT_ARTIFACT_DIR_PREFIX, u as removeWorkflowArtifacts } from "./writer-BG8poUm3-BbXlU2kI.mjs";
+import { a as createDiscoveryFailure, c as createNamespaceStarExportDiscoveryError, d as isWorkflowLoadResult, f as loadWorkflowMetadataBatch, i as createAmbiguousExportDiscoveryError, l as isAgentLoadResult, o as createDuplicateWorkflowIdFailure, t as DuplicateWorkflowIdError, u as isTaskLoadResult } from "./import-module-CV84H5fZ-B_CBCmb4.mjs";
+import { a as literalString, n as identifierName, o as parseSourceFile, r as isNode } from "./oxc-B3KI3rf_-n9d1hKNq.mjs";
+import { a as getLocalModuleSpecifier, c as removeAllMetadataArtifacts, d as resolveDefaultExportAssignment, f as resolveLocalModulePath, i as collectWorkflowImportNames, n as DISCOVERY_IGNORE, o as getVariableDeclarators, r as collectLocalWorkflowBindings, s as isExportedVariableStatement, t as DISCOVERY_GLOB, u as removeMetadataArtifacts } from "./source-analysis-Cj-ADyu--BJQcFPCG.mjs";
+import { n as parseRelativeFilePath } from "./normalize-path-CojS-CgQ-DLCOvnD1.mjs";
+import * as fs from "node:fs/promises";
+import { mkdir, readFile, stat, writeFile } from "node:fs/promises";
+import * as path$1 from "node:path";
+import path from "node:path";
+import { z } from "zod";
+import { fileURLToPath } from "node:url";
+import { createHash } from "node:crypto";
+import "oxc-parser";
+import { performance } from "node:perf_hooks";
+//#region ../../packages/workflow-core/dist/chunks/schema-DnT5yizJ.mjs
+var import_out = /* @__PURE__ */ __toESM(require_out(), 1);
+const MAX_JSON_DEPTH = 20;
+function buildJsonValueSchema(depth) {
+	const primitives = z.union([
+		z.string(),
+		z.number(),
+		z.boolean(),
+		z.null()
+	]);
+	if (depth <= 0) return primitives;
+	const nested = buildJsonValueSchema(depth - 1);
+	return z.union([
+		primitives,
+		z.array(nested),
+		z.record(z.string(), nested)
+	]);
+}
+const jsonValueSchema = buildJsonValueSchema(MAX_JSON_DEPTH);
+z.record(z.string(), jsonValueSchema);
+z.custom((value) => value instanceof z.ZodType, "Expected a Zod schema");
+z.custom((value) => value instanceof z.ZodObject, "Expected a Zod object schema");
+//#endregion
+//#region ../../packages/workflow-core/dist/flow-graph-toolkit/index.mjs
+function detectAgentInPathCycles(input) {
+	const nodes = /* @__PURE__ */ new Map();
+	const edges = /* @__PURE__ */ new Map();
+	for (const node of [
+		...input.agents,
+		...input.workflows,
+		...input.operations
+	]) {
+		nodes.set(node.id, node);
+		edges.set(node.id, node.kind === "agent" ? node.tools : node.kind === "workflow" ? node.callees : []);
+	}
+	const cycles = [];
+	const path = [];
+	const visited = /* @__PURE__ */ new Set();
+	const visit = (id) => {
+		const existingIndex = path.indexOf(id);
+		if (existingIndex >= 0) {
+			const cycleNodes = path.slice(existingIndex).concat(id).flatMap((cycleId) => {
+				const node = nodes.get(cycleId);
+				return node ? [toCycleNode(node)] : [];
+			});
+			if (cycleNodes.some((node) => node.kind === "agent")) cycles.push({
+				path: cycleNodes,
+				description: cycleNodes.map((node) => `${node.kind}:${node.id}`).join(" -> ")
+			});
+			return;
+		}
+		if (visited.has(id)) return;
+		visited.add(id);
+		path.push(id);
+		for (const next of edges.get(id) ?? []) visit(next);
+		path.pop();
+	};
+	for (const id of nodes.keys()) visit(id);
+	return cycles;
+}
+function toCycleNode(node) {
+	return {
+		kind: node.kind,
+		id: node.id,
+		displayName: node.displayName,
+		source: node.source
+	};
+}
+//#endregion
+//#region ../../packages/workflow-builder/dist/build-9Sd6SkIz.mjs
+const DiscoveredWorkflowSchema = z.object({
+	exportFilePath: z.string(),
+	resolvedFilePath: z.string(),
+	relativePath: z.string(),
+	exportName: z.string(),
+	isDefaultExport: z.boolean(),
+	localExportName: z.string(),
+	bindingKey: z.string(),
+	exportKind: z.union([
+		z.literal("workflow"),
+		z.literal("agent"),
+		z.literal("task")
+	])
+});
+const ScanCacheEntrySchema = z.object({
+	mtimeMs: z.number(),
+	size: z.number(),
+	hasWorkflow: z.boolean(),
+	exportNames: z.array(z.string()),
+	discoveryEntries: z.array(DiscoveredWorkflowSchema),
+	dependencyPaths: z.array(z.string())
+});
+const WorkflowCacheEntrySchema = z.object({
+	bindingKey: z.string(),
+	workflowId: z.string(),
+	resolvedFilePath: z.string().optional(),
+	inputFingerprint: z.string(),
+	dependencyPaths: z.array(z.string()),
+	manifestHash: z.string(),
+	flowGraphHash: z.string(),
+	bundleHash: z.string(),
+	sourceMapHash: z.string().optional(),
+	outputFiles: z.array(z.string()),
+	updatedAt: z.string()
+});
+const AgentCacheEntrySchema = z.object({
+	bindingKey: z.string(),
+	agentId: z.string(),
+	resolvedFilePath: z.string().optional(),
+	inputFingerprint: z.string(),
+	dependencyPaths: z.array(z.string()),
+	manifestHash: z.string(),
+	bundleHash: z.string(),
+	sandboxPackageHash: z.string(),
+	sourceMapHash: z.string().optional(),
+	outputFiles: z.array(z.string()),
+	updatedAt: z.string()
+});
+const FileMetadataCacheEntrySchema = z.object({
+	filePath: RelativeFilePathSchema,
+	sourceChecksum: z.string().length(64).regex(/^[a-f0-9]{64}$/i),
+	metadataHash: z.string().min(1),
+	outputFile: z.string().min(1),
+	updatedAt: z.iso.datetime(),
+	crossReferenceFingerprint: z.string().min(1).optional()
+});
+const BuildCacheSchema = z.object({
+	cacheVersion: z.literal(2),
+	builderFingerprint: z.string(),
+	scanEntries: z.record(z.string(), ScanCacheEntrySchema),
+	bindings: z.record(z.string(), WorkflowCacheEntrySchema),
+	agentBindings: z.record(z.string(), AgentCacheEntrySchema).default({}),
+	metadata: z.record(z.string(), FileMetadataCacheEntrySchema).default({})
+});
+function sha256Buffer(buffer) {
+	return createHash("sha256").update(buffer).digest("hex");
+}
+async function readBuildCache(outputDir) {
+	const cachePath = path.join(outputDir, BUILD_CACHE_FILE_NAME);
+	try {
+		const parsed = JSON.parse(await readFile(cachePath, "utf-8"));
+		const result = BuildCacheSchema.safeParse(parsed);
+		return result.success ? result.data : null;
+	} catch {
+		return null;
+	}
+}
+async function writeBuildCache(outputDir, cache) {
+	const cachePath = path.join(outputDir, BUILD_CACHE_FILE_NAME);
+	const validatedCache = BuildCacheSchema.parse(cache);
+	await mkdir(outputDir, { recursive: true });
+	await writeFile(cachePath, `${JSON.stringify(validatedCache, null, 2)}\n`, "utf-8");
+}
+function createEmptyBuildCache(builderFingerprint) {
+	return {
+		cacheVersion: 2,
+		builderFingerprint,
+		scanEntries: {},
+		bindings: {},
+		agentBindings: {},
+		metadata: {}
+	};
+}
+async function loadCachedArtifact(outputDir, discoveredWorkflow, cachedEntry) {
+	if (!await allOutputFilesExist(outputDir, cachedEntry.outputFiles)) return null;
+	try {
+		const artifactPaths = getWorkflowArtifactPaths(outputDir, cachedEntry.workflowId);
+		const [manifestText, flowText, bundleCode, sourceMap] = await Promise.all([
+			readFile(artifactPaths.manifestPath, "utf-8"),
+			readFile(artifactPaths.flowPath, "utf-8"),
+			readFile(artifactPaths.bundlePath, "utf-8"),
+			cachedEntry.sourceMapHash ? readFile(artifactPaths.sourceMapPath, "utf-8") : null
+		]);
+		if (sha256String(manifestText) !== cachedEntry.manifestHash) return null;
+		if (sha256String(flowText) !== cachedEntry.flowGraphHash) return null;
+		const manifest = WorkflowManifestSchema.parse(JSON.parse(manifestText));
+		const flowGraph = FlowGraphSchema.parse(JSON.parse(flowText));
+		if (manifest.id !== cachedEntry.workflowId) return null;
+		if (path.basename(artifactPaths.workflowDir) !== manifest.id) return null;
+		if (sha256String(bundleCode) !== cachedEntry.bundleHash) return null;
+		if (cachedEntry.sourceMapHash && sourceMap && sha256String(sourceMap) !== cachedEntry.sourceMapHash) return null;
+		return {
+			workflow: {
+				...discoveredWorkflow,
+				workflowId: manifest.id
+			},
+			manifest,
+			flowGraph,
+			bundle: {
+				code: bundleCode,
+				sourceMap,
+				hash: cachedEntry.bundleHash,
+				...cachedEntry.sourceMapHash ? { sourceMapHash: cachedEntry.sourceMapHash } : {},
+				localDependencies: [...cachedEntry.dependencyPaths],
+				externalImports: [],
+				size: Buffer.byteLength(bundleCode)
+			},
+			triggers: [],
+			timing: {
+				importMs: 0,
+				manifestMs: 0,
+				flowGraphMs: 0,
+				bundleMs: 0,
+				triggerMs: 0,
+				totalMs: 0
+			}
+		};
+	} catch {
+		return null;
+	}
+}
+async function loadCachedAgentArtifact(outputDir, discoveredWorkflow, cachedEntry) {
+	if (!await allOutputFilesExist(outputDir, cachedEntry.outputFiles)) return null;
+	try {
+		const artifactPaths = getAgentArtifactPaths(outputDir, cachedEntry.agentId);
+		const [manifestText, sandboxPackageBuffer] = await Promise.all([readFile(artifactPaths.manifestPath, "utf-8"), readFile(artifactPaths.sandboxPackagePath)]);
+		if (sha256String(manifestText) !== cachedEntry.manifestHash) return null;
+		const manifest = AgentVersionManifestSchema.parse(JSON.parse(manifestText));
+		if (sha256Buffer(sandboxPackageBuffer) !== cachedEntry.sandboxPackageHash) return null;
+		const toolsRuntimeFile = (await readAgentSandboxPackage(sandboxPackageBuffer)).find((file) => path.posix.normalize(file.path) === AGENT_VM_TOOLS_RUNTIME_RELATIVE_PATH);
+		if (!toolsRuntimeFile) return null;
+		const bundleCode = Buffer.isBuffer(toolsRuntimeFile.content) ? toolsRuntimeFile.content.toString("utf-8") : toolsRuntimeFile.content;
+		if (sha256String(bundleCode) !== cachedEntry.bundleHash) return null;
+		return {
+			agent: {
+				bindingKey: discoveredWorkflow.bindingKey,
+				exportFilePath: discoveredWorkflow.exportFilePath,
+				resolvedFilePath: discoveredWorkflow.resolvedFilePath,
+				exportName: discoveredWorkflow.exportName,
+				localExportName: discoveredWorkflow.localExportName,
+				agentId: cachedEntry.agentId,
+				agentName: manifest.agentName
+			},
+			manifest,
+			bundle: {
+				code: bundleCode,
+				sourceMap: null,
+				hash: cachedEntry.bundleHash,
+				localDependencies: [...cachedEntry.dependencyPaths],
+				externalImports: [],
+				size: Buffer.byteLength(bundleCode)
+			},
+			sandboxPackage: {
+				buffer: sandboxPackageBuffer,
+				size: sandboxPackageBuffer.byteLength,
+				hash: cachedEntry.sandboxPackageHash
+			},
+			timing: {
+				importMs: 0,
+				manifestMs: 0,
+				bundleMs: 0,
+				totalMs: 0
+			}
+		};
+	} catch {
+		return null;
+	}
+}
+function createWorkflowCacheEntries(artifacts, validatedHashes) {
+	return Object.fromEntries(artifacts.map((artifact) => {
+		const outputFiles = createArtifactOutputFiles(artifact.workflow.workflowId, artifact.bundle.sourceMap !== null || artifact.bundle.sourceMapHash !== void 0 || artifact.bundle.sourceMapPath !== void 0);
+		const existing = validatedHashes?.get(artifact.workflow.bindingKey);
+		return [artifact.workflow.bindingKey, {
+			bindingKey: artifact.workflow.bindingKey,
+			workflowId: artifact.workflow.workflowId,
+			resolvedFilePath: artifact.workflow.resolvedFilePath,
+			inputFingerprint: "",
+			dependencyPaths: artifact.bundle.localDependencies.filter((dependencyPath) => path.isAbsolute(dependencyPath) && !dependencyPath.includes("\0")),
+			manifestHash: existing?.manifestHash ?? hashWorkflowManifestForDisk(artifact.manifest),
+			flowGraphHash: existing?.flowGraphHash ?? hashWorkflowFlowForDisk(artifact.flowGraph),
+			bundleHash: existing?.bundleHash ?? artifact.bundle.hash ?? sha256String(artifact.bundle.code),
+			sourceMapHash: existing?.sourceMapHash ?? artifact.bundle.sourceMapHash ?? (artifact.bundle.sourceMap ? sha256String(artifact.bundle.sourceMap) : void 0),
+			outputFiles,
+			updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+		}];
+	}));
+}
+function createAgentCacheEntries(artifacts, validatedHashes) {
+	return Object.fromEntries(artifacts.map((artifact) => {
+		const existing = validatedHashes?.get(artifact.agent.bindingKey);
+		return [artifact.agent.bindingKey, {
+			bindingKey: artifact.agent.bindingKey,
+			agentId: artifact.agent.agentId,
+			resolvedFilePath: artifact.agent.resolvedFilePath,
+			inputFingerprint: "",
+			dependencyPaths: artifact.bundle.localDependencies.filter((dependencyPath) => path.isAbsolute(dependencyPath) && !dependencyPath.includes("\0")),
+			manifestHash: existing?.manifestHash ?? hashAgentManifestForDisk(artifact.manifest),
+			bundleHash: existing?.bundleHash ?? artifact.bundle.hash ?? sha256String(artifact.bundle.code),
+			sandboxPackageHash: existing?.sandboxPackageHash ?? sha256Buffer(artifact.sandboxPackage.buffer),
+			outputFiles: createAgentOutputFiles(artifact.agent.agentId),
+			updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+		}];
+	}));
+}
+async function resolveCachedArtifacts(options) {
+	const cachedArtifacts = [];
+	const cachedAgentArtifacts = [];
+	const workflowsToBuild = [];
+	const fingerprintByBinding = /* @__PURE__ */ new Map();
+	const validatedHashesByBinding = /* @__PURE__ */ new Map();
+	const warnings = [];
+	let cacheHits = 0;
+	let cacheMisses = 0;
+	let cachedWorkflowIndex = 0;
+	const cacheResolutionStartedAt = performance.now();
+	createFileContentCache();
+	await prewarmFileContentCache(collectDependencyPaths(options.scopedDiscoveredWorkflows, options.buildCache));
+	for (const discoveredWorkflow of options.scopedDiscoveredWorkflows) {
+		if (options.config.force) {
+			workflowsToBuild.push(discoveredWorkflow);
+			cacheMisses += 1;
+			continue;
+		}
+		if (discoveredWorkflow.exportKind === "agent") {
+			const resolved = await resolveCachedAgentArtifact({
+				buildCache: options.buildCache,
+				discoveredWorkflow,
+				outputDir: options.outputDir,
+				fingerprintByBinding
+			});
+			if (!resolved) {
+				workflowsToBuild.push(discoveredWorkflow);
+				cacheMisses += 1;
+				continue;
+			}
+			cachedAgentArtifacts.push(resolved.artifact);
+			cacheHits += 1;
+			validatedHashesByBinding.set(discoveredWorkflow.bindingKey, resolved.validatedHashes);
+			continue;
+		}
+		const resolved = await resolveCachedWorkflowArtifact({
+			config: options.config,
+			buildCache: options.buildCache,
+			discoveredWorkflow,
+			outputDir: options.outputDir,
+			fingerprintByBinding
+		});
+		if (!resolved) {
+			workflowsToBuild.push(discoveredWorkflow);
+			cacheMisses += 1;
+			continue;
+		}
+		cachedArtifacts.push(resolved.artifact);
+		cacheHits += 1;
+		validatedHashesByBinding.set(discoveredWorkflow.bindingKey, resolved.validatedHashes);
+		options.emit({
+			phase: "workflow-stage",
+			stage: "cached",
+			workflow: resolved.artifact.workflow,
+			workflowIndex: cachedWorkflowIndex,
+			workflowCount: options.scopedWorkflowCount,
+			elapsedMs: 0
+		});
+		cachedWorkflowIndex += 1;
+	}
+	resetFileContentCache();
+	const cacheResolutionMs = performance.now() - cacheResolutionStartedAt;
+	options.emit({
+		phase: "cache-stats",
+		cacheHits,
+		cacheMisses,
+		invalidated: options.cacheInvalidated
+	});
+	return {
+		cachedArtifacts,
+		cachedAgentArtifacts,
+		workflowsToBuild,
+		fingerprintByBinding,
+		validatedHashesByBinding,
+		warnings,
+		cacheHits,
+		cacheMisses,
+		cacheResolutionMs
+	};
+}
+function collectDependencyPaths(scopedDiscoveredWorkflows, buildCache) {
+	const allDepPaths = [];
+	for (const discoveredWorkflow of scopedDiscoveredWorkflows) {
+		allDepPaths.push(discoveredWorkflow.resolvedFilePath);
+		const cached = discoveredWorkflow.exportKind === "agent" ? buildCache.agentBindings[discoveredWorkflow.bindingKey] : buildCache.bindings[discoveredWorkflow.bindingKey];
+		if (cached) allDepPaths.push(...cached.dependencyPaths);
+	}
+	return allDepPaths;
+}
+async function resolveCachedAgentArtifact(options) {
+	const cachedEntry = options.buildCache.agentBindings[options.discoveredWorkflow.bindingKey];
+	if (!cachedEntry) return null;
+	try {
+		const inputFingerprint = await computeWorkflowFingerprint(options.discoveredWorkflow.resolvedFilePath, cachedEntry.dependencyPaths);
+		options.fingerprintByBinding.set(options.discoveredWorkflow.bindingKey, inputFingerprint);
+		if (inputFingerprint !== cachedEntry.inputFingerprint) return null;
+		const artifact = await loadCachedAgentArtifact(options.outputDir, options.discoveredWorkflow, cachedEntry);
+		if (!artifact) return null;
+		return {
+			artifact,
+			validatedHashes: {
+				manifestHash: cachedEntry.manifestHash,
+				bundleHash: cachedEntry.bundleHash,
+				sandboxPackageHash: cachedEntry.sandboxPackageHash
+			}
+		};
+	} catch {
+		return null;
+	}
+}
+async function resolveCachedWorkflowArtifact(options) {
+	const cachedEntry = options.buildCache.bindings[options.discoveredWorkflow.bindingKey];
+	if (!cachedEntry) return null;
+	try {
+		const inputFingerprint = await computeWorkflowFingerprint(options.discoveredWorkflow.resolvedFilePath, cachedEntry.dependencyPaths);
+		options.fingerprintByBinding.set(options.discoveredWorkflow.bindingKey, inputFingerprint);
+		if (inputFingerprint !== cachedEntry.inputFingerprint) return null;
+		const artifact = await loadCachedArtifact(options.outputDir, options.discoveredWorkflow, cachedEntry);
+		if (!artifact) return null;
+		return {
+			artifact,
+			validatedHashes: {
+				manifestHash: cachedEntry.manifestHash,
+				flowGraphHash: cachedEntry.flowGraphHash,
+				bundleHash: cachedEntry.bundleHash,
+				sourceMapHash: cachedEntry.sourceMapHash
+			}
+		};
+	} catch {
+		return null;
+	}
+}
+/** Narrows to any failure tied to a specific workflow (workflow or loader-protocol). */
+function isWorkflowScopedBuildFailure(failure) {
+	return failure.kind === "workflow" || failure.kind === "loader-protocol";
+}
+/** Narrows to a duplicate-workflow-id conflict failure. */
+function isDuplicateWorkflowIdFailure(failure) {
+	return failure.kind === "duplicate-workflow-id";
+}
+/** Narrows to a duplicate-agent-id conflict failure. */
+function isDuplicateAgentIdFailure(failure) {
+	return failure.kind === "duplicate-agent-id";
+}
+async function cleanupFailedBuildState(options) {
+	const workflowIdsToRemove = Array.from(new Set(options.workflowIdsToRemove));
+	if (workflowIdsToRemove.length > 0) await removeWorkflowArtifacts(options.outputDir, workflowIdsToRemove);
+	const agentIdsToRemove = Array.from(new Set(options.agentIdsToRemove ?? []));
+	if (agentIdsToRemove.length > 0) await removeAgentArtifacts(options.outputDir, agentIdsToRemove);
+	if (options.metadataPathsToRemove && options.metadataPathsToRemove.length > 0) await removeMetadataArtifacts(options.outputDir, options.metadataPathsToRemove.map((filePath) => createMetadataOutputFile(filePath)));
+	else await removeAllMetadataArtifacts(options.outputDir);
+	if (!options.cache) return;
+	const bindingKeysToRemove = new Set(options.bindingKeysToRemove);
+	const workflowIdsToRemoveSet = new Set(workflowIdsToRemove);
+	const agentIdsToRemoveSet = new Set(agentIdsToRemove);
+	const bindings = Object.fromEntries(typedEntries(options.cache.bindings).filter(([bindingKey, entry]) => !bindingKeysToRemove.has(bindingKey) && !workflowIdsToRemoveSet.has(entry.workflowId)));
+	const agentBindings = Object.fromEntries(typedEntries(options.cache.agentBindings).filter(([bindingKey, entry]) => !bindingKeysToRemove.has(bindingKey) && !agentIdsToRemoveSet.has(entry.agentId)));
+	const metadataPathsToRemove = new Set(options.metadataPathsToRemove ?? []);
+	const metadata = metadataPathsToRemove.size > 0 ? Object.fromEntries(typedEntries(options.cache.metadata).filter(([filePath]) => !metadataPathsToRemove.has(parseRelativeFilePath(filePath)))) : {};
+	await writeBuildCache(options.outputDir, {
+		...options.cache,
+		builderFingerprint: options.builderFingerprint ?? options.cache.builderFingerprint,
+		scanEntries: options.scanEntries ?? options.cache.scanEntries,
+		bindings,
+		agentBindings,
+		metadata
+	});
+}
+async function resolveCandidateFiles(projectRoot) {
+	const resolvedProjectRoot = path.resolve(projectRoot);
+	const files = await (0, import_out.default)([...DISCOVERY_GLOB], {
+		cwd: resolvedProjectRoot,
+		absolute: true,
+		onlyFiles: true,
+		ignore: [...DISCOVERY_IGNORE]
+	});
+	files.sort((left, right) => left.localeCompare(right));
+	return files;
+}
+async function resolveDiscoveredWorkflowEntries(candidateFiles, projectRoot) {
+	const resolutionContext = { cache: /* @__PURE__ */ new Map() };
+	const entries = [];
+	for (const exportFilePath of candidateFiles) {
+		const moduleResolution = await resolveModuleExports(exportFilePath, resolutionContext, []);
+		const discoveredByBindingKey = /* @__PURE__ */ new Map();
+		for (const [exportName, target] of moduleResolution.namedExports) {
+			if (!target) continue;
+			const discovered = createDiscoveredWorkflow({
+				exportFilePath,
+				exportName,
+				isDefaultExport: false,
+				projectRoot,
+				target
+			});
+			discoveredByBindingKey.set(discovered.bindingKey, discoveredByBindingKey.get(discovered.bindingKey) ?? discovered);
+		}
+		if (moduleResolution.defaultExport) {
+			const discovered = createDiscoveredWorkflow({
+				exportFilePath,
+				exportName: "default",
+				isDefaultExport: true,
+				projectRoot,
+				target: moduleResolution.defaultExport
+			});
+			discoveredByBindingKey.set(discovered.bindingKey, discoveredByBindingKey.get(discovered.bindingKey) ?? discovered);
+		}
+		entries.push({
+			exportFilePath,
+			discoveryEntries: [...discoveredByBindingKey.values()].sort((left, right) => left.bindingKey.localeCompare(right.bindingKey)),
+			dependencyPaths: moduleResolution.dependencyPaths.filter((dependencyPath) => dependencyPath !== exportFilePath)
+		});
+	}
+	return entries.sort((left, right) => left.exportFilePath.localeCompare(right.exportFilePath));
+}
+async function resolveModuleExports(filePath, context, resolutionStack) {
+	const resolvedFilePath = path.resolve(filePath);
+	const cached = context.cache.get(resolvedFilePath);
+	if (cached) return cached;
+	const resolutionPromise = resolveModuleExportsUncached(resolvedFilePath, context, resolutionStack);
+	context.cache.set(resolvedFilePath, resolutionPromise);
+	return resolutionPromise;
+}
+async function resolveModuleExportsUncached(filePath, context, resolutionStack) {
+	if (resolutionStack.includes(filePath)) return {
+		namedExports: /* @__PURE__ */ new Map(),
+		defaultExport: null,
+		dependencyPaths: [filePath]
+	};
+	const analysis = await analyzeModule(filePath, parseSourceFile(filePath, await readFile(filePath, "utf-8")), context, [...resolutionStack, filePath]);
+	if (analysis.hasNamespaceStarExport) throw createNamespaceStarExportDiscoveryError(filePath);
+	const ambiguousExports = [...analysis.namedExports.entries()].filter(([, target]) => target === null).map(([exportName]) => exportName);
+	if (ambiguousExports.length > 0) throw createAmbiguousExportDiscoveryError(filePath, ambiguousExports);
+	return {
+		namedExports: analysis.namedExports,
+		defaultExport: analysis.defaultExport,
+		dependencyPaths: [...new Set([filePath, ...analysis.dependencyPaths])].sort((left, right) => left.localeCompare(right))
+	};
+}
+async function analyzeModule(filePath, sourceFile, context, resolutionStack) {
+	const workflowImportNames = collectWorkflowImportNames(sourceFile);
+	const localWorkflowBindings = collectLocalWorkflowBindings(sourceFile, workflowImportNames);
+	const namedExports = /* @__PURE__ */ new Map();
+	let defaultExport = null;
+	let hasNamespaceStarExport = false;
+	const dependencyPaths = /* @__PURE__ */ new Set();
+	for (const statement of sourceFile.statements) {
+		if (isExportedVariableStatement(statement)) {
+			for (const declaration of getVariableDeclarators(statement)) {
+				const localName = identifierName(declaration.id);
+				if (!localName) continue;
+				const exportKind = localWorkflowBindings.get(localName);
+				if (!exportKind) continue;
+				addNamedExport(namedExports, localName, {
+					resolvedFilePath: filePath,
+					localExportName: localName,
+					exportKind
+				});
+			}
+			continue;
+		}
+		if (statement.type === "ExportNamedDeclaration") {
+			const moduleSpecifier = getLocalModuleSpecifier(literalString(statement.source));
+			if (!moduleSpecifier) {
+				if (Array.isArray(statement.specifiers)) for (const specifier of statement.specifiers) {
+					if (!isNode(specifier) || specifier.type !== "ExportSpecifier") continue;
+					const localName = identifierName(specifier.local);
+					const exportName = identifierName(specifier.exported);
+					if (!localName || !exportName) continue;
+					const exportKind = localWorkflowBindings.get(localName);
+					if (!exportKind) continue;
+					addNamedExport(namedExports, exportName, {
+						resolvedFilePath: filePath,
+						localExportName: localName,
+						exportKind
+					});
+				}
+				continue;
+			}
+			const resolvedModuleFile = await resolveLocalModulePath(filePath, moduleSpecifier);
+			if (!resolvedModuleFile) continue;
+			const targetResolution = await resolveModuleExports(resolvedModuleFile, context, resolutionStack);
+			dependencyPaths.add(resolvedModuleFile);
+			for (const dependencyPath of targetResolution.dependencyPaths) dependencyPaths.add(dependencyPath);
+			for (const specifier of Array.isArray(statement.specifiers) ? statement.specifiers : []) {
+				if (!isNode(specifier) || specifier.type !== "ExportSpecifier") continue;
+				const sourceExportName = identifierName(specifier.local);
+				const exportName = identifierName(specifier.exported);
+				if (!sourceExportName || !exportName) continue;
+				if (sourceExportName === "default") {
+					if (exportName === "default") defaultExport = targetResolution.defaultExport;
+					else addNamedExport(namedExports, exportName, targetResolution.defaultExport);
+					continue;
+				}
+				addNamedExport(namedExports, exportName, targetResolution.namedExports.get(sourceExportName) ?? null);
+			}
+			continue;
+		}
+		if (statement.type === "ExportAllDeclaration") {
+			const moduleSpecifier = getLocalModuleSpecifier(literalString(statement.source));
+			if (!moduleSpecifier) continue;
+			const resolvedModuleFile = await resolveLocalModulePath(filePath, moduleSpecifier);
+			if (!resolvedModuleFile) continue;
+			const targetResolution = await resolveModuleExports(resolvedModuleFile, context, resolutionStack);
+			dependencyPaths.add(resolvedModuleFile);
+			for (const dependencyPath of targetResolution.dependencyPaths) dependencyPaths.add(dependencyPath);
+			if (identifierName(statement.exported)) {
+				hasNamespaceStarExport = true;
+				continue;
+			}
+			for (const [exportName, target] of targetResolution.namedExports) addNamedExport(namedExports, exportName, target);
+			continue;
+		}
+		if (statement.type === "ExportDefaultDeclaration" && isNode(statement.declaration)) defaultExport = resolveDefaultExportAssignment(statement.declaration, filePath, localWorkflowBindings, workflowImportNames);
+	}
+	return {
+		localWorkflowBindings,
+		namedExports,
+		defaultExport,
+		hasNamespaceStarExport,
+		dependencyPaths: [...dependencyPaths].sort((left, right) => left.localeCompare(right))
+	};
+}
+function addNamedExport(exportsMap, exportName, target) {
+	if (!target) return;
+	const existing = exportsMap.get(exportName);
+	if (!existing) {
+		exportsMap.set(exportName, target);
+		return;
+	}
+	if (existing.resolvedFilePath === target.resolvedFilePath && existing.localExportName === target.localExportName && existing.exportKind === target.exportKind) return;
+	exportsMap.set(exportName, null);
+}
+function createDiscoveredWorkflow(options) {
+	return {
+		exportFilePath: options.exportFilePath,
+		resolvedFilePath: options.target.resolvedFilePath,
+		relativePath: path.relative(options.projectRoot, options.target.resolvedFilePath),
+		exportName: options.exportName,
+		isDefaultExport: options.isDefaultExport,
+		localExportName: options.target.localExportName,
+		bindingKey: `${options.target.resolvedFilePath}::${options.target.localExportName}`,
+		exportKind: options.target.exportKind
+	};
+}
+const BLOCK_COMMENTS_RE = /\/\*[\s\S]*?\*\//g;
+const LINE_COMMENTS_RE = /(^|[^:])\/\/.*$/gm;
+function stripComments(source) {
+	return source.replace(BLOCK_COMMENTS_RE, "").replace(LINE_COMMENTS_RE, "$1");
+}
+/**
+* Fast pre-filter: returns true if the file MIGHT contain a workflow, agent,
+* or task export. Files that return false are guaranteed not to export
+* Workflow/Agent/Task instances and can skip expensive AST parsing.
+*
+* The heuristic checks for:
+* 1. Direct `new Workflow(`, `new Agent(`, or `new Task(` constructor calls
+* 2. Re-exports that reference a local module (`export { ... } from './...`)
+*    or `export * from './...` — these might re-export a workflow/agent/task
+*
+* We intentionally skip `export {` without a `from` clause when there's no
+* Workflow/Agent/Task reference, since those are just re-exports of local bindings
+* which would already be caught by the constructor check.
+*/
+function couldContainWorkflowExport(source) {
+	const codeOnly = stripComments(source);
+	if (codeOnly.includes("new Workflow(") || codeOnly.includes("new Agent(") || codeOnly.includes("new Task(")) return true;
+	if (REEXPORT_FROM_LOCAL_RE.test(codeOnly)) return true;
+	if (codeOnly.includes("export default")) return codeOnly.includes("Workflow") || codeOnly.includes("Agent") || codeOnly.includes("Task");
+	return false;
+}
+const REEXPORT_FROM_LOCAL_RE = /export\s+(?:\{[^}]*\}|\*(?:\s+as\s+\w+)?)\s+from\s+['"]\.[\w./-]*['"]/;
+const CONCURRENCY_LIMIT = 20;
+async function discoverWorkflows(options) {
+	const startedAt = performance.now();
+	const projectRoot = path.resolve(options.projectRoot);
+	const allCandidateFiles = await resolveCandidateFiles(projectRoot);
+	const scanEntries = {};
+	const discoveredByBindingKey = /* @__PURE__ */ new Map();
+	const fileStats = await batchStat(allCandidateFiles);
+	const cacheHitFiles = [];
+	const cacheMissFiles = [];
+	for (let i = 0; i < allCandidateFiles.length; i++) {
+		const filePath = allCandidateFiles[i];
+		const fileStat = fileStats[i];
+		const cachedEntry = options.scanEntries?.[filePath];
+		if (cachedEntry && isScanCacheEntryValid(fileStat, cachedEntry, options.scanEntries ?? {}, fileStats, allCandidateFiles)) cacheHitFiles.push({
+			filePath,
+			entry: cachedEntry
+		});
+		else cacheMissFiles.push({
+			filePath,
+			fileStat
+		});
+	}
+	for (const { filePath, entry } of cacheHitFiles) {
+		scanEntries[filePath] = entry;
+		for (const workflow of entry.discoveryEntries) discoveredByBindingKey.set(workflow.bindingKey, discoveredByBindingKey.get(workflow.bindingKey) ?? workflow);
+	}
+	let filesScanned = cacheHitFiles.length;
+	options.onProgress?.({
+		filesScanned,
+		filesTotal: allCandidateFiles.length
+	});
+	for (let batchStart = 0; batchStart < cacheMissFiles.length; batchStart += CONCURRENCY_LIMIT) {
+		const batch = cacheMissFiles.slice(batchStart, batchStart + CONCURRENCY_LIMIT);
+		const batchResults = await Promise.all(batch.map(async ({ filePath, fileStat }) => {
+			if (!couldContainWorkflowExport(await readFile(filePath, "utf-8"))) return {
+				filePath,
+				entry: {
+					mtimeMs: fileStat.mtimeMs,
+					size: fileStat.size,
+					hasWorkflow: false,
+					exportNames: [],
+					discoveryEntries: [],
+					dependencyPaths: []
+				}
+			};
+			const [resolvedEntry] = await resolveDiscoveredWorkflowEntries([filePath], projectRoot);
+			const discoveryEntries = resolvedEntry?.discoveryEntries ?? [];
+			return {
+				filePath,
+				entry: {
+					mtimeMs: fileStat.mtimeMs,
+					size: fileStat.size,
+					hasWorkflow: discoveryEntries.length > 0,
+					exportNames: discoveryEntries.map((w) => w.exportName),
+					discoveryEntries,
+					dependencyPaths: resolvedEntry?.dependencyPaths ?? []
+				}
+			};
+		}));
+		for (const { filePath, entry } of batchResults) {
+			scanEntries[filePath] = entry;
+			for (const workflow of entry.discoveryEntries) discoveredByBindingKey.set(workflow.bindingKey, discoveredByBindingKey.get(workflow.bindingKey) ?? workflow);
+		}
+		filesScanned += batch.length;
+		options.onProgress?.({
+			filesScanned,
+			filesTotal: allCandidateFiles.length
+		});
+	}
+	const discoveredExports = [...discoveredByBindingKey.values()].sort((left, right) => left.bindingKey.localeCompare(right.bindingKey));
+	const { workflowCount, agentCount, taskCount } = countDiscoveredExports$1(discoveredExports);
+	return {
+		projectRoot,
+		workflows: discoveredExports,
+		workflowCount,
+		agentCount,
+		taskCount,
+		filesScanned,
+		elapsedMs: performance.now() - startedAt,
+		scanEntries
+	};
+}
+async function batchStat(files) {
+	const results = [];
+	for (let i = 0; i < files.length; i += CONCURRENCY_LIMIT) {
+		const batch = files.slice(i, i + CONCURRENCY_LIMIT);
+		const batchResults = await Promise.all(batch.map(async (filePath) => {
+			const s = await stat(filePath);
+			return {
+				mtimeMs: s.mtimeMs,
+				size: s.size
+			};
+		}));
+		results.push(...batchResults);
+	}
+	return results;
+}
+function isScanCacheEntryValid(fileStat, cachedEntry, previousScanEntries, allFileStats, allFilePaths) {
+	if (cachedEntry.discoveryEntries.some((entry) => entry.exportKind !== "workflow" && entry.exportKind !== "agent" && entry.exportKind !== "task")) return false;
+	if (cachedEntry.mtimeMs !== fileStat.mtimeMs || cachedEntry.size !== fileStat.size) return false;
+	const fileStatLookup = /* @__PURE__ */ new Map();
+	for (let i = 0; i < allFilePaths.length; i++) {
+		const fp = allFilePaths[i];
+		const fs = allFileStats[i];
+		fileStatLookup.set(fp, fs);
+	}
+	for (const dependencyPath of cachedEntry.dependencyPaths) {
+		const dependencyEntry = previousScanEntries[dependencyPath];
+		if (!dependencyEntry) return false;
+		const dependencyStat = fileStatLookup.get(dependencyPath);
+		if (!dependencyStat) return false;
+		if (dependencyEntry.mtimeMs !== dependencyStat.mtimeMs || dependencyEntry.size !== dependencyStat.size) return false;
+	}
+	return true;
+}
+function countDiscoveredExports$1(discoveredExports) {
+	let workflowCount = 0;
+	let agentCount = 0;
+	let taskCount = 0;
+	for (const discoveredExport of discoveredExports) if (discoveredExport.exportKind === "agent") agentCount += 1;
+	else if (discoveredExport.exportKind === "task") taskCount += 1;
+	else workflowCount += 1;
+	return {
+		workflowCount,
+		agentCount,
+		taskCount
+	};
+}
+function createProgressEmitter(callback) {
+	return function emit(event) {
+		if (!callback) return;
+		queueMicrotask(() => {
+			try {
+				callback(event);
+			} catch {}
+		});
+	};
+}
+function runCycleDetection(params) {
+	const detectedCycles = detectAgentInPathCycles(buildCycleAnalysisInput(params));
+	return {
+		detectedCycles,
+		blocking: detectedCycles.length > 0
+	};
+}
+function buildCycleAnalysisInput(params) {
+	return {
+		agents: params.agentArtifacts.map((artifact) => ({
+			kind: "agent",
+			id: artifact.agent.agentId,
+			displayName: artifact.agent.agentName,
+			tools: (artifact.manifest.tools ?? []).filter((tool) => tool.sourceKind === "workflow" && tool.authoredWorkflowId).map((tool) => tool.authoredWorkflowId)
+		})),
+		workflows: params.workflowArtifacts.map((artifact) => ({
+			kind: "workflow",
+			id: artifact.workflow.workflowId,
+			displayName: artifact.manifest.name,
+			callees: artifact.flowGraph.nodes.flatMap((node) => {
+				if (node.type !== "step" || node.data.kind !== "call") return [];
+				if (node.data.callKind !== "child-workflow" && node.data.callKind !== "agent") return [];
+				return node.data.stepId ? [node.data.stepId] : [];
+			})
+		})),
+		operations: []
+	};
+}
+/**
+* Names that conflict with builder output directories/files.
+* A workflow id matching any of these would overwrite builder infrastructure.
+*
+* Note: `.keystroke` is not included because it contains a dot, which is already
+* rejected by the workflow id schema (`[a-zA-Z0-9_-]+`).
+*/
+const RESERVED_WORKFLOW_IDS = new Set([
+	METADATA_ROOT_DIR_NAME,
+	BUILD_DIR_NAME,
+	"node_modules"
+]);
+/**
+* Prefixes that conflict with builder output directory naming conventions.
+* A workflow id starting with any of these would collide with agent artifact dirs.
+*/
+const RESERVED_WORKFLOW_ID_PREFIXES = [AGENT_ARTIFACT_DIR_PREFIX];
+var ReservedWorkflowIdError = class extends Error {
+	workflowId;
+	file;
+	bindingKey;
+	constructor(options) {
+		const reserved = RESERVED_WORKFLOW_ID_PREFIXES.some((prefix) => options.workflowId.startsWith(prefix)) ? `prefix "${options.workflowId.split("_")[0]}_"` : `"${options.workflowId}"`;
+		super(`Workflow id ${reserved} is reserved by the build system and cannot be used (in ${options.file})`);
+		this.name = "ReservedWorkflowIdError";
+		this.workflowId = options.workflowId;
+		this.file = options.file;
+		this.bindingKey = options.bindingKey;
+	}
+};
+function assertUniqueWorkflowIds(artifacts) {
+	const artifactByWorkflowId = /* @__PURE__ */ new Map();
+	for (const artifact of artifacts) {
+		assertNotReservedWorkflowId(artifact);
+		const existingSource = artifactByWorkflowId.get(artifact.workflow.workflowId);
+		if (existingSource) throw new DuplicateWorkflowIdError({
+			workflowId: artifact.workflow.workflowId,
+			files: [existingSource.file, artifact.workflow.resolvedFilePath],
+			bindingKeys: [existingSource.bindingKey, artifact.workflow.bindingKey]
+		});
+		artifactByWorkflowId.set(artifact.workflow.workflowId, {
+			file: artifact.workflow.resolvedFilePath,
+			bindingKey: artifact.workflow.bindingKey
+		});
+	}
+}
+var DuplicateAgentIdError = class extends Error {
+	agentId;
+	files;
+	bindingKeys;
+	constructor(options) {
+		super(`Duplicate agent id "${options.agentId}" found in ${options.files.join(" and ")}`);
+		this.name = "DuplicateAgentIdError";
+		this.agentId = options.agentId;
+		this.files = [...options.files];
+		this.bindingKeys = [...options.bindingKeys];
+	}
+};
+function assertUniqueAgentIds(artifacts) {
+	const seen = /* @__PURE__ */ new Map();
+	for (const artifact of artifacts) {
+		const existing = seen.get(artifact.agent.agentId);
+		if (existing) throw new DuplicateAgentIdError({
+			agentId: artifact.agent.agentId,
+			files: [existing.file, artifact.agent.resolvedFilePath],
+			bindingKeys: [existing.bindingKey, artifact.agent.bindingKey]
+		});
+		seen.set(artifact.agent.agentId, {
+			file: artifact.agent.resolvedFilePath,
+			bindingKey: artifact.agent.bindingKey
+		});
+	}
+}
+var DuplicateCredentialSetIdError = class extends Error {
+	resolvedCredentialSetId;
+	files;
+	constructor(options) {
+		super(`Duplicate credential set resolved ID "${options.resolvedCredentialSetId}" found in ${options.files.join(" and ")}`);
+		this.name = "DuplicateCredentialSetIdError";
+		this.resolvedCredentialSetId = options.resolvedCredentialSetId;
+		this.files = [...options.files];
+	}
+};
+function assertUniqueCredentialSetDefinitionResolvedIds(analyzedFiles) {
+	const seen = /* @__PURE__ */ new Map();
+	for (const analyzedFile of analyzedFiles) for (const credentialSet of analyzedFile.definitions.credentialSets) {
+		if (!credentialSet.resolvedCredentialSetId) continue;
+		const existing = seen.get(credentialSet.resolvedCredentialSetId);
+		if (existing && existing !== analyzedFile.filePath) throw new DuplicateCredentialSetIdError({
+			resolvedCredentialSetId: credentialSet.resolvedCredentialSetId,
+			files: [existing, analyzedFile.filePath]
+		});
+		seen.set(credentialSet.resolvedCredentialSetId, analyzedFile.filePath);
+	}
+}
+function assertNotReservedWorkflowId(artifact) {
+	const id = artifact.workflow.workflowId;
+	if (RESERVED_WORKFLOW_IDS.has(id)) throw new ReservedWorkflowIdError({
+		workflowId: id,
+		file: artifact.workflow.resolvedFilePath,
+		bindingKey: artifact.workflow.bindingKey
+	});
+	for (const prefix of RESERVED_WORKFLOW_ID_PREFIXES) if (id.startsWith(prefix)) throw new ReservedWorkflowIdError({
+		workflowId: id,
+		file: artifact.workflow.resolvedFilePath,
+		bindingKey: artifact.workflow.bindingKey
+	});
+}
+async function buildDiscoveredWorkflows(options) {
+	const emit = createProgressEmitter(options.onProgressEvent);
+	const emitLifecycleEvents = options.emitLifecycleEvents ?? true;
+	const startedAt = performance.now();
+	const workflowCount = options.discoveredWorkflows.length;
+	const workflowBuildCount = options.discoveredWorkflows.filter((discoveredWorkflow) => discoveredWorkflow.exportKind === "workflow").length;
+	const agentBuildCount = options.discoveredWorkflows.filter((discoveredWorkflow) => discoveredWorkflow.exportKind === "agent").length;
+	const taskBuildCount = options.discoveredWorkflows.filter((discoveredWorkflow) => discoveredWorkflow.exportKind === "task").length;
+	if (emitLifecycleEvents) emit({
+		phase: "build-start",
+		workflowCount: workflowBuildCount,
+		agentCount: agentBuildCount,
+		taskCount: taskBuildCount
+	});
+	const workflowsByKey = /* @__PURE__ */ new Map();
+	for (let i = 0; i < workflowCount; i++) {
+		const workflow = options.discoveredWorkflows[i];
+		if (workflow) workflowsByKey.set(workflow.bindingKey, {
+			workflow,
+			index: i
+		});
+	}
+	const batchResults = await loadWorkflowMetadataBatch([...options.discoveredWorkflows], { concurrency: options.metadataLoaderConcurrency });
+	const metadataByKey = /* @__PURE__ */ new Map();
+	for (const result of batchResults) metadataByKey.set(result.bindingKey, result);
+	const buildPlan = await createBuildPlan({
+		discoveredWorkflows: options.discoveredWorkflows,
+		metadataByKey
+	});
+	const artifacts = [];
+	const agentArtifacts = [];
+	const taskArtifacts = [];
+	const failures = [...buildPlan.failures];
+	const warnings = [];
+	if (buildPlan.workflows.length > 0) {
+		const { buildWorkflowArtifacts } = await import("./build-workflows-CfxBnIWh-CdYPv8w2.mjs");
+		const result = await buildWorkflowArtifacts({
+			entries: buildPlan.workflows,
+			workflowsByKey,
+			metadataByKey,
+			projectRoot: options.projectRoot,
+			workflowCount: workflowBuildCount,
+			sourceMaps: options.sourceMaps,
+			onProgressEvent: options.onProgressEvent
+		});
+		artifacts.push(...result.artifacts);
+		failures.push(...result.failures);
+		warnings.push(...result.warnings);
+	}
+	if (buildPlan.agents.length > 0) {
+		const { buildAgentArtifacts } = await import("./build-agents-BmM_AsSd-BGi9wtzt.mjs");
+		const result = await buildAgentArtifacts({
+			entries: buildPlan.agents,
+			projectRoot: options.projectRoot
+		});
+		agentArtifacts.push(...result.agentArtifacts);
+		failures.push(...result.failures);
+	}
+	if (buildPlan.tasks.length > 0) {
+		const { buildTaskArtifacts } = await import("./build-tasks-CdihpudT-D5r5HUHe.mjs");
+		const result = await buildTaskArtifacts({
+			entries: buildPlan.tasks,
+			projectRoot: options.projectRoot,
+			sourceMaps: options.sourceMaps
+		});
+		taskArtifacts.push(...result.taskArtifacts);
+		failures.push(...result.failures);
+	}
+	try {
+		assertUniqueWorkflowIds(artifacts);
+	} catch (error) {
+		if (error instanceof ReservedWorkflowIdError) failures.push({
+			kind: "workflow",
+			workflow: {
+				bindingKey: error.bindingKey,
+				exportFilePath: error.file,
+				resolvedFilePath: error.file,
+				exportName: "",
+				localExportName: ""
+			},
+			phase: "output",
+			error: error.message
+		});
+		else {
+			const duplicateFailure = createDuplicateWorkflowIdFailure(artifacts, error);
+			emit({
+				phase: "duplicate-id-conflict",
+				workflowId: duplicateFailure.workflowId,
+				files: duplicateFailure.files
+			});
+			failures.push(duplicateFailure);
+		}
+	}
+	try {
+		assertUniqueAgentIds(agentArtifacts);
+	} catch (error) {
+		if (error instanceof DuplicateAgentIdError) failures.push({
+			kind: "duplicate-agent-id",
+			agentId: error.agentId,
+			files: error.files,
+			bindingKeys: error.bindingKeys,
+			phase: "output",
+			error: error.message
+		});
+	}
+	const cycleDetection = runCycleDetection({
+		workflowArtifacts: artifacts,
+		agentArtifacts
+	});
+	for (const cycle of cycleDetection.detectedCycles) failures.push({
+		kind: "agent-cycle",
+		cyclePath: cycle.path.map((node) => `${node.kind}:${node.id}`),
+		phase: "output",
+		error: `Agent-in-path cycle detected: ${cycle.description}`
+	});
+	const successfulArtifacts = failures.some((failure) => failure.kind === "duplicate-workflow-id" || failure.kind === "duplicate-agent-id" || failure.kind === "agent-cycle") ? [] : artifacts;
+	const totalMs = performance.now() - startedAt;
+	if (emitLifecycleEvents) emit({
+		phase: "build-complete",
+		workflowBuiltCount: successfulArtifacts.length,
+		agentBuiltCount: agentArtifacts.length,
+		taskBuiltCount: taskArtifacts.length,
+		cachedWorkflowCount: 0,
+		cachedAgentCount: 0,
+		cachedTaskCount: 0,
+		builtCount: successfulArtifacts.length + agentArtifacts.length + taskArtifacts.length,
+		failedCount: failures.length,
+		cachedCount: 0,
+		elapsedMs: totalMs
+	});
+	return {
+		artifacts: successfulArtifacts,
+		agentArtifacts,
+		taskArtifacts,
+		failures,
+		warnings,
+		totalMs,
+		success: failures.length === 0
+	};
+}
+async function createBuildPlan(options) {
+	const plan = {
+		workflows: [],
+		agents: [],
+		tasks: [],
+		failures: []
+	};
+	let workflowProgressIndex = 0;
+	for (const discoveredWorkflow of options.discoveredWorkflows) {
+		const loadResult = options.metadataByKey.get(discoveredWorkflow.bindingKey);
+		if (loadResult && isAgentLoadResult(loadResult)) {
+			plan.agents.push({
+				discoveredWorkflow,
+				agentMetadata: loadResult.agentMetadata
+			});
+			continue;
+		}
+		if (loadResult && isTaskLoadResult(loadResult)) {
+			plan.tasks.push({
+				discoveredWorkflow,
+				taskMetadata: loadResult.taskMetadata
+			});
+			continue;
+		}
+		const currentWorkflowIndex = workflowProgressIndex;
+		workflowProgressIndex += 1;
+		if (!loadResult?.ok) {
+			const { createWorkflowMetadataFailure } = await import("./build-workflows-CfxBnIWh-CdYPv8w2.mjs");
+			plan.failures.push(createWorkflowMetadataFailure(discoveredWorkflow, loadResult?.error));
+			continue;
+		}
+		if (isWorkflowLoadResult(loadResult)) plan.workflows.push({
+			discoveredWorkflow,
+			metadata: loadResult.metadata,
+			workflowIndex: currentWorkflowIndex
+		});
+	}
+	return plan;
+}
+function countDiscoveredExports(discoveredWorkflows) {
+	let workflowCount = 0;
+	let agentCount = 0;
+	let taskCount = 0;
+	for (const discoveredWorkflow of discoveredWorkflows) if (discoveredWorkflow.exportKind === "agent") agentCount += 1;
+	else if (discoveredWorkflow.exportKind === "task") taskCount += 1;
+	else workflowCount += 1;
+	return {
+		workflowCount,
+		agentCount,
+		taskCount
+	};
+}
+/**
+* Main build entry point. Discovers workflow exports, builds each through the pipeline
+* (import, manifest, flow-graph, bundle), and writes output artifacts.
+* Returns all artifacts on success or a list of failures with output set to null.
+*/
+async function build(config) {
+	return runBuild(config);
+}
+async function runBuild(config, initialTargetBindingKeys, metadataRebuildDecision) {
+	const context = await prepareBuildContext(config);
+	const { emit, startedAt, outputDir, builderFingerprint, buildCache } = context;
+	const discoveryStage = await runDiscoveryStage(config, context);
+	if (discoveryStage.result) return discoveryStage.result;
+	const { cacheInvalidated, discovery } = discoveryStage;
+	const targetResolution = resolveTargetedDiscovery({
+		projectRoot: config.projectRoot,
+		discovery,
+		targetFiles: config.targetFiles
+	});
+	if (targetResolution && "failure" in targetResolution) {
+		const result = createFailedExecutionResult({
+			failure: targetResolution.failure,
+			startedAt
+		});
+		emit({
+			phase: "complete",
+			success: false,
+			totalMs: result.totalMs
+		});
+		return result;
+	}
+	let targetBindingKeys = targetResolution?.targetBindingKeys ?? initialTargetBindingKeys;
+	let scopedPlan = null;
+	if (targetResolution) scopedPlan = {
+		scopedDiscoveredWorkflows: discovery.workflows.filter((workflow) => targetResolution.targetBindingKeys.has(workflow.bindingKey)),
+		preservedArtifacts: [],
+		targetBindingKeys: targetResolution.targetBindingKeys
+	};
+	else while (!scopedPlan) {
+		scopedPlan = await buildScopedDiscoveryPlan({
+			outputDir,
+			buildCache,
+			discovery,
+			targetBindingKeys
+		});
+		if (!scopedPlan) targetBindingKeys = void 0;
+	}
+	const { preservedArtifacts, scopedDiscoveredWorkflows } = scopedPlan;
+	const { workflowCount: scopedWorkflowCount, agentCount: scopedAgentCount, taskCount: scopedTaskCount } = countDiscoveredExports(scopedDiscoveredWorkflows);
+	const { cachedArtifacts, cachedAgentArtifacts, workflowsToBuild, fingerprintByBinding, validatedHashesByBinding, warnings: cacheWarnings, cacheResolutionMs } = await resolveCachedArtifacts({
+		config,
+		scopedDiscoveredWorkflows,
+		buildCache,
+		outputDir,
+		cacheInvalidated,
+		scopedWorkflowCount,
+		emit
+	});
+	const warnings = [...cacheWarnings];
+	const duplicateBindingKeys = /* @__PURE__ */ new Set();
+	const duplicateWorkflowIds = /* @__PURE__ */ new Set();
+	const buildStartedAt = performance.now();
+	emit({
+		phase: "build-start",
+		workflowCount: scopedWorkflowCount,
+		agentCount: scopedAgentCount,
+		taskCount: scopedTaskCount
+	});
+	const bundlePipelineStartedAt = performance.now();
+	const pipelineResult = workflowsToBuild.length > 0 ? await buildDiscoveredWorkflows({
+		discoveredWorkflows: workflowsToBuild,
+		projectRoot: config.projectRoot,
+		metadataLoaderConcurrency: config.metadataLoaderConcurrency,
+		sourceMaps: config.sourceMaps ?? true,
+		onProgressEvent: config.onProgressEvent,
+		emitLifecycleEvents: false
+	}) : {
+		artifacts: [],
+		agentArtifacts: [],
+		taskArtifacts: [],
+		failures: [],
+		warnings: [],
+		totalMs: 0,
+		success: true
+	};
+	const bundlePipelineMs = performance.now() - bundlePipelineStartedAt;
+	const failures = [...pipelineResult.failures];
+	warnings.push(...pipelineResult.warnings);
+	const artifacts = [
+		...preservedArtifacts,
+		...cachedArtifacts,
+		...pipelineResult.artifacts
+	];
+	const agentArtifacts = [...cachedAgentArtifacts, ...pipelineResult.agentArtifacts];
+	const taskArtifacts = [...pipelineResult.taskArtifacts];
+	const finalizedScopedArtifacts = failures.length === 0 ? [...cachedArtifacts, ...pipelineResult.artifacts] : [];
+	try {
+		assertUniqueWorkflowIds(artifacts);
+	} catch (error) {
+		if (error instanceof ReservedWorkflowIdError) {
+			const failure = {
+				kind: "workflow",
+				workflow: {
+					bindingKey: error.bindingKey,
+					exportFilePath: error.file,
+					resolvedFilePath: error.file,
+					exportName: "",
+					localExportName: ""
+				},
+				phase: "output",
+				error: error.message
+			};
+			failures.push(failure);
+		} else {
+			const duplicateFailure = createDuplicateWorkflowIdFailure(artifacts, error);
+			duplicateWorkflowIds.add(duplicateFailure.workflowId);
+			for (const bindingKey of duplicateFailure.bindingKeys) duplicateBindingKeys.add(bindingKey);
+			emit({
+				phase: "duplicate-id-conflict",
+				workflowId: duplicateFailure.workflowId,
+				files: duplicateFailure.files
+			});
+			failures.push(duplicateFailure);
+		}
+	}
+	try {
+		assertUniqueAgentIds(agentArtifacts);
+	} catch (error) {
+		if (error instanceof DuplicateAgentIdError) {
+			for (const bindingKey of error.bindingKeys) duplicateBindingKeys.add(bindingKey);
+			failures.push({
+				kind: "duplicate-agent-id",
+				agentId: error.agentId,
+				files: error.files,
+				bindingKeys: error.bindingKeys,
+				phase: "output",
+				error: error.message
+			});
+		}
+	}
+	const successfulArtifacts = failures.length === 0 ? artifacts : [];
+	emit({
+		phase: "build-complete",
+		workflowBuiltCount: pipelineResult.artifacts.length,
+		agentBuiltCount: pipelineResult.agentArtifacts.length,
+		taskBuiltCount: pipelineResult.taskArtifacts.length,
+		cachedWorkflowCount: cachedArtifacts.length,
+		cachedAgentCount: cachedAgentArtifacts.length,
+		cachedTaskCount: 0,
+		builtCount: pipelineResult.artifacts.length + pipelineResult.agentArtifacts.length + pipelineResult.taskArtifacts.length,
+		failedCount: failures.length,
+		cachedCount: cachedArtifacts.length + cachedAgentArtifacts.length,
+		elapsedMs: performance.now() - buildStartedAt,
+		cacheResolutionMs,
+		bundlePipelineMs
+	});
+	const finalizedArtifacts = failures.length === 0 ? successfulArtifacts : [];
+	let output = null;
+	let metadataCacheEntries = buildCache.metadata;
+	if (failures.length === 0) {
+		emit({
+			phase: "output-start",
+			artifactCount: finalizedArtifacts.length + agentArtifacts.length + taskArtifacts.length
+		});
+		const writeStartedAt = performance.now();
+		const cacheResolvedBindingKeys = new Set([...cachedArtifacts.map((a) => a.workflow.bindingKey), ...cachedAgentArtifacts.map((a) => a.agent.bindingKey)]);
+		const writeOptions = {
+			skipUnchangedWrites: !config.force,
+			buildCache,
+			force: config.force,
+			cacheResolvedBindingKeys,
+			releaseBundleMemory: config.releaseBundleMemory
+		};
+		const { writeBuildOutput, writeTargetedBuildOutput } = await import("./writer-BG8poUm3-BbXlU2kI.mjs").then((n) => n.f).then((n) => n.t);
+		const writeResult = targetBindingKeys ? await writeTargetedBuildOutput({
+			artifacts: finalizedScopedArtifacts,
+			agentArtifacts,
+			taskArtifacts,
+			failures: [],
+			warnings,
+			totalMs: pipelineResult.totalMs,
+			success: true
+		}, outputDir, collectPreviousWorkflowIds(buildCache, targetBindingKeys), writeOptions) : await writeBuildOutput({
+			artifacts: finalizedArtifacts,
+			agentArtifacts,
+			taskArtifacts,
+			failures: [],
+			warnings,
+			totalMs: pipelineResult.totalMs,
+			success: true
+		}, outputDir, writeOptions);
+		emit({
+			phase: "output-complete",
+			writtenCount: writeResult.writtenCount,
+			cleanedCount: writeResult.cleanedCount,
+			elapsedMs: performance.now() - writeStartedAt,
+			...writeResult.skippedWriteCount !== void 0 && writeResult.skippedWriteCount > 0 ? { skippedWriteCount: writeResult.skippedWriteCount } : {}
+		});
+		const { buildMetadataArtifacts } = await import("./build-metadata-BWS7uhd_-DR8gJjTX.mjs");
+		const metadata = await buildMetadataArtifacts({
+			projectRoot: config.projectRoot,
+			outputDir,
+			artifacts: finalizedArtifacts,
+			cacheEntries: buildCache.metadata,
+			cacheInvalidated,
+			rebuildDecision: targetResolution && "affectedPaths" in targetResolution ? {
+				action: "targeted",
+				affectedPaths: targetResolution.affectedPaths
+			} : metadataRebuildDecision,
+			emit
+		});
+		const conventionErrors = [];
+		for (const violation of metadata.conventionViolations) if (violation.level === "warning") warnings.push(violation.message);
+		else {
+			failures.push({
+				kind: "convention",
+				filePath: violation.filePath,
+				error: violation.message
+			});
+			conventionErrors.push(violation.message);
+		}
+		if (conventionErrors.length > 0) emit({
+			phase: "convention-errors",
+			errorCount: conventionErrors.length,
+			errors: conventionErrors
+		});
+		try {
+			assertUniqueCredentialSetDefinitionResolvedIds(metadata.analyzedFacts);
+		} catch (error) {
+			if (error instanceof Error) failures.push({
+				kind: "convention",
+				filePath: error instanceof DuplicateCredentialSetIdError ? error.files[0] ?? "" : "",
+				error: error.message
+			});
+		}
+		output = {
+			writtenCount: writeResult.writtenCount,
+			cleanedCount: writeResult.cleanedCount,
+			outputDir: writeResult.outputDir,
+			...writeResult.skippedWriteCount !== void 0 && writeResult.skippedWriteCount > 0 ? { skippedWriteCount: writeResult.skippedWriteCount } : {},
+			metadata: metadata.result
+		};
+		metadataCacheEntries = metadata.cacheEntries;
+	}
+	if (failures.length === 0) {
+		const cacheEntries = createWorkflowCacheEntries(targetBindingKeys ? finalizedScopedArtifacts : finalizedArtifacts, validatedHashesByBinding);
+		const agentCacheEntries = createAgentCacheEntries(targetBindingKeys ? pipelineResult.agentArtifacts : agentArtifacts, validatedHashesByBinding);
+		for (const artifact of finalizedArtifacts) {
+			const fingerprint = fingerprintByBinding.get(artifact.workflow.bindingKey) ?? await computeWorkflowFingerprint(artifact.workflow.resolvedFilePath, artifact.bundle.localDependencies);
+			const cacheEntry = cacheEntries[artifact.workflow.bindingKey];
+			if (cacheEntry) cacheEntry.inputFingerprint = fingerprint;
+		}
+		for (const artifact of agentArtifacts) {
+			const fingerprint = fingerprintByBinding.get(artifact.agent.bindingKey) ?? await computeWorkflowFingerprint(artifact.agent.resolvedFilePath, artifact.bundle.localDependencies);
+			const cacheEntry = agentCacheEntries[artifact.agent.bindingKey];
+			if (cacheEntry) cacheEntry.inputFingerprint = fingerprint;
+		}
+		await writeBuildCache(outputDir, {
+			...buildCache,
+			builderFingerprint,
+			scanEntries: discovery.scanEntries,
+			bindings: targetBindingKeys ? mergeScopedBindings(buildCache, cacheEntries, targetBindingKeys) : cacheEntries,
+			agentBindings: targetBindingKeys ? mergeScopedAgentBindings(buildCache, agentCacheEntries, targetBindingKeys) : agentCacheEntries,
+			metadata: metadataCacheEntries
+		});
+	} else await cleanupFailedBuild({
+		buildCache,
+		builderFingerprint,
+		discoveryScanEntries: discovery.scanEntries,
+		duplicateBindingKeys,
+		duplicateWorkflowIds,
+		failures,
+		metadataRebuildDecision,
+		outputDir
+	});
+	const totalMs = performance.now() - startedAt;
+	const result = {
+		artifacts: finalizedArtifacts,
+		agentArtifacts,
+		taskArtifacts,
+		failures,
+		warnings,
+		totalMs,
+		success: failures.length === 0,
+		output
+	};
+	emit({
+		phase: "complete",
+		success: result.success,
+		totalMs
+	});
+	return result;
+}
+async function prepareBuildContext(config) {
+	const emit = createProgressEmitter(config.onProgressEvent);
+	const startedAt = performance.now();
+	await assertWorkflowProjectRoot(config.projectRoot);
+	const outputDir = resolveBuildOutputDir(config);
+	if (hasTargetFiles(config) && !config.outDir) await fs.rm(outputDir, {
+		recursive: true,
+		force: true
+	});
+	const builderFingerprint = await computeBuilderFingerprint(path$1.join(path$1.dirname(fileURLToPath(import.meta.url)), ".."));
+	const existingCache = config.force ? null : await readBuildCache(outputDir);
+	return {
+		emit,
+		startedAt,
+		outputDir,
+		builderFingerprint,
+		buildCache: config.force || !existingCache || existingCache.builderFingerprint !== builderFingerprint ? createEmptyBuildCache(builderFingerprint) : existingCache
+	};
+}
+function hasTargetFiles(config) {
+	return (config.targetFiles?.length ?? 0) > 0;
+}
+function resolveBuildOutputDir(config) {
+	if (!hasTargetFiles(config)) return resolveOutputDir(config.projectRoot, config);
+	if (config.outDir) return resolveOutputDir(config.projectRoot, config);
+	const normalizedTargets = (config.targetFiles ?? []).map((target) => path$1.isAbsolute(target) ? target : path$1.resolve(config.projectRoot, target)).map((target) => path$1.normalize(target)).sort((left, right) => left.localeCompare(right));
+	const targetHash = createHash("sha256").update(JSON.stringify(normalizedTargets)).digest("hex");
+	return path$1.join(getKeystrokeTmpDir({ projectRoot: config.projectRoot }), "target-builds", targetHash);
+}
+async function runDiscoveryStage(config, context) {
+	const existingCache = config.force ? null : await readBuildCache(context.outputDir);
+	const cacheInvalidated = Boolean(existingCache && existingCache.builderFingerprint !== context.builderFingerprint);
+	context.emit({
+		phase: "discovery-start",
+		filesTotal: 0
+	});
+	try {
+		const discovery = await discoverWorkflows({
+			projectRoot: config.projectRoot,
+			scanEntries: context.buildCache.scanEntries,
+			onProgress: ({ filesScanned, filesTotal }) => {
+				context.emit({
+					phase: "discovery-scan",
+					filesScanned,
+					filesTotal
+				});
+			}
+		});
+		context.emit({
+			phase: "discovery-complete",
+			workflowCount: discovery.workflowCount,
+			agentCount: discovery.agentCount,
+			filesScanned: discovery.filesScanned,
+			elapsedMs: discovery.elapsedMs
+		});
+		return {
+			cacheInvalidated,
+			discovery
+		};
+	} catch (error) {
+		const result = createFailedExecutionResult({
+			failure: createDiscoveryFailure(error),
+			startedAt: context.startedAt
+		});
+		context.emit({
+			phase: "complete",
+			success: false,
+			totalMs: result.totalMs
+		});
+		return { result };
+	}
+}
+async function buildScopedDiscoveryPlan(options) {
+	if (!options.targetBindingKeys) return {
+		scopedDiscoveredWorkflows: options.discovery.workflows,
+		preservedArtifacts: [],
+		targetBindingKeys: void 0
+	};
+	const discoveredBindingKeys = new Set(options.discovery.workflows.map((workflow) => workflow.bindingKey));
+	for (const bindingKey of Array.from(options.targetBindingKeys)) if (!discoveredBindingKeys.has(bindingKey)) return null;
+	const preservedArtifacts = [];
+	for (const discoveredWorkflow of options.discovery.workflows) {
+		if (options.targetBindingKeys.has(discoveredWorkflow.bindingKey)) continue;
+		const preservedArtifact = await loadPreservedArtifact(options.outputDir, discoveredWorkflow, options.buildCache);
+		if (!preservedArtifact) return null;
+		preservedArtifacts.push(preservedArtifact);
+	}
+	return {
+		scopedDiscoveredWorkflows: options.discovery.workflows.filter((workflow) => options.targetBindingKeys?.has(workflow.bindingKey)),
+		preservedArtifacts,
+		targetBindingKeys: options.targetBindingKeys
+	};
+}
+function resolveTargetedDiscovery(options) {
+	const targetFiles = options.targetFiles?.filter((target) => target.trim().length > 0) ?? [];
+	if (targetFiles.length === 0) return null;
+	const normalizedTargets = /* @__PURE__ */ new Map();
+	for (const target of targetFiles) {
+		const absolutePath = path$1.normalize(path$1.isAbsolute(target) ? target : path$1.resolve(options.projectRoot, target));
+		normalizedTargets.set(absolutePath, target);
+	}
+	const matchedBindingKeys = /* @__PURE__ */ new Set();
+	const affectedPaths = /* @__PURE__ */ new Set();
+	const matchedTargets = /* @__PURE__ */ new Set();
+	for (const discoveredWorkflow of options.discovery.workflows) {
+		const resolvedPath = path$1.normalize(discoveredWorkflow.resolvedFilePath);
+		if (!normalizedTargets.has(resolvedPath)) continue;
+		matchedBindingKeys.add(discoveredWorkflow.bindingKey);
+		affectedPaths.add(discoveredWorkflow.relativePath);
+		matchedTargets.add(resolvedPath);
+	}
+	for (const [absolutePath, originalTarget] of normalizedTargets) {
+		if (matchedTargets.has(absolutePath)) continue;
+		return { failure: {
+			kind: "discovery",
+			code: "unknown-discovery-error",
+			filePath: absolutePath,
+			exportNames: [],
+			error: `Target file "${originalTarget}" did not contain any deployable workflow, agent, or task exports.`
+		} };
+	}
+	return {
+		targetBindingKeys: matchedBindingKeys,
+		affectedPaths: Array.from(affectedPaths).sort((left, right) => left.localeCompare(right))
+	};
+}
+function createFailedExecutionResult(options) {
+	return {
+		artifacts: [],
+		agentArtifacts: [],
+		taskArtifacts: [],
+		failures: options.failures ?? (options.failure ? [options.failure] : []),
+		warnings: options.warnings ?? [],
+		totalMs: performance.now() - options.startedAt,
+		success: false,
+		output: null
+	};
+}
+function collectPreviousWorkflowIds(buildCache, targetBindingKeys) {
+	const workflowIds = /* @__PURE__ */ new Set();
+	for (const bindingKey of Array.from(targetBindingKeys)) {
+		const workflowId = buildCache.bindings[bindingKey]?.workflowId;
+		if (workflowId) workflowIds.add(workflowId);
+	}
+	return Array.from(workflowIds).sort((left, right) => left.localeCompare(right));
+}
+async function loadPreservedArtifact(outputDir, discoveredWorkflow, buildCache) {
+	const cachedEntry = buildCache.bindings[discoveredWorkflow.bindingKey];
+	if (!cachedEntry) return null;
+	return loadCachedArtifact(outputDir, discoveredWorkflow, cachedEntry);
+}
+function mergeScopedBindings(buildCache, nextBindings, targetBindingKeys) {
+	const mergedBindings = Object.fromEntries(typedEntries(buildCache.bindings).filter(([bindingKey]) => !targetBindingKeys.has(bindingKey)));
+	for (const [bindingKey, entry] of Object.entries(nextBindings)) mergedBindings[bindingKey] = entry;
+	return mergedBindings;
+}
+function mergeScopedAgentBindings(buildCache, nextBindings, targetBindingKeys) {
+	const mergedBindings = Object.fromEntries(typedEntries(buildCache.agentBindings).filter(([bindingKey]) => !targetBindingKeys.has(bindingKey)));
+	for (const [bindingKey, entry] of Object.entries(nextBindings)) mergedBindings[bindingKey] = entry;
+	return mergedBindings;
+}
+async function cleanupFailedBuild(options) {
+	const bindingKeysToRemove = new Set(options.duplicateBindingKeys);
+	const workflowIdsToRemove = new Set(options.duplicateWorkflowIds);
+	const agentIdsToRemove = /* @__PURE__ */ new Set();
+	for (const failure of options.failures) {
+		if (isWorkflowScopedBuildFailure(failure) && failure.workflow.bindingKey) bindingKeysToRemove.add(failure.workflow.bindingKey);
+		if (isWorkflowScopedBuildFailure(failure) && failure.workflow.workflowId) workflowIdsToRemove.add(failure.workflow.workflowId);
+		if (isDuplicateWorkflowIdFailure(failure)) {
+			for (const bindingKey of failure.bindingKeys) {
+				bindingKeysToRemove.add(bindingKey);
+				const cachedEntry = options.buildCache.bindings[bindingKey];
+				if (cachedEntry) workflowIdsToRemove.add(cachedEntry.workflowId);
+			}
+			workflowIdsToRemove.add(failure.workflowId);
+			continue;
+		}
+		if (isDuplicateAgentIdFailure(failure)) {
+			for (const bindingKey of failure.bindingKeys) {
+				bindingKeysToRemove.add(bindingKey);
+				const cachedAgentEntry = options.buildCache.agentBindings[bindingKey];
+				if (cachedAgentEntry) agentIdsToRemove.add(cachedAgentEntry.agentId);
+			}
+			agentIdsToRemove.add(failure.agentId);
+			continue;
+		}
+		if (!isWorkflowScopedBuildFailure(failure)) continue;
+		const cachedEntry = options.buildCache.bindings[failure.workflow.bindingKey];
+		if (cachedEntry) workflowIdsToRemove.add(cachedEntry.workflowId);
+		const cachedAgentEntry = options.buildCache.agentBindings[failure.workflow.bindingKey];
+		if (cachedAgentEntry) agentIdsToRemove.add(cachedAgentEntry.agentId);
+	}
+	await cleanupFailedBuildState({
+		outputDir: options.outputDir,
+		cache: options.buildCache,
+		bindingKeysToRemove: Array.from(bindingKeysToRemove),
+		workflowIdsToRemove: Array.from(workflowIdsToRemove),
+		agentIdsToRemove: Array.from(agentIdsToRemove),
+		metadataPathsToRemove: options.metadataRebuildDecision?.action === "targeted" ? options.metadataRebuildDecision.affectedPaths : void 0,
+		builderFingerprint: options.builderFingerprint,
+		scanEntries: options.discoveryScanEntries
+	});
+}
+//#endregion
+//#region ../../packages/workflow-builder/dist/build-format-06ylK1PX.mjs
+const RAW_OUTPUT_MAX_LENGTH = 500;
+function truncateRawOutput(raw) {
+	const trimmed = raw.trim();
+	if (trimmed.length <= RAW_OUTPUT_MAX_LENGTH) return trimmed;
+	return `${trimmed.slice(0, RAW_OUTPUT_MAX_LENGTH)}… (truncated)`;
+}
+/** Formats a build failure into a human-readable single-line message. */
+function formatBuildFailure(failure) {
+	switch (failure.kind) {
+		case "workflow": return `${failure.workflow.resolvedFilePath}: ${failure.error}`;
+		case "loader-protocol": {
+			const raw = failure.rawOutput?.trim();
+			if (raw && raw.length > 0 && !failure.error.includes(raw)) {
+				const detail = truncateRawOutput(raw);
+				return `${failure.workflow.resolvedFilePath}: ${failure.error}\n    ${detail.split("\n").join("\n    ")}`;
+			}
+			return `${failure.workflow.resolvedFilePath}: ${failure.error}`;
+		}
+		case "duplicate-workflow-id": return `${failure.workflowId}: ${failure.error}`;
+		case "duplicate-agent-id": return `${failure.agentId}: ${failure.error}`;
+		case "agent-cycle": return failure.error;
+		case "discovery": return `${failure.filePath}: ${failure.error}`;
+		case "trigger": return `trigger "${failure.triggerName}" (${failure.triggerExportName}) in workflow ${failure.workflowId}: ${failure.error}`;
+		case "convention": return `${failure.filePath}: ${failure.error}`;
+		case "agent": return `${failure.agent.resolvedFilePath}: ${failure.error}`;
+		case "task": return `${failure.task.resolvedFilePath}: ${failure.error}`;
+	}
+}
+//#endregion
+//#region src/lib/workflow-build.ts
+var workflow_build_exports = /* @__PURE__ */ __exportAll({
+	WorkflowBuildExecutionError: () => WorkflowBuildExecutionError,
+	WorkflowBuildFailedError: () => WorkflowBuildFailedError,
+	WorkflowNotFoundError: () => WorkflowNotFoundError,
+	renderBuildFailure: () => renderBuildFailure,
+	renderBuildHeader: () => renderBuildHeader,
+	renderBuildSummary: () => renderBuildSummary,
+	runWorkflowBuild: () => runWorkflowBuild,
+	workflowBuildDependencies: () => workflowBuildDependencies
+});
+const workflowBuildDependencies = {
+	assertWorkflowProjectRoot,
+	build
+};
+var WorkflowNotFoundError = class extends Error {
+	workflowName;
+	availableNames;
+	constructor(workflowName, availableNames) {
+		super(`Workflow "${workflowName}" not found.`);
+		this.name = "WorkflowNotFoundError";
+		this.workflowName = workflowName;
+		this.availableNames = availableNames;
+	}
+};
+var WorkflowBuildExecutionError = class extends Error {
+	causeValue;
+	constructor(causeValue) {
+		const message = causeValue instanceof Error ? causeValue.message : String(causeValue);
+		super(`Build error: ${message}`);
+		this.name = "WorkflowBuildExecutionError";
+		this.causeValue = causeValue;
+	}
+};
+var WorkflowBuildFailedError = class extends Error {
+	errors;
+	constructor(errors) {
+		super("Build failed with errors.");
+		this.name = "WorkflowBuildFailedError";
+		this.errors = errors;
+	}
+};
+async function runWorkflowBuild(options) {
+	const projectConfig = await workflowBuildDependencies.assertWorkflowProjectRoot(options.workflowsDir);
+	const outDir = resolveConfiguredBuildOutputDir(options.workflowsDir, projectConfig.build);
+	let result;
+	try {
+		result = await workflowBuildDependencies.build({
+			projectRoot: options.workflowsDir,
+			outDir,
+			force: options.force,
+			targetFiles: options.targetFiles,
+			metadataLoaderConcurrency: options.metadataLoaderConcurrency,
+			releaseBundleMemory: options.releaseBundleMemory,
+			sourceMaps: options.sourceMaps,
+			onProgressEvent: options.onProgressEvent
+		});
+	} catch (error) {
+		throw new WorkflowBuildExecutionError(error);
+	}
+	if (!result.success) throw new WorkflowBuildFailedError(result.failures);
+	if (options.name) assertWorkflowRefExists(result, options.name);
+	if (options.workflowRef) assertWorkflowRefExists(result, options.workflowRef);
+	return {
+		result,
+		outDir: result.output?.outputDir ?? outDir
+	};
+}
+function renderBuildHeader(workflowName) {
+	if (workflowName) {
+		ui.header(`Building workflow "${workflowName}"...`);
+		return;
+	}
+	ui.header("Building workflows and agents...");
+}
+function renderBuildSummary(result, outDir) {
+	ui.success("Build complete");
+	const check = style("✓", `${ANSI.bold}${ANSI.green}`);
+	const workflowLine = `Workflows: ${result.artifacts.length}`;
+	const agentLine = `Agents: ${result.agentArtifacts.length}`;
+	originalConsole.info(`  ${check} ${workflowLine}`);
+	logger.info(`  ✓ ${workflowLine}`);
+	originalConsole.info(`  ${check} ${agentLine}`);
+	logger.info(`  ✓ ${agentLine}`);
+	if (result.output?.metadata) {
+		const metadataLine = `Metadata: ${result.output.metadata.fileCount} file(s)`;
+		originalConsole.info(`  ${check} ${metadataLine}`);
+		logger.info(`  ✓ ${metadataLine}`);
+	}
+	const totalLine = `Total: ${formatTotalTime(result.totalMs)}`;
+	originalConsole.info(`  ${check} ${totalLine}`);
+	logger.info(`  ✓ ${totalLine}`);
+	if (result.warnings.length > 0) {
+		ui.warn(`Build produced ${result.warnings.length} warning(s):`);
+		for (const warning of result.warnings) ui.hint(`- ${warning}`);
+	}
+	ui.hint(`Output: ${outDir}`);
+}
+function formatTotalTime(ms) {
+	if (ms < 1e3) return `${Math.round(ms)}ms`;
+	const seconds = ms / 1e3;
+	return seconds < 60 ? `${seconds.toFixed(1)}s` : `${Math.floor(seconds / 60)}m ${(seconds % 60).toFixed(1)}s`;
+}
+function renderBuildFailure(error) {
+	if (error instanceof WorkflowNotFoundError) {
+		ui.error(`Workflow "${error.workflowName}" not found.`);
+		if (error.availableNames.length === 0) {
+			ui.hint("No workflows were discovered in this project.");
+			return;
+		}
+		ui.hint(`Available workflows: ${error.availableNames.join(", ")}`);
+		return;
+	}
+	if (error instanceof WorkflowBuildExecutionError) {
+		ui.error(error.message);
+		return;
+	}
+	if (error instanceof WorkflowBuildFailedError) {
+		ui.error("Build failed with errors:");
+		for (const buildError of error.errors) ui.hint(`- ${formatBuildFailure(buildError)}`);
+		return;
+	}
+	ui.error(`Build error: ${toErrorMessage(error)}`);
+}
+function assertWorkflowRefExists(result, workflowRef) {
+	if (result.artifacts.find((artifact) => artifact.manifest.id === workflowRef || artifact.manifest.name === workflowRef)) return;
+	const availableNames = result.artifacts.map((artifact) => artifact.manifest.name).sort((left, right) => left.localeCompare(right));
+	const availableIds = result.artifacts.map((artifact) => artifact.manifest.id).sort((left, right) => left.localeCompare(right));
+	throw new WorkflowNotFoundError(workflowRef, availableNames.length > 0 ? availableNames : availableIds);
+}
+//#endregion
+export { runWorkflowBuild as a, renderBuildSummary as i, renderBuildFailure as n, workflow_build_exports as o, renderBuildHeader as r, build as s, WorkflowNotFoundError as t };