feat(core): adaptateur workflow->signature de trajectoire (BFS edges, cibles stables)

Extrait d'un workflow core (dict) la sequence ordonnee (action_type, target stable)
via traversee BFS depuis entry_nodes (comme le bridge d'import), en n'utilisant que
des champs stables (by_role/by_text/window) et en ignorant coords/IDs de noeuds.
Branche la primitive trajectory_signature sur de vrais workflows.

Test TDD: tests/unit/test_workflow_trajectory_signature.py (3 tests, RED->GREEN).

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

core/execution/trajectory_signature.py

@@ -32,3 +32,77 @@ def trajectory_signature(steps: Iterable[Mapping[str, Any]]) -> str:
     """
     canonical = _STEP_SEP.join(_normalize_step(step) for step in steps)
     return hashlib.sha256(canonical.encode("utf-8")).hexdigest()
+
+
+# ---------------------------------------------------------------------------
+# Adaptateur : workflow core (dict) → signature de trajectoire
+# ---------------------------------------------------------------------------
+
+def _stable_target(target: Any) -> str:
+    """Descripteur de cible **stable** entre sessions (by_role/by_text, fallback window)."""
+    if not isinstance(target, Mapping):
+        return ""
+    by_role = str(target.get("by_role") or "").strip()
+    by_text = str(target.get("by_text") or "").strip()
+    base = f"{by_role}:{by_text}".strip(":")
+    if base:
+        return base
+    hints = target.get("context_hints")
+    if isinstance(hints, Mapping):
+        return str(hints.get("window_title") or hints.get("vlm_description") or "").strip()
+    return ""
+
+
+def _ordered_edges(workflow: Mapping[str, Any]) -> list:
+    """Edges dans l'ordre du parcours (BFS depuis entry_nodes), comme le bridge d'import."""
+    edges = list(workflow.get("edges") or [])
+    if not edges:
+        return []
+    by_from: dict = {}
+    for edge in edges:
+        by_from.setdefault((edge or {}).get("from_node"), []).append(edge)
+    entry = list(workflow.get("entry_nodes") or [])
+    nodes = workflow.get("nodes") or []
+    if not entry and nodes:
+        entry = [(nodes[0] or {}).get("node_id")]
+    if not entry:
+        return edges  # pas de point d'entrée : ordre brut de la liste
+    ordered: list = []
+    seen_edges: set = set()
+    visited: set = set()
+    queue = list(entry)
+    while queue:
+        node = queue.pop(0)
+        if node in visited:
+            continue
+        visited.add(node)
+        for edge in by_from.get(node, []):
+            key = id(edge)
+            if key in seen_edges:
+                continue
+            seen_edges.add(key)
+            ordered.append(edge)
+            to_node = (edge or {}).get("to_node")
+            if to_node and to_node not in visited:
+                queue.append(to_node)
+    for edge in edges:  # edges non atteints : ajout déterministe en fin
+        if id(edge) not in seen_edges:
+            ordered.append(edge)
+    return ordered
+
+
+def workflow_step_descriptors(workflow: Mapping[str, Any]) -> list:
+    """Séquence ordonnée de descripteurs `(action_type, target stable)` d'un workflow core."""
+    descriptors: list = []
+    for edge in _ordered_edges(workflow):
+        action = (edge or {}).get("action") or {}
+        descriptors.append({
+            "action_type": action.get("type", "unknown"),
+            "target": _stable_target(action.get("target")),
+        })
+    return descriptors
+
+
+def workflow_trajectory_signature(workflow: Mapping[str, Any]) -> str:
+    """Signature de trajectoire d'un workflow core (dict). Cf. `trajectory_signature`."""
+    return trajectory_signature(workflow_step_descriptors(workflow))