feat: add Mermaid acyclic parity profile

Split the layered acyclic policy so the Mermaid profile uses Dagre's default DFS feedback-arc behavior while native Flux layouts keep semantic compound feedback selection.

Wire the policy through both layered config propagation paths and add parity coverage for the compound backward-edge fixture, including MMDS replay evidence.

This preserves the acyclic/reversal contract targeted by Plan 0157. Full Mermaid compound-positioning parity remains a follow-up because it is an ordering/positioning gap, not a feedback-arc selection issue.

Author: kevinswiber

src/engines/graph/algorithms/layered/float_layout.rs

@@ -99,6 +99,7 @@ pub(crate) fn build_float_layout_with_flags(
     let direction = diagram.direction;
     let mut layered_config = layered_config_for_layout(diagram, config);
     if let Some(flags) = engine_flags {
+        layered_config.acyclic_policy = flags.acyclic_policy;
         layered_config.greedy_switch = flags.greedy_switch;
         layered_config.model_order_tiebreak = flags.model_order_tiebreak;
         layered_config.variable_rank_spacing = flags.variable_rank_spacing;

src/engines/graph/algorithms/layered/kernel/acyclic.rs

@@ -7,6 +7,7 @@
 use std::collections::BTreeSet;
 
 use super::graph::LayoutGraph;
+use super::types::AcyclicPolicy;
 
 #[derive(Clone, Copy)]
 struct CompoundEdge {
@@ -23,7 +24,12 @@ struct CompoundEdge {
 /// Uses DFS to find back-edges (edges pointing to ancestors in the DFS tree).
 /// This preserves the natural forward flow of the graph better than
 /// greedy_feedback_arc_set which may reverse arbitrary edges.
+#[cfg(test)]
 pub fn run(graph: &mut LayoutGraph) {
+    run_with_policy(graph, AcyclicPolicy::default());
+}
+
+pub(super) fn run_with_policy(graph: &mut LayoutGraph, policy: AcyclicPolicy) {
     let n = graph.node_ids.len();
     if n == 0 {
         return;
@@ -51,7 +57,8 @@ pub fn run(graph: &mut LayoutGraph) {
     // missed. An edge from compound X to compound Y participates in a
     // compound-level cycle if there is already a path from Y back to X through
     // other compounds. See issue #155.
-    if !graph.compound_nodes.is_empty() {
+    if matches!(policy, AcyclicPolicy::SemanticCompoundFeedback) && !graph.compound_nodes.is_empty()
+    {
         detect_compound_back_edges(graph, &mut back_edges);
     }
 
@@ -340,6 +347,30 @@ mod tests {
         }
     }
 
+    #[test]
+    fn test_acyclic_policy_dfs_only_skips_compound_feedback_edge() {
+        let mut lg = compound_cycle_graph_with_order(&["sg_c", "sg_b", "sg_a"]);
+        run_with_policy(&mut lg, AcyclicPolicy::DfsOnly);
+
+        assert!(
+            !lg.reversed_edges.contains(&2),
+            "DfsOnly should skip semantic compound feedback detection; got {:?}",
+            lg.reversed_edges
+        );
+    }
+
+    #[test]
+    fn test_acyclic_policy_semantic_compound_feedback_reverses_c_to_a() {
+        let mut lg = compound_cycle_graph_with_order(&["sg_c", "sg_b", "sg_a"]);
+        run_with_policy(&mut lg, AcyclicPolicy::SemanticCompoundFeedback);
+
+        assert!(
+            lg.reversed_edges.contains(&2),
+            "SemanticCompoundFeedback should preserve compound feedback detection; got {:?}",
+            lg.reversed_edges
+        );
+    }
+
     #[test]
     fn test_acyclic_compound_level_back_edges_converge_across_disjoint_cycles() {
         let mut graph: DiGraph<()> = DiGraph::new();

src/engines/graph/algorithms/layered/kernel/dagre_parity_tests.rs

@@ -8,6 +8,7 @@ use std::path::Path;
 
 use serde::Deserialize;
 
+use super::types::AcyclicPolicy;
 use super::{DiGraph, LayoutConfig, NodeId, layout};
 
 #[test]
@@ -115,6 +116,14 @@ fn build_digraph_from_input(input: &InputGraph) -> DiGraph<(f64, f64)> {
     graph
 }
 
+fn dagre_node<'a>(layout: &'a DagreLayout, id: &str) -> &'a DagreNode {
+    layout
+        .nodes
+        .iter()
+        .find(|node| node.id == id)
+        .unwrap_or_else(|| panic!("missing dagre node {id}"))
+}
+
 /// Border node info parsed from debug dump files.
 #[derive(Debug, Clone)]
 struct BorderNodeInfo {
@@ -229,6 +238,80 @@ fn assert_points_close(actual: &[(f64, f64)], expected: &[[f64; 2]], tolerance:
 // Parity Tests
 // =============================================================================
 
+mod compound_backward_disconnected {
+    use super::*;
+
+    const INPUT_PATH: &str =
+        "tests/parity-fixtures/compound_backward_disconnected/mmdflux-dagre-input.json";
+    const EXPECTED_PATH: &str =
+        "tests/parity-fixtures/compound_backward_disconnected/dagre-layout.json";
+
+    #[test]
+    fn compound_backward_disconnected_input_records_mermaid_order() {
+        let input: InputGraph = load_json(INPUT_PATH);
+        let ids: Vec<&str> = input.nodes.iter().map(|node| node.id.as_str()).collect();
+
+        assert_eq!(
+            ids,
+            vec!["C", "B", "A", "a1", "a2", "b1", "b2", "c1", "c2"],
+            "raw Dagre fixture should preserve Mermaid FlowDB node order"
+        );
+    }
+
+    #[test]
+    fn compound_backward_disconnected_raw_dagre_fixture_is_tall_top_right() {
+        let expected: DagreLayout = load_json(EXPECTED_PATH);
+        let top = dagre_node(&expected, "A");
+        let middle = dagre_node(&expected, "B");
+        let bottom = dagre_node(&expected, "C");
+        let sibling_max = middle.height.max(bottom.height);
+
+        assert!(top.is_compound && middle.is_compound && bottom.is_compound);
+        assert!(
+            top.x > middle.x && top.x > bottom.x,
+            "raw Dagre should place A/Top to the right; A={top:?} B={middle:?} C={bottom:?}"
+        );
+        assert!(
+            top.height > sibling_max * 1.8,
+            "raw Dagre should stretch A/Top vertically; A={top:?} B={middle:?} C={bottom:?}"
+        );
+        assert!(
+            middle.y + middle.height <= bottom.y,
+            "raw Dagre should stack B/Middle above C/Bottom; B={middle:?} C={bottom:?}"
+        );
+
+        let edge2 = expected
+            .edges
+            .iter()
+            .find(|edge| edge.index == 2)
+            .expect("raw Dagre fixture should include edge 2");
+        assert_eq!(edge2._from, "c2");
+        assert_eq!(edge2._to, "a2");
+    }
+
+    #[test]
+    fn compound_backward_disconnected_dfs_only_keeps_edge_2_forward() {
+        let input: InputGraph = load_json(INPUT_PATH);
+        let graph = build_digraph_from_input(&input);
+        let config = LayoutConfig {
+            node_sep: 50.0,
+            edge_sep: 20.0,
+            rank_sep: 75.0,
+            margin: 8.0,
+            acyclic_policy: AcyclicPolicy::DfsOnly,
+            ..Default::default()
+        };
+
+        let result = layout(&graph, &config, |_, dims| *dims);
+
+        assert!(
+            !result.reversed_edges.contains(&2),
+            "DFS-only strict parity should not reverse c2 -> a2; got {:?}",
+            result.reversed_edges
+        );
+    }
+}
+
 mod subgraph_bounds {
     use super::*;
 

src/engines/graph/algorithms/layered/kernel/pipeline.rs

@@ -64,7 +64,7 @@ where
 
     // Phase 1: Make graph acyclic
     if config.acyclic {
-        acyclic::run(&mut lg);
+        acyclic::run_with_policy(&mut lg, config.acyclic_policy);
     }
 
     // Phase 1.5: Create space for edge label dummies.

src/engines/graph/algorithms/layered/kernel/types.rs

@@ -44,6 +44,17 @@ pub enum Direction {
     RightLeft, // RL
 }
 
+/// Strategy for selecting feedback edges during acyclic preprocessing.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
+pub enum AcyclicPolicy {
+    /// Mermaid dagre-wrapper default: Dagre DFS feedback-arc detection,
+    /// without the greedy `acyclicer` mode.
+    DfsOnly,
+    /// Preserve semantic compound feedback selection for native Flux layouts.
+    #[default]
+    SemanticCompoundFeedback,
+}
+
 impl Direction {
     /// Is this a vertical (TB/BT) layout?
     pub fn is_vertical(self) -> bool {
@@ -328,6 +339,9 @@ pub struct LayoutConfig {
     /// Whether to apply layout optimization for acyclic graphs.
     pub acyclic: bool,
 
+    /// Strategy to use when selecting feedback edges.
+    pub acyclic_policy: AcyclicPolicy,
+
     /// Ranking algorithm to use.
     pub ranker: Ranker,
 
@@ -406,6 +420,7 @@ impl Default for LayoutConfig {
             rank_sep_overrides: HashMap::new(),
             margin: 8.0,
             acyclic: true,
+            acyclic_policy: AcyclicPolicy::default(),
             ranker: Ranker::default(),
             greedy_switch: false,
             model_order_tiebreak: false,

src/engines/graph/algorithms/layered/measurement.rs

@@ -130,6 +130,7 @@ pub fn run_layered_layout(
     let override_subgraphs = override_subgraph_projections(diagram, layered_cfg);
     let grid_config = layout_config_from_layered(layered_cfg, diagram);
     let mut lc = layered_config_for_layout(diagram, &grid_config);
+    lc.acyclic_policy = layered_cfg.acyclic_policy;
     lc.greedy_switch = layered_cfg.greedy_switch;
     lc.model_order_tiebreak = layered_cfg.model_order_tiebreak;
     lc.variable_rank_spacing = layered_cfg.variable_rank_spacing;

src/engines/graph/algorithms/layered/mod.rs

@@ -18,7 +18,8 @@ pub use kernel::graph::DiGraph;
 #[cfg(test)]
 pub(crate) use kernel::pipeline::layout;
 pub use kernel::types::{
-    Direction, LabelDummyPlacement, LabelDummyRouting, LabelSideStrategy, LayoutConfig, Ranker,
+    AcyclicPolicy, Direction, LabelDummyPlacement, LabelDummyRouting, LabelSideStrategy,
+    LayoutConfig, Ranker,
 };
 #[cfg(test)]
 pub use kernel::types::{EdgeLayout, LayoutResult, NodeId, Point, Rect, SelfEdgeLayout};

src/engines/graph/flux.rs

@@ -5,7 +5,7 @@
 //! routing behavior.
 
 use crate::engines::graph::algorithms::layered::{
-    LabelDummyPlacement, LabelDummyRouting, LabelSideStrategy, LayoutConfig,
+    AcyclicPolicy, LabelDummyPlacement, LabelDummyRouting, LabelSideStrategy, LayoutConfig,
     build_float_layout_with_flags, layout_config_from_layered, run_layered_layout,
 };
 use crate::engines::graph::contracts::MeasurementMode;
@@ -32,6 +32,7 @@ pub(crate) fn flux_layout_profile(
     _edge_routing: EdgeRouting,
 ) -> LayoutConfig {
     LayoutConfig {
+        acyclic_policy: AcyclicPolicy::SemanticCompoundFeedback,
         greedy_switch: true,
         model_order_tiebreak: input_cfg.model_order_tiebreak,
         variable_rank_spacing: true,

src/engines/graph/layout.rs

@@ -252,6 +252,7 @@ impl From<LayoutConfig> for crate::engines::graph::algorithms::layered::LayoutCo
             rank_sep_overrides: value.rank_sep_overrides,
             margin: value.margin,
             acyclic: value.acyclic,
+            acyclic_policy: Default::default(),
             ranker: value.ranker.into(),
             greedy_switch: value.greedy_switch,
             model_order_tiebreak: value.model_order_tiebreak,

src/engines/graph/mermaid.rs

@@ -7,7 +7,7 @@
 use std::collections::HashMap;
 
 use crate::engines::graph::algorithms::layered::{
-    LabelDummyPlacement, LabelDummyRouting, LabelSideStrategy, LayoutConfig,
+    AcyclicPolicy, LabelDummyPlacement, LabelDummyRouting, LabelSideStrategy, LayoutConfig,
     build_float_layout_with_flags, layout_config_from_layered,
 };
 use crate::engines::graph::contracts::MeasurementMode;
@@ -102,6 +102,30 @@ fn apply_mermaid_subgraph_direction_policy(diagram: &Graph) -> Option<Graph> {
 /// Mermaid-layered engine: shared layered layout with Mermaid-compatible policy.
 pub struct MermaidLayeredEngine;
 
+fn mermaid_layout_flags() -> LayoutConfig {
+    LayoutConfig {
+        acyclic_policy: AcyclicPolicy::DfsOnly,
+        always_compound_ordering: true,
+        label_side_selection: true,
+        label_side_strategy: LabelSideStrategy::DirectionDown,
+        // Plan 0147 Task 2.3 / 2.6: mermaid profile pins placement +
+        // routing explicitly at the dagre-parity defaults so later
+        // `..Default::default()` changes never drift the profile off parity.
+        label_dummy_placement: LabelDummyPlacement::Midpoint,
+        label_dummy_routing: LabelDummyRouting::Center,
+        // Plan 0147 Task 1.7: mermaid profile enables wrap at 200 px;
+        // dagre parity is preserved because `LabelDummyRouting` stays on
+        // `Center` here.
+        edge_label_max_width: Some(200.0),
+        ..Default::default()
+    }
+}
+
+#[cfg(test)]
+pub(crate) fn mermaid_layout_flags_for_test() -> LayoutConfig {
+    mermaid_layout_flags()
+}
+
 impl Default for MermaidLayeredEngine {
     fn default() -> Self {
         Self::new()
@@ -153,22 +177,7 @@ impl GraphEngine for MermaidLayeredEngine {
         let EngineConfig::Layered(ref layered_cfg) = *config;
         let mut layout_config = layout_config_from_layered(layered_cfg, diagram);
         layout_config.cluster_rank_sep = 0.0;
-        let mermaid_flags = LayoutConfig {
-            always_compound_ordering: true,
-            label_side_selection: true,
-            label_side_strategy: LabelSideStrategy::DirectionDown,
-            // Plan 0147 Task 2.3 / 2.6: mermaid profile pins placement +
-            // routing explicitly at the dagre-parity defaults so later
-            // `..Default::default()` changes never drift the profile off
-            // parity.
-            label_dummy_placement: LabelDummyPlacement::Midpoint,
-            label_dummy_routing: LabelDummyRouting::Center,
-            // Plan 0147 Task 1.7: mermaid profile enables wrap at 200 px;
-            // dagre parity is preserved because `LabelDummyRouting` stays on
-            // `Center` here.
-            edge_label_max_width: Some(200.0),
-            ..Default::default()
-        };
+        let mermaid_flags = mermaid_layout_flags();
         let geometry = build_float_layout_with_flags(
             diagram,
             &layout_config,