@diagrammo/dgmo 0.6.2 → 0.7.0

package/src/infra/renderer.ts

@@ -7,12 +7,10 @@ import * as d3Shape from 'd3-shape';
 import { FONT_FAMILY } from '../fonts';
 import type { PaletteColors } from '../palettes';
 import { mix } from '../palettes/color-utils';
-import type { ParsedInfra, InfraTagGroup } from './types';
+import type { InfraTagGroup } from './types';
 import { resolveColor } from '../colors';
-import type { ComputedInfraModel } from './types';
 import type { InfraLayoutResult, InfraLayoutNode, InfraLayoutEdge, InfraLayoutGroup } from './layout';
 import { inferRoles, collectDiagramRoles, collectFanoutSourceIds, FANOUT_ROLE } from './roles';
-import type { InfraRole } from './roles';
 import { parseInfra } from './parser';
 import { computeInfra } from './compute';
 import { layoutInfra } from './layout';
@@ -34,11 +32,9 @@ import {
 // Constants
 // ============================================================
 
-const DIAGRAM_PADDING = 20;
 const NODE_FONT_SIZE = 13;
 const META_FONT_SIZE = 10;
 const META_LINE_HEIGHT = 14;
-const RPS_FONT_SIZE = 11;
 const EDGE_LABEL_FONT_SIZE = 11;
 const GROUP_LABEL_FONT_SIZE = 14;
 const NODE_BORDER_RADIUS = 8;
@@ -58,8 +54,6 @@ const LEGEND_FIXED_GAP = 16; // gap between fixed legend and scaled diagram —
 const COLOR_HEALTHY = '#22c55e';
 const COLOR_WARNING = '#eab308';
 const COLOR_OVERLOADED = '#ef4444';
-const COLOR_NEUTRAL = '#94a3b8';
-
 /** SLO thresholds resolved for a single node (chart-level + per-node override). */
 interface NodeSlo {
   availThreshold: number | null; // fraction e.g. 0.999
@@ -106,11 +100,8 @@ interface ComputedRow {
 }
 
 // Animation constants
-const FLOW_DASH = '8 6';          // dash-array for animated edges
-const FLOW_DASH_LEN = 14;         // sum of dash + gap (for offset keyframe)
 const FLOW_SPEED_MIN = 2.5;       // seconds at max RPS
 const FLOW_SPEED_MAX = 6;         // seconds at min RPS
-const OVERLOAD_PULSE_SPEED = 0.8; // seconds for overload pulse cycle
 const PARTICLE_R = 5;             // particle circle radius
 const PARTICLE_COUNT_MIN = 1;     // min particles per edge
 const PARTICLE_COUNT_MAX = 4;     // max particles per edge (at max RPS)
@@ -742,11 +733,6 @@ function getDisplayProps(node: InfraLayoutNode, expanded: boolean, diagramOption
 }
 
 
-function formatRps(rps: number): string {
-  if (rps >= 1000) return `${(rps / 1000).toFixed(1)}k rps`;
-  return `${Math.round(rps)} rps`;
-}
-
 /** RPS value without "rps" suffix — for key-value rows where the key already says "RPS". */
 function formatRpsShort(rps: number): string {
   if (rps >= 1000) return `${(rps / 1000).toFixed(1)}k`;
@@ -1681,8 +1667,8 @@ function renderLegend(
     const isActive = activeGroup != null && group.name.toLowerCase() === activeGroup.toLowerCase();
 
     const groupBg = isDark
-      ? mix(palette.bg, palette.text, 85)
-      : mix(palette.bg, palette.text, 92);
+      ? mix(palette.surface, palette.bg, 50)
+      : mix(palette.surface, palette.bg, 30);
 
     const pillLabel = group.name;
     const pillWidth = pillLabel.length * LEGEND_PILL_FONT_W + LEGEND_PILL_PAD;
@@ -1812,12 +1798,42 @@ export function renderInfra(
 
   const shouldAnimate = animate !== false;
 
+  // In app mode with legend + title, render the title as a separate fixed-size SVG
+  // so the legend can be inserted between title and diagram.
+  const fixedTitleH = fixedLegend && title ? 40 : 0;
+  const diagramViewHeight = fixedLegend
+    ? layout.height + (title && !fixedTitleH ? titleOffset : 0) + legendOffset
+    : totalHeight;
+
+  if (fixedTitleH) {
+    const titleSvg = d3Selection.select(container)
+      .append('svg')
+      .attr('class', 'infra-title-fixed')
+      .attr('width', '100%')
+      .attr('height', fixedTitleH)
+      .attr('viewBox', `0 0 ${totalWidth} ${fixedTitleH}`)
+      .attr('preserveAspectRatio', 'xMidYMid meet')
+      .style('display', 'block');
+    titleSvg.append('text')
+      .attr('class', 'chart-title')
+      .attr('x', totalWidth / 2)
+      .attr('y', 28)
+      .attr('text-anchor', 'middle')
+      .attr('font-family', FONT_FAMILY)
+      .attr('font-size', 18)
+      .attr('font-weight', '700')
+      .attr('fill', palette.text)
+      .attr('data-line-number', titleLineNumber != null ? titleLineNumber : '')
+      .text(title!);
+  }
+
+  const fixedOverheadH = (fixedLegend ? LEGEND_HEIGHT + LEGEND_FIXED_GAP : 0) + fixedTitleH;
   const rootSvg = d3Selection.select(container)
     .append('svg')
     .attr('xmlns', 'http://www.w3.org/2000/svg')
     .attr('width', '100%')
-    .attr('height', fixedLegend ? `calc(100% - ${LEGEND_HEIGHT + LEGEND_FIXED_GAP}px)` : '100%')
-    .attr('viewBox', `0 0 ${totalWidth} ${totalHeight}`)
+    .attr('height', fixedOverheadH > 0 ? `calc(100% - ${fixedOverheadH}px)` : '100%')
+    .attr('viewBox', `0 0 ${totalWidth} ${diagramViewHeight}`)
     .attr('preserveAspectRatio', 'xMidYMid meet');
 
   // Inject animation keyframes + edge label hover styles
@@ -1864,11 +1880,13 @@ export function renderInfra(
     `);
   }
 
+  // Content group offset: skip title space (unless title was extracted to fixed SVG)
+  const contentTitleOffset = fixedTitleH ? 0 : titleOffset;
   const svg = rootSvg.append('g')
-    .attr('transform', `translate(0, ${titleOffset})`);
+    .attr('transform', `translate(0, ${contentTitleOffset + legendOffset})`);
 
-  // Title
-  if (title) {
+  // Title (inside rootSvg when not using fixed title)
+  if (title && !fixedTitleH) {
     rootSvg.append('text')
       .attr('class', 'chart-title')
       .attr('x', totalWidth / 2)
@@ -1901,22 +1919,26 @@ export function renderInfra(
   }
   renderEdgeLabels(svg, layout.edges, layout.nodes, layout.groups, palette, isDark, shouldAnimate, layout.direction);
 
-  // Legend at bottom
+  // Legend at top
   if (hasLegend) {
     if (fixedLegend) {
-      // Render legend in a separate SVG that stays at fixed pixel size
+      // Render legend in a separate SVG that stays at fixed pixel size, inserted between title and diagram
       const containerWidth = container.clientWidth || totalWidth;
       const legendSvg = d3Selection.select(container)
-        .append('svg')
+        .insert('svg', 'svg:last-of-type')
         .attr('class', 'infra-legend-fixed')
         .attr('width', '100%')
         .attr('height', LEGEND_HEIGHT + LEGEND_FIXED_GAP)
         .attr('viewBox', `0 0 ${containerWidth} ${LEGEND_HEIGHT + LEGEND_FIXED_GAP}`)
         .attr('preserveAspectRatio', 'xMidYMid meet')
-        .style('display', 'block');
+        .style('display', 'block')
+        .style('pointer-events', 'none');
       renderLegend(legendSvg, legendGroups, containerWidth, LEGEND_FIXED_GAP / 2, palette, isDark, activeGroup ?? null);
+      // Re-enable pointer events on interactive legend elements
+      legendSvg.selectAll('.infra-legend-group').style('pointer-events', 'auto');
     } else {
-      renderLegend(rootSvg, legendGroups, totalWidth, titleOffset + layout.height + 4, palette, isDark, activeGroup ?? null);
+      // Export mode: render legend at top (below title)
+      renderLegend(rootSvg, legendGroups, totalWidth, titleOffset, palette, isDark, activeGroup ?? null);
     }
   }
 }

package/src/initiative-status/filter.ts

@@ -0,0 +1,63 @@
+// ============================================================
+// Initiative Status — Tag-Based Filter
+//
+// Immutable graph transform: returns a new ParsedInitiativeStatus
+// with hidden-value nodes removed, their edges dropped,
+// and group.nodeLabels cleaned.
+// ============================================================
+
+import type { ParsedInitiativeStatus } from './types';
+
+/**
+ * Filter an initiative-status graph by hiding nodes whose tag metadata
+ * matches any hidden value. Returns a new (immutable copy) ParsedInitiativeStatus.
+ *
+ * @param parsed  Fully-resolved parsed result (defaults already injected)
+ * @param hiddenTagValues  Map<groupKey, Set<hiddenValues>> — all keys/values lowercase
+ * @returns Filtered copy; original is not mutated
+ */
+export function filterInitiativeStatusByTags(
+  parsed: ParsedInitiativeStatus,
+  hiddenTagValues: Map<string, Set<string>>
+): ParsedInitiativeStatus {
+  // Fast path: no filtering
+  if (hiddenTagValues.size === 0) return parsed;
+
+  // Build set of hidden node labels
+  const hiddenNodeLabels = new Set<string>();
+  for (const node of parsed.nodes) {
+    for (const [groupKey, hiddenValues] of hiddenTagValues) {
+      const nodeValue = node.metadata[groupKey];
+      if (nodeValue && hiddenValues.has(nodeValue.toLowerCase())) {
+        hiddenNodeLabels.add(node.label);
+        break;
+      }
+    }
+  }
+
+  // No nodes hidden — return input unchanged
+  if (hiddenNodeLabels.size === 0) return parsed;
+
+  // Filter nodes
+  const nodes = parsed.nodes.filter((n) => !hiddenNodeLabels.has(n.label));
+
+  // Filter edges: remove edges where source OR target is hidden
+  const edges = parsed.edges.filter(
+    (e) => !hiddenNodeLabels.has(e.source) && !hiddenNodeLabels.has(e.target)
+  );
+
+  // Clean group nodeLabels; remove empty groups
+  const groups = parsed.groups
+    .map((g) => ({
+      ...g,
+      nodeLabels: g.nodeLabels.filter((l) => !hiddenNodeLabels.has(l)),
+    }))
+    .filter((g) => g.nodeLabels.length > 0);
+
+  return {
+    ...parsed,
+    nodes,
+    edges,
+    groups,
+  };
+}

package/src/initiative-status/layout.ts

@@ -1,9 +1,9 @@
 // ============================================================
 // Initiative Status Diagram — Layout
 //
-// Uses dagre for rank assignment, node ordering, and edge
-// routing.  Edge waypoints are taken directly from dagre's
-// output without modification.
+// Uses dagre for rank assignment and crossing minimization.
+// Post-dagre grid quantization snaps Y positions to a fixed
+// grid for horizontal alignment across columns.
 // ============================================================
 
 import dagre from '@dagrejs/dagre';
@@ -19,6 +19,7 @@ export interface ISLayoutNode {
   y: number;
   width: number;
   height: number;
+  metadata: Record<string, string>;
 }
 
 export interface ISLayoutEdge {
@@ -74,7 +75,8 @@ const PHI = 1.618;
 const NODE_HEIGHT = 60;
 const NODE_WIDTH = Math.round(NODE_HEIGHT * PHI);
 const GROUP_PADDING = 20;
-const NODESEP = 80;
+const GROUP_LABEL_HEIGHT = 20; // approximate height of the group label text rendered above the box
+const NODESEP = 100;
 const RANKSEP = 160;
 const PARALLEL_SPACING = 16; // px between parallel edges sharing same source→target (~27% of NODE_HEIGHT)
 const PARALLEL_EDGE_MARGIN = 12; // total vertical margin reserved at top+bottom of node for edge bundles (6px each side)
@@ -85,6 +87,138 @@ const TOP_EXIT_STEP = 10; // px: control-point offset giving near-vertical depar
 const CHAR_WIDTH_RATIO = 0.6;
 const NODE_FONT_SIZE = 13;
 const NODE_TEXT_PADDING = 12;
+const GRID_ROW_HEIGHT = NODESEP; // 80px — one node (60px) + gap (20px)
+const COLUMN_X_TOLERANCE = 5; // px — dagre may offset same-rank nodes slightly
+
+// ============================================================
+// Grid quantization — replaces dagre's freeform Y with a fixed
+// grid while preserving dagre's rank assignment and crossing-
+// minimized within-column ordering.
+// ============================================================
+
+interface GridNode {
+  label: string;
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+}
+
+/** Find nearest available grid row, searching outward. Tie-breaks downward. */
+function findNearestAvailable(preferred: number, taken: Set<number>): number {
+  if (!taken.has(preferred)) return preferred;
+  for (let delta = 1; ; delta++) {
+    if (!taken.has(preferred + delta)) return preferred + delta;
+    if (!taken.has(preferred - delta)) return preferred - delta;
+  }
+}
+
+export function gridQuantize(
+  nodes: GridNode[],
+  edges: { source: string; target: string }[]
+): void {
+  if (nodes.length === 0) return;
+
+  // 1. Cluster columns by X with tolerance
+  const columns: GridNode[][] = [];
+  const sorted = [...nodes].sort((a, b) => a.x - b.x);
+  for (const node of sorted) {
+    const lastCol = columns[columns.length - 1];
+    if (lastCol && Math.abs(node.x - lastCol[0].x) <= COLUMN_X_TOLERANCE) {
+      lastCol.push(node);
+    } else {
+      columns.push([node]);
+    }
+  }
+
+  // Normalize X within each column to the mean, sort nodes by dagre Y
+  for (const col of columns) {
+    const meanX = col.reduce((s, n) => s + n.x, 0) / col.length;
+    for (const n of col) n.x = meanX;
+    col.sort((a, b) => a.y - b.y);
+  }
+
+  // 2. Build upstream map: target → source labels
+  const upstreamMap = new Map<string, string[]>();
+  for (const edge of edges) {
+    const list = upstreamMap.get(edge.target);
+    if (list) list.push(edge.source);
+    else upstreamMap.set(edge.target, [edge.source]);
+  }
+
+  // 3. Assign grid rows column by column, left to right
+  const rowAssignment = new Map<string, number>();
+
+  for (const col of columns) {
+    const takenRows = new Set<number>();
+    const preferredRows: number[] = [];
+
+    for (const node of col) {
+      const upstreams = upstreamMap.get(node.label);
+      let preferred: number;
+
+      if (upstreams && upstreams.length > 0) {
+        const upstreamRows = upstreams
+          .map((l) => rowAssignment.get(l))
+          .filter((r): r is number => r !== undefined);
+
+        if (upstreamRows.length === 1) {
+          preferred = upstreamRows[0];
+        } else if (upstreamRows.length > 1) {
+          upstreamRows.sort((a, b) => a - b);
+          const mid = Math.floor(upstreamRows.length / 2);
+          preferred =
+            upstreamRows.length % 2 === 0
+              ? Math.round((upstreamRows[mid - 1] + upstreamRows[mid]) / 2)
+              : upstreamRows[mid];
+        } else {
+          preferred = preferredRows.length;
+        }
+      } else {
+        preferred = preferredRows.length;
+      }
+
+      preferredRows.push(preferred);
+    }
+
+    // Order preservation: preferred rows must be monotonically non-decreasing
+    let monotone = true;
+    for (let i = 1; i < preferredRows.length; i++) {
+      if (preferredRows[i] < preferredRows[i - 1]) {
+        monotone = false;
+        break;
+      }
+    }
+
+    if (!monotone) {
+      const minRow = Math.min(...preferredRows);
+      for (let i = 0; i < col.length; i++) {
+        preferredRows[i] = minRow + i;
+      }
+    }
+
+    // Resolve collisions
+    for (let i = 0; i < col.length; i++) {
+      const row = findNearestAvailable(preferredRows[i], takenRows);
+      takenRows.add(row);
+      rowAssignment.set(col[i].label, row);
+      col[i].y = row * GRID_ROW_HEIGHT;
+    }
+  }
+
+  // 4. Vertical centering, ensure minY >= 20
+  const allY = nodes.map((n) => n.y);
+  const minY = Math.min(...allY);
+  const maxY = Math.max(...allY);
+  const centerOffset = -(minY + maxY) / 2;
+  for (const n of nodes) n.y += centerOffset;
+
+  const adjustedMinY = Math.min(...nodes.map((n) => n.y));
+  if (adjustedMinY < 20) {
+    const shift = 20 - adjustedMinY;
+    for (const n of nodes) n.y += shift;
+  }
+}
 
 // ============================================================
 // Main layout function
@@ -144,7 +278,7 @@ export function layoutInitiativeStatus(
 
   dagre.layout(g);
 
-  // Extract node positions
+  // Extract node positions from dagre
   const layoutNodes: ISLayoutNode[] = parsed.nodes.map((node) => {
     const pos = g.node(node.label);
     return {
@@ -156,20 +290,194 @@ export function layoutInitiativeStatus(
       y: pos.y,
       width: pos.width,
       height: pos.height,
+      metadata: node.metadata,
     };
   });
 
+  // Collect collapsed group positions for grid quantization
+  const collapsedGroupPositions: GridNode[] = [];
+  for (const label of collapsedGroupLabels) {
+    const pos = g.node(label);
+    if (pos) collapsedGroupPositions.push({ label, x: pos.x, y: pos.y, width: pos.width, height: pos.height });
+  }
+
+  // Grid-quantize all node positions (regular + collapsed groups)
+  const allGridNodes: GridNode[] = [
+    ...layoutNodes.map((n) => ({ label: n.label, x: n.x, y: n.y, width: n.width, height: n.height })),
+    ...collapsedGroupPositions,
+  ];
+  gridQuantize(allGridNodes, parsed.edges);
+
+  // Write quantized positions back
+  const quantizedMap = new Map(allGridNodes.map((n) => [n.label, n]));
+  for (const node of layoutNodes) {
+    const q = quantizedMap.get(node.label)!;
+    node.x = q.x;
+    node.y = q.y;
+  }
+  for (const cgp of collapsedGroupPositions) {
+    const q = quantizedMap.get(cgp.label)!;
+    cgp.x = q.x;
+    cgp.y = q.y;
+  }
+
+
   // Build a unified position map covering both regular nodes and collapsed groups
   interface NodePos { x: number; y: number; width: number; height: number }
   const posMap = new Map<string, NodePos>(layoutNodes.map((n) => [n.label, n]));
-  for (const label of collapsedGroupLabels) {
-    const pos = g.node(label);
-    if (pos) posMap.set(label, { x: pos.x, y: pos.y, width: pos.width, height: pos.height });
+  for (const cgp of collapsedGroupPositions) {
+    posMap.set(cgp.label, { x: cgp.x, y: cgp.y, width: cgp.width, height: cgp.height });
+  }
+
+  // Compute group bounding boxes BEFORE edge routing so overlap resolution
+  // can fix node positions before edges are computed.
+  const layoutGroups: ISLayoutGroup[] = [];
+
+  // Collapsed groups
+  for (const group of originalGroups) {
+    if (collapsedGroupLabels.has(group.label)) {
+      const cgp = collapsedGroupPositions.find((p) => p.label === group.label);
+      if (!cgp) continue;
+      layoutGroups.push({
+        label: group.label,
+        status: collapsedGroupStatuses.get(group.label) ?? null,
+        x: cgp.x - cgp.width / 2,
+        y: cgp.y - cgp.height / 2,
+        width: cgp.width,
+        height: cgp.height,
+        lineNumber: group.lineNumber,
+        collapsed: true,
+      });
+    }
+  }
+
+  // Expanded groups: bounding box from member positions
+  if (parsed.groups.length > 0) {
+    const nMap = new Map(layoutNodes.map((n) => [n.label, n]));
+    for (const group of parsed.groups) {
+      const members = group.nodeLabels
+        .map((label) => nMap.get(label))
+        .filter((n): n is ISLayoutNode => n !== undefined);
+      if (members.length === 0) continue;
+      let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+      for (const member of members) {
+        const left = member.x - member.width / 2;
+        const right = member.x + member.width / 2;
+        const top = member.y - member.height / 2;
+        const bottom = member.y + member.height / 2;
+        if (left < minX) minX = left;
+        if (right > maxX) maxX = right;
+        if (top < minY) minY = top;
+        if (bottom > maxY) maxY = bottom;
+      }
+      layoutGroups.push({
+        label: group.label,
+        status: rollUpStatus(members),
+        x: minX - GROUP_PADDING,
+        y: minY - GROUP_PADDING,
+        width: maxX - minX + GROUP_PADDING * 2,
+        height: maxY - minY + GROUP_PADDING * 2,
+        lineNumber: group.lineNumber,
+        collapsed: false,
+      });
+    }
+  }
+
+  // Resolve overlaps between expanded group boxes and non-member nodes.
+  // Must happen BEFORE edge routing so edges use final node positions.
+  if (layoutGroups.length > 0) {
+    const groupMemberLabels = new Set(parsed.groups.flatMap((gr) => gr.nodeLabels));
+    let changed = true;
+    let iterations = 0;
+    while (changed && iterations < 10) {
+      changed = false;
+      iterations++;
+      for (const group of layoutGroups) {
+        if (group.collapsed) continue;
+        // Use rendered group bounds (includes GROUP_EXTRA_PADDING + label)
+        const gTop = group.y - GROUP_LABEL_HEIGHT - GROUP_PADDING;
+        const gBottom = group.y + group.height + GROUP_PADDING;
+        const gLeft = group.x - GROUP_PADDING;
+        const gRight = group.x + group.width + GROUP_PADDING;
+        for (const node of layoutNodes) {
+          if (groupMemberLabels.has(node.label)) continue;
+          const nTop = node.y - node.height / 2;
+          const nBottom = node.y + node.height / 2;
+          const nLeft = node.x - node.width / 2;
+          const nRight = node.x + node.width / 2;
+          if (nRight <= gLeft || nLeft >= gRight) continue;
+          if (nBottom < gTop || nTop > gBottom) continue;
+          const groupCenterY = group.y + group.height / 2;
+          if (node.y < groupCenterY) {
+            node.y = gTop - node.height / 2 - GROUP_PADDING;
+          } else {
+            node.y = gBottom + node.height / 2 + GROUP_PADDING;
+          }
+          const pm = posMap.get(node.label);
+          if (pm) pm.y = node.y;
+          changed = true;
+        }
+      }
+      if (changed) {
+        const nMap = new Map(layoutNodes.map((n) => [n.label, n]));
+        for (const group of layoutGroups) {
+          if (group.collapsed) continue;
+          const pg = parsed.groups.find((gr) => gr.label === group.label);
+          if (!pg) continue;
+          const members = pg.nodeLabels
+            .map((label) => nMap.get(label))
+            .filter((n): n is ISLayoutNode => n !== undefined);
+          if (members.length === 0) continue;
+          let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+          for (const member of members) {
+            const left = member.x - member.width / 2;
+            const right = member.x + member.width / 2;
+            const top = member.y - member.height / 2;
+            const bottom = member.y + member.height / 2;
+            if (left < minX) minX = left;
+            if (right > maxX) maxX = right;
+            if (top < minY) minY = top;
+            if (bottom > maxY) maxY = bottom;
+          }
+          group.x = minX - GROUP_PADDING;
+          group.y = minY - GROUP_PADDING;
+          group.width = maxX - minX + GROUP_PADDING * 2;
+          group.height = maxY - minY + GROUP_PADDING * 2;
+        }
+      }
+    }
+  }
+
+  // Normalize Y: ensure all coordinates are non-negative after overlap resolution
+  {
+    let minNodeY = Infinity;
+    for (const node of layoutNodes) {
+      const top = node.y - node.height / 2;
+      if (top < minNodeY) minNodeY = top;
+    }
+    for (const group of layoutGroups) {
+      const top = group.collapsed ? group.y : group.y - GROUP_LABEL_HEIGHT;
+      if (top < minNodeY) minNodeY = top;
+    }
+    if (minNodeY < 20) {
+      const shift = 20 - minNodeY;
+      for (const node of layoutNodes) {
+        node.y += shift;
+        const pm = posMap.get(node.label);
+        if (pm) pm.y = node.y;
+      }
+      for (const group of layoutGroups) {
+        group.y += shift;
+      }
+      for (const cgp of collapsedGroupPositions) {
+        cgp.y += shift;
+        const pm = posMap.get(cgp.label);
+        if (pm) pm.y = cgp.y;
+      }
+    }
   }
 
   const allNodeX = [...posMap.values()].map((n) => n.x);
-  // avgNodeY / avgNodeX: O(1) scalars used for back-edge above/below heuristic and arc spread direction.
-  // layoutNodes.length === 0 is unreachable here (early-return guard at line 92 exits for empty diagrams).
   const avgNodeY = layoutNodes.length > 0
     ? layoutNodes.reduce((s, n) => s + n.y, 0) / layoutNodes.length
     : 0;
@@ -305,7 +613,7 @@ export function layoutInitiativeStatus(
       ];
     } else {
       // fixedDagrePoints: multi-rank forward edges — dagre interior waypoints for obstacle avoidance.
-      // dagrePoints is still fetched above (line 209) and available here.
+      // dagrePoints is still fetched above and available here.
       points = dagrePoints.length >= 2 ? [
         { x: exitX, y: src.y + yOffset },
         ...dagrePoints.slice(1, -1),
@@ -316,62 +624,6 @@ export function layoutInitiativeStatus(
                        status: edge.status, lineNumber: edge.lineNumber, points, parallelCount });
   }
 
-  // Compute group bounding boxes
-  const layoutGroups: ISLayoutGroup[] = [];
-
-  // Collapsed groups: dagre placed them as regular nodes → normalize to top-left
-  for (const group of originalGroups) {
-    if (collapsedGroupLabels.has(group.label)) {
-      const pos = g.node(group.label);
-      if (!pos) continue;
-      layoutGroups.push({
-        label: group.label,
-        status: collapsedGroupStatuses.get(group.label) ?? null,
-        x: pos.x - pos.width / 2,
-        y: pos.y - pos.height / 2,
-        width: pos.width,
-        height: pos.height,
-        lineNumber: group.lineNumber,
-        collapsed: true,
-      });
-    }
-  }
-
-  // Expanded groups: bounding box from member positions
-  if (parsed.groups.length > 0) {
-    const nMap = new Map(layoutNodes.map((n) => [n.label, n]));
-    for (const group of parsed.groups) {
-      const members = group.nodeLabels
-        .map((label) => nMap.get(label))
-        .filter((n): n is ISLayoutNode => n !== undefined);
-      if (members.length === 0) continue;
-
-      let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
-      for (const member of members) {
-        const left = member.x - member.width / 2;
-        const right = member.x + member.width / 2;
-        const top = member.y - member.height / 2;
-        const bottom = member.y + member.height / 2;
-        if (left < minX) minX = left;
-        if (right > maxX) maxX = right;
-        if (top < minY) minY = top;
-        if (bottom > maxY) maxY = bottom;
-      }
-
-      layoutGroups.push({
-        label: group.label,
-        status: rollUpStatus(members),
-        x: minX - GROUP_PADDING,
-        y: minY - GROUP_PADDING,
-        width: maxX - minX + GROUP_PADDING * 2,
-        height: maxY - minY + GROUP_PADDING * 2,
-        lineNumber: group.lineNumber,
-        collapsed: false,
-      });
-    }
-  }
-
-
   // Compute total dimensions
   let totalWidth = 0;
   let totalHeight = 0;