@oisincoveney/pipeline 2.8.0 → 2.8.1

package/dist/config/schemas.d.ts

@@ -226,8 +226,8 @@ declare const configSchema: z.ZodObject<{
     policy: z.ZodOptional<z.ZodObject<{
       commands: z.ZodOptional<z.ZodEnum<{
         allow: "allow";
-        deny: "deny";
         "trusted-only": "trusted-only";
+        deny: "deny";
       }>>;
       modules: z.ZodOptional<z.ZodEnum<{
         allow: "allow";
@@ -255,8 +255,8 @@ declare const configSchema: z.ZodObject<{
       global: "global";
     }>>;
     mode: z.ZodEnum<{
-      local: "local";
       hosted: "hosted";
+      local: "local";
     }>;
     provider: z.ZodLiteral<"toolhive">;
     authorization_env: z.ZodDefault<z.ZodString>;
@@ -299,10 +299,10 @@ declare const configSchema: z.ZodObject<{
     }, z.core.$strict>>;
     output: z.ZodOptional<z.ZodObject<{
       format: z.ZodEnum<{
-        json_schema: "json_schema";
         text: "text";
         json: "json";
         jsonl: "jsonl";
+        json_schema: "json_schema";
       }>;
       repair: z.ZodOptional<z.ZodObject<{
         enabled: z.ZodOptional<z.ZodBoolean>;
@@ -371,10 +371,10 @@ declare const configSchema: z.ZodObject<{
         disabled: "disabled";
       }>>>;
       output_formats: z.ZodOptional<z.ZodArray<z.ZodEnum<{
-        json_schema: "json_schema";
         text: "text";
         json: "json";
         jsonl: "jsonl";
+        json_schema: "json_schema";
       }>>>;
       rules: z.ZodOptional<z.ZodBoolean>;
       skills: z.ZodOptional<z.ZodBoolean>;
@@ -481,8 +481,8 @@ declare const configSchema: z.ZodObject<{
   schedules: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
     description: z.ZodOptional<z.ZodString>;
     baseline: z.ZodEnum<{
-      execute: "execute";
       quick: "quick";
+      execute: "execute";
     }>;
     max_parallel_nodes: z.ZodOptional<z.ZodNumber>;
     node_catalog: z.ZodOptional<z.ZodString>;

package/dist/mcp/gateway-error.js

@@ -0,0 +1,15 @@
+import { Data } from "effect";
+//#region src/mcp/gateway-error.ts
+/**
+* Tagged error for the MCP (ToolHive) gateway subsystem. Lives in its own module
+* so both the gateway facade (src/mcp/gateway.ts) and the Effect service
+* (src/runtime/services/mcp-gateway-service.ts) can import it without forming a
+* circular dependency between them.
+*/
+var PipelineMcpGatewayError = class extends Data.TaggedError("PipelineMcpGatewayError") {
+	constructor(message) {
+		super({ message });
+	}
+};
+//#endregion
+export { PipelineMcpGatewayError };

package/dist/mcp/gateway.js

@@ -1,23 +1,22 @@
+import { PipelineMcpGatewayError } from "./gateway-error.js";
+import { McpGatewayService, McpGatewayServiceLive } from "../runtime/services/mcp-gateway-service.js";
 import { resolveRepoLocalBackendSpecs } from "./repo-local-backends.js";
 import { renderToolHiveVmcpInventory } from "./toolhive-vmcp.js";
-import { Data } from "effect";
+import { Effect } from "effect";
 import { copyFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { homedir } from "node:os";
-import { execa } from "execa";
 //#region src/mcp/gateway.ts
 const PIPELINE_GATEWAY_SERVER_ID = "pipeline-gateway";
 const DEFAULT_LOCAL_GATEWAY_URL = "http://127.0.0.1:4483/mcp";
 const LEGACY_OPENCODE_MCP_RE = /"mcp"\s*:\s*{(?!\s*"pipeline-gateway")/s;
 const LEGACY_PIPELINE_MCP_RE = /path:\s*\.mcp\.json|uvx\s+mcpm|mcpm\s+run/;
-var PipelineMcpGatewayError = class extends Data.TaggedError("PipelineMcpGatewayError") {
-	constructor(message) {
-		super({ message });
-	}
-};
 function profileNeedsMcpGateway(actor) {
 	return (actor?.mcp_servers ?? []).length > 0;
 }
+function runMcpGatewayEffect(program) {
+	return Effect.runPromise(Effect.provide(program, McpGatewayServiceLive));
+}
 function gatewayServerForProfile(config, actor, env = process.env) {
 	if (!(config && profileNeedsMcpGateway(actor))) return {};
 	return { [PIPELINE_GATEWAY_SERVER_ID]: gatewayServer(config, env) };
@@ -88,128 +87,79 @@ function configureGatewayHosts(config, options) {
 		};
 	});
 }
-async function runGatewayDoctor(config, cwd) {
-	const gateway = configuredGateway(config);
-	const checks = [
-		{
-			detail: `${gateway.provider}/${gateway.mode}`,
-			name: "gateway-config",
-			passed: true
-		},
-		checkGatewayUrl(gateway),
-		checkGatewayToken(gateway),
-		...gateway.mode === "local" ? [await checkThv(cwd)] : [],
-		await checkGatewayHealth(gateway),
-		await checkGatewayRequiredTools(gateway),
-		checkLegacyDirectMcp(cwd)
-	];
-	return {
-		checks,
-		passed: checks.every((check) => check.passed)
-	};
+function runGatewayDoctor(config, cwd) {
+	return runMcpGatewayEffect(Effect.gen(function* () {
+		const gateway = configuredGateway(config);
+		const checks = [
+			{
+				detail: `${gateway.provider}/${gateway.mode}`,
+				name: "gateway-config",
+				passed: true
+			},
+			checkGatewayUrl(gateway),
+			checkGatewayToken(gateway),
+			...gateway.mode === "local" ? [yield* checkThv(cwd)] : [],
+			yield* checkGatewayHealth(gateway),
+			yield* checkGatewayRequiredTools(gateway),
+			checkLegacyDirectMcp(cwd)
+		];
+		return {
+			checks,
+			passed: checks.every((check) => check.passed)
+		};
+	}));
 }
-async function startLocalGateway(config, cwd) {
-	if (configuredGateway(config).mode !== "local") throw new PipelineMcpGatewayError("mcp gateway local-start is only valid when mcp_gateway.mode is local.");
-	const result = await reconcileGateway(config, cwd);
-	if (result.readinessFailures.length > 0) throw new PipelineMcpGatewayError(`Cannot start local MCP gateway; readiness failures: ${result.readinessFailures.join("; ")}`);
-	await execa("thv", [
-		"vmcp",
-		"serve",
-		"--config",
-		result.configPath,
-		"--host",
-		"127.0.0.1",
-		"--port",
-		"4483"
-	], {
-		cwd,
-		env: await toolhiveEnv(cwd),
-		stderr: "inherit",
-		stdout: "inherit"
-	});
+function startLocalGateway(config, cwd) {
+	return runMcpGatewayEffect(Effect.gen(function* () {
+		if (configuredGateway(config).mode !== "local") return yield* Effect.fail(new PipelineMcpGatewayError("mcp gateway local-start is only valid when mcp_gateway.mode is local."));
+		const result = yield* reconcileGatewayEffect(config, cwd, process.env);
+		if (result.readinessFailures.length > 0) return yield* Effect.fail(new PipelineMcpGatewayError(`Cannot start local MCP gateway; readiness failures: ${result.readinessFailures.join("; ")}`));
+		yield* (yield* McpGatewayService).serveToolHiveVmcp(result.configPath, cwd);
+	}));
 }
-async function reconcileGateway(config, cwd, env = process.env) {
-	const gateway = configuredGateway(config);
-	if (gateway.provider !== "toolhive") throw new PipelineMcpGatewayError(`Unsupported MCP gateway provider '${gateway.provider}'.`);
-	const workspacePath = env.PIPELINE_TARGET_PATH || cwd;
-	const repoLocalBackends = resolveRepoLocalBackendSpecs(config, {
-		cwd: workspacePath,
-		env
-	});
-	const inventory = renderToolHiveVmcpInventory(config, {
-		repoLocalBackends,
-		toolHiveWorkloads: await listToolHiveGroupWorkloads(gateway.default_profile ?? "default", workspacePath)
-	});
-	const configPath = join(workspacePath, ".pipeline", "mcp-gateway", "vmcp.yaml");
-	mkdirSync(dirname(configPath), { recursive: true });
-	writeFileSync(configPath, inventory.yaml);
-	await execa("thv", [
-		"vmcp",
-		"validate",
-		"--config",
-		configPath
-	], {
-		cwd: workspacePath,
-		env: await toolhiveEnv(workspacePath),
-		stdin: "ignore"
-	});
-	return {
-		backendCount: inventory.backends.length,
-		configPath,
-		readinessFailures: [...repoLocalBackends.filter((backend) => backend.enabled && !backend.readiness.ok).map((backend) => `${backend.id}: ${backend.readiness.reason}`), ...inventory.backends.filter((backend) => backend.enabled && backend.required && !backend.url).map((backend) => `${backend.name}: missing ToolHive workload`)],
-		workspacePath
-	};
+function reconcileGateway(config, cwd, env = process.env) {
+	return runMcpGatewayEffect(reconcileGatewayEffect(config, cwd, env));
 }
-async function listToolHiveGroupWorkloads(group, cwd) {
-	const result = await execa("thv", [
-		"list",
-		"--group",
-		group,
-		"--format",
-		"json"
-	], {
-		cwd,
-		env: await toolhiveEnv(cwd),
-		stdin: "ignore"
-	});
-	let parsed;
-	const stdout = result.stdout.trim();
-	if (!stdout) return [];
-	try {
-		parsed = JSON.parse(stdout);
-	} catch {
-		throw new PipelineMcpGatewayError("ToolHive list returned malformed JSON while reconciling MCP gateway workloads.");
-	}
-	if (!Array.isArray(parsed)) throw new PipelineMcpGatewayError("ToolHive list returned a non-array payload while reconciling MCP gateway workloads.");
-	return parsed.flatMap((item) => {
-		if (!item || typeof item.name !== "string") return [];
-		return [{
-			name: item.name,
-			status: typeof item.status === "string" ? item.status : void 0,
-			transport: toolHiveWorkloadTransport(item),
-			url: typeof item.url === "string" ? item.url : void 0
-		}];
+function reconcileGatewayEffect(config, cwd, env) {
+	const gateway = configuredGateway(config);
+	if (gateway.provider !== "toolhive") return Effect.fail(new PipelineMcpGatewayError(`Unsupported MCP gateway provider '${gateway.provider}'.`));
+	return Effect.gen(function* () {
+		const service = yield* McpGatewayService;
+		const workspacePath = env.PIPELINE_TARGET_PATH || cwd;
+		const repoLocalBackends = resolveRepoLocalBackendSpecs(config, {
+			cwd: workspacePath,
+			env
+		});
+		const inventory = renderToolHiveVmcpInventory(config, {
+			repoLocalBackends,
+			toolHiveWorkloads: yield* service.listToolHiveGroupWorkloads(gateway.default_profile ?? "default", workspacePath)
+		});
+		const configPath = join(workspacePath, ".pipeline", "mcp-gateway", "vmcp.yaml");
+		mkdirSync(dirname(configPath), { recursive: true });
+		writeFileSync(configPath, inventory.yaml);
+		yield* service.validateToolHiveVmcp(configPath, workspacePath);
+		return {
+			backendCount: inventory.backends.length,
+			configPath,
+			readinessFailures: [...repoLocalBackends.filter((backend) => backend.enabled && !backend.readiness.ok).map((backend) => `${backend.id}: ${backend.readiness.reason}`), ...inventory.backends.filter((backend) => backend.enabled && backend.required && !backend.url).map((backend) => `${backend.name}: missing ToolHive workload`)],
+			workspacePath
+		};
 	});
 }
-function toolHiveWorkloadTransport(item) {
-	if (typeof item.transport_type === "string") return item.transport_type;
-	if (typeof item.transport === "string") return item.transport;
-}
-async function localGatewayStatus(cwd) {
-	return (await execa("thv", ["list"], {
-		cwd,
-		env: await toolhiveEnv(cwd)
-	})).stdout.trim();
+function localGatewayStatus(cwd) {
+	return runMcpGatewayEffect(Effect.gen(function* () {
+		return yield* (yield* McpGatewayService).localGatewayStatus(cwd);
+	}));
 }
-async function checkGatewayRequiredTools(gateway) {
+function checkGatewayRequiredTools(gateway) {
 	const requiredPrefixes = requiredGatewayToolPrefixes(gateway);
-	if (requiredPrefixes.length === 0) return {
+	if (requiredPrefixes.length === 0) return Effect.succeed({
 		detail: "no required tools declared",
 		name: "gateway-required-tools",
 		passed: true
-	};
-	try {
-		const tools = await listGatewayTools(gateway);
+	});
+	return Effect.gen(function* () {
+		const tools = yield* listGatewayTools(gateway);
 		const missing = requiredPrefixes.filter((prefix) => !tools.some((tool) => tool === prefix || tool.startsWith(`${prefix}_`)));
 		return missing.length === 0 ? {
 			detail: `found: ${requiredPrefixes.join(", ")}`,
@@ -220,54 +170,45 @@ async function checkGatewayRequiredTools(gateway) {
 			name: "gateway-required-tools",
 			passed: false
 		};
-	} catch (err) {
-		return {
-			detail: err instanceof Error ? err.message : String(err),
-			name: "gateway-required-tools",
-			passed: false
-		};
-	}
+	}).pipe(Effect.catchAll((error) => Effect.succeed({
+		detail: error instanceof Error ? error.message : String(error),
+		name: "gateway-required-tools",
+		passed: false
+	})));
 }
 function requiredGatewayToolPrefixes(gateway) {
 	return [...new Set(Object.values(gateway.backends).filter((backend) => backend.required).flatMap((backend) => backend.tool_prefixes))].sort();
 }
-async function listGatewayTools(gateway) {
+function listGatewayTools(gateway) {
 	const url = gatewayUrl(gateway);
-	await callGatewayRpc(gateway, url, {
-		id: 1,
-		jsonrpc: "2.0",
-		method: "initialize",
-		params: {
-			capabilities: {},
-			clientInfo: {
-				name: "@oisincoveney/pipeline",
-				version: "1"
-			},
-			protocolVersion: "2025-06-18"
-		}
+	return Effect.gen(function* () {
+		yield* callGatewayRpc(gateway, url, {
+			id: 1,
+			jsonrpc: "2.0",
+			method: "initialize",
+			params: {
+				capabilities: {},
+				clientInfo: {
+					name: "@oisincoveney/pipeline",
+					version: "1"
+				},
+				protocolVersion: "2025-06-18"
+			}
+		});
+		const tools = (yield* callGatewayRpc(gateway, url, {
+			id: 2,
+			jsonrpc: "2.0",
+			method: "tools/list",
+			params: {}
+		})).result?.tools;
+		if (!Array.isArray(tools)) return yield* Effect.fail(new PipelineMcpGatewayError("Malformed tools/list response."));
+		return tools.flatMap((tool) => tool && typeof tool.name === "string" ? [tool.name] : []);
 	});
-	const tools = (await callGatewayRpc(gateway, url, {
-		id: 2,
-		jsonrpc: "2.0",
-		method: "tools/list",
-		params: {}
-	})).result?.tools;
-	if (!Array.isArray(tools)) throw new PipelineMcpGatewayError("Malformed tools/list response.");
-	return tools.flatMap((tool) => tool && typeof tool.name === "string" ? [tool.name] : []);
-}
-async function callGatewayRpc(gateway, url, body) {
-	const authorization = process.env[gateway.authorization_env];
-	const response = await fetch(url, {
-		body: JSON.stringify(body),
-		headers: {
-			Accept: "application/json",
-			"Content-Type": "application/json",
-			...authorization ? { Authorization: authorization } : {}
-		},
-		method: "POST"
+}
+function callGatewayRpc(gateway, url, body) {
+	return Effect.gen(function* () {
+		return yield* (yield* McpGatewayService).callGatewayRpc(url, body, process.env[gateway.authorization_env]);
 	});
-	if (!response.ok) throw new PipelineMcpGatewayError(`Gateway MCP request failed: HTTP ${response.status}.`);
-	return await response.json();
 }
 function selectedGatewayHosts(host) {
 	return host === "all" ? ["opencode"] : [host];
@@ -314,86 +255,44 @@ function gatewayAuthorizationHeader(gateway) {
 function gatewayOpenCodeHeaders(gateway) {
 	return { Authorization: gatewayAuthorizationHeader(gateway) };
 }
-async function checkThv(cwd) {
-	try {
-		await execa("thv", ["version"], {
-			cwd,
-			env: await toolhiveEnv(cwd),
-			stdin: "ignore"
-		});
+function checkThv(cwd) {
+	return Effect.gen(function* () {
+		yield* (yield* McpGatewayService).runToolHiveVersion(cwd);
 		return {
 			detail: "available",
 			name: "toolhive",
 			passed: true
 		};
-	} catch (err) {
-		const error = err;
-		return {
-			detail: (error.shortMessage || error.stderr || "not available").trim(),
-			name: "toolhive",
-			passed: false
-		};
-	}
-}
-async function toolhiveEnv(cwd) {
-	if (process.env.DOCKER_HOST) return process.env;
-	const dockerHost = await activeDockerHost(cwd);
-	return dockerHost ? {
-		...process.env,
-		DOCKER_HOST: dockerHost
-	} : process.env;
-}
-async function activeDockerHost(cwd) {
-	try {
-		const result = await execa("docker", ["context", "inspect"], {
-			cwd,
-			stdin: "ignore"
-		});
-		const host = JSON.parse(result.stdout)[0]?.Endpoints?.docker?.Host;
-		return typeof host === "string" && host.length > 0 ? host : void 0;
-	} catch {
-		return;
-	}
+	}).pipe(Effect.catchAll((error) => Effect.succeed({
+		detail: error.message || "not available",
+		name: "toolhive",
+		passed: false
+	})));
 }
-async function checkGatewayHealth(gateway) {
+function checkGatewayHealth(gateway) {
 	let url;
 	try {
 		url = gatewayUrl(gateway);
 	} catch (err) {
-		return {
+		return Effect.succeed({
 			detail: err instanceof Error ? err.message : String(err),
 			name: "gateway-health",
 			passed: false
-		};
+		});
 	}
-	try {
-		const response = await firstHealthyGatewayResponse(url, gateway);
+	return Effect.gen(function* () {
+		const response = yield* (yield* McpGatewayService).firstHealthyGatewayResponse(gatewayHealthUrls(url), process.env[gateway.authorization_env]);
 		const passed = Boolean(response);
 		return {
 			detail: response ? `HTTP ${response.status} ${response.url}` : "gateway endpoint did not report healthy",
 			name: "gateway-health",
 			passed
 		};
-	} catch (err) {
-		return {
-			detail: err instanceof Error ? err.message : String(err),
-			name: "gateway-health",
-			passed: false
-		};
-	}
-}
-async function firstHealthyGatewayResponse(url, gateway) {
-	const authorization = process.env[gateway.authorization_env];
-	for (const healthUrl of gatewayHealthUrls(url)) {
-		const response = await fetch(healthUrl, {
-			headers: {
-				Accept: "application/json, text/event-stream",
-				...authorization ? { Authorization: authorization } : {}
-			},
-			method: "GET"
-		});
-		if (response.status >= 200 && response.status < 300 || response.status === 405) return response;
-	}
+	}).pipe(Effect.catchAll((error) => Effect.succeed({
+		detail: error instanceof Error ? error.message : String(error),
+		name: "gateway-health",
+		passed: false
+	})));
 }
 function gatewayHealthUrls(url) {
 	const urls = [];

package/dist/moka-global-config.js

@@ -1,8 +1,8 @@
 import { PipelineConfigError } from "./config/schemas.js";
+import { ConfigIoService, runConfigIoSync } from "./runtime/services/config-io-service.js";
 import "./config.js";
-import { parseDocument } from "yaml";
 import { z } from "zod";
-import { existsSync, readFileSync } from "node:fs";
+import { Effect } from "effect";
 import { join } from "node:path";
 import { homedir } from "node:os";
 //#region src/moka-global-config.ts
@@ -30,27 +30,27 @@ function mokaGlobalConfigPath(homeDir = homedir()) {
 }
 function loadMokaGlobalConfig() {
 	const configPath = mokaGlobalConfigPath();
-	if (!existsSync(configPath)) return null;
-	return parseMokaGlobalConfig(readFileSync(configPath, "utf8"), configPath);
+	return runConfigIoSync(Effect.gen(function* () {
+		const source = yield* (yield* ConfigIoService).readOptionalText(configPath);
+		return source === null ? null : yield* parseMokaGlobalConfigEffect(source, configPath);
+	}));
 }
 function parseMokaGlobalConfig(source, sourcePath) {
-	const document = parseDocument(source, {
-		prettyErrors: false,
-		uniqueKeys: true
+	return runConfigIoSync(parseMokaGlobalConfigEffect(source, sourcePath));
+}
+function parseMokaGlobalConfigEffect(source, sourcePath) {
+	return Effect.gen(function* () {
+		const yaml = yield* (yield* ConfigIoService).parseYaml(source, sourcePath);
+		const parsed = mokaGlobalConfigSchema.safeParse(yaml);
+		if (!parsed.success) {
+			const issues = parsed.error.issues.map((issue) => ({
+				path: issue.path.join("."),
+				message: issue.message
+			}));
+			return yield* Effect.fail(new PipelineConfigError("PIPELINE_CONFIG_VALIDATION_ERROR", [`Invalid ${sourcePath}:`, ...issues.map((issue) => issue.path ? `- ${issue.path}: ${issue.message}` : `- ${issue.message}`)].join("\n"), issues));
+		}
+		return parsed.data;
 	});
-	if (document.errors.length > 0) throw new PipelineConfigError("PIPELINE_CONFIG_PARSE_ERROR", `Failed to parse ${sourcePath}`, document.errors.map((err) => ({
-		message: err.message,
-		path: sourcePath
-	})));
-	const parsed = mokaGlobalConfigSchema.safeParse(document.toJS());
-	if (!parsed.success) {
-		const issues = parsed.error.issues.map((issue) => ({
-			path: issue.path.join("."),
-			message: issue.message
-		}));
-		throw new PipelineConfigError("PIPELINE_CONFIG_VALIDATION_ERROR", [`Invalid ${sourcePath}:`, ...issues.map((issue) => issue.path ? `- ${issue.path}: ${issue.message}` : `- ${issue.message}`)].join("\n"), issues);
-	}
-	return parsed.data;
 }
 //#endregion
 export { MOKA_GLOBAL_CONFIG_PATH, loadMokaGlobalConfig, mokaGlobalConfigPath, mokaGlobalConfigSchema, parseMokaGlobalConfig };

package/dist/moka-submit.d.ts

@@ -5,13 +5,13 @@ import { z } from "zod";
 //#region src/moka-submit.d.ts
 declare const mokaSubmitDirectHooksSchema: z.ZodRecord<z.ZodEnum<{
   "workflow.start": "workflow.start";
-  "node.finish": "node.finish";
-  "node.start": "node.start";
   "workflow.success": "workflow.success";
   "workflow.failure": "workflow.failure";
   "workflow.complete": "workflow.complete";
+  "node.start": "node.start";
   "node.success": "node.success";
   "node.error": "node.error";
+  "node.finish": "node.finish";
   "gate.failure": "gate.failure";
 }> & z.core.$partial, z.ZodDiscriminatedUnion<[z.ZodObject<{
   failure: z.ZodDefault<z.ZodEnum<{
@@ -94,13 +94,13 @@ declare const mokaSubmitOptionsSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
   }, z.core.$strict>>;
   hooks: z.ZodOptional<z.ZodRecord<z.ZodEnum<{
     "workflow.start": "workflow.start";
-    "node.finish": "node.finish";
-    "node.start": "node.start";
     "workflow.success": "workflow.success";
     "workflow.failure": "workflow.failure";
     "workflow.complete": "workflow.complete";
+    "node.start": "node.start";
     "node.success": "node.success";
     "node.error": "node.error";
+    "node.finish": "node.finish";
     "gate.failure": "gate.failure";
   }> & z.core.$partial, z.ZodDiscriminatedUnion<[z.ZodObject<{
     failure: z.ZodDefault<z.ZodEnum<{
@@ -160,8 +160,8 @@ declare const mokaSubmitOptionsSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
   }, z.core.$strict>>;
   serviceAccountName: z.ZodOptional<z.ZodString>;
   mode: z.ZodEnum<{
-    quick: "quick";
     full: "full";
+    quick: "quick";
   }>;
   schedulePath: z.ZodOptional<z.ZodString>;
   scheduleYaml: z.ZodOptional<z.ZodString>;
@@ -206,13 +206,13 @@ declare const mokaSubmitOptionsSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
   }, z.core.$strict>>;
   hooks: z.ZodOptional<z.ZodRecord<z.ZodEnum<{
     "workflow.start": "workflow.start";
-    "node.finish": "node.finish";
-    "node.start": "node.start";
     "workflow.success": "workflow.success";
     "workflow.failure": "workflow.failure";
     "workflow.complete": "workflow.complete";
+    "node.start": "node.start";
     "node.success": "node.success";
     "node.error": "node.error";
+    "node.finish": "node.finish";
     "gate.failure": "gate.failure";
   }> & z.core.$partial, z.ZodDiscriminatedUnion<[z.ZodObject<{
     failure: z.ZodDefault<z.ZodEnum<{