agent-worker 0.17.0 → 0.19.0

package/dist/workflow-LOZUlaDo.mjs

@@ -1,744 +0,0 @@
-import "./backends-D7DT0uox.mjs";
-import "./create-tool-gcUuI1FD.mjs";
-import { A as resolveContextDir, C as retrySection, S as projectSection, T as LOOP_DEFAULTS, _ as documentSection, a as getBackendByType, b as inboxSection, c as createAgentLoop, d as generateWorkflowMCPConfig, f as writeBackendMcpConfig, g as buildAgentPrompt, h as assemblePrompt, i as createSilentLogger, l as runSdkAgent, m as activitySection, n as createWiredLoop, o as getBackendForModel, p as DEFAULT_SECTIONS, r as createChannelLogger, s as checkWorkflowIdle, t as createMinimalRuntime, u as runMockAgent, v as exitSection, w as workflowSection, x as instructionsSection, y as formatInbox, z as CONTEXT_DEFAULTS } from "./cli/index.mjs";
-import "./memory-provider-Z9D8NdwS.mjs";
-import { createWorkflowProvider, initWorkflow, n as interpolate, runWorkflowWithLoops, shutdownLoops, t as createContext } from "./runner-BmT0Y8MD.mjs";
-import { existsSync, mkdirSync, readFileSync, rmSync } from "node:fs";
-import { basename, dirname, join, resolve } from "node:path";
-import { parse } from "yaml";
-import { homedir } from "node:os";
-import { execFileSync } from "node:child_process";
-import { parseArgs } from "node:util";
-
-//#region src/workflow/types.ts
-/** Type guard: is this agent entry a reference to a global agent? */
-function isRefAgentEntry(entry) {
-	return "ref" in entry && typeof entry.ref === "string";
-}
-
-//#endregion
-//#region src/workflow/source.ts
-/**
-* Workflow source resolver — supports local files and remote GitHub references.
-*
-* Formats:
-*   Local:  ./review.yml, /path/to/review.yml, review.yml
-*
-*   Remote (full path):
-*     github:owner/repo@ref/path/file.yml    (pinned to ref)
-*     github:owner/repo/path/file.yml         (default branch: main)
-*
-*   Remote (shorthand — resolves to workflows/<name>.yml):
-*     github:owner/repo@ref#name
-*     github:owner/repo#name
-*
-* The @ref is always on the repo segment (format D), keeping repo+version
-* as a single semantic unit.
-*
-* Remote sources are cloned (shallow) to a local cache directory:
-*   ~/.cache/agent-worker/sources/{owner}/{repo}/{ref}/
-*
-* The `sourceDir` field exposes the repo root, accessible in workflows
-* as ${{ source.dir }}.
-*/
-const GITHUB_PREFIX = "github:";
-const DEFAULT_REF = "main";
-const CACHE_BASE = join(homedir(), ".cache", "agent-worker", "sources");
-/** Check if the input is a remote source reference */
-function isRemoteSource(input) {
-	return input.startsWith(GITHUB_PREFIX);
-}
-/**
-* Resolve a workflow source — local file or remote GitHub reference.
-* Returns a WorkflowSource that can read the YAML and resolve relative files.
-*/
-async function resolveSource(input) {
-	if (isRemoteSource(input)) return resolveGitHubSource(input);
-	return resolveLocalSource(input);
-}
-function resolveLocalSource(filePath) {
-	const absolutePath = resolve(filePath);
-	if (!existsSync(absolutePath)) throw new Error(`Workflow file not found: ${absolutePath}`);
-	const content = readFileSync(absolutePath, "utf-8");
-	const workflowDir = dirname(absolutePath);
-	return {
-		content,
-		displayPath: absolutePath,
-		inferredName: basename(absolutePath, ".yml").replace(".yaml", ""),
-		sourceDir: workflowDir,
-		readRelativeFile: async (relativePath) => {
-			const fullPath = relativePath.startsWith("/") ? relativePath : join(workflowDir, relativePath);
-			if (existsSync(fullPath)) return readFileSync(fullPath, "utf-8");
-			return null;
-		}
-	};
-}
-/**
-* Parse a github: reference string into its components.
-*
-* Supports two formats:
-*   Full path:  github:owner/repo[@ref]/path/to/file.yml
-*   Shorthand:  github:owner/repo[@ref]#name  -> workflows/name.yml
-*/
-function parseGitHubRef(input) {
-	if (!input.startsWith(GITHUB_PREFIX)) throw new Error(`Not a GitHub reference: "${input}"`);
-	const rest = input.slice(7);
-	const hashIdx = rest.indexOf("#");
-	if (hashIdx !== -1) {
-		const repoStr = rest.slice(0, hashIdx);
-		const name = rest.slice(hashIdx + 1);
-		if (!name) throw new Error(`Missing workflow name after '#' in: "${input}"`);
-		const { owner, repo, ref } = parseRepoSegment(repoStr);
-		return {
-			owner,
-			repo,
-			ref,
-			path: `workflows/${name}.yml`
-		};
-	}
-	const firstSlash = rest.indexOf("/");
-	const secondSlash = firstSlash === -1 ? -1 : rest.indexOf("/", firstSlash + 1);
-	if (firstSlash === -1 || secondSlash === -1) throw new Error(`Invalid GitHub reference: "${input}". Expected: github:owner/repo/path or github:owner/repo#name`);
-	const repoStr = rest.slice(0, secondSlash);
-	const path = rest.slice(secondSlash + 1);
-	if (!path) throw new Error(`Missing file path in: "${input}"`);
-	const { owner, repo, ref } = parseRepoSegment(repoStr);
-	return {
-		owner,
-		repo,
-		ref,
-		path
-	};
-}
-/**
-* Validate a git ref (branch, tag, or SHA) to prevent injection.
-* Allows alphanumeric, hyphens, dots, underscores, slashes — the standard git ref charset.
-*/
-function validateGitRef(ref) {
-	if (!/^[a-zA-Z0-9._\-/]+$/.test(ref)) throw new Error(`Invalid git ref: "${ref}". Only alphanumeric, hyphens, dots, underscores, and slashes are allowed.`);
-}
-/** Parse "owner/repo" or "owner/repo@ref" */
-function parseRepoSegment(repoStr) {
-	let ref = DEFAULT_REF;
-	const atIdx = repoStr.indexOf("@");
-	let cleanStr = repoStr;
-	if (atIdx !== -1) {
-		ref = repoStr.slice(atIdx + 1);
-		cleanStr = repoStr.slice(0, atIdx);
-		if (!ref) throw new Error(`Empty ref after '@' in: "${repoStr}"`);
-	}
-	const parts = cleanStr.split("/");
-	if (parts.length !== 2 || !parts[0] || !parts[1]) throw new Error(`Invalid repository format: "${repoStr}". Expected "owner/repo"`);
-	validateGitRef(ref);
-	return {
-		owner: parts[0],
-		repo: parts[1],
-		ref
-	};
-}
-/**
-* Get cache directory for a repo+ref combination.
-*/
-function getCacheDir(ref) {
-	return join(CACHE_BASE, ref.owner, ref.repo, ref.ref);
-}
-/**
-* Build the clone URL. Uses HTTPS; GITHUB_TOKEN auth via git credential helper
-* or the GIT_ASKPASS/GIT_AUTH mechanism handled by git itself.
-*/
-function getCloneUrl(ref) {
-	const token = process.env.GITHUB_TOKEN;
-	if (token) return `https://${token}@github.com/${ref.owner}/${ref.repo}.git`;
-	return `https://github.com/${ref.owner}/${ref.repo}.git`;
-}
-/**
-* Check if a ref looks like a branch/tag name (mutable) vs a commit SHA (immutable).
-* Commit SHAs are 7-40 hex chars.
-*/
-function isImmutableRef(ref) {
-	return /^[0-9a-f]{7,40}$/.test(ref);
-}
-/**
-* Clone or update a remote repo to the cache directory.
-*
-* Strategy:
-* - If cache exists and ref is immutable (SHA): skip, use cached
-* - If cache exists and ref is mutable (branch/tag): git fetch + reset
-* - If cache doesn't exist: shallow clone
-*
-* @returns Absolute path to the cache directory (repo root)
-*/
-function ensureClone(ref) {
-	const cacheDir = getCacheDir(ref);
-	if (existsSync(join(cacheDir, ".git"))) {
-		if (isImmutableRef(ref.ref)) return cacheDir;
-		try {
-			execFileSync("git", [
-				"fetch",
-				"origin",
-				ref.ref,
-				"--depth",
-				"1"
-			], {
-				cwd: cacheDir,
-				stdio: "pipe",
-				timeout: 3e4
-			});
-			execFileSync("git", [
-				"reset",
-				"--hard",
-				"FETCH_HEAD"
-			], {
-				cwd: cacheDir,
-				stdio: "pipe",
-				timeout: 1e4
-			});
-			return cacheDir;
-		} catch {}
-	}
-	mkdirSync(dirname(cacheDir), { recursive: true });
-	if (existsSync(cacheDir)) rmSync(cacheDir, {
-		recursive: true,
-		force: true
-	});
-	const url = getCloneUrl(ref);
-	execFileSync("git", [
-		"clone",
-		"--depth",
-		"1",
-		"--single-branch",
-		"--branch",
-		ref.ref,
-		url,
-		cacheDir
-	], {
-		stdio: "pipe",
-		timeout: 6e4
-	});
-	return cacheDir;
-}
-/** Resolve a github: reference to a WorkflowSource */
-async function resolveGitHubSource(input) {
-	const ref = parseGitHubRef(input);
-	const repoDir = ensureClone(ref);
-	const workflowPath = join(repoDir, ref.path);
-	if (!existsSync(workflowPath)) throw new Error(`Remote workflow not found: ${ref.path}\n  Source: ${input}\n  Parsed: ${ref.owner}/${ref.repo}@${ref.ref} -> ${ref.path}\n  Clone: ${repoDir}`);
-	const content = readFileSync(workflowPath, "utf-8");
-	const workflowDir = dirname(workflowPath);
-	const inferredName = basename(ref.path, ".yml").replace(".yaml", "");
-	return {
-		content,
-		displayPath: `${GITHUB_PREFIX}${ref.owner}/${ref.repo}@${ref.ref}/${ref.path}`,
-		inferredName,
-		sourceDir: repoDir,
-		readRelativeFile: async (relativePath) => {
-			const fullPath = relativePath.startsWith("/") ? relativePath : join(workflowDir, relativePath);
-			if (existsSync(fullPath)) return readFileSync(fullPath, "utf-8");
-			return null;
-		}
-	};
-}
-
-//#endregion
-//#region src/workflow/parser.ts
-/**
-* Workflow file parser
-*/
-/**
-* Parse a workflow file (local or remote).
-*
-* Supports:
-*   Local:  review.yml, ./path/to/review.yml
-*   Remote: github:owner/repo@ref/path/file.yml
-*           github:owner/repo#name[@ref]
-*/
-async function parseWorkflowFile(filePath, options) {
-	const workflow = options?.workflow ?? "global";
-	const tag = options?.tag ?? "main";
-	const source = await resolveSource(filePath);
-	const contextBaseDir = isRemoteSource(filePath) ? process.cwd() : dirname(resolve(filePath));
-	let raw;
-	try {
-		raw = parse(source.content);
-	} catch (error) {
-		throw new Error(`Failed to parse YAML: ${error instanceof Error ? error.message : String(error)}`);
-	}
-	const validation = validateWorkflow(raw);
-	if (!validation.valid) {
-		const messages = validation.errors.map((e) => `  - ${e.path}: ${e.message}`).join("\n");
-		throw new Error(`Invalid workflow file:\n${messages}`);
-	}
-	const name = raw.name || source.inferredName;
-	const agents = {};
-	for (const [agentName, entry] of Object.entries(raw.agents)) if (isRefAgentEntry(entry)) agents[agentName] = resolveRefAgent(entry, options?.agentRegistry);
-	else agents[agentName] = await resolveInlineAgent(entry, source.readRelativeFile);
-	const context = resolveContext(raw.context, contextBaseDir, name, workflow, tag);
-	return {
-		name,
-		filePath: source.displayPath,
-		sourceDir: source.sourceDir,
-		agents,
-		context,
-		params: raw.params,
-		setup: raw.setup || [],
-		kickoff: raw.kickoff
-	};
-}
-/**
-* Resolve context configuration
-*
-* - undefined (not set): default file provider enabled
-* - null: default file provider enabled (YAML `context:` syntax)
-* - false: explicitly disabled
-* - { provider: 'file', config?: { dir | bind } }: file provider (ephemeral or persistent)
-* - { provider: 'memory' }: memory provider (for testing)
-*/
-function resolveContext(config, workflowDir, workflowName, workflow, tag) {
-	const resolve = (template) => resolveContextDir(template, {
-		workflowName,
-		workflow,
-		tag,
-		baseDir: workflowDir
-	});
-	if (config === false) return;
-	if (config === void 0 || config === null) return {
-		provider: "file",
-		dir: resolve(CONTEXT_DEFAULTS.dir)
-	};
-	if (config.provider === "memory") return {
-		provider: "memory",
-		documentOwner: config.documentOwner
-	};
-	const bindPath = config.config?.bind;
-	if (bindPath) return {
-		provider: "file",
-		dir: resolve(bindPath),
-		persistent: true,
-		documentOwner: config.documentOwner
-	};
-	return {
-		provider: "file",
-		dir: resolve(config.config?.dir || CONTEXT_DEFAULTS.dir),
-		documentOwner: config.documentOwner
-	};
-}
-/**
-* Resolve an inline agent definition (load system prompt from file if needed).
-*
-* Uses a `readRelativeFile` function to abstract local vs remote file access.
-* Also transforms `wakeup` and `wakeup_prompt` fields into a `ScheduleConfig`
-* object, which is the format expected by the daemon and loop layers
-* for setting up periodic wakeup timers.
-*/
-async function resolveInlineAgent(agent, readRelativeFile) {
-	let resolvedSystemPrompt = agent.system_prompt;
-	if (resolvedSystemPrompt?.endsWith(".txt") || resolvedSystemPrompt?.endsWith(".md")) {
-		const content = await readRelativeFile(resolvedSystemPrompt);
-		if (content !== null) resolvedSystemPrompt = content;
-	}
-	let schedule;
-	if (agent.wakeup !== void 0) {
-		schedule = { wakeup: agent.wakeup };
-		if (agent.wakeup_prompt) schedule.prompt = agent.wakeup_prompt;
-	}
-	return {
-		...agent,
-		resolvedSystemPrompt,
-		schedule,
-		isRef: false
-	};
-}
-/**
-* Resolve a ref agent entry — load from AgentRegistry, map to WorkflowAgentDef,
-* apply workflow overrides (prompt.append, max_tokens, max_steps).
-*/
-function resolveRefAgent(entry, registry) {
-	if (!registry) throw new Error(`Agent ref "${entry.ref}" requires an AgentRegistry. Pass agentRegistry in ParseOptions.`);
-	const handle = registry.get(entry.ref);
-	if (!handle) throw new Error(`Agent ref "${entry.ref}" not found in registry. Available agents: ${registry.list().map((h) => h.definition.name).join(", ") || "(none)"}`);
-	const def = handle.definition;
-	const basePrompt = def.prompt.system ?? "";
-	let resolvedSystemPrompt = basePrompt;
-	if (entry.prompt?.append) resolvedSystemPrompt = basePrompt ? `${basePrompt}\n\n${entry.prompt.append}` : entry.prompt.append;
-	const backend = def.backend === "sdk" ? "default" : def.backend;
-	return {
-		model: def.model,
-		backend,
-		provider: def.provider,
-		system_prompt: basePrompt,
-		max_tokens: entry.max_tokens ?? def.max_tokens,
-		max_steps: entry.max_steps ?? def.max_steps,
-		schedule: def.schedule,
-		resolvedSystemPrompt,
-		handle,
-		isRef: true
-	};
-}
-/**
-* Validate workflow structure
-*/
-function validateWorkflow(workflow) {
-	const errors = [];
-	if (!workflow || typeof workflow !== "object") {
-		errors.push({
-			path: "",
-			message: "Workflow must be an object"
-		});
-		return {
-			valid: false,
-			errors
-		};
-	}
-	const w = workflow;
-	if (!w.agents || typeof w.agents !== "object") errors.push({
-		path: "agents",
-		message: "Required field \"agents\" must be an object"
-	});
-	else {
-		const agents = w.agents;
-		for (const [name, agent] of Object.entries(agents)) validateAgent(name, agent, errors);
-	}
-	if (w.context !== void 0 && w.context !== null && w.context !== false) validateContext(w.context, errors);
-	if (w.params !== void 0) if (!Array.isArray(w.params)) errors.push({
-		path: "params",
-		message: "Params must be an array"
-	});
-	else {
-		const names = /* @__PURE__ */ new Set();
-		const shorts = /* @__PURE__ */ new Set();
-		for (let i = 0; i < w.params.length; i++) validateParam(`params[${i}]`, w.params[i], errors, names, shorts);
-	}
-	if (w.setup !== void 0) if (!Array.isArray(w.setup)) errors.push({
-		path: "setup",
-		message: "Setup must be an array"
-	});
-	else for (let i = 0; i < w.setup.length; i++) validateSetupTask(`setup[${i}]`, w.setup[i], errors);
-	if (w.kickoff !== void 0 && typeof w.kickoff !== "string") errors.push({
-		path: "kickoff",
-		message: "Kickoff must be a string"
-	});
-	return {
-		valid: errors.length === 0,
-		errors
-	};
-}
-function validateContext(context, errors) {
-	if (typeof context !== "object" || context === null) {
-		errors.push({
-			path: "context",
-			message: "Context must be an object or false"
-		});
-		return;
-	}
-	const c = context;
-	if (!c.provider || typeof c.provider !== "string") {
-		errors.push({
-			path: "context.provider",
-			message: "Context requires \"provider\" field (file or memory)"
-		});
-		return;
-	}
-	if (c.provider !== "file" && c.provider !== "memory") {
-		errors.push({
-			path: "context.provider",
-			message: "Context provider must be \"file\" or \"memory\""
-		});
-		return;
-	}
-	if (c.documentOwner !== void 0 && typeof c.documentOwner !== "string") errors.push({
-		path: "context.documentOwner",
-		message: "Context documentOwner must be a string"
-	});
-	if (c.provider === "file" && c.config !== void 0) {
-		if (typeof c.config !== "object" || c.config === null) {
-			errors.push({
-				path: "context.config",
-				message: "Context config must be an object"
-			});
-			return;
-		}
-		const cfg = c.config;
-		if (cfg.dir !== void 0 && cfg.bind !== void 0) {
-			errors.push({
-				path: "context.config",
-				message: "\"dir\" and \"bind\" are mutually exclusive — use one or the other"
-			});
-			return;
-		}
-		if (cfg.dir !== void 0 && typeof cfg.dir !== "string") errors.push({
-			path: "context.config.dir",
-			message: "Context config dir must be a string"
-		});
-		if (cfg.bind !== void 0 && typeof cfg.bind !== "string") errors.push({
-			path: "context.config.bind",
-			message: "Context config bind must be a string path"
-		});
-	}
-}
-const RESERVED_NAMESPACES = [
-	"env",
-	"workflow",
-	"params",
-	"source"
-];
-const VALID_PARAM_TYPES = [
-	"string",
-	"number",
-	"boolean"
-];
-function validateSetupTask(path, task, errors) {
-	if (!task || typeof task !== "object") {
-		errors.push({
-			path,
-			message: "Setup task must be an object"
-		});
-		return;
-	}
-	const t = task;
-	if (!t.shell || typeof t.shell !== "string") errors.push({
-		path: `${path}.shell`,
-		message: "Setup task requires \"shell\" field as string"
-	});
-	if (t.as !== void 0 && typeof t.as !== "string") errors.push({
-		path: `${path}.as`,
-		message: "Setup task \"as\" field must be a string"
-	});
-	if (typeof t.as === "string" && RESERVED_NAMESPACES.includes(t.as)) errors.push({
-		path: `${path}.as`,
-		message: `"${t.as}" is a reserved namespace and cannot be used as a variable name`
-	});
-}
-function validateParam(path, param, errors, names, shorts) {
-	if (!param || typeof param !== "object") {
-		errors.push({
-			path,
-			message: "Param must be an object"
-		});
-		return;
-	}
-	const p = param;
-	if (!p.name || typeof p.name !== "string") {
-		errors.push({
-			path: `${path}.name`,
-			message: "Param requires \"name\" field as string"
-		});
-		return;
-	}
-	if (names.has(p.name)) errors.push({
-		path: `${path}.name`,
-		message: `Duplicate param name: "${p.name}"`
-	});
-	names.add(p.name);
-	if (p.description !== void 0 && typeof p.description !== "string") errors.push({
-		path: `${path}.description`,
-		message: "Param description must be a string"
-	});
-	if (p.type !== void 0) {
-		if (typeof p.type !== "string" || !VALID_PARAM_TYPES.includes(p.type)) errors.push({
-			path: `${path}.type`,
-			message: `Param type must be one of: ${VALID_PARAM_TYPES.join(", ")}`
-		});
-	}
-	if (p.short !== void 0) if (typeof p.short !== "string" || p.short.length !== 1) errors.push({
-		path: `${path}.short`,
-		message: "Param short must be a single character"
-	});
-	else {
-		if (shorts.has(p.short)) errors.push({
-			path: `${path}.short`,
-			message: `Duplicate param short flag: "-${p.short}"`
-		});
-		shorts.add(p.short);
-	}
-	if (p.required !== void 0 && typeof p.required !== "boolean") errors.push({
-		path: `${path}.required`,
-		message: "Param required must be a boolean"
-	});
-}
-/** Backends that don't require an explicit model field */
-const CLI_BACKENDS = [
-	"claude",
-	"cursor",
-	"codex",
-	"opencode",
-	"mock"
-];
-function validateAgent(name, agent, errors) {
-	const path = `agents.${name}`;
-	if (!agent || typeof agent !== "object") {
-		errors.push({
-			path,
-			message: "Agent must be an object"
-		});
-		return;
-	}
-	const a = agent;
-	if (typeof a.ref === "string") validateRefAgent(path, a, errors);
-	else validateInlineAgent(path, a, errors);
-}
-function validateRefAgent(path, a, errors) {
-	if (!a.ref.length) errors.push({
-		path: `${path}.ref`,
-		message: "Field \"ref\" must be a non-empty string"
-	});
-	if (a.prompt !== void 0) if (typeof a.prompt !== "object" || a.prompt === null) errors.push({
-		path: `${path}.prompt`,
-		message: "Field \"prompt\" for ref agents must be an object with optional \"append\""
-	});
-	else {
-		const p = a.prompt;
-		if (p.append !== void 0 && typeof p.append !== "string") errors.push({
-			path: `${path}.prompt.append`,
-			message: "Field \"prompt.append\" must be a string"
-		});
-	}
-	if (a.system_prompt !== void 0) errors.push({
-		path: `${path}.system_prompt`,
-		message: "Field \"system_prompt\" cannot be used with ref agents — use \"prompt.append\" instead"
-	});
-	for (const field of [
-		"model",
-		"backend",
-		"provider",
-		"tools",
-		"wakeup",
-		"wakeup_prompt",
-		"timeout"
-	]) if (a[field] !== void 0) errors.push({
-		path: `${path}.${field}`,
-		message: `Field "${field}" cannot be used with ref agents — it comes from the agent definition`
-	});
-	if (a.max_tokens !== void 0 && typeof a.max_tokens !== "number") errors.push({
-		path: `${path}.max_tokens`,
-		message: "Field \"max_tokens\" must be a number"
-	});
-	if (a.max_steps !== void 0 && typeof a.max_steps !== "number") errors.push({
-		path: `${path}.max_steps`,
-		message: "Field \"max_steps\" must be a number"
-	});
-}
-function validateInlineAgent(path, a, errors) {
-	const backend = typeof a.backend === "string" ? a.backend : "default";
-	if (a.model !== void 0 && typeof a.model !== "string") errors.push({
-		path: `${path}.model`,
-		message: "Field \"model\" must be a string"
-	});
-	else if (!a.model && !CLI_BACKENDS.includes(backend)) errors.push({
-		path: `${path}.model`,
-		message: "Required field \"model\" must be a string (required for default backend)"
-	});
-	if (a.system_prompt !== void 0 && typeof a.system_prompt !== "string") errors.push({
-		path: `${path}.system_prompt`,
-		message: "Optional field \"system_prompt\" must be a string"
-	});
-	if (a.tools !== void 0 && !Array.isArray(a.tools)) errors.push({
-		path: `${path}.tools`,
-		message: "Optional field \"tools\" must be an array"
-	});
-	if (a.wakeup !== void 0) {
-		if (typeof a.wakeup !== "string" && typeof a.wakeup !== "number") errors.push({
-			path: `${path}.wakeup`,
-			message: "Field \"wakeup\" must be a string (duration or cron) or number (ms)"
-		});
-		else if (typeof a.wakeup === "number" && a.wakeup <= 0) errors.push({
-			path: `${path}.wakeup`,
-			message: "Field \"wakeup\" must be a positive number when specified as ms"
-		});
-	}
-	if (a.wakeup_prompt !== void 0) {
-		if (typeof a.wakeup_prompt !== "string") errors.push({
-			path: `${path}.wakeup_prompt`,
-			message: "Field \"wakeup_prompt\" must be a string"
-		});
-		if (a.wakeup === void 0) errors.push({
-			path: `${path}.wakeup_prompt`,
-			message: "Field \"wakeup_prompt\" can only be used when \"wakeup\" is also specified"
-		});
-	}
-	if (a.provider !== void 0) {
-		if (typeof a.provider === "string") {} else if (typeof a.provider === "object" && a.provider !== null && !Array.isArray(a.provider)) {
-			const p = a.provider;
-			if (!p.name || typeof p.name !== "string") errors.push({
-				path: `${path}.provider.name`,
-				message: "Field \"provider.name\" is required and must be a string"
-			});
-			if (p.base_url !== void 0 && typeof p.base_url !== "string") errors.push({
-				path: `${path}.provider.base_url`,
-				message: "Field \"provider.base_url\" must be a string"
-			});
-			if (p.api_key !== void 0 && typeof p.api_key !== "string") errors.push({
-				path: `${path}.provider.api_key`,
-				message: "Field \"provider.api_key\" must be a string"
-			});
-		} else errors.push({
-			path: `${path}.provider`,
-			message: "Field \"provider\" must be a string or object with { name, base_url?, api_key? }"
-		});
-		if (CLI_BACKENDS.includes(backend) && backend !== "mock") errors.push({
-			path: `${path}.provider`,
-			message: `Field "provider" is ignored for CLI backend "${backend}" (only works with default backend)`
-		});
-	}
-}
-/**
-* Parse CLI arguments against workflow param definitions.
-* Uses Node's built-in util.parseArgs().
-*
-* @param defs  Param definitions from workflow YAML
-* @param argv  Raw CLI arguments (everything after the workflow file)
-* @returns     Resolved param values as string map
-* @throws      Error if required params are missing or types are invalid
-*/
-function parseWorkflowParams(defs, argv) {
-	if (defs.length === 0) return {};
-	const options = {};
-	for (const def of defs) {
-		const opt = { type: def.type === "boolean" ? "boolean" : "string" };
-		if (def.short) opt.short = def.short;
-		options[def.name] = opt;
-	}
-	const { values } = parseArgs({
-		args: argv,
-		options,
-		strict: true
-	});
-	const result = {};
-	const missing = [];
-	for (const def of defs) {
-		let raw = values[def.name];
-		if (raw === void 0 && def.default !== void 0) raw = String(def.default);
-		if (raw === void 0) {
-			if (def.required) {
-				const flag = def.short ? `-${def.short}/--${def.name}` : `--${def.name}`;
-				missing.push(flag);
-			}
-			continue;
-		}
-		if (def.type === "number") {
-			const num = Number(raw);
-			if (isNaN(num)) throw new Error(`Parameter --${def.name} must be a number, got: "${raw}"`);
-			result[def.name] = String(num);
-		} else result[def.name] = String(raw);
-	}
-	if (missing.length > 0) throw new Error(`Missing required parameter(s): ${missing.join(", ")}`);
-	return result;
-}
-/**
-* Format parameter help text for workflow params
-*/
-function formatParamHelp(defs) {
-	if (defs.length === 0) return "";
-	const lines = ["", "Workflow parameters:"];
-	for (const def of defs) {
-		const flags = def.short ? `-${def.short}, --${def.name}` : `    --${def.name}`;
-		const type = def.type || "string";
-		const req = def.required ? " (required)" : "";
-		const dflt = def.default !== void 0 ? ` [default: ${def.default}]` : "";
-		const desc = def.description || "";
-		lines.push(`  ${flags} <${type}>  ${desc}${req}${dflt}`);
-	}
-	return lines.join("\n");
-}
-
-//#endregion
-export { formatParamHelp, parseWorkflowFile, parseWorkflowParams, runWorkflowWithLoops, shutdownLoops };