@oisincoveney/pipeline 3.24.1 → 3.24.3

package/README.md

@@ -290,8 +290,8 @@ sources of truth. Host resources use OpenCode native agents for model-backed
 nodes. Otherwise generated instructions dispatch to the configured command
 runner.
 
-| Host | Generated files | Invocation |
-| --- | --- | --- |
+| Host     | Generated files                                                                                                         | Invocation                                                           |
+| -------- | ----------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------- |
 | OpenCode | `.opencode/commands/moka-<entrypoint>.md`, `.opencode/agents/*.md`, `.opencode/plugins/*.ts`, `.opencode/opencode.json` | `/moka-quick <task>`, `/moka-execute <task>`, `/moka-inspect <task>` |
 
 The installer is idempotent, supports `--check` and `--dry-run`, and refuses to

package/defaults/pipeline.yaml

@@ -36,7 +36,12 @@ hooks:
   functions:
     generated-defaults-audit:
       kind: command
-      command: [node, -e, "const fs=require('node:fs'); fs.writeFileSync(process.env.PIPELINE_HOOK_RESULT, JSON.stringify({status:'pass',summary:'Generated defaults audit passed'}));"]
+      command:
+        [
+          node,
+          -e,
+          "const fs=require('node:fs'); fs.writeFileSync(process.env.PIPELINE_HOOK_RESULT, JSON.stringify({status:'pass',summary:'Generated defaults audit passed'}));",
+        ]
       trusted: true
       timeout_ms: 5000
       output_limit_bytes: 4096
@@ -111,7 +116,8 @@ scheduler:
         green-implementation:
           category: green
           profile: moka-code-writer
-          models: [opencode-go/qwen3.7-max, broker/gpt-5.5, kimi-for-coding/k2p6]
+          models:
+            [opencode-go/qwen3.7-max, broker/gpt-5.5, kimi-for-coding/k2p6]
           reasoning_effort: high
         verification:
           category: verification
@@ -119,7 +125,17 @@ scheduler:
           models: [broker/gpt-5.5, kimi-for-coding/kimi-k2-thinking]
           reasoning_effort: medium
     execute:
-      required_categories: [intake, research, red, green, mechanical, acceptance, verification, learn]
+      required_categories:
+        [
+          intake,
+          research,
+          red,
+          green,
+          mechanical,
+          acceptance,
+          verification,
+          learn,
+        ]
       nodes:
         backlog-intake:
           category: intake
@@ -139,12 +155,14 @@ scheduler:
         green-backend:
           category: green
           profile: moka-code-writer
-          models: [opencode-go/qwen3.7-max, broker/gpt-5.5, kimi-for-coding/k2p6]
+          models:
+            [opencode-go/qwen3.7-max, broker/gpt-5.5, kimi-for-coding/k2p6]
           reasoning_effort: high
         green-frontend:
           category: green
           profile: moka-code-writer
-          models: [broker/gpt-5.5, kimi-for-coding/k2p6, opencode-go/qwen3.7-max]
+          models:
+            [broker/gpt-5.5, kimi-for-coding/k2p6, opencode-go/qwen3.7-max]
           reasoning_effort: high
         acceptance-review:
           category: acceptance

package/defaults/profiles.yaml

@@ -93,21 +93,37 @@ profiles:
     model: broker/gpt-5.5
     reasoning_effort: xhigh
     description: Orchestrate the configured pipeline and enforce gates.
-    instructions: { inline: "Orchestrate through the canonical local `moka run` supervisor. For compatibility slash commands, run the `moka run` command and flags shown in the command body. Treat execution as CLI/supervised runtime, not OpenCode-native Task execution. Enforce only package-configured gates." }
+    instructions:
+      {
+        inline: "Orchestrate through the canonical local `moka run` supervisor. For compatibility slash commands, run the `moka run` command and flags shown in the command body. Treat execution as CLI/supervised runtime, not OpenCode-native Task execution. Enforce only package-configured gates.",
+      }
     skills: [orchestrate, execute, quick, inspect]
     mcp_servers: [pipeline-gateway]
     tools: [read, list, grep, glob, bash]
-    filesystem: { mode: read-only, allow: ["**/*"], deny: ["node_modules/**", "dist/**", ".git/**"] }
+    filesystem:
+      {
+        mode: read-only,
+        allow: ["**/*"],
+        deny: ["node_modules/**", "dist/**", ".git/**"],
+      }
     network: { mode: inherit }
   moka-researcher:
     runner: opencode
     description: Research the requested task and produce structured findings.
-    instructions: { inline: "Inspect first-party source, tests, docs, and task context for the current task only. Produce concise findings with file references and stop; do not perform open-ended repository exploration." }
+    instructions:
+      {
+        inline: "Inspect first-party source, tests, docs, and task context for the current task only. Produce concise findings with file references and stop; do not perform open-ended repository exploration.",
+      }
     timeout_ms: 900000
     skills: [research, spec, scope]
     mcp_servers: [pipeline-gateway]
     tools: [read, list, grep, glob, bash]
-    filesystem: { mode: read-only, allow: ["**/*"], deny: ["node_modules/**", "dist/**", ".git/**"] }
+    filesystem:
+      {
+        mode: read-only,
+        allow: ["**/*"],
+        deny: ["node_modules/**", "dist/**", ".git/**"],
+      }
     network: { mode: inherit }
     output:
       format: json_schema
@@ -116,12 +132,20 @@ profiles:
   moka-ticket-scoper:
     runner: opencode
     description: Scope a request into a validated Backlog ticket plan.
-    instructions: { inline: "Use the scope skill contract to produce implementation-complete Backlog tickets. Return only valid JSON matching `.pipeline/schemas/ticket-plan.schema.json`. Every acceptance criterion must include concrete evidence text. Do not emit partial tickets; include dependencies, likely files, references, priorities, and plan text for each proposed ticket." }
+    instructions:
+      {
+        inline: "Use the scope skill contract to produce implementation-complete Backlog tickets. Return only valid JSON matching `.pipeline/schemas/ticket-plan.schema.json`. Every acceptance criterion must include concrete evidence text. Do not emit partial tickets; include dependencies, likely files, references, priorities, and plan text for each proposed ticket.",
+      }
     timeout_ms: 300000
     skills: [scope]
     mcp_servers: [pipeline-gateway]
     tools: [read, list, grep, glob, bash]
-    filesystem: { mode: read-only, allow: ["**/*"], deny: ["node_modules/**", "dist/**", ".git/**"] }
+    filesystem:
+      {
+        mode: read-only,
+        allow: ["**/*"],
+        deny: ["node_modules/**", "dist/**", ".git/**"],
+      }
     network: { mode: inherit }
     output:
       format: json_schema
@@ -136,30 +160,51 @@ profiles:
     skills: [research]
     mcp_servers: [pipeline-gateway]
     tools: [read, list, grep, glob, bash]
-    filesystem: { mode: read-only, allow: ["**/*"], deny: ["node_modules/**", "dist/**", ".git/**"] }
+    filesystem:
+      {
+        mode: read-only,
+        allow: ["**/*"],
+        deny: ["node_modules/**", "dist/**", ".git/**"],
+      }
     network: { mode: inherit }
   moka-schedule-planner:
     runner: opencode
     model: broker/gpt-5.5
     reasoning_effort: xhigh
     description: Refine a baseline schedule into a specialized approved-plan artifact.
-    instructions: { inline: "Generate exactly one workflow named root as an explicit schedule graph. Return YAML only." }
+    instructions:
+      {
+        inline: "Generate exactly one workflow named root as an explicit schedule graph. Return YAML only.",
+      }
     timeout_ms: 300000
     skills: [schedule-graph-shaping]
     mcp_servers: [pipeline-gateway]
     tools: [read, list, grep, glob, bash]
-    filesystem: { mode: read-only, allow: ["**/*"], deny: ["node_modules/**", "dist/**", ".git/**"] }
+    filesystem:
+      {
+        mode: read-only,
+        allow: ["**/*"],
+        deny: ["node_modules/**", "dist/**", ".git/**"],
+      }
     network: { mode: inherit }
   moka-test-writer:
     runner: opencode
     scheduling_roles: [implementation]
     description: Add focused failing tests for the requested behavior.
     timeout_ms: 1800000
-    instructions: { inline: "This scheduled node is already dispatched by Moka; do direct repository work inside the current workspace. Do not invoke `moka run`, `moka submit`, `$dispatch`, `$scope`, `$execute`, or any nested Moka/workflow supervisor from this node. Add focused failing tests for the requested behavior only. Do not change production code. Only edit files matching test paths such as **/*.test.*, **/*.spec.*, **/*_test.*, **/__tests__/**, test/**, or tests/**. Tool findings about lint, types, complexity, or dead code must be resolved at source; comments must not hide them. If a gate flags your test, restructure the test (e.g. move restricted imports into shared support/fixture helpers). Return only valid JSON with top-level changes and verification. Every changes entry must include summary, why, and files. Include risks, followups, and lessons when present. Do not use Markdown fences or prose outside the JSON object." }
+    instructions:
+      {
+        inline: "This scheduled node is already dispatched by Moka; do direct repository work inside the current workspace. Do not invoke `moka run`, `moka submit`, `$dispatch`, `$scope`, `$execute`, or any nested Moka/workflow supervisor from this node. Add focused failing tests for the requested behavior only. Do not change production code. Only edit files matching test paths such as **/*.test.*, **/*.spec.*, **/*_test.*, **/__tests__/**, test/**, or tests/**. Tool findings about lint, types, complexity, or dead code must be resolved at source; comments must not hide them. If a gate flags your test, restructure the test (e.g. move restricted imports into shared support/fixture helpers). Return only valid JSON with top-level changes and verification. Every changes entry must include summary, why, and files. Include risks, followups, and lessons when present. Do not use Markdown fences or prose outside the JSON object.",
+      }
     skills: [test]
     mcp_servers: [pipeline-gateway]
     tools: [read, list, grep, glob, bash, edit, write]
-    filesystem: { mode: workspace-write, allow: ["**/*"], deny: ["node_modules/**", "dist/**", ".git/**"] }
+    filesystem:
+      {
+        mode: workspace-write,
+        allow: ["**/*"],
+        deny: ["node_modules/**", "dist/**", ".git/**"],
+      }
     network: { mode: inherit }
     output:
       format: json_schema
@@ -170,11 +215,19 @@ profiles:
     scheduling_roles: [implementation]
     description: Implement production code until the failing tests pass.
     timeout_ms: 1800000
-    instructions: { inline: "This scheduled node is already dispatched by Moka; do direct repository work inside the current workspace. Do not invoke `moka run`, `moka submit`, `$dispatch`, `$scope`, `$execute`, or any nested Moka/workflow supervisor from this node. Implement the smallest production change that makes the failing tests pass. Tool findings about lint, types, complexity, or dead code must be resolved at source; comments must not hide them. Reduce complexity by extracting helpers, remove genuinely dead code, and migrate off deprecated APIs rather than hiding the warning. Return only valid JSON with top-level changes and verification. Every changes entry must include summary, why, and files. Include risks, followups, and lessons when present. Do not use Markdown fences or prose outside the JSON object." }
+    instructions:
+      {
+        inline: "This scheduled node is already dispatched by Moka; do direct repository work inside the current workspace. Do not invoke `moka run`, `moka submit`, `$dispatch`, `$scope`, `$execute`, or any nested Moka/workflow supervisor from this node. Implement the smallest production change that makes the failing tests pass. Tool findings about lint, types, complexity, or dead code must be resolved at source; comments must not hide them. Reduce complexity by extracting helpers, remove genuinely dead code, and migrate off deprecated APIs rather than hiding the warning. Return only valid JSON with top-level changes and verification. Every changes entry must include summary, why, and files. Include risks, followups, and lessons when present. Do not use Markdown fences or prose outside the JSON object.",
+      }
     skills: [trace, test, fix, library-first-development]
     mcp_servers: [pipeline-gateway]
     tools: [read, list, grep, glob, bash, edit, write]
-    filesystem: { mode: workspace-write, allow: ["**/*"], deny: ["node_modules/**", "dist/**", ".git/**"] }
+    filesystem:
+      {
+        mode: workspace-write,
+        allow: ["**/*"],
+        deny: ["node_modules/**", "dist/**", ".git/**"],
+      }
     network: { mode: inherit }
     output:
       format: json_schema
@@ -184,11 +237,19 @@ profiles:
     runner: opencode
     scheduling_roles: [coverage]
     description: Audit the finished change against every acceptance criterion.
-    instructions: { inline: 'Audit the completed change against each canonical acceptance criterion independently. Return only valid JSON with top-level "verdict", "evidence", "acceptance", and optional "violations". Each "acceptance" entry must include "id", "verdict", and non-empty "evidence". Do not use Markdown fences or prose outside the JSON object.' }
+    instructions:
+      {
+        inline: 'Audit the completed change against each canonical acceptance criterion independently. Return only valid JSON with top-level "verdict", "evidence", "acceptance", and optional "violations". Each "acceptance" entry must include "id", "verdict", and non-empty "evidence". Do not use Markdown fences or prose outside the JSON object.',
+      }
     skills: [critique, doubt]
     mcp_servers: [pipeline-gateway]
     tools: [read, list, grep, glob, bash]
-    filesystem: { mode: read-only, allow: ["**/*"], deny: ["node_modules/**", "dist/**", ".git/**"] }
+    filesystem:
+      {
+        mode: read-only,
+        allow: ["**/*"],
+        deny: ["node_modules/**", "dist/**", ".git/**"],
+      }
     network: { mode: inherit }
     output:
       format: json_schema
@@ -198,11 +259,19 @@ profiles:
     runner: opencode
     scheduling_roles: [coverage]
     description: Perform the final thermo-nuclear code quality review of the integration branch.
-    instructions: { inline: "Perform the final code quality review of the integration branch." }
+    instructions:
+      {
+        inline: "Perform the final code quality review of the integration branch.",
+      }
     skills: [critique]
     mcp_servers: [pipeline-gateway]
     tools: [read, list, grep, glob, bash]
-    filesystem: { mode: read-only, allow: ["**/*"], deny: ["node_modules/**", "dist/**", ".git/**"] }
+    filesystem:
+      {
+        mode: read-only,
+        allow: ["**/*"],
+        deny: ["node_modules/**", "dist/**", ".git/**"],
+      }
     network: { mode: inherit }
     output:
       format: json_schema
@@ -212,11 +281,19 @@ profiles:
     runner: opencode
     scheduling_roles: [coverage]
     description: Verify checks, implementation fit, and final evidence.
-    instructions: { inline: 'Verify checks, implementation fit, and final evidence. Return only valid JSON with top-level "verdict", "evidence", and optional "violations". Do not use Markdown fences or prose outside the JSON object.' }
+    instructions:
+      {
+        inline: 'Verify checks, implementation fit, and final evidence. Return only valid JSON with top-level "verdict", "evidence", and optional "violations". Do not use Markdown fences or prose outside the JSON object.',
+      }
     skills: [verify, critique, secure, optimize]
     mcp_servers: [pipeline-gateway]
     tools: [read, list, grep, glob, bash]
-    filesystem: { mode: read-only, allow: ["**/*"], deny: ["node_modules/**", "dist/**", ".git/**"] }
+    filesystem:
+      {
+        mode: read-only,
+        allow: ["**/*"],
+        deny: ["node_modules/**", "dist/**", ".git/**"],
+      }
     network: { mode: inherit }
     output:
       format: json_schema
@@ -227,11 +304,17 @@ profiles:
     model: broker/gpt-5.5
     reasoning_effort: low
     description: Store durable lessons from the completed run.
-    instructions: { inline: "Store durable lessons from the completed run when useful." }
+    instructions:
+      { inline: "Store durable lessons from the completed run when useful." }
     skills: [migrate]
     mcp_servers: [pipeline-gateway]
     tools: [read, list, grep, glob, bash]
-    filesystem: { mode: read-only, allow: ["**/*"], deny: ["node_modules/**", "dist/**", ".git/**"] }
+    filesystem:
+      {
+        mode: read-only,
+        allow: ["**/*"],
+        deny: ["node_modules/**", "dist/**", ".git/**"],
+      }
     network: { mode: inherit }
     output:
       format: json_schema

package/dist/argo-graph.js

@@ -1,107 +1,107 @@
 import { uniqueStrings } from "./strings.js";
-import { resolveExecutableDependencyIds } from "./planning/dependency-refs.js";
+import { indexPlannedNodesById, resolveExecutableDependencyIds } from "./planning/dependency-refs.js";
 import { terminalDependencyItems } from "./planning/graph.js";
-import { Data } from "effect";
-import { z } from "zod";
+import { mutableArray, nonEmptyMutableArray, parseStrictWithSchema, requiredString, struct } from "./schema-boundary.js";
+import * as Option$1 from "effect/Option";
+import * as Schema from "effect/Schema";
+import * as Arr from "effect/Array";
+import * as HashMap from "effect/HashMap";
+import * as Match from "effect/Match";
 //#region src/argo-graph.ts
-const argoExecutableTaskSchema = z.object({
-	dependencies: z.array(z.string().min(1)),
-	nodeId: z.string().min(1),
-	taskName: z.string().min(1),
-	templateName: z.string().min(1)
-}).strict();
-const argoExecutionGraphSchema = z.object({
-	terminalNodeIds: z.array(z.string().min(1)),
-	tasks: z.array(argoExecutableTaskSchema).min(1),
-	terminalTaskNames: z.array(z.string().min(1)),
-	workflowId: z.string().min(1)
-}).strict();
+const argoExecutableTaskSchema = struct({
+	dependencies: mutableArray(requiredString),
+	nodeId: requiredString,
+	taskName: requiredString,
+	templateName: requiredString
+});
+const argoExecutionGraphSchema = struct({
+	tasks: nonEmptyMutableArray(argoExecutableTaskSchema),
+	terminalNodeIds: mutableArray(requiredString),
+	terminalTaskNames: mutableArray(requiredString),
+	workflowId: requiredString
+});
 /**
 * Thrown when the Argo graph compiler encounters a node kind that cannot be
 * lowered to an Argo DAG task. Callers should surface this as a validation
 * failure before attempting a cluster submission.
 */
-var ArgoGraphCompilerError = class extends Data.TaggedError("ArgoGraphCompilerError") {
+var ArgoGraphCompilerError = class extends Schema.TaggedErrorClass()("ArgoGraphCompilerError", {
+	kind: Schema.String,
+	message: Schema.String,
+	nodeId: Schema.String
+}) {
 	constructor(kind, nodeId) {
 		super({
 			kind,
-			nodeId,
-			message: `Argo graph compiler: node kind '${kind}' on node '${nodeId}' cannot be lowered to an Argo DAG task`
+			message: `Argo graph compiler: node kind '${kind}' on node '${nodeId}' cannot be lowered to an Argo DAG task`,
+			nodeId
 		});
 	}
 };
-function compileArgoExecutionGraph(plan) {
-	const compiler = new ArgoGraphCompiler(plan);
-	return argoExecutionGraphSchema.parse(compiler.compile());
-}
-var ArgoGraphCompiler = class {
-	nodeById = /* @__PURE__ */ new Map();
-	plan;
-	tasks = [];
-	constructor(plan) {
-		this.plan = plan;
-		this.indexNodes(plan.topologicalOrder);
-	}
-	compile() {
-		this.compileNodes(this.plan.topologicalOrder, []);
-		const terminalTasks = this.terminalTasks();
-		return {
-			terminalNodeIds: terminalTasks.map((task) => task.nodeId),
-			tasks: this.tasks,
-			terminalTaskNames: terminalTasks.map((task) => task.taskName),
-			workflowId: this.plan.workflowId
-		};
-	}
-	indexNodes(nodes) {
-		for (const node of nodes) {
-			if (this.nodeById.has(node.id)) throw new Error(`Argo schedule contains duplicate node id '${node.id}'`);
-			this.nodeById.set(node.id, node);
-			this.indexNodes(node.children ?? []);
-		}
-	}
-	compileNodes(nodes, inheritedNeeds) {
-		for (const node of nodes) this.compileNode(node, inheritedNeeds);
-	}
-	compileNode(node, inheritedNeeds) {
-		const kind = node.kind;
-		switch (kind) {
-			case "agent":
-			case "builtin":
-			case "command":
-				this.compileExecutableNode(node, inheritedNeeds);
-				return;
-			case "group": return;
-			case "parallel":
-				this.compileParallelNode(node, inheritedNeeds);
-				return;
-			default: throw new ArgoGraphCompilerError(String(kind), node.id);
-		}
-	}
-	compileExecutableNode(node, inheritedNeeds) {
-		const dependencies = this.resolveDependencyTaskNames([...inheritedNeeds, ...node.needs]);
-		const task = argoExecutableTaskSchema.parse({
-			dependencies,
-			nodeId: node.id,
-			taskName: argoTaskName(node.id),
-			templateName: argoTemplateName(node.id)
+var ArgoGraphDuplicateNodeError = class extends Schema.TaggedErrorClass()("ArgoGraphDuplicateNodeError", {
+	message: Schema.String,
+	nodeId: Schema.String
+}) {
+	constructor(nodeId) {
+		super({
+			message: `Argo schedule contains duplicate node id '${nodeId}'`,
+			nodeId
 		});
-		this.tasks.push(task);
-	}
-	compileParallelNode(node, inheritedNeeds) {
-		this.compileNodes(node.children ?? [], [...inheritedNeeds, ...node.needs]);
-	}
-	resolveDependencyTaskNames(nodeIds) {
-		return uniqueStrings(resolveExecutableDependencyIds(this.nodeById, nodeIds).map((id) => argoTaskName(id)));
-	}
-	terminalTasks() {
-		return terminalDependencyItems(this.tasks, (task) => task.taskName, (task) => task.dependencies);
 	}
 };
-function argoTaskName(nodeId) {
-	return `node-${nodeId}`;
-}
-function argoTemplateName(nodeId) {
-	return `task-${nodeId}`;
-}
+const argoTaskName = (nodeId) => `node-${nodeId}`;
+const argoTemplateName = (nodeId) => `task-${nodeId}`;
+const emptyDuplicateNodeSearchState = {
+	duplicate: Option$1.none(),
+	seen: HashMap.empty()
+};
+const nodeAndDescendants = (node) => [node, ...Arr.flatMap(node.children ?? [], nodeAndDescendants)];
+const plannedNodeTree = (nodes) => Arr.flatMap(nodes, nodeAndDescendants);
+const trackDuplicateNodeId = (state, node) => Option$1.isSome(state.duplicate) ? state : HashMap.has(state.seen, node.id) ? {
+	...state,
+	duplicate: Option$1.some(node.id)
+} : {
+	duplicate: Option$1.none(),
+	seen: HashMap.set(state.seen, node.id, true)
+};
+const duplicateNodeId = (nodes) => Arr.reduce(plannedNodeTree(nodes), emptyDuplicateNodeSearchState, trackDuplicateNodeId).duplicate;
+const assertUniqueNodeIds = (nodes) => {
+	Option$1.match(duplicateNodeId(nodes), {
+		onNone: () => void 0,
+		onSome: (nodeId) => {
+			throw new ArgoGraphDuplicateNodeError(nodeId);
+		}
+	});
+};
+const resolveDependencyTaskNames = (context, nodeIds) => uniqueStrings(resolveExecutableDependencyIds(context.nodeById, nodeIds).map((id) => argoTaskName(id)));
+const compileExecutableNode = (context, node, inheritedNeeds) => {
+	return parseStrictWithSchema(argoExecutableTaskSchema, {
+		dependencies: resolveDependencyTaskNames(context, [...inheritedNeeds, ...node.needs]),
+		nodeId: node.id,
+		taskName: argoTaskName(node.id),
+		templateName: argoTemplateName(node.id)
+	});
+};
+const compileArgoNodes = (context, nodes, inheritedNeeds, initialTasks = []) => Arr.reduce(nodes, initialTasks, (tasks, node) => compileArgoNode({
+	context,
+	inheritedNeeds,
+	node,
+	tasks
+}));
+const compileArgoNode = (input) => Match.value(input.node.kind).pipe(Match.whenOr("agent", "builtin", "command", () => [...input.tasks, compileExecutableNode(input.context, input.node, input.inheritedNeeds)]), Match.when("group", () => input.tasks), Match.when("parallel", () => compileArgoNodes(input.context, input.node.children ?? [], [...input.inheritedNeeds, ...input.node.needs], input.tasks)), Match.exhaustive);
+const compileArgoExecutionGraphUnchecked = (plan) => {
+	const tasks = compileArgoNodes({ nodeById: indexPlannedNodesById(plan.topologicalOrder) }, plan.topologicalOrder, []);
+	const terminalTasks = terminalDependencyItems(tasks, (task) => task.taskName, (task) => task.dependencies);
+	return {
+		tasks,
+		terminalNodeIds: terminalTasks.map((task) => task.nodeId),
+		terminalTaskNames: terminalTasks.map((task) => task.taskName),
+		workflowId: plan.workflowId
+	};
+};
+const compileArgoExecutionGraph = (plan) => {
+	assertUniqueNodeIds(plan.topologicalOrder);
+	return parseStrictWithSchema(argoExecutionGraphSchema, compileArgoExecutionGraphUnchecked(plan));
+};
 //#endregion
 export { ArgoGraphCompilerError, compileArgoExecutionGraph };