feat: use Rust engine trace instead of Python-side tracking

Replace the handcrafted Python input_sources / _build_input_path trace
with the Rust engine's built-in execution trace. The engine already
records every step (variable resolution, operations, requirement checks,
definition lookups) via its TraceBuilder — we just weren't using it.

Changes:
- Add evaluate_with_trace() PyO3 binding to regelrecht engine that
  calls evaluate_law_with_trace() and returns the trace as JSON string
- RegelrechtServices.evaluate() now calls evaluate_with_trace() and
  logs the full trace tree via IndentLogger for the demo UI
- Remove _build_input_path() and input_sources tracking (was duplicate
  of what the engine already does)
- Web adapter converts the Rust trace tree to PathNode objects for
  extract_value_tree / render_path templates
- Cross-law pre-resolution traces now show recursive sub-evaluations
  with full detail (operations, comparisons, definitions)

The trace now shows the same depth as the old Python engine: every
GREATER_OR_EQUAL, SUBTRACT_DATE, IF/THEN/ELSE, AND/OR, definition
lookup, and data source resolution.

Also: fix case-insensitive BSN lookup in cross-law parameter references
(web UI passes BSN uppercase, YAML uses $bsn lowercase).

340/340 BDD scenarios pass (1m55s, down from 2m34s).

Author: anneschuth

machine/regelrecht_services.py

@@ -780,9 +780,6 @@ def evaluate(
                     if isinstance(sv, dict):
                         params.update(_to_native(sv))
 
-            # Track where each input value came from for the path tree
-            input_sources: dict[str, str] = {}  # name → resolve_type
-
             # Resolve claims (citizen-submitted data) and merge into params.
             bsn = params.get("bsn")
             if bsn:
@@ -791,7 +788,6 @@ def evaluate(
                     for key, claim in claims.items():
                         if key not in params:
                             params[key] = _to_native(claim.new_value)
-                            input_sources[key] = "CLAIM"
                             logger.debug("Claim: %s = %s", key, params[key])
 
             import yaml as yaml_mod
@@ -817,32 +813,13 @@ def evaluate(
                     missing_required=True,
                 )
 
-            # Collect input specs from YAML for path tree building
-            input_specs: list[dict[str, Any]] = []
-            for art in data.get("articles", []):
-                for inp in art.get("machine_readable", {}).get("execution", {}).get("input", []):
-                    input_specs.append(inp)
-
             # Pre-resolve data source inputs
             with logger.indent_block("Resolving data sources"):
-                params_before = set(params.keys())
                 self._pre_resolve_data_sources(law_id, params, data)
-                for k in set(params.keys()) - params_before:
-                    input_sources[k] = "SOURCE"
-                    logger.debug("Source: %s = %s", k, params[k])
 
             # Pre-resolve cross-law inputs
             with logger.indent_block("Resolving cross-law inputs"):
-                params_before = set(params.keys())
                 self._pre_resolve_cross_law_inputs(data, params, reference_date)
-                for k in set(params.keys()) - params_before:
-                    input_sources[k] = "SERVICE"
-                    logger.debug("Cross-law: %s = %s", k, params[k])
-
-            # Mark remaining params as NONE (directly supplied)
-            for k in params:
-                if k not in input_sources:
-                    input_sources[k] = "NONE"
 
             # Check for missing required source: {} inputs.
             missing = _find_missing_required_inputs(data, params)
@@ -853,25 +830,26 @@ def evaluate(
                     requirements_met=False,
                     input=params,
                     rulespec_uuid=rule.uuid,
-                    path=_build_input_path(input_specs, params, input_sources),
+                    path=None,
                     missing_required=True,
                 )
 
             # Fill defaults for remaining unresolved source: {} inputs.
             _fill_input_defaults(data, params)
 
-            # Evaluate
+            # Evaluate with trace — the Rust engine records every step
+            trace_json = None
             try:
-                with logger.indent_block("Engine evaluate"):
-                    result = self._engine.evaluate(law_id, output_names, params, reference_date)
+                result = self._engine.evaluate_with_trace(law_id, output_names, params, reference_date)
+                trace_json = result.get("trace")
             except Exception as e:
                 logger.warning("Engine error for %s: %s", law, e)
                 return RuleResult(
                     output={},
                     requirements_met=False,
                     input=params,
                     rulespec_uuid=rule.uuid,
-                    path=_build_input_path(input_specs, params, input_sources),
+                    path=None,
                     missing_required=True,
                 )
 
@@ -889,64 +867,48 @@ def evaluate(
             if not req_met and voldoet is not _MISSING:
                 outputs = {}
 
+            # Log the Rust engine trace tree as DEBUG output
+            if trace_json:
+                _log_trace(json.loads(trace_json))
+
             for name, val in outputs.items():
                 logger.debug("Output: %s = %s", name, val)
             logger.debug("Requirements met: %s", req_met)
 
-            # Use params as resolved input (engine doesn't track this)
-            resolved_input = {k: v for k, v in params.items() if k in input_sources}
-
             return RuleResult(
                 output=outputs,
                 requirements_met=req_met,
-                input=resolved_input,
+                input=params,
                 rulespec_uuid=rule.uuid,
-                path=_build_input_path(input_specs, params, input_sources),
+                path=json.loads(trace_json) if trace_json else None,
                 missing_required=False,
             )
 
 
-def _build_input_path(
-    input_specs: list[dict[str, Any]],
-    params: dict[str, Any],
-    input_sources: dict[str, str],
-) -> dict[str, Any]:
-    """Build a path info dict from YAML input specs and resolved params.
-
-    Returns a dict that the web adapter converts to PathNode objects.
-    Keys are input names, values have ``result``, ``required``,
-    ``resolve_type``, and ``details``.
-    """
-    path: dict[str, Any] = {}
-    for spec in input_specs:
-        name = spec.get("name")
-        if not name:
-            continue
-        source = spec.get("source", {})
-        required = spec.get("required", False)
-        value = params.get(name)
-        resolve_type = input_sources.get(name, "NONE")
-
-        # Cross-law inputs show as SERVICE with law details
-        regulation = source.get("regulation")
-        if regulation:
-            resolve_type = "SERVICE"
-
-        entry: dict[str, Any] = {
-            "result": value,
-            "required": required,
-            "resolve_type": resolve_type,
-            "details": {
-                "path": f"${name}",
-                "type": spec.get("type"),
-                "type_spec": spec.get("type_spec"),
-            },
-        }
-        if regulation:
-            entry["details"]["service"] = source.get("service")
-            entry["details"]["law"] = regulation
-        path[name] = entry
-    return path
+def _log_trace(node: dict, depth: int = 0) -> None:
+    """Recursively log a Rust engine trace tree via the IndentLogger."""
+    name = node.get("name", "?")
+    ntype = node.get("node_type", "?")
+    result = node.get("result")
+    rtype = node.get("resolve_type")
+    msg = node.get("message")
+
+    label = f"{ntype}: {name}"
+    if rtype:
+        label += f" [{rtype}]"
+    if result is not None:
+        label += f" = {result}"
+    if msg and msg != name:
+        label += f" ({msg})"
+
+    if depth == 0:
+        logger.debug(label)
+    else:
+        logger.debug(label)
+
+    for child in node.get("children", []):
+        with logger.indent_block(None):
+            _log_trace(child, depth + 1)
 
 
 def _evaluate_action_in_python(data: dict, params: dict, requested_output: str, reference_date: str = "") -> Any | None:

web/engines/regelrecht_engine/engine.py

@@ -82,49 +82,13 @@ def evaluate(
             approved=approved,
         )
 
-        # Build PathNode tree from the path info dict returned by RegelrechtServices
-        root = PathNode(type="root", name="evaluation", result=None)
-        path_info = result.path or {}
-        for input_name, info in path_info.items():
-            resolve_type = info.get("resolve_type", "NONE")
-            details = info.get("details", {})
-            regulation = details.get("law")
-
-            if regulation:
-                # Cross-law dependency: wrap in a service_evaluation node
-                svc_node = PathNode(
-                    type="service_evaluation",
-                    name=input_name,
-                    result=info.get("result"),
-                    required=info.get("required", False),
-                    details={
-                        "path": details.get("path", f"${input_name}"),
-                        "service": details.get("service"),
-                        "law": regulation,
-                    },
-                    children=[
-                        PathNode(
-                            type="resolve",
-                            name=input_name,
-                            result=info.get("result"),
-                            resolve_type="SERVICE",
-                            required=info.get("required", False),
-                            details=details,
-                        )
-                    ],
-                )
-                root.children.append(svc_node)
-            else:
-                root.children.append(
-                    PathNode(
-                        type="resolve",
-                        name=input_name,
-                        result=info.get("result"),
-                        resolve_type=resolve_type,
-                        required=info.get("required", False),
-                        details=details,
-                    )
-                )
+        # Convert the Rust engine trace tree to a web PathNode tree.
+        # The trace is a nested dict with node_type/name/result/resolve_type/children.
+        root = (
+            _rust_trace_to_pathnode(result.path)
+            if result.path
+            else PathNode(type="root", name="evaluation", result=None)
+        )
 
         return RuleResult(
             output=dict(result.output),
@@ -135,6 +99,44 @@ def evaluate(
             missing_required=result.missing_required,
         )
 
+
+def _rust_trace_to_pathnode(trace: dict) -> PathNode:
+    """Convert a Rust engine trace dict to a web PathNode tree.
+
+    The Rust trace has node_type (article/action/operation/resolve),
+    while the web PathNode uses type/resolve_type. This maps between them
+    so extract_value_tree and render_path templates work correctly.
+    """
+    node_type = trace.get("node_type", "root")
+    name = trace.get("name", "")
+    result_val = trace.get("result")
+    resolve_type = trace.get("resolve_type")
+    message = trace.get("message")
+
+    # Map Rust node types to web PathNode types
+    web_type = node_type
+    if node_type == "resolve":
+        web_type = "resolve"
+    elif node_type == "article":
+        web_type = "root"
+    elif node_type in ("action", "operation"):
+        web_type = "resolve"
+
+    children = [_rust_trace_to_pathnode(c) for c in trace.get("children", [])]
+
+    details: dict[str, Any] = {"path": f"${name}"}
+    if message:
+        details["message"] = message
+
+    return PathNode(
+        type=web_type,
+        name=name,
+        result=result_val,
+        resolve_type=resolve_type or "NONE",
+        details=details,
+        children=children,
+    )
+
     def get_rule_spec(self, law: str, reference_date: str, service: str) -> dict[str, Any]:
         return self.resolver.get_rule_spec(law, reference_date, service)