Expose matched rule id to action callbacks

c/include/dd/policies/eval_ctx.h

@@ -160,6 +160,27 @@ unsigned long plcs_eval_ctx_get_unumeric_param(plcs_numeric_evaluators id);
  */
 plcs_action_function_ptr plcs_eval_ctx_get_action(plcs_actions ix);
 
+/**
+ * @brief Returns the rule id that produced the current policy's TRUE verdict,
+ * or NULL if no rule-id-bearing top-level OR child matched.
+ *
+ * Set by the evaluator when composite_evaluator at depth 0 sees an OR child
+ * return TRUE; the description of that child is captured as the rule id. This
+ * lets action callbacks identify *which* rule fired in policies that bundle
+ * many rules under one Action (e.g. the requirements.bin produced by
+ * dd-requirements-converter, where each top-level OR child is wrapped in a
+ * composite whose description is the rule's stable identifier).
+ *
+ * For single-rule policies (rules tree root is not an OR), this returns NULL
+ * and callers should fall back to Action.description, which by convention
+ * carries the rule id in that shape (see dd-rules-converter).
+ *
+ * @note Reset to NULL at the start of each evaluate_policy. The returned
+ * pointer is owned by the FlatBuffer passed to plcs_evaluate_buffer and is
+ * only valid until that buffer is freed.
+ */
+const char *plcs_eval_ctx_get_matched_rule_id(void);
+
 /**
  * @brief An accessor for the last error
  * @return the last error as a plcs_errors enum, NOTE: This will RESET the error!

c/src/eval_ctx.c

@@ -208,6 +208,14 @@ plcs_errors plcs_eval_ctx_get_unum_eval_error(plcs_numeric_evaluators ix) {
   return PLCS_EIX_OVERFLOW;
 }
 
+const char *plcs_eval_ctx_get_matched_rule_id(void) {
+  return ctx.matched_rule_id;
+}
+
+void plcs_eval_ctx_set_matched_rule_id(const char *id) {
+  ctx.matched_rule_id = id;
+}
+
 plcs_errors plcs_eval_ctx_peek_last_error(void) {
   return ctx.error;
 }
@@ -244,6 +252,7 @@ void plcs_eval_ctx_reset(void) {
   }
 
   ctx.error = PLCS_ESUCCESS;
+  ctx.matched_rule_id = NULL;
 }
 
 plcs_errors plcs_eval_ctx_init(void) {

c/src/eval_ctx.h

@@ -111,6 +111,17 @@ typedef struct plcs_eval_ctx {
   /**< TODO: consider implementing this as a stack to preserve history of errors */
   plcs_errors error;
 
+  /**
+   * @brief Description of the top-level OR child whose evaluation returned
+   * TRUE within the policy currently being evaluated, or NULL if no such
+   * match occurred (e.g. single-rule policies whose top of the rules tree is
+   * not an OR). Set by composite_evaluator at depth 0, read by action
+   * callbacks via plcs_eval_ctx_get_matched_rule_id(). Points into the
+   * caller-owned FlatBuffer; lifetime is tied to plcs_evaluate_buffer's
+   * buffer argument.
+   */
+  const char *matched_rule_id;
+
 } plcs_eval_ctx;
 
 /**
@@ -146,3 +157,16 @@ void plcs_eval_ctx_set_num_eval_error(plcs_numeric_evaluators id, plcs_errors er
  * @param error plcs_errors enum
  */
 void plcs_eval_ctx_set_unum_eval_error(plcs_numeric_evaluators ix, plcs_errors error);
+
+/**
+ * @brief Set the matched rule id captured during policy evaluation.
+ *
+ * Internal — called by composite_evaluator when a top-level OR child returns
+ * TRUE. The pointer is stored verbatim (no copy), so it must reference memory
+ * with a lifetime at least as long as the next plcs_eval_ctx_reset() or
+ * plcs_evaluate_buffer() call — in practice, a string inside the FlatBuffer
+ * being evaluated.
+ *
+ * @param id Rule id string, or NULL to clear.
+ */
+void plcs_eval_ctx_set_matched_rule_id(const char *id);

c/src/evaluator.c

@@ -168,6 +168,35 @@ plcs_evaluation_result DoOper(dd_ns(BoolOperation_enum_t) oper, plcs_evaluation_
   }
 }
 
+// Reads the rule_id field from a NodeTypeWrapper's inner node (composite or
+// evaluator) and records it as the policy's matched rule id. Used at depth 0
+// in OR composites to identify which top-level rule fired. The field is empty
+// on nodes that aren't rule roots; the engine treats empty as "no rule id."
+static inline void capture_matched_rule_id(dd_ns(NodeTypeWrapper_table_t) wrapper) {
+  if (!wrapper) {
+    return;
+  }
+  switch (dd_ns(NodeTypeWrapper_node_type)(wrapper)) {
+    case dd_ns(NodeType_CompositeNode): {
+      dd_ns(CompositeNode_table_t) c = dd_ns(NodeTypeWrapper_node)(wrapper);
+      if (c) {
+        plcs_eval_ctx_set_matched_rule_id(dd_ns(CompositeNode_rule_id)(c));
+      }
+      break;
+    }
+    case dd_ns(NodeType_EvaluatorNode): {
+      dd_ns(EvaluatorNode_table_t) e = dd_ns(NodeTypeWrapper_node)(wrapper);
+      if (e) {
+        plcs_eval_ctx_set_matched_rule_id(dd_ns(EvaluatorNode_rule_id)(e));
+      }
+      break;
+    }
+    default:
+      // unknown node type — leave matched_rule_id unchanged
+      break;
+  }
+}
+
 plcs_evaluation_result composite_evaluator(dd_ns(CompositeNode_table_t) node, int depth) {
   if (!node) {
     return PLCS_EVAL_RESULT_ABSTAIN;
@@ -205,10 +234,20 @@ plcs_evaluation_result composite_evaluator(dd_ns(CompositeNode_table_t) node, in
 
   // keep iterating recursively over the tree
   for (size_t ix = 0; ix < children_len; ++ix) {
-    res = DoOper(oper, res, evaluate_rules(dd_ns(NodeTypeWrapper_vec_at)(children, ix), depth + 1));
+    dd_ns(NodeTypeWrapper_table_t) child = dd_ns(NodeTypeWrapper_vec_at)(children, ix);
+    res = DoOper(oper, res, evaluate_rules(child, depth + 1));
 
     // short circuit
     if (oper == dd_ns(BoolOperation_BOOL_OR) && res == PLCS_EVAL_RESULT_TRUE) {
+      // When the top-level rules tree is an OR (depth == 0), the matching
+      // child's description is the rule's stable identifier (see
+      // dd-requirements-converter, which wraps each rule in such a composite).
+      // Capture it here so action callbacks can surface "which rule fired" in
+      // telemetry. Nested ORs (depth > 0) are part of a single rule's
+      // sub-tree (e.g. "match any cmd pattern") and must not overwrite.
+      if (depth == 0) {
+        capture_matched_rule_id(child);
+      }
       return res;
     }
 
@@ -286,6 +325,11 @@ plcs_errors evaluate_policy(dd_ns(Policy_table_t) policy) {
   // extract rules
   dd_ns(NodeTypeWrapper_table_t) rules = dd_ns(Policy_rules)(policy);
 
+  // Clear any matched-rule-id residue from the previous policy. composite_evaluator
+  // sets this if/when a top-level OR child returns TRUE; if none does, it stays NULL
+  // and action callbacks fall back to Action.description.
+  plcs_eval_ctx_set_matched_rule_id(NULL);
+
   // // evaluate rules if they exist, otherwise return EVAL_RESULT_ABSTAIN
   plcs_evaluation_result eval_res = rules ? evaluate_rules(rules, 0) : PLCS_EVAL_RESULT_ABSTAIN;
 

c/src/schema/nodes_builder.h

@@ -35,25 +35,25 @@ __flatbuffers_build_table(flatbuffers_, dd_wls_NodeTypeWrapper, 2)
 static const flatbuffers_voffset_t __dd_wls_CompositeNode_required[] = { 0 };
 typedef flatbuffers_ref_t dd_wls_CompositeNode_ref_t;
 static dd_wls_CompositeNode_ref_t dd_wls_CompositeNode_clone(flatbuffers_builder_t *B, dd_wls_CompositeNode_table_t t);
-__flatbuffers_build_table(flatbuffers_, dd_wls_CompositeNode, 3)
+__flatbuffers_build_table(flatbuffers_, dd_wls_CompositeNode, 4)
 
 static const flatbuffers_voffset_t __dd_wls_EvaluatorNode_required[] = { 0 };
 typedef flatbuffers_ref_t dd_wls_EvaluatorNode_ref_t;
 static dd_wls_EvaluatorNode_ref_t dd_wls_EvaluatorNode_clone(flatbuffers_builder_t *B, dd_wls_EvaluatorNode_table_t t);
-__flatbuffers_build_table(flatbuffers_, dd_wls_EvaluatorNode, 3)
+__flatbuffers_build_table(flatbuffers_, dd_wls_EvaluatorNode, 4)
 
 #define __dd_wls_NodeTypeWrapper_formal_args , dd_wls_NodeType_union_ref_t v1
 #define __dd_wls_NodeTypeWrapper_call_args , v1
 static inline dd_wls_NodeTypeWrapper_ref_t dd_wls_NodeTypeWrapper_create(flatbuffers_builder_t *B __dd_wls_NodeTypeWrapper_formal_args);
 __flatbuffers_build_table_prolog(flatbuffers_, dd_wls_NodeTypeWrapper, dd_wls_NodeTypeWrapper_file_identifier, dd_wls_NodeTypeWrapper_type_identifier)
 
-#define __dd_wls_CompositeNode_formal_args , flatbuffers_string_ref_t v0, dd_wls_BoolOperation_enum_t v1, dd_wls_NodeTypeWrapper_vec_ref_t v2
-#define __dd_wls_CompositeNode_call_args , v0, v1, v2
+#define __dd_wls_CompositeNode_formal_args , flatbuffers_string_ref_t v0, dd_wls_BoolOperation_enum_t v1, dd_wls_NodeTypeWrapper_vec_ref_t v2, flatbuffers_string_ref_t v3
+#define __dd_wls_CompositeNode_call_args , v0, v1, v2, v3
 static inline dd_wls_CompositeNode_ref_t dd_wls_CompositeNode_create(flatbuffers_builder_t *B __dd_wls_CompositeNode_formal_args);
 __flatbuffers_build_table_prolog(flatbuffers_, dd_wls_CompositeNode, dd_wls_CompositeNode_file_identifier, dd_wls_CompositeNode_type_identifier)
 
-#define __dd_wls_EvaluatorNode_formal_args , flatbuffers_string_ref_t v0, dd_wls_EvaluatorType_union_ref_t v2
-#define __dd_wls_EvaluatorNode_call_args , v0, v2
+#define __dd_wls_EvaluatorNode_formal_args , flatbuffers_string_ref_t v0, dd_wls_EvaluatorType_union_ref_t v2, flatbuffers_string_ref_t v3
+#define __dd_wls_EvaluatorNode_call_args , v0, v2, v3
 static inline dd_wls_EvaluatorNode_ref_t dd_wls_EvaluatorNode_create(flatbuffers_builder_t *B __dd_wls_EvaluatorNode_formal_args);
 __flatbuffers_build_table_prolog(flatbuffers_, dd_wls_EvaluatorNode, dd_wls_EvaluatorNode_file_identifier, dd_wls_EvaluatorNode_type_identifier)
 
@@ -101,12 +101,14 @@ static dd_wls_NodeTypeWrapper_ref_t dd_wls_NodeTypeWrapper_clone(flatbuffers_bui
 __flatbuffers_build_string_field(0, flatbuffers_, dd_wls_CompositeNode_description, dd_wls_CompositeNode)
 __flatbuffers_build_scalar_field(1, flatbuffers_, dd_wls_CompositeNode_op, dd_wls_BoolOperation, dd_wls_BoolOperation_enum_t, 1, 1, INT8_C(0), dd_wls_CompositeNode)
 __flatbuffers_build_table_vector_field(2, flatbuffers_, dd_wls_CompositeNode_children, dd_wls_NodeTypeWrapper, dd_wls_CompositeNode)
+__flatbuffers_build_string_field(3, flatbuffers_, dd_wls_CompositeNode_rule_id, dd_wls_CompositeNode)
 
 static inline dd_wls_CompositeNode_ref_t dd_wls_CompositeNode_create(flatbuffers_builder_t *B __dd_wls_CompositeNode_formal_args)
 {
     if (dd_wls_CompositeNode_start(B)
         || dd_wls_CompositeNode_description_add(B, v0)
         || dd_wls_CompositeNode_children_add(B, v2)
+        || dd_wls_CompositeNode_rule_id_add(B, v3)
         || dd_wls_CompositeNode_op_add(B, v1)) {
         return 0;
     }
@@ -119,6 +121,7 @@ static dd_wls_CompositeNode_ref_t dd_wls_CompositeNode_clone(flatbuffers_builder
     if (dd_wls_CompositeNode_start(B)
         || dd_wls_CompositeNode_description_pick(B, t)
         || dd_wls_CompositeNode_children_pick(B, t)
+        || dd_wls_CompositeNode_rule_id_pick(B, t)
         || dd_wls_CompositeNode_op_pick(B, t)) {
         return 0;
     }
@@ -130,12 +133,14 @@ __flatbuffers_build_union_field(2, flatbuffers_, dd_wls_EvaluatorNode_eval, dd_w
 __flatbuffers_build_union_table_value_field(flatbuffers_, dd_wls_EvaluatorNode_eval, dd_wls_EvaluatorType, StrEvaluator, dd_wls_StrEvaluator)
 __flatbuffers_build_union_table_value_field(flatbuffers_, dd_wls_EvaluatorNode_eval, dd_wls_EvaluatorType, NumEvaluator, dd_wls_NumEvaluator)
 __flatbuffers_build_union_table_value_field(flatbuffers_, dd_wls_EvaluatorNode_eval, dd_wls_EvaluatorType, UNumEvaluator, dd_wls_UNumEvaluator)
+__flatbuffers_build_string_field(3, flatbuffers_, dd_wls_EvaluatorNode_rule_id, dd_wls_EvaluatorNode)
 
 static inline dd_wls_EvaluatorNode_ref_t dd_wls_EvaluatorNode_create(flatbuffers_builder_t *B __dd_wls_EvaluatorNode_formal_args)
 {
     if (dd_wls_EvaluatorNode_start(B)
         || dd_wls_EvaluatorNode_description_add(B, v0)
         || dd_wls_EvaluatorNode_eval_add_value(B, v2)
+        || dd_wls_EvaluatorNode_rule_id_add(B, v3)
         || dd_wls_EvaluatorNode_eval_add_type(B, v2.type)) {
         return 0;
     }
@@ -147,7 +152,8 @@ static dd_wls_EvaluatorNode_ref_t dd_wls_EvaluatorNode_clone(flatbuffers_builder
     __flatbuffers_memoize_begin(B, t);
     if (dd_wls_EvaluatorNode_start(B)
         || dd_wls_EvaluatorNode_description_pick(B, t)
-        || dd_wls_EvaluatorNode_eval_pick(B, t)) {
+        || dd_wls_EvaluatorNode_eval_pick(B, t)
+        || dd_wls_EvaluatorNode_rule_id_pick(B, t)) {
         return 0;
     }
     __flatbuffers_memoize_end(B, t, dd_wls_EvaluatorNode_end(B));

c/src/schema/nodes_reader.h

@@ -131,9 +131,14 @@ __flatbuffers_table_as_root(dd_wls_CompositeNode)
 
 __flatbuffers_define_string_field(0, dd_wls_CompositeNode, description, 0)
 __flatbuffers_define_scalar_field(1, dd_wls_CompositeNode, op, dd_wls_BoolOperation, dd_wls_BoolOperation_enum_t, INT8_C(0))
-/**  At some point we will switch back to; children: [NodeType]; 
+/**  At some point we will switch back to; children: [NodeType];
  *  (union vectors are not supported in GO so we are wrapping the table in a table) */
 __flatbuffers_define_vector_field(2, dd_wls_CompositeNode, children, dd_wls_NodeTypeWrapper_vec_t, 0)
+/**  Stable identifier for the rule this node is the root of. Set only on
+ *  nodes that sit directly under a policy's top-level OR (one per rule);
+ *  empty/unset on all other nodes. Read by the engine to surface "which
+ *  rule fired" to action callbacks via plcs_eval_ctx_get_matched_rule_id(). */
+__flatbuffers_define_string_field(3, dd_wls_CompositeNode, rule_id, 0)
 
 /**  Represents a leaf node in the policy tree.
  *  It contains a description and an evaluator. */
@@ -149,6 +154,10 @@ __flatbuffers_table_as_root(dd_wls_EvaluatorNode)
 __flatbuffers_define_string_field(0, dd_wls_EvaluatorNode, description, 0)
 /**  The evaluator is a union of different evaluator types (String, Numeric, etc.). */
 __flatbuffers_define_union_field(flatbuffers_, 2, dd_wls_EvaluatorNode, eval, dd_wls_EvaluatorType, 0)
+/**  Stable identifier for the rule this node is the root of. Same semantics
+ *  as CompositeNode.rule_id: set only when this evaluator is itself the
+ *  root of a rule (single-condition rule), empty otherwise. */
+__flatbuffers_define_string_field(3, dd_wls_EvaluatorNode, rule_id, 0)
 
 
 #include "flatcc/flatcc_epilogue.h"

c/src/schema/nodes_verifier.h

@@ -81,6 +81,7 @@ static int dd_wls_CompositeNode_verify_table(flatcc_table_verifier_descriptor_t
     if ((ret = flatcc_verify_string_field(td, 0, 0) /* description */)) return ret;
     if ((ret = flatcc_verify_field(td, 1, 1, 1) /* op */)) return ret;
     if ((ret = flatcc_verify_table_vector_field(td, 2, 0, &dd_wls_NodeTypeWrapper_verify_table) /* children */)) return ret;
+    if ((ret = flatcc_verify_string_field(td, 3, 0) /* rule_id */)) return ret;
     return flatcc_verify_ok;
 }
 
@@ -129,6 +130,7 @@ static int dd_wls_EvaluatorNode_verify_table(flatcc_table_verifier_descriptor_t
     int ret;
     if ((ret = flatcc_verify_string_field(td, 0, 0) /* description */)) return ret;
     if ((ret = flatcc_verify_union_field(td, 2, 0, &dd_wls_EvaluatorType_union_verifier) /* eval */)) return ret;
+    if ((ret = flatcc_verify_string_field(td, 3, 0) /* rule_id */)) return ret;
     return flatcc_verify_ok;
 }
 

c/src/test/test_evaluator.c

@@ -614,7 +614,9 @@ UTEST(evaluator, test_node_evaluator_basic_functionality) {
       &b, dd_wls_StringEvaluators_RUNTIME_ENTRY_POINT_JAR, dd_wls_CmpTypeSTR_CMP_EXACT,
       flatbuffers_string_create_str(&b, "test.jar")
   );
-  dd_wls_EvaluatorNode_create_as_root(&b, str, dd_wls_EvaluatorType_as_StrEvaluator(str));
+  dd_wls_EvaluatorNode_create_as_root(
+      &b, str, dd_wls_EvaluatorType_as_StrEvaluator(str), flatbuffers_string_create_str(&b, "")
+  );
   void *buf = flatcc_builder_finalize_buffer(&b, &sz);
   dd_wls_EvaluatorNode_table_t eval = dd_wls_EvaluatorNode_as_root(buf);
 
@@ -634,7 +636,9 @@ UTEST(evaluator, test_node_evaluator_basic_functionality) {
   dd_wls_NumEvaluator_ref_t num =
       dd_wls_NumEvaluator_create(&b, dd_wls_NumericEvaluators_JAVA_HEAP, dd_wls_CmpTypeNUM_CMP_EQ, 100);
 
-  dd_wls_EvaluatorNode_create_as_root(&b, num, dd_wls_EvaluatorType_as_NumEvaluator(num));
+  dd_wls_EvaluatorNode_create_as_root(
+      &b, num, dd_wls_EvaluatorType_as_NumEvaluator(num), flatbuffers_string_create_str(&b, "")
+  );
 
   buf = flatcc_builder_finalize_buffer(&b, &sz);
   eval = dd_wls_EvaluatorNode_as_root(buf);
@@ -653,7 +657,9 @@ UTEST(evaluator, test_node_evaluator_basic_functionality) {
   dd_wls_UNumEvaluator_ref_t unum =
       dd_wls_UNumEvaluator_create(&b, dd_wls_NumericEvaluators_RUNTIME_VERSION_MINOR, dd_wls_CmpTypeNUM_CMP_EQ, 4);
 
-  dd_wls_EvaluatorNode_create_as_root(&b, unum, dd_wls_EvaluatorType_as_UNumEvaluator(unum));
+  dd_wls_EvaluatorNode_create_as_root(
+      &b, unum, dd_wls_EvaluatorType_as_UNumEvaluator(unum), flatbuffers_string_create_str(&b, "")
+  );
 
   buf = flatcc_builder_finalize_buffer(&b, &sz);
   eval = dd_wls_EvaluatorNode_as_root(buf);
@@ -940,6 +946,29 @@ UTEST(evaluator, test_boolean_operations_distributivity) {
   ASSERT_EQ(left, right);
 }
 
+UTEST(evaluator, matched_rule_id_starts_null_and_round_trips) {
+  /* Newly-initialized contexts must have no matched rule. */
+  int rc = plcs_eval_ctx_init();
+  ASSERT_TRUE(rc == PLCS_ESUCCESS || rc == PLCS_EINITIZLIED);
+  plcs_eval_ctx_reset();
+  ASSERT_TRUE(plcs_eval_ctx_get_matched_rule_id() == NULL);
+
+  /* Setter stores by pointer (no copy). */
+  static const char rule[] = "java8_version";
+  plcs_eval_ctx_set_matched_rule_id(rule);
+  ASSERT_STREQ(rule, plcs_eval_ctx_get_matched_rule_id());
+
+  /* Setting NULL clears it (so callers can detect "no rule matched"). */
+  plcs_eval_ctx_set_matched_rule_id(NULL);
+  ASSERT_TRUE(plcs_eval_ctx_get_matched_rule_id() == NULL);
+
+  /* plcs_eval_ctx_reset must also clear it so a fresh evaluation cycle
+     never inherits a stale id from a previous run. */
+  plcs_eval_ctx_set_matched_rule_id(rule);
+  plcs_eval_ctx_reset();
+  ASSERT_TRUE(plcs_eval_ctx_get_matched_rule_id() == NULL);
+}
+
 UTEST(evaluator, test_extern_declarations_working) {
   /* Simple test to verify that extern declarations are working */
   /* This test calls the functions to ensure they can be linked */

fbs-schema/nodes.fbs

@@ -29,9 +29,10 @@ table NodeTypeWrapper {
 table CompositeNode {
   description: string;
   op: BoolOperation = BOOL_UNKNOWN;
-  /// At some point we will switch back to; children: [NodeType]; 
+  /// At some point we will switch back to; children: [NodeType];
   /// (union vectors are not supported in GO so we are wrapping the table in a table)
   children: [NodeTypeWrapper];
+  rule_id: string;
 }
 
 /// Represents a leaf node in the policy tree.
@@ -41,4 +42,5 @@ table EvaluatorNode {
  description: string;
   /// The evaluator is a union of different evaluator types (String, Numeric, etc.).
  eval: EvaluatorType;
+  rule_id: string;
 }

go/cmd/dd-requirements-converter/converter/arguments.go

@@ -66,7 +66,7 @@ func wildcardMatchToEvaluators(builder *flatbuffers.Builder, pattern string, pos
 	}
 
 	strEvaluator := schema.StrEvaluatorCreate(builder, ev, pattern, cmp)
-	node := schema.EvaluatorNodeCreate(builder, wls.EvaluatorTypeStrEvaluator, "Argument matching: "+pattern, strEvaluator)
+	node := schema.EvaluatorNodeCreate(builder, wls.EvaluatorTypeStrEvaluator, "Argument matching: "+pattern, strEvaluator, "")
 	return schema.NodeTypeWrapperCreate(builder, node, wls.NodeTypeEvaluatorNode), nil
 }
 
@@ -117,6 +117,6 @@ func (a ArgumentList) ConvertToWLS(builder *flatbuffers.Builder) (flatbuffers.UO
 	// EvaluatorNode: arg matches "-version" at position 1
 	// EvaluatorNode: arg matches "1.*" at position 2
 	// )
-	andNode := schema.CompositeNodeCreate(builder, wls.BoolOperationBOOL_AND, "Match argument pattern: "+strings.Join(a.Arguments, " "), nodes)
+	andNode := schema.CompositeNodeCreate(builder, wls.BoolOperationBOOL_AND, "Match argument pattern: "+strings.Join(a.Arguments, " "), nodes, "")
 	return schema.NodeTypeWrapperCreate(builder, andNode, wls.NodeTypeCompositeNode), nil
 }

go/cmd/dd-requirements-converter/converter/commands.go

@@ -24,6 +24,6 @@ func (c CmdPattern) ConvertToWLS(builder *flatbuffers.Builder) (flatbuffers.UOff
 		matcher = wls.CmpTypeSTRCMP_EXACT
 	}
 	strEvaluator := schema.StrEvaluatorCreate(builder, wls.StringEvaluatorsPROCESS_EXE_FULL_PATH, pattern, matcher)
-	node := schema.EvaluatorNodeCreate(builder, wls.EvaluatorTypeStrEvaluator, "Path matching: "+pattern, strEvaluator)
+	node := schema.EvaluatorNodeCreate(builder, wls.EvaluatorTypeStrEvaluator, "Path matching: "+pattern, strEvaluator, "")
 	return schema.NodeTypeWrapperCreate(builder, node, wls.NodeTypeEvaluatorNode), nil
 }