diff --git a/apps/desktop/src/renderer/components/graph/WorkspaceGraphPage.tsx b/apps/desktop/src/renderer/components/graph/WorkspaceGraphPage.tsx
index be65588de..41f23f0ed 100644
--- a/apps/desktop/src/renderer/components/graph/WorkspaceGraphPage.tsx
+++ b/apps/desktop/src/renderer/components/graph/WorkspaceGraphPage.tsx
@@ -101,7 +101,8 @@ import {
   createGraphPreferences,
   createSessionState,
   normalizeGraphPreferences,
-  computeAutoLayout
+  computeAutoLayout,
+  laneHierarchyFromPrimary
 } from "./graphLayout";
 import { GraphLaneNode } from "./graphNodes/LaneNode";
 import { GraphProposalNode } from "./graphNodes/ProposalNode";
@@ -336,6 +337,12 @@ function GraphInner() {
   const [textPromptError, setTextPromptError] = React.useState<string | null>(null);
   const [singleActionsOpen, setSingleActionsOpen] = React.useState(false);
   const [batchActionsOpen, setBatchActionsOpen] = React.useState(false);
+  /** In Overview, risk edges are hidden by default so the tree stays readable. */
+  const [showOverviewRiskEdges, setShowOverviewRiskEdges] = React.useState(false);
+
+  React.useEffect(() => {
+    if (viewMode !== "all") setShowOverviewRiskEdges(false);
+  }, [viewMode]);
 
   React.useEffect(() => {
     void refreshEnvironmentMappings();
@@ -463,7 +470,8 @@ function GraphInner() {
   }, [collapsedLaneIds, lanes]);
 
   const laneById = React.useMemo(() => new Map(lanes.map((lane) => [lane.id, lane] as const)), [lanes]);
-  const primaryLaneId = React.useMemo(() => lanes.find((lane) => lane.laneType === "primary")?.id ?? null, [lanes]);
+  const primaryHierarchyMeta = React.useMemo(() => laneHierarchyFromPrimary(lanes), [lanes]);
+  const primaryLaneId = primaryHierarchyMeta.primary?.id ?? null;
   const laneIdByBranchRef = React.useMemo(() => {
     const map = new Map<string, string>();
     for (const lane of lanes) {
@@ -514,7 +522,7 @@ function GraphInner() {
     (laneId: string): string | null => {
       const lane = laneById.get(laneId);
       if (!lane) return null;
-      return resolvePrBaseLaneId(lane, lane.baseRef);
+      return resolvePrBaseLaneId(lane, lane.baseRef) ?? null;
     },
     [laneById, resolvePrBaseLaneId]
   );
@@ -1135,7 +1143,13 @@ function GraphInner() {
       };
     }
 
-    const autoPositions = computeAutoLayout(lanes, viewMode, activityScoreByLaneId, environmentByLaneId);
+    const autoPositions = computeAutoLayout(
+      lanes,
+      viewMode,
+      activityScoreByLaneId,
+      environmentByLaneId,
+      primaryHierarchyMeta.depthByLaneId
+    );
     const savedPositions = activeSnapshot.nodePositions;
     const positions = Object.keys(savedPositions).length > 0 ? { ...autoPositions, ...savedPositions } : autoPositions;
     const nextNodes: Array<Node<GraphNodeData>> = [];
@@ -1166,6 +1180,8 @@ function GraphInner() {
           autoRebaseStatus: autoRebaseByLaneId[lane.id] ?? null,
           activeSessions: activeSessionsByLaneId[lane.id] ?? 0,
           collapsedChildCount,
+          hierarchyDepth: primaryHierarchyMeta.depthByLaneId.get(lane.id) ?? 0,
+          parentLaneName: primaryHierarchyMeta.parentNameByLaneId.get(lane.id) ?? null,
           dimmed: false,
           activityBucket: activityBucketByLaneId[lane.id] ?? "medium",
           viewMode,
@@ -1246,6 +1262,8 @@ function GraphInner() {
           autoRebaseStatus: null,
           activeSessions: 0,
           collapsedChildCount: 0,
+          hierarchyDepth: 0,
+          parentLaneName: null,
           dimmed: false,
           activityBucket: "medium",
           viewMode,
@@ -1274,7 +1292,7 @@ function GraphInner() {
     }
 
     const nextEdges: Array<Edge<GraphEdgeData>> = [];
-    const primaryLane = lanes.find((lane) => lane.laneType === "primary") ?? null;
+    const primaryLane = primaryHierarchyMeta.primary;
     const riskPairsWithVisibleEdge = new Set<string>();
     const laneHasProposalConflict = (proposal: IntegrationProposal, sourceLaneId: string): boolean => {
       const steps = proposalSteps(proposal);
@@ -1292,7 +1310,7 @@ function GraphInner() {
       );
     };
 
-    if (viewMode === "all" || viewMode === "risk") {
+    if (viewMode === "risk" || (viewMode === "all" && showOverviewRiskEdges)) {
       for (const [key, risk] of riskByPair.entries()) {
         if (risk.riskLevel === "none" && risk.overlapCount === 0) continue;
         const [laneAId, laneBId] = key.split("::");
@@ -1306,6 +1324,8 @@ function GraphInner() {
     if (viewMode === "all" || viewMode === "stack") {
       for (const lane of lanes) {
         if (!primaryLane || lane.id === primaryLane.id) continue;
+        // In Overview, stack edges already show the tree; skip redundant "primary → lane" spokes.
+        if (viewMode === "all" && lane.parentLaneId && visibleNodeIds.has(lane.parentLaneId)) continue;
         if (!visibleNodeIds.has(primaryLane.id) || !visibleNodeIds.has(lane.id)) continue;
         const pair = edgePairKey(primaryLane.id, lane.id);
         const pr = prOverlayByPair.get(pair);
@@ -1341,7 +1361,7 @@ function GraphInner() {
       }
     }
 
-    if (viewMode === "all" || viewMode === "risk") {
+    if (viewMode === "risk" || (viewMode === "all" && showOverviewRiskEdges)) {
       for (const [key, risk] of riskByPair.entries()) {
         if (risk.riskLevel === "none" && risk.overlapCount === 0) continue;
         const [laneAId, laneBId] = key.split("::");
@@ -1433,7 +1453,9 @@ function GraphInner() {
     loadedGraphPreferences,
     prOverlayByPair,
     prOverlayByLaneId,
+    primaryHierarchyMeta,
     riskByPair,
+    showOverviewRiskEdges,
     statusByLane,
     syncByLaneId,
     viewMode,
@@ -2922,6 +2944,18 @@ function GraphInner() {
             Reset View
           </Button>
 
+          {viewMode === "all" ? (
+            <Button
+              size="sm"
+              variant={showOverviewRiskEdges ? "primary" : "outline"}
+              className="h-7 px-2 text-[11px]"
+              title="Show or hide predicted file-overlap links between lanes. Stack links stay visible."
+              onClick={() => setShowOverviewRiskEdges((prev) => !prev)}
+            >
+              {showOverviewRiskEdges ? "Hide overlap web" : "Show overlap web"}
+            </Button>
+          ) : null}
+
           <Button
             size="sm"
             variant={showRiskMatrix ? "primary" : "outline"}
@@ -2940,6 +2974,8 @@ function GraphInner() {
           edges={edges}
           nodeTypes={nodeTypes}
           edgeTypes={edgeTypes}
+          onlyRenderVisibleElements
+          nodesConnectable={false}
           onNodesChange={onNodesChange}
           onEdgesChange={onEdgesChange}
           onNodeDragStart={onNodeDragStart}
diff --git a/apps/desktop/src/renderer/components/graph/graphHelpers.ts b/apps/desktop/src/renderer/components/graph/graphHelpers.ts
index 28cae637c..0004f4eb7 100644
--- a/apps/desktop/src/renderer/components/graph/graphHelpers.ts
+++ b/apps/desktop/src/renderer/components/graph/graphHelpers.ts
@@ -16,19 +16,23 @@ export const VIEW_MODES: GraphViewMode[] = ["stack", "risk", "activity", "all"];
 export const VIEW_MODE_META: Record<GraphViewMode, { label: string; helper: string }> = {
   all: {
     label: "Overview",
-    helper: "See the full workspace map with dependencies, environments, and active pull requests."
+    helper:
+      "Primary lane on top, children row by row. Solid lines are stack order; use Show overlap web for conflict-risk links."
   },
   stack: {
     label: "Dependencies",
-    helper: "Follow parent-child lane relationships and drag lanes to change how work is stacked."
+    helper:
+      "Same top-down tree as Overview: primary on top, children row by row. Drag lanes to change how work is stacked."
   },
   risk: {
     label: "Conflict Risk",
-    helper: "Highlight overlapping work and jump into the pair matrix when you need file-level conflict detail."
+    helper:
+      "Same tree layout as Overview; risk edges highlight overlapping work. Open the pair matrix for file-level detail."
   },
   activity: {
     label: "Activity",
-    helper: "Surface the lanes with the most recent work, sessions, and movement."
+    helper:
+      "Same tree rows as other modes; siblings within a row sort by recent activity, then stack depth and name."
   }
 };
 
@@ -169,9 +173,9 @@ export function nodeDimensions(
     if (bucket === "high") return { width: 200, height: 100 };
     return { width: 160, height: 80 };
   }
-  if (isIntegration) return { width: 220, height: integrationSourceCount > 2 ? 122 : 110 };
-  if (lane.laneType === "primary") return { width: 200, height: 100 };
-  return { width: 160, height: 80 };
+  if (isIntegration) return { width: 228, height: integrationSourceCount > 2 ? 130 : 118 };
+  if (lane.laneType === "primary") return { width: 228, height: 132 };
+  return { width: 208, height: 124 };
 }
 
 export function branchNameFromRef(ref: string): string {
diff --git a/apps/desktop/src/renderer/components/graph/graphLayout.test.ts b/apps/desktop/src/renderer/components/graph/graphLayout.test.ts
index 15192052c..914c032ad 100644
--- a/apps/desktop/src/renderer/components/graph/graphLayout.test.ts
+++ b/apps/desktop/src/renderer/components/graph/graphLayout.test.ts
@@ -1,5 +1,27 @@
 import { describe, expect, it } from "vitest";
-import { normalizeGraphPreferences } from "./graphLayout";
+import type { LaneSummary } from "../../../shared/types";
+import { computeAutoLayout, laneHierarchyFromPrimary, normalizeGraphPreferences } from "./graphLayout";
+
+function lane(partial: Partial<LaneSummary> & Pick<LaneSummary, "id" | "name" | "laneType" | "parentLaneId">): LaneSummary {
+  return {
+    description: null,
+    attachedRootPath: null,
+    baseRef: "refs/heads/main",
+    branchRef: `refs/heads/${partial.name}`,
+    worktreePath: "",
+    childCount: 0,
+    stackDepth: 0,
+    parentStatus: null,
+    isEditProtected: false,
+    status: { dirty: false, ahead: 0, behind: 0, remoteBehind: -1, rebaseInProgress: false },
+    color: null,
+    icon: null,
+    tags: [],
+    createdAt: "2026-01-01T00:00:00.000Z",
+    archivedAt: null,
+    ...partial
+  };
+}
 
 describe("normalizeGraphPreferences", () => {
   it("keeps the new preferences shape unchanged", () => {
@@ -40,3 +62,76 @@ describe("normalizeGraphPreferences", () => {
     });
   });
 });
+
+describe("laneHierarchyFromPrimary", () => {
+  it("assigns depth 0 to primary and increments along parent chain", () => {
+    const lanes = [
+      lane({ id: "p", name: "main", laneType: "primary", parentLaneId: null }),
+      lane({ id: "a", name: "feat-a", laneType: "worktree", parentLaneId: "p" }),
+      lane({ id: "b", name: "feat-b", laneType: "worktree", parentLaneId: "a" })
+    ];
+    const { depthByLaneId, parentNameByLaneId } = laneHierarchyFromPrimary(lanes);
+    expect(depthByLaneId.get("p")).toBe(0);
+    expect(depthByLaneId.get("a")).toBe(1);
+    expect(depthByLaneId.get("b")).toBe(2);
+    expect(parentNameByLaneId.get("a")).toBe("main");
+    expect(parentNameByLaneId.get("b")).toBe("feat-a");
+  });
+
+  it("marks lanes not under primary with a large sentinel depth", () => {
+    const lanes = [
+      lane({ id: "p", name: "main", laneType: "primary", parentLaneId: null }),
+      lane({ id: "o", name: "orphan", laneType: "worktree", parentLaneId: null })
+    ];
+    const { depthByLaneId } = laneHierarchyFromPrimary(lanes);
+    expect(depthByLaneId.get("o")).toBe(10_000);
+  });
+
+  it("returns a null primary and empty maps when given no lanes", () => {
+    const { primary, depthByLaneId, parentNameByLaneId } = laneHierarchyFromPrimary([]);
+    expect(primary).toBeNull();
+    expect(depthByLaneId.size).toBe(0);
+    expect(parentNameByLaneId.size).toBe(0);
+  });
+});
+
+describe("computeAutoLayout overview", () => {
+  it("places primary above children in row order", () => {
+    const lanes = [
+      lane({ id: "p", name: "main", laneType: "primary", parentLaneId: null, stackDepth: 0 }),
+      lane({ id: "x", name: "z-last", laneType: "worktree", parentLaneId: "p", stackDepth: 1 }),
+      lane({ id: "y", name: "a-first", laneType: "worktree", parentLaneId: "p", stackDepth: 1 })
+    ];
+    const pos = computeAutoLayout(lanes, "all", {}, {});
+    expect(pos.p!.y).toBeLessThan(pos.x!.y);
+    expect(pos.p!.y).toBeLessThan(pos.y!.y);
+    expect(pos.x!.y).toBe(pos.y!.y);
+    expect(pos.y!.x).toBeLessThan(pos.x!.x);
+  });
+});
+
+describe("computeAutoLayout aligned modes", () => {
+  it("matches stack and risk positions to overview for the same lanes", () => {
+    const lanes = [
+      lane({ id: "p", name: "main", laneType: "primary", parentLaneId: null, stackDepth: 0 }),
+      lane({ id: "c", name: "child", laneType: "worktree", parentLaneId: "p", stackDepth: 1 })
+    ];
+    const allPos = computeAutoLayout(lanes, "all", {}, {});
+    const stackPos = computeAutoLayout(lanes, "stack", {}, {});
+    const riskPos = computeAutoLayout(lanes, "risk", {}, {});
+    expect(stackPos).toEqual(allPos);
+    expect(riskPos).toEqual(allPos);
+  });
+
+  it("activity mode sorts siblings by activity score within the same depth", () => {
+    const lanes = [
+      lane({ id: "p", name: "main", laneType: "primary", parentLaneId: null, stackDepth: 0 }),
+      lane({ id: "low", name: "low", laneType: "worktree", parentLaneId: "p", stackDepth: 1 }),
+      lane({ id: "high", name: "high", laneType: "worktree", parentLaneId: "p", stackDepth: 1 })
+    ];
+    const scores = { low: 1, high: 99 };
+    const pos = computeAutoLayout(lanes, "activity", scores, {});
+    expect(pos.low!.y).toBe(pos.high!.y);
+    expect(pos.high!.x).toBeLessThan(pos.low!.x);
+  });
+});
diff --git a/apps/desktop/src/renderer/components/graph/graphLayout.ts b/apps/desktop/src/renderer/components/graph/graphLayout.ts
index 082c1e11e..95277952a 100644
--- a/apps/desktop/src/renderer/components/graph/graphLayout.ts
+++ b/apps/desktop/src/renderer/components/graph/graphLayout.ts
@@ -96,100 +96,132 @@ export function normalizeGraphPreferences(state: unknown): {
   };
 }
 
-export function buildTreeDepth(lanes: LaneSummary[]): Map<string, number> {
+/** Workspace primary lane and hierarchy relative to it (for overview layout and cards). */
+export function laneHierarchyFromPrimary(lanes: LaneSummary[]): {
+  primary: LaneSummary | null;
+  depthByLaneId: Map<string, number>;
+  parentNameByLaneId: Map<string, string | null>;
+} {
+  const primary = lanes.find((lane) => lane.laneType === "primary") ?? lanes[0] ?? null;
+  if (!primary) {
+    return { primary: null, depthByLaneId: new Map(), parentNameByLaneId: new Map() };
+  }
   const byId = new Map(lanes.map((lane) => [lane.id, lane] as const));
-  const cache = new Map<string, number>();
-  const visit = (laneId: string): number => {
-    const existing = cache.get(laneId);
-    if (existing != null) return existing;
-    const lane = byId.get(laneId);
-    if (!lane || !lane.parentLaneId || !byId.has(lane.parentLaneId)) {
-      cache.set(laneId, 0);
-      return 0;
+  const depthByLaneId = new Map<string, number>();
+  const parentNameByLaneId = new Map<string, string | null>();
+
+  depthByLaneId.set(primary.id, 0);
+
+  const resolveDepth = (startId: string): number => {
+    const chain: string[] = [];
+    const onChain = new Set<string>();
+    let cursor: LaneSummary | undefined = byId.get(startId);
+    let baseDepth = 10_000;
+    while (cursor) {
+      const cached = depthByLaneId.get(cursor.id);
+      if (cached !== undefined) {
+        baseDepth = cached;
+        break;
+      }
+      if (onChain.has(cursor.id)) {
+        baseDepth = 10_000;
+        break;
+      }
+      chain.push(cursor.id);
+      onChain.add(cursor.id);
+      if (!cursor.parentLaneId) {
+        baseDepth = 10_000;
+        break;
+      }
+      cursor = byId.get(cursor.parentLaneId);
+    }
+    if (baseDepth === 10_000) {
+      for (const id of chain) depthByLaneId.set(id, 10_000);
+      return 10_000;
     }
-    const depth = visit(lane.parentLaneId) + 1;
-    cache.set(laneId, depth);
-    return depth;
+    for (let i = chain.length - 1; i >= 0; i -= 1) {
+      baseDepth += 1;
+      depthByLaneId.set(chain[i]!, baseDepth);
+    }
+    return depthByLaneId.get(startId) ?? 10_000;
   };
-  for (const lane of lanes) visit(lane.id);
-  return cache;
+
+  for (const lane of lanes) {
+    if (!depthByLaneId.has(lane.id)) resolveDepth(lane.id);
+    const parent = lane.parentLaneId ? byId.get(lane.parentLaneId) : null;
+    parentNameByLaneId.set(lane.id, parent?.name ?? null);
+  }
+
+  return { primary, depthByLaneId, parentNameByLaneId };
 }
 
-export function computeAutoLayout(
+/** Shared auto-layout: primary centered on top row, descendants on deeper rows (same for every view mode). */
+function layoutPrimaryCentricRows(
   lanes: LaneSummary[],
-  viewMode: GraphViewMode,
   activityScoreByLaneId: Record<string, number>,
-  environmentByLaneId: Record<string, { env: string; color: string | null }>
+  tieBreak: "stack" | "activity",
+  precomputedDepthByLaneId?: Map<string, number>
 ): Record<string, { x: number; y: number }> {
   const positions: Record<string, { x: number; y: number }> = {};
   if (lanes.length === 0) return positions;
 
-  if (viewMode === "stack") {
-    const depthMap = buildTreeDepth(lanes);
-    const lanesByDepth = new Map<number, LaneSummary[]>();
-    for (const lane of lanes) {
-      const depth = depthMap.get(lane.id) ?? 0;
-      const list = lanesByDepth.get(depth) ?? [];
-      list.push(lane);
-      lanesByDepth.set(depth, list);
-    }
-    for (const [depth, levelLanes] of lanesByDepth.entries()) {
-      levelLanes.sort((a, b) => a.name.localeCompare(b.name));
-      levelLanes.forEach((lane, index) => {
-        positions[lane.id] = { x: index * 220, y: depth * 170 };
-      });
+  const depthByLaneId = precomputedDepthByLaneId ?? laneHierarchyFromPrimary(lanes).depthByLaneId;
+
+  const compareLanes = (a: LaneSummary, b: LaneSummary) => {
+    if (tieBreak === "activity") {
+      const scoreA = activityScoreByLaneId[a.id] ?? 0;
+      const scoreB = activityScoreByLaneId[b.id] ?? 0;
+      if (scoreB !== scoreA) return scoreB - scoreA;
     }
-    return positions;
+    if (a.stackDepth !== b.stackDepth) return a.stackDepth - b.stackDepth;
+    const nameCmp = a.name.localeCompare(b.name);
+    if (nameCmp !== 0) return nameCmp;
+    return a.createdAt.localeCompare(b.createdAt);
+  };
+
+  const depthBuckets = new Map<number, LaneSummary[]>();
+  for (const lane of lanes) {
+    const depth = depthByLaneId.get(lane.id) ?? 10_000;
+    const list = depthBuckets.get(depth) ?? [];
+    list.push(lane);
+    depthBuckets.set(depth, list);
   }
 
-  if (viewMode === "risk") {
-    const radius = Math.max(180, lanes.length * 24);
-    const centerX = 380;
-    const centerY = 260;
-    lanes.forEach((lane, index) => {
-      const angle = (index / lanes.length) * Math.PI * 2;
-      positions[lane.id] = {
-        x: centerX + Math.cos(angle) * radius,
-        y: centerY + Math.sin(angle) * radius
-      };
+  const X_PITCH = 252;
+  const Y_STEP = 168;
+
+  const finiteDepths = [...depthBuckets.keys()].filter((d) => d < 5000).sort((a, b) => a - b);
+  const maxFiniteDepth = finiteDepths.length > 0 ? Math.max(...finiteDepths) : 0;
+
+  for (const depth of finiteDepths) {
+    const row = (depthBuckets.get(depth) ?? []).slice().sort(compareLanes);
+    const rowWidth = Math.max(1, row.length) * X_PITCH;
+    row.forEach((lane, index) => {
+      const x = index * X_PITCH - (rowWidth - X_PITCH) / 2;
+      positions[lane.id] = { x, y: depth * Y_STEP };
     });
-    return positions;
   }
 
-  if (viewMode === "activity") {
-    const sorted = [...lanes].sort((a, b) => (activityScoreByLaneId[b.id] ?? 0) - (activityScoreByLaneId[a.id] ?? 0));
-    const cols = Math.max(1, Math.ceil(Math.sqrt(sorted.length)));
-    sorted.forEach((lane, index) => {
-      positions[lane.id] = {
-        x: (index % cols) * 230,
-        y: Math.floor(index / cols) * 180
-      };
+  const orphans = (depthBuckets.get(10_000) ?? []).slice().sort(compareLanes);
+  if (orphans.length > 0) {
+    const baseY = (maxFiniteDepth + 1) * Y_STEP + 40;
+    const rowWidth = Math.max(1, orphans.length) * X_PITCH;
+    orphans.forEach((lane, index) => {
+      const x = index * X_PITCH - (rowWidth - X_PITCH) / 2;
+      positions[lane.id] = { x, y: baseY };
     });
-    return positions;
   }
 
-  const primary = lanes.find((lane) => lane.laneType === "primary") ?? lanes[0]!;
-  positions[primary.id] = { x: 420, y: 240 };
-  const rest = lanes.filter((lane) => lane.id !== primary.id);
-  const core = rest.filter((lane) => Boolean(environmentByLaneId[lane.id]));
-  const others = rest.filter((lane) => !environmentByLaneId[lane.id]);
-
-  const innerRadius = Math.max(160, core.length * 26);
-  core.forEach((lane, index) => {
-    const angle = (index / Math.max(1, core.length)) * Math.PI * 2;
-    positions[lane.id] = {
-      x: 420 + Math.cos(angle) * innerRadius,
-      y: 240 + Math.sin(angle) * innerRadius
-    };
-  });
-
-  const outerRadius = Math.max(260, others.length * 26);
-  others.forEach((lane, index) => {
-    const angle = (index / Math.max(1, others.length)) * Math.PI * 2;
-    positions[lane.id] = {
-      x: 420 + Math.cos(angle) * outerRadius,
-      y: 240 + Math.sin(angle) * outerRadius
-    };
-  });
   return positions;
 }
+
+export function computeAutoLayout(
+  lanes: LaneSummary[],
+  viewMode: GraphViewMode,
+  activityScoreByLaneId: Record<string, number>,
+  _environmentByLaneId: Record<string, { env: string; color: string | null }>,
+  precomputedDepthByLaneId?: Map<string, number>
+): Record<string, { x: number; y: number }> {
+  const tieBreak: "stack" | "activity" = viewMode === "activity" ? "activity" : "stack";
+  return layoutPrimaryCentricRows(lanes, activityScoreByLaneId, tieBreak, precomputedDepthByLaneId);
+}
diff --git a/apps/desktop/src/renderer/components/graph/graphNodes/LaneNode.tsx b/apps/desktop/src/renderer/components/graph/graphNodes/LaneNode.tsx
index 19951e7c6..34448df81 100644
--- a/apps/desktop/src/renderer/components/graph/graphNodes/LaneNode.tsx
+++ b/apps/desktop/src/renderer/components/graph/graphNodes/LaneNode.tsx
@@ -1,15 +1,40 @@
-import { Handle, Node, NodeProps, Position } from "@xyflow/react";
-import { ClockCounterClockwise, GitBranch, Stack } from "@phosphor-icons/react";
+import { Handle, Position } from "@xyflow/react";
+import type { Node, NodeProps } from "@xyflow/react";
+import {
+  ArrowsDownUp,
+  CaretRight,
+  ClockCounterClockwise,
+  GitBranch,
+  House,
+  Stack,
+  TreeStructure
+} from "@phosphor-icons/react";
+import type { ConflictStatus } from "../../../../shared/types";
 import { Chip } from "../../ui/Chip";
 import { cn } from "../../ui/cn";
 import { iconGlyph, nodeDimensions } from "../graphHelpers";
 import type { GraphNodeData } from "../graphTypes";
 
+function conflictStatusLabel(status: ConflictStatus["status"] | "unknown"): string {
+  switch (status) {
+    case "conflict-active":
+      return "Conflict";
+    case "conflict-predicted":
+      return "Risk";
+    case "behind-base":
+      return "Behind base";
+    case "merge-ready":
+      return "Merge ready";
+    default:
+      return "Unknown";
+  }
+}
+
 export function GraphLaneNode({ data, selected }: NodeProps<Node<GraphNodeData>>) {
   const lane = data.lane;
   const dimensions = nodeDimensions(lane, data.activityBucket, data.viewMode, {
     isIntegration: data.isIntegration,
-    integrationSourceCount: data.integrationSources.length,
+    integrationSourceCount: data.integrationSources.length
   });
   const remoteSync = data.remoteSync;
   const autoRebase = data.autoRebaseStatus;
@@ -21,6 +46,9 @@ export function GraphLaneNode({ data, selected }: NodeProps<Node<GraphNodeData>>
   const remoteNeedsPublish = Boolean(remoteSync && ((remoteSync.hasUpstream === false) || remoteSync.ahead > 0));
   const remoteNeedsPull = Boolean(remoteSync?.hasUpstream && remoteSync.recommendedAction === "pull");
   const baseBehind = lane.status.behind > 0 || data.status === "behind-base";
+  const isPrimary = lane.laneType === "primary";
+  const depth = data.hierarchyDepth;
+  const orphanStack = depth >= 1000;
 
   const syncBadge = (() => {
     if (remoteDiverged) return { label: "Diverged", className: "text-red-300" };
@@ -45,55 +73,128 @@ export function GraphLaneNode({ data, selected }: NodeProps<Node<GraphNodeData>>
     return { label: `PR #${pr.number} open`, className: "text-sky-300" };
   })();
 
+  function resolveLaneRoleLabel(): string {
+    switch (lane.laneType) {
+      case "attached":
+        return "Attached lane";
+      case "worktree":
+        return "Lane";
+      default:
+        return "Primary lane";
+    }
+  }
+  const laneRoleLabel = resolveLaneRoleLabel();
+
+  const accentBorder = data.isIntegration ? "#A78BFA" : (lane.color ?? data.environment?.color ?? undefined);
+
+  function renderLaneIcon() {
+    if (lane.icon) return iconGlyph(lane.icon);
+    if (isPrimary) return <House size={15} weight="duotone" />;
+    return null;
+  }
+
   return (
     <div
       className={cn(
-        "group relative rounded-xl border bg-card/92 px-2.5 py-2 text-[11px] shadow-sm transition-all duration-150",
-        lane.laneType === "attached" ? "border-dashed text-muted-fg" : "border-border text-fg",
-        lane.laneType === "primary" && "border-[3px] border-accent",
+        "group relative overflow-hidden rounded-xl border bg-white/[0.03] px-3 py-2.5 text-[11px] shadow-card backdrop-blur-sm transition-all duration-150",
+        "border-white/[0.08]",
+        lane.laneType === "attached" ? "border-dashed text-muted-fg" : "text-fg",
+        isPrimary && "border-[2.5px] border-accent/90",
         data.isIntegration && "border-2",
-        selected && "ring-2 ring-accent",
+        selected && "ring-2 ring-accent ring-offset-2 ring-offset-bg",
         data.dimmed && "opacity-55",
-        data.highlight && "shadow-[0_4px_14px_rgba(0,0,0,0.18)]",
-        data.activityBucket === "high" && "shadow-[0_0_18px_rgba(34,197,94,0.2)]",
+        data.highlight && "shadow-[0_4px_18px_rgba(0,0,0,0.22)]",
+        data.activityBucket === "high" && "shadow-[0_0_20px_rgba(34,197,94,0.18)]",
         data.rebaseFailed && "border-red-500 ring-1 ring-red-500/80",
         data.rebasePulse && "ade-node-failed-pulse",
         data.mergeInProgress && "ade-node-merging",
         data.mergeDisappearing && "ade-node-disappear",
         data.focusGlow && "ring-2 ring-purple-400/60 shadow-[0_0_20px_rgba(167,139,250,0.35)]",
-        data.isIntegration && "bg-[linear-gradient(180deg,rgba(167,139,250,0.14),rgba(24,24,27,0.9))]"
+        data.isIntegration && "bg-[linear-gradient(180deg,rgba(167,139,250,0.12),rgba(24,24,27,0.88))]"
       )}
       style={{
         width: dimensions.width,
         minHeight: dimensions.height,
-        borderColor: data.isIntegration ? "#A78BFA" : (lane.color ?? data.environment?.color ?? undefined)
+        borderColor: accentBorder
       }}
     >
-      <div className="flex items-center gap-1">
-        {iconGlyph(lane.icon)}
-        <span className="truncate font-semibold text-fg">{lane.name}</span>
-        {data.isIntegration ? (
-          <span
-            className="ml-auto flex items-center gap-0.5 rounded px-1 py-0 text-[9px] font-medium uppercase tracking-wider"
-            style={{ color: "#A78BFA", backgroundColor: "rgba(167,139,250,0.12)", border: "1px solid rgba(167,139,250,0.3)" }}
-            title="Integration lane"
-          >
-            <GitBranch size={10} weight="bold" />
-            Integration
+      <div className="flex items-start gap-2">
+        <div className="mt-0.5 shrink-0 text-muted-fg">{renderLaneIcon()}</div>
+        <div className="min-w-0 flex-1">
+          <div className="flex flex-wrap items-center gap-1">
+            <span className="truncate font-semibold tracking-tight text-fg">{lane.name}</span>
+            {data.isIntegration ? (
+              <span
+                className="ml-auto flex items-center gap-0.5 rounded-md px-1.5 py-0 text-[9px] font-semibold uppercase tracking-wider"
+                style={{ color: "#C4B5FD", backgroundColor: "rgba(167,139,250,0.14)", border: "1px solid rgba(167,139,250,0.35)" }}
+                title="Integration lane"
+              >
+                <GitBranch size={10} weight="bold" />
+                Integration
+              </span>
+            ) : (
+              <span className="ml-auto rounded-md border border-white/[0.08] bg-white/[0.02] px-1.5 py-0 text-[9px] font-medium uppercase tracking-wide text-muted-fg">
+                {laneRoleLabel}
+              </span>
+            )}
+          </div>
+          <div className="mt-0.5 flex flex-wrap items-center gap-x-1.5 gap-y-0.5 text-[10px] text-muted-fg">
+            <span className="truncate font-mono" title={lane.branchRef}>
+              {lane.branchRef}
+            </span>
+            {!data.isIntegration && !orphanStack ? (
+              <span className="inline-flex shrink-0 items-center gap-0.5 text-[10px] text-muted-fg/90" title="Depth from workspace primary">
+                <TreeStructure size={11} weight="bold" className="text-muted-fg" />
+                L{depth}
+              </span>
+            ) : null}
+          </div>
+          {!data.isIntegration && data.parentLaneName ? (
+            <div className="mt-1 flex items-center gap-0.5 truncate text-[10px] text-muted-fg" title="Parent in this workspace">
+              <CaretRight size={11} weight="bold" className="shrink-0 text-muted-fg/70" />
+              <span className="truncate">On {data.parentLaneName}</span>
+            </div>
+          ) : null}
+          {orphanStack && !data.isIntegration ? (
+            <div className="mt-1 rounded-md border border-amber-500/25 bg-amber-500/10 px-1.5 py-0.5 text-[10px] text-amber-200/90">
+              Not stacked under the workspace primary — drag onto a parent or open the lane list to fix.
+            </div>
+          ) : null}
+        </div>
+      </div>
+
+      <div className="mt-2 flex flex-wrap items-center gap-1 border-t border-white/[0.06] pt-2">
+        <span
+          className={cn(
+            "rounded-md border px-1.5 py-0 text-[10px] font-medium",
+            data.status === "conflict-active" && "border-red-500/35 bg-red-500/10 text-red-200",
+            data.status === "conflict-predicted" && "border-amber-500/35 bg-amber-500/10 text-amber-100",
+            data.status === "behind-base" && "border-amber-500/25 bg-amber-500/8 text-amber-100",
+            data.status === "merge-ready" && "border-emerald-500/30 bg-emerald-500/10 text-emerald-100",
+            (data.status === "unknown" || !data.status) && "border-white/[0.06] bg-white/[0.02] text-muted-fg"
+          )}
+        >
+          {conflictStatusLabel(data.status)}
+        </span>
+        <span className="inline-flex items-center gap-0.5 rounded-md border border-white/[0.06] bg-white/[0.02] px-1.5 py-0 font-mono text-[10px] text-muted-fg" title="Commits ahead / behind parent base">
+          <ArrowsDownUp size={10} weight="bold" />
+          {lane.status.ahead}↑ {lane.status.behind}↓
+        </span>
+        {lane.status.remoteBehind >= 0 ? (
+          <span className="rounded-md border border-white/[0.06] bg-white/[0.02] px-1.5 py-0 font-mono text-[10px] text-muted-fg" title="Remote tracking">
+            r{lane.status.remoteBehind}
           </span>
         ) : null}
       </div>
-      <div className="mt-0.5 truncate text-[11px] text-muted-fg">{lane.branchRef}</div>
+
       {data.integrationSources.length > 0 ? (
         <div className="mt-2">
-          <div className="mb-1 text-[9px] font-semibold uppercase tracking-[0.12em] text-[#C4B5FD]">
-            Fed By
-          </div>
+          <div className="mb-1 text-[9px] font-semibold uppercase tracking-[0.12em] text-[#C4B5FD]">Fed by</div>
           <div className="flex flex-wrap gap-1">
             {visibleIntegrationSources.map((source) => (
               <span
                 key={source.laneId}
-                className="rounded border px-1.5 py-0.5 text-[10px] font-medium text-[#E9D5FF]"
+                className="rounded-md border px-1.5 py-0.5 text-[10px] font-medium text-[#E9D5FF]"
                 style={{ borderColor: "rgba(167,139,250,0.35)", background: "rgba(167,139,250,0.12)" }}
                 title={source.laneName}
               >
@@ -102,7 +203,7 @@ export function GraphLaneNode({ data, selected }: NodeProps<Node<GraphNodeData>>
             ))}
             {hiddenIntegrationSourceCount > 0 ? (
               <span
-                className="rounded border px-1.5 py-0.5 text-[10px] font-medium text-[#DDD6FE]"
+                className="rounded-md border px-1.5 py-0.5 text-[10px] font-medium text-[#DDD6FE]"
                 style={{ borderColor: "rgba(167,139,250,0.28)", background: "rgba(167,139,250,0.08)" }}
                 title={`${hiddenIntegrationSourceCount} more source lanes`}
               >
@@ -112,8 +213,9 @@ export function GraphLaneNode({ data, selected }: NodeProps<Node<GraphNodeData>>
           </div>
         </div>
       ) : null}
+
       <div className="mt-2 flex flex-wrap items-center gap-1">
-        <Chip className={cn("px-1.5 py-0 text-[10px]", lane.status.dirty ? "text-amber-300" : "text-emerald-300")}>
+        <Chip className={cn("px-1.5 py-0 text-[10px]", lane.status.dirty ? "text-amber-200" : "text-emerald-200")}>
           {lane.status.dirty ? "Dirty" : "Clean"}
         </Chip>
         <Chip className={cn("px-1.5 py-0 text-[10px]", syncBadge.className)} title={`Compared to base ${lane.baseRef}`}>
@@ -126,7 +228,7 @@ export function GraphLaneNode({ data, selected }: NodeProps<Node<GraphNodeData>>
         ) : null}
         {data.environment ? (
           <span
-            className="rounded border px-1.5 py-0 text-[10px] uppercase tracking-wide"
+            className="rounded-md border px-1.5 py-0 text-[10px] uppercase tracking-wide"
             style={{
               borderColor: data.environment.color ?? undefined,
               color: data.environment.color ?? "var(--color-muted-fg)",
@@ -146,12 +248,20 @@ export function GraphLaneNode({ data, selected }: NodeProps<Node<GraphNodeData>>
         ) : null}
         {data.activeSessions > 0 ? <span className="h-2 w-2 animate-pulse rounded-full bg-emerald-400" title="Active sessions" /> : null}
       </div>
+
       {data.collapsedChildCount > 0 ? (
-        <div className="mt-2 inline-flex items-center gap-1 rounded border border-border/10 bg-card/60 px-1.5 py-0.5 text-[11px]">
+        <div className="mt-2 inline-flex items-center gap-1 rounded-md border border-white/[0.08] bg-white/[0.02] px-1.5 py-0.5 text-[11px] text-muted-fg">
           <Stack size={12} weight="regular" />
-          {data.collapsedChildCount} children
+          {data.collapsedChildCount} children hidden
         </div>
       ) : null}
+
+      <div className="pointer-events-none mt-2 flex items-center justify-between border-t border-white/[0.05] pt-1.5 text-[9px] uppercase tracking-wide text-muted-fg/80">
+        <span>Click · menu</span>
+        <span>Double · lane</span>
+        <span>Drag · reparent</span>
+      </div>
+
       <Handle
         id="target"
         type="target"
@@ -164,7 +274,6 @@ export function GraphLaneNode({ data, selected }: NodeProps<Node<GraphNodeData>>
         position={Position.Bottom}
         style={{ width: 8, height: 8, opacity: 0, pointerEvents: "none", border: 0, background: "transparent" }}
       />
-      <div className="pointer-events-none absolute inset-0 rounded-xl opacity-0 transition-opacity duration-150 group-hover:opacity-100 group-hover:shadow-[0_2px_8px_rgba(0,0,0,0.2)]" />
     </div>
   );
 }
diff --git a/apps/desktop/src/renderer/components/graph/graphTypes.ts b/apps/desktop/src/renderer/components/graph/graphTypes.ts
index 409118a69..6c64738f6 100644
--- a/apps/desktop/src/renderer/components/graph/graphTypes.ts
+++ b/apps/desktop/src/renderer/components/graph/graphTypes.ts
@@ -25,6 +25,10 @@ export type GraphNodeData = {
   autoRebaseStatus: AutoRebaseLaneStatus | null;
   activeSessions: number;
   collapsedChildCount: number;
+  /** Steps from the workspace primary lane along parent links (0 = primary). */
+  hierarchyDepth: number;
+  /** Immediate parent lane name when parent exists in the workspace. */
+  parentLaneName: string | null;
   dimmed: boolean;
   activityBucket: "min" | "low" | "medium" | "high";
   viewMode: GraphViewMode;
diff --git a/docs/features/workspace-graph/README.md b/docs/features/workspace-graph/README.md
index 60393317b..91881a6f3 100644
--- a/docs/features/workspace-graph/README.md
+++ b/docs/features/workspace-graph/README.md
@@ -49,17 +49,38 @@ Lane topology (parent-child stack relationships)
 
 `GraphViewMode` — one of:
 
-| Mode | Label | Layout |
-|------|-------|--------|
-| `all` | Overview | Concentric rings around primary, split into core (environment-tagged) and others |
-| `stack` | Dependencies | Tree by stack depth, children arranged beneath parents |
-| `risk` | Conflict Risk | Circular layout, all lanes equidistant for cleaner overlap edges |
-| `activity` | Activity | Grid sorted by activity score (most active first) |
-
-`computeAutoLayout(lanes, viewMode, activityScoreByLaneId,
-environmentByLaneId)` returns positions for each lane id. User
-drags override auto-positions and persist in the session layout
-snapshot.
+| Mode | Label | What changes |
+|------|-------|--------------|
+| `all` | Overview | Primary-centric tree. Stack edges are shown; risk "overlap web" is hidden by default behind a "Show overlap web" toggle. |
+| `stack` | Dependencies | Same tree layout as Overview. Emphasis on parent-child stack edges; drag to reparent. |
+| `risk` | Conflict Risk | Same tree layout, risk edges always drawn between overlapping lanes. Matrix panel available for file-level detail. |
+| `activity` | Activity | Same row grid, but siblings within a row sort by activity score (high → low) before stack depth and name. |
+
+All view modes share a single primary-centric row layout. The
+primary lane sits at the top, each descendant appears on row
+`depth * Y_STEP` below it, and row members are spaced at
+`X_PITCH` centered horizontally. Lanes that can't be traced back
+to the workspace primary via parent links are bucketed into a
+single "orphan" row at the bottom (`depthByLaneId = 10_000`).
+
+Implementation:
+
+- `laneHierarchyFromPrimary(lanes)` returns
+  `{ primary: LaneSummary | null, depthByLaneId, parentNameByLaneId }`.
+  Returns an empty shape when `lanes` is empty — callers must
+  handle `primary: null` (this matters during project open/switch
+  when the lane list briefly empties out).
+- `layoutPrimaryCentricRows(lanes, activityScoreByLaneId, tieBreak)`
+  produces the actual positions. `tieBreak` is `"activity"` in
+  activity mode, `"stack"` everywhere else.
+- `computeAutoLayout(lanes, viewMode, activityScoreByLaneId, _environmentByLaneId)`
+  is the public entry point the page calls. The environment map
+  parameter is accepted for signature stability but no longer
+  influences layout — lanes aren't split into "core" vs "others"
+  any more.
+
+User drags override auto-positions and persist in the session
+layout snapshot per view mode.
 
 ## Persisted state
 
@@ -97,6 +118,10 @@ type GraphNodeData = {
   autoRebaseStatus: AutoRebaseLaneStatus | null;
   activeSessions: number;
   collapsedChildCount: number;
+  /** Steps from the workspace primary lane along parent links (0 = primary). */
+  hierarchyDepth: number;
+  /** Immediate parent lane name when parent exists in the workspace. */
+  parentLaneName: string | null;
   dimmed: boolean;
   activityBucket: "min" | "low" | "medium" | "high";
   viewMode: GraphViewMode;
@@ -117,9 +142,30 @@ type GraphNodeData = {
 };
 ```
 
-The `LaneNode` renderer chooses sync/PR badges entirely from this
-data — see `syncBadge` / `prBadge` IIFEs in
-`graphNodes/LaneNode.tsx`.
+`hierarchyDepth` and `parentLaneName` come from
+`laneHierarchyFromPrimary(lanes)` (memoized once per lane list as
+`primaryHierarchyMeta`) and are threaded into every lane node
+during derivation. Orphan lanes (not under primary) use the
+sentinel `10_000`; `LaneNode` treats anything `>= 1000` as an
+orphan and suppresses the depth badge.
+
+The `LaneNode` renderer:
+
+- Chooses sync/PR badges entirely from this data — see `syncBadge`
+  / `prBadge` IIFEs in `graphNodes/LaneNode.tsx`.
+- Renders a role-label chip top-right using lane terminology:
+  `"Primary lane"` for `laneType === "primary"`,
+  `"Attached lane"` for `"attached"`, and `"Lane"` for
+  `"worktree"`. Integration lanes get a distinctive purple
+  `Integration` badge instead.
+- Shows the custom `lane.icon` glyph when set; the primary lane
+  falls back to a `House` icon if no custom icon is configured.
+- Renders an `L{depth}` badge next to the branch ref
+  (`TreeStructure` icon) when the lane sits under primary. For
+  orphans, the badge is replaced with an amber "Not stacked under
+  the workspace primary" hint.
+- Renders a parent-lane breadcrumb ("On <parentName>") underneath
+  the header when `parentLaneName` is non-null.
 
 ## Edge data (`GraphEdgeData`)
 
@@ -140,6 +186,31 @@ type GraphEdgeData = {
 from `getPrEdgeColor` (PR-aware edges) or from the risk level
 palette (conflict edges). Stale edges render at reduced opacity.
 
+### Risk edges and the overview overlap web
+
+The page has a `showOverviewRiskEdges` boolean (toggled by the
+"Show overlap web" / "Hide overlap web" button in the filter bar,
+shown only when `viewMode === "all"`). It resets to `false` on
+any view-mode change.
+
+Risk edges render when:
+
+```
+viewMode === "risk"
+|| (viewMode === "all" && showOverviewRiskEdges)
+```
+
+Both the render pass and the `riskPairsWithVisibleEdge`
+population (used to decide whether PR overlays get their own edge
+or piggyback on an existing risk/stack edge) use this same gate,
+so PR overlays in Overview consistently stick to the visible
+topology/stack edge when the overlap web is hidden.
+
+In Overview, redundant "primary → lane" spokes are also
+suppressed when the lane already has a parent within the
+workspace — the stack edge chain already communicates the tree,
+so the extra spoke would just add clutter.
+
 ## Core interactions
 
 - **Pan/zoom** — React Flow default.
@@ -287,13 +358,16 @@ persistence on next save.
 
 ## Current product contract
 
-Per the design doc in `docs/features/WORKSPACE_GRAPH.md`:
-
-- Make topology visible first.
-- Stage non-essential overlays (risk, PR, sync) after first paint.
+- Make topology visible first: one shared primary-centric row
+  layout across Overview / Dependencies / Conflict Risk /
+  Activity so switching modes doesn't rearrange the canvas.
+- Stage non-essential overlays (risk, PR, sync) after first
+  paint.
+- Hide the overlap web by default in Overview — stack edges are
+  enough on their own; the overlap web is one click away.
 - Bound activity and polling work.
-- Avoid history-backed activity recompute on every terminal event;
-  use the live PTY signal instead.
+- Avoid history-backed activity recompute on every terminal
+  event; use the live PTY signal instead.
 - Keep risk, PR, and sync overlays fresh enough without constant
   churn.
 
@@ -318,10 +392,17 @@ sequence in detail.
 - **Refresh coalescing.** Direct `refresh*` calls bypass the
   in-flight guard; prefer `scheduleRefresh*` variants from the
   refresh-scheduling section.
-- **Node positions persist per view mode.** Switching modes can
-  show a dramatically different layout if the user has not yet
-  moved nodes in the new mode. Auto-layout runs when no persisted
-  positions exist.
+- **Node positions persist per view mode.** Every view mode
+  auto-layouts to the same primary-centric rows, so the canvas
+  stays stable when switching modes as long as the user hasn't
+  dragged nodes. Once the user drags in a given mode, that
+  mode's snapshot diverges and auto-layout stops applying until
+  "Reset View" clears it.
+- **`laneHierarchyFromPrimary` can return `primary: null`.** The
+  workspace briefly has zero lanes during project open/switch;
+  callers (layout, edge derivation, node data) must tolerate the
+  null primary rather than dereference it. Regression coverage
+  lives in `graphLayout.test.ts`.
 - **Integration lane nodes use distinctive styling** (purple
   gradient, dashed integration badge). `isIntegration` is set via
   `isIntegrationLaneFromMetadata(lane)` from
diff --git a/docs/features/workspace-graph/data-sources.md b/docs/features/workspace-graph/data-sources.md
index d585eeffe..0f0c6d62d 100644
--- a/docs/features/workspace-graph/data-sources.md
+++ b/docs/features/workspace-graph/data-sources.md
@@ -143,6 +143,12 @@ stored in the session snapshot and persisted via
 Several derived maps are memoized:
 
 - `laneById` — `Map<string, LaneSummary>` built from `lanes`.
+- `primaryHierarchyMeta` — `laneHierarchyFromPrimary(lanes)`;
+  returns `{ primary, depthByLaneId, parentNameByLaneId }`. Used
+  both by node data (hierarchyDepth / parentLaneName) and by
+  edge derivation (primary spokes, risk edges). Handles the
+  empty-lanes case by returning `primary: null` with empty maps
+  so derivation can short-circuit safely.
 - `overlapFilesByPair` — `Map<pairKey, string[]>` from
   `batch.overlaps`; used by `ConflictPanel`.
 - `integrationSourcesByLaneId` — built via
@@ -167,6 +173,8 @@ lane (from appStore.lanes)
   + environmentByLaneId[laneId] → node.environment
   + prByLaneId[laneId] → node.pr (via buildGraphPrOverlay)
   + integrationSourcesByLaneId[laneId] → node.integrationSources
+  + primaryHierarchyMeta.depthByLaneId[laneId] → node.hierarchyDepth
+  + primaryHierarchyMeta.parentNameByLaneId[laneId] → node.parentLaneName
   + collapsed state (session snapshot) → node.collapsedChildCount
   + current filters → node.dimmed / node.highlight
   + merge/rebase animation refs → rebasePulse, mergeInProgress, etc.
@@ -178,12 +186,23 @@ Topology edges:
 
 - For each lane with `parentLaneId`, emit a `stack` edge
   parent → child. Dimmed if either endpoint is filtered out.
+- In Overview + Dependencies modes, a "primary → lane" spoke is
+  emitted for lanes that have no workspace parent. Lanes that
+  already have a parent inside the workspace skip the spoke
+  (the stack-edge chain already communicates the tree).
 
 Risk edges:
 
 - For each non-zero `RiskMatrixEntry`, emit a `risk` edge between
   the two lanes with `riskLevel`, `overlapCount`, and `stale`
   metadata.
+- Render gating:
+  `viewMode === "risk" || (viewMode === "all" && showOverviewRiskEdges)`.
+  The `riskPairsWithVisibleEdge` set (used to let PR overlays
+  piggyback on an existing risk/stack edge) is populated with the
+  same gate, so PR overlays in Overview consistently stick to
+  the visible topology/stack edge when the overlap web is
+  hidden.
 
 Proposal edges:
 
@@ -219,7 +238,8 @@ rewrites on next save.
 | Create/delete lane | `refreshLanes`, re-run auto-layout for fresh node |
 | Apply AI proposal | `refreshRiskBatch`, `refreshLanes` |
 | Run merge simulation | No refresh (inline panel state only) |
-| Change view mode | Recompute auto-layout if positions missing |
+| Change view mode | Recompute auto-layout if positions missing; resets `showOverviewRiskEdges` to `false` |
+| Toggle "Show overlap web" (Overview only) | No IPC; local boolean drives risk-edge render gate |
 | Change filters | No refresh; local dimmed/highlight recalculation |
 | PR update event | `scheduleRefreshPrs()` |