aifastdb-devplan 1.6.1 → 1.6.2

package/dist/visualize/graph-canvas/core.js

@@ -73,6 +73,10 @@ function GraphCanvas(container, options) {
   this._idleFrames = 0;       // consecutive frames with nothing to draw
   this._idleThreshold = 30;   // sleep after N idle frames (~0.5s at 60fps)
 
+  // ── Interaction performance flags (T11.8) ──
+  this._isZooming = false;    // true during wheel zoom (edges hidden)
+  this._zoomTimer = null;     // debounce timer for zoom end
+
   // ── Event Callbacks ───────────────────────────────────────────────────
   this._eventHandlers = {};   // eventName → [callback, ...]
 
@@ -102,6 +106,8 @@ function GraphCanvas(container, options) {
     self._metrics.layoutProgress = 0;
     self._metrics.layoutAlgorithm = '';
     self._metrics.layoutEta = 0;
+    // T11.6: Arrange document mind maps after layout stabilizes
+    self._arrangeDocMindMaps();
     self.markDirty();
   });
 
@@ -266,14 +272,236 @@ GraphCanvas.prototype.setData = function(data) {
 };
 
 /**
- * Assign random initial positions for layout bootstrapping.
+ * Assign initial positions for layout bootstrapping.
+ * Uses structured hierarchical layout if typed nodes are available,
+ * otherwise falls back to Fibonacci spiral distribution.
  */
 GraphCanvas.prototype._assignRandomPositions = function() {
-  var spread = Math.sqrt(this._nodeCount) * 80;
+  // Try structured layout if we have DevPlan-typed nodes
+  if (this._hasDevPlanTypes()) {
+    this._assignStructuredPositions();
+    return;
+  }
+  // Fallback: Fibonacci spiral (better than pure random)
+  this._assignFibonacciPositions();
+};
+
+/**
+ * Check if nodes have DevPlan type annotations.
+ */
+GraphCanvas.prototype._hasDevPlanTypes = function() {
   for (var i = 0; i < this._nodes.length; i++) {
-    this._nodes[i].x = (Math.random() - 0.5) * spread;
-    this._nodes[i].y = (Math.random() - 0.5) * spread;
+    var t = this._nodes[i].type;
+    if (t === 'project' || t === 'module' || t === 'main-task') return true;
+  }
+  return false;
+};
+
+/**
+ * Fibonacci spiral distribution — evenly spaced initial positions.
+ * Better than random for force-directed convergence.
+ */
+GraphCanvas.prototype._assignFibonacciPositions = function() {
+  var n = this._nodes.length;
+  if (n === 0) return;
+  var goldenAngle = Math.PI * (3 - Math.sqrt(5)); // ~2.39996
+  var maxRadius = Math.sqrt(n) * 40;
+  for (var i = 0; i < n; i++) {
+    var theta = goldenAngle * i;
+    var r = Math.sqrt((i + 1) / n) * maxRadius;
+    this._nodes[i].x = Math.cos(theta) * r;
+    this._nodes[i].y = Math.sin(theta) * r;
+  }
+  this._spatialIndex.buildFromNodes(this._nodes);
+  this._spatialIndex.buildEdgeIndex(this._edges, this._nodeMap);
+};
+
+/**
+ * Structured hierarchical initial layout for DevPlan graphs.
+ *
+ * Strategy:
+ * - Project node at center (0,0)
+ * - Modules in first ring (R1)
+ * - Main tasks in second ring (R2), grouped near their parent module
+ * - Sub-tasks clustered near their parent main task with small jitter
+ * - Documents clustered near their related entity
+ *
+ * This gives the force-directed layout a MUCH better starting point
+ * compared to random positions, enabling fast convergence.
+ */
+GraphCanvas.prototype._assignStructuredPositions = function() {
+  var nodes = this._nodes;
+  var edges = this._edges;
+  var nodeCount = nodes.length;
+  if (nodeCount === 0) return;
+
+  // 1. Group nodes by type
+  var byType = { 'project': [], 'module': [], 'main-task': [], 'sub-task': [], 'document': [], 'other': [] };
+  for (var i = 0; i < nodeCount; i++) {
+    var type = nodes[i].type || 'other';
+    if (byType[type]) byType[type].push(nodes[i]);
+    else byType['other'].push(nodes[i]);
+  }
+
+  // 2. Build child→parent mapping (edges go from parent → child)
+  var childToParent = {};
+  for (var i = 0; i < edges.length; i++) {
+    // First edge wins as primary parent
+    if (!childToParent[edges[i].to]) {
+      childToParent[edges[i].to] = edges[i].from;
+    }
+  }
+
+  // 3. Build parent→children mapping
+  var parentToChildren = {};
+  for (var i = 0; i < edges.length; i++) {
+    if (!parentToChildren[edges[i].from]) parentToChildren[edges[i].from] = [];
+    parentToChildren[edges[i].from].push(edges[i].to);
+  }
+
+  // 4. Adaptive ring radii based on node counts
+  var moduleCount = byType['module'].length || 1;
+  var mainTaskCount = byType['main-task'].length || 1;
+  var R1 = Math.max(200, moduleCount * 60);                       // Module ring
+  var R2 = R1 + Math.max(250, mainTaskCount * 18);                 // Main-task ring
+  var R3 = R2 + 150;                                               // Sub-task/doc zone
+
+  // 5. Place project node at center
+  for (var i = 0; i < byType['project'].length; i++) {
+    byType['project'][i].x = 0;
+    byType['project'][i].y = 0;
+  }
+
+  // 6. Place modules in first ring (evenly spaced)
+  for (var i = 0; i < byType['module'].length; i++) {
+    var angle = (2 * Math.PI * i) / byType['module'].length - Math.PI / 2;
+    byType['module'][i].x = Math.cos(angle) * R1;
+    byType['module'][i].y = Math.sin(angle) * R1;
+  }
+
+  // 7. Place main tasks in second ring, grouped by parent module
+  var mainTasks = byType['main-task'];
+  var mainByParent = {};   // parentId → [mainTaskNode, ...]
+  var ungroupedMain = [];
+  for (var i = 0; i < mainTasks.length; i++) {
+    var parent = childToParent[mainTasks[i].id];
+    if (parent && this._nodeMap[parent]) {
+      if (!mainByParent[parent]) mainByParent[parent] = [];
+      mainByParent[parent].push(mainTasks[i]);
+    } else {
+      ungroupedMain.push(mainTasks[i]);
+    }
+  }
+
+  // Place grouped main tasks in fan around their parent's angle
+  var parentKeys = Object.keys(mainByParent);
+  var globalMainIdx = 0;
+  for (var p = 0; p < parentKeys.length; p++) {
+    var parentNode = this._nodeMap[parentKeys[p]];
+    var children = mainByParent[parentKeys[p]];
+    if (!parentNode) continue;
+
+    var pAngle = Math.atan2(parentNode.y || 0.001, parentNode.x || 0.001);
+    var fanSpread = Math.min(Math.PI * 0.6, children.length * 0.12);
+
+    for (var c = 0; c < children.length; c++) {
+      var childAngle = pAngle - fanSpread / 2 + (fanSpread * c) / Math.max(children.length - 1, 1);
+      var radius = R2 + (Math.random() - 0.5) * 60;
+      children[c].x = Math.cos(childAngle) * radius;
+      children[c].y = Math.sin(childAngle) * radius;
+      globalMainIdx++;
+    }
   }
+
+  // Place ungrouped main tasks evenly in remaining space
+  for (var i = 0; i < ungroupedMain.length; i++) {
+    var angle = (2 * Math.PI * (globalMainIdx + i)) / Math.max(mainTasks.length, 1) - Math.PI / 2;
+    ungroupedMain[i].x = Math.cos(angle) * R2;
+    ungroupedMain[i].y = Math.sin(angle) * R2;
+  }
+
+  // 8. Place sub-tasks near their parent main task
+  var subTasks = byType['sub-task'];
+  var subByParent = {};
+  var ungroupedSub = [];
+  for (var i = 0; i < subTasks.length; i++) {
+    var parent = childToParent[subTasks[i].id];
+    if (parent && this._nodeMap[parent]) {
+      if (!subByParent[parent]) subByParent[parent] = [];
+      subByParent[parent].push(subTasks[i]);
+    } else {
+      ungroupedSub.push(subTasks[i]);
+    }
+  }
+
+  // Place grouped sub-tasks in small cluster around parent
+  var subParentKeys = Object.keys(subByParent);
+  for (var sp = 0; sp < subParentKeys.length; sp++) {
+    var pNode = this._nodeMap[subParentKeys[sp]];
+    var subs = subByParent[subParentKeys[sp]];
+    if (!pNode) continue;
+
+    // Arrange in small ring around parent
+    var subRadius = Math.max(40, subs.length * 8);
+    for (var si = 0; si < subs.length; si++) {
+      var subAngle = (2 * Math.PI * si) / subs.length;
+      subs[si].x = pNode.x + Math.cos(subAngle) * subRadius;
+      subs[si].y = pNode.y + Math.sin(subAngle) * subRadius;
+    }
+  }
+
+  // Ungrouped sub-tasks in outer ring
+  for (var i = 0; i < ungroupedSub.length; i++) {
+    var angle = (2 * Math.PI * i) / Math.max(ungroupedSub.length, 1);
+    ungroupedSub[i].x = Math.cos(angle) * R3;
+    ungroupedSub[i].y = Math.sin(angle) * R3;
+  }
+
+  // 9. Place documents near their related entity
+  var docs = byType['document'];
+  var docByParent = {};
+  var ungroupedDoc = [];
+  for (var i = 0; i < docs.length; i++) {
+    var parent = childToParent[docs[i].id];
+    if (parent && this._nodeMap[parent]) {
+      if (!docByParent[parent]) docByParent[parent] = [];
+      docByParent[parent].push(docs[i]);
+    } else {
+      ungroupedDoc.push(docs[i]);
+    }
+  }
+
+  var docParentKeys = Object.keys(docByParent);
+  for (var dp = 0; dp < docParentKeys.length; dp++) {
+    var dParent = this._nodeMap[docParentKeys[dp]];
+    var docChildren = docByParent[docParentKeys[dp]];
+    if (!dParent) continue;
+
+    // Place documents in a horizontal line to the right of parent (mind-map style)
+    var vGap = 50;
+    var startY = dParent.y - ((docChildren.length - 1) * vGap) / 2;
+    for (var di = 0; di < docChildren.length; di++) {
+      docChildren[di].x = dParent.x + 120;
+      docChildren[di].y = startY + di * vGap;
+    }
+  }
+
+  // Ungrouped documents
+  for (var i = 0; i < ungroupedDoc.length; i++) {
+    var angle = (2 * Math.PI * i) / Math.max(ungroupedDoc.length, 1) + Math.PI / 6;
+    ungroupedDoc[i].x = Math.cos(angle) * (R3 + 100);
+    ungroupedDoc[i].y = Math.sin(angle) * (R3 + 100);
+  }
+
+  // 10. Place other/unknown type nodes
+  var others = byType['other'];
+  for (var i = 0; i < others.length; i++) {
+    var angle = (2 * Math.PI * i) / Math.max(others.length, 1);
+    others[i].x = Math.cos(angle) * (R3 + 200);
+    others[i].y = Math.sin(angle) * (R3 + 200);
+  }
+
+  // Rebuild spatial indices
   this._spatialIndex.buildFromNodes(this._nodes);
   this._spatialIndex.buildEdgeIndex(this._edges, this._nodeMap);
 };
@@ -826,6 +1054,70 @@ GraphCanvas.prototype.destroy = function() {
   this._eventHandlers = {};
 };
 
+// ── Document Mind-Map Arrangement (T11.6) ─────────────────────────────────
+
+/**
+ * Arrange parent-child document nodes in a horizontal mind-map layout.
+ * Called automatically after force-directed layout stabilizes.
+ */
+GraphCanvas.prototype._arrangeDocMindMaps = function() {
+  var nodes = this._nodes;
+  var edges = this._edges;
+  if (!nodes || nodes.length === 0) return;
+
+  // 1. Find all parent document nodes (have 'doc_has_child' outgoing edges)
+  var parentDocIds = {};  // parentId -> [childId, ...]
+  for (var i = 0; i < edges.length; i++) {
+    var e = edges[i];
+    if (e.label === 'doc_has_child' || e._label === 'doc_has_child') {
+      if (!parentDocIds[e.from]) parentDocIds[e.from] = [];
+      parentDocIds[e.from].push(e.to);
+    }
+  }
+
+  var parentKeys = Object.keys(parentDocIds);
+  if (parentKeys.length === 0) return;
+
+  var arranged = 0;
+  for (var pi = 0; pi < parentKeys.length; pi++) {
+    var parentId = parentKeys[pi];
+    var parentNode = this._nodeMap[parentId];
+    if (!parentNode) continue;
+
+    var childIds = parentDocIds[parentId];
+    // Filter to existing children
+    var validChildren = [];
+    for (var ci = 0; ci < childIds.length; ci++) {
+      if (this._nodeMap[childIds[ci]]) validChildren.push(childIds[ci]);
+    }
+    if (validChildren.length === 0) continue;
+
+    // 2. Compute layout: children to the right of parent, vertically centered
+    var parentR = parentNode._radius || 20;
+    var hGap = 40;  // horizontal gap from parent right edge
+    var vGap = 45;  // vertical gap between children
+    var leftEdgeX = parentNode.x + parentR + hGap;
+
+    var count = validChildren.length;
+    var totalHeight = (count - 1) * vGap;
+    var startY = parentNode.y - totalHeight / 2;
+
+    for (var j = 0; j < count; j++) {
+      var childNode = this._nodeMap[validChildren[j]];
+      if (!childNode) continue;
+      var childR = childNode._radius || 15;
+      var cx = leftEdgeX + childR;
+      var cy = startY + j * vGap;
+      this.moveNode(validChildren[j], cx, cy);
+    }
+    arranged++;
+  }
+
+  if (arranged > 0) {
+    this._emit('docMindMapsArranged', { count: arranged });
+  }
+};
+
 /**
  * Convert screen coordinates to world coordinates.
  */

package/dist/visualize/graph-canvas/core.js.map

@@ -1 +1 @@
-{"version":3,"file":"core.js","sourceRoot":"","sources":["../../../src/visualize/graph-canvas/core.ts"],"names":[],"mappings":";AAAA;;;;;;;;GAQG;;AAEH,sCA8zBC;AA9zBD,SAAgB,aAAa;IAC3B,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4zBR,CAAC;AACF,CAAC"}
+{"version":3,"file":"core.js","sourceRoot":"","sources":["../../../src/visualize/graph-canvas/core.ts"],"names":[],"mappings":";AAAA;;;;;;;;GAQG;;AAEH,sCAkmCC;AAlmCD,SAAgB,aAAa;IAC3B,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgmCR,CAAC;AACF,CAAC"}

package/dist/visualize/graph-canvas/interaction.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"interaction.d.ts","sourceRoot":"","sources":["../../../src/visualize/graph-canvas/interaction.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,wBAAgB,oBAAoB,IAAI,MAAM,CA8a7C"}
+{"version":3,"file":"interaction.d.ts","sourceRoot":"","sources":["../../../src/visualize/graph-canvas/interaction.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,wBAAgB,oBAAoB,IAAI,MAAM,CAyb7C"}

package/dist/visualize/graph-canvas/interaction.js

@@ -250,6 +250,17 @@ InteractionManager.prototype._hitTest = function(sx, sy) {
 // ── Hover ─────────────────────────────────────────────────────────────────
 
 InteractionManager.prototype._handleHover = function(sx, sy) {
+  // T11.9: Skip hover detection for large graphs (>800 nodes) to save CPU
+  if (this._engine._nodeCount > 800) {
+    if (this._hoveredNode) {
+      this._hoveredNode._hovered = false;
+      this._engine.markDirtyNode(this._hoveredNode);
+      this._hoveredNode = null;
+      this._engine._canvas.style.cursor = 'default';
+    }
+    return;
+  }
+
   var hitNode = this._hitTest(sx, sy);
   var prevHovered = this._hoveredNode;
 

package/dist/visualize/graph-canvas/interaction.js.map

@@ -1 +1 @@
-{"version":3,"file":"interaction.js","sourceRoot":"","sources":["../../../src/visualize/graph-canvas/interaction.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;GAUG;;AAEH,oDA8aC;AA9aD,SAAgB,oBAAoB;IAClC,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4aR,CAAC;AACF,CAAC"}
+{"version":3,"file":"interaction.js","sourceRoot":"","sources":["../../../src/visualize/graph-canvas/interaction.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;GAUG;;AAEH,oDAybC;AAzbD,SAAgB,oBAAoB;IAClC,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAubR,CAAC;AACF,CAAC"}

package/dist/visualize/graph-canvas/layout-worker.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"layout-worker.d.ts","sourceRoot":"","sources":["../../../src/visualize/graph-canvas/layout-worker.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,wBAAgB,qBAAqB,IAAI,MAAM,CAygB9C"}
+{"version":3,"file":"layout-worker.d.ts","sourceRoot":"","sources":["../../../src/visualize/graph-canvas/layout-worker.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,wBAAgB,qBAAqB,IAAI,MAAM,CA6iB9C"}

package/dist/visualize/graph-canvas/layout-worker.js

@@ -41,7 +41,8 @@ function LayoutEngine(engine) {
     batchSize: 10,        // iterations per message
     idealEdgeLength: 120,
     theta: 0.8,           // Barnes-Hut approximation parameter
-    earlyTerminationThreshold: 0.5, // stop when energy below this
+    earlyTerminationThreshold: 0.3, // stop when energy below this (lowered for better convergence)
+    avoidOverlap: 0.8,    // overlap avoidance strength (0=off, 1=full)
   };
 }
 
@@ -63,17 +64,21 @@ LayoutEngine.prototype.start = function(options) {
   var edges = engine._edges;
 
   // Auto-select algorithm based on node count
-  var useBarnesHut = nodes.length > 1000;
+  var useBarnesHut = nodes.length > 500; // Lower threshold: BH is better for 500+ nodes
   opts.useBarnesHut = useBarnesHut;
 
-  // Adapt max iterations for large graphs
-  if (nodes.length > 5000) {
-    opts.maxIterations = Math.min(opts.maxIterations, 150);
-    opts.batchSize = 5;
-  } else if (nodes.length > 10000) {
-    opts.maxIterations = Math.min(opts.maxIterations, 80);
+  // Adapt max iterations based on graph size
+  if (nodes.length > 10000) {
+    opts.maxIterations = Math.min(opts.maxIterations, 100);
     opts.batchSize = 3;
+  } else if (nodes.length > 5000) {
+    opts.maxIterations = Math.min(opts.maxIterations, 200);
+    opts.batchSize = 5;
+  } else if (nodes.length > 2000) {
+    opts.maxIterations = Math.min(opts.maxIterations, 300);
+    opts.batchSize = 8;
   }
+  // For medium graphs (<2000), keep higher iteration count for quality
   this._maxIterations = opts.maxIterations;
 
   // Prepare node/edge data for worker
@@ -393,7 +398,8 @@ LayoutEngine.prototype._getWorkerCode = function() {
       var damping = options.damping || 0.4;
       var theta = options.theta || 0.8;
       var useBarnesHut = options.useBarnesHut || false;
-      var earlyTermThreshold = options.earlyTerminationThreshold || 0.5;
+      var earlyTermThreshold = options.earlyTerminationThreshold || 0.3;
+      var avoidOverlap = options.avoidOverlap || 0.8;
       var algorithm = useBarnesHut ? 'barnes-hut' : 'fruchterman-reingold';
 
       // Track energy for early termination
@@ -465,6 +471,36 @@ LayoutEngine.prototype._getWorkerCode = function() {
             nodes[i].fy -= nodes[i].y * gravity;
           }
 
+          // ── Overlap avoidance ──
+          // For Barnes-Hut mode, only check within local neighborhood (using spatial hash)
+          if (avoidOverlap > 0) {
+            if (!useBarnesHut || nodes.length < 2000) {
+              // O(n²) check — acceptable for <2000 nodes
+              for (var i = 0; i < nodes.length; i++) {
+                var ri = (nodes[i].radius || 10);
+                for (var j = i + 1; j < nodes.length; j++) {
+                  var rj = (nodes[j].radius || 10);
+                  var minDist = (ri + rj) * avoidOverlap * 1.5;
+                  var odx = nodes[j].x - nodes[i].x;
+                  var ody = nodes[j].y - nodes[i].y;
+                  var oDist = Math.sqrt(odx * odx + ody * ody);
+                  if (oDist < minDist && oDist > 0.1) {
+                    var pushForce = (minDist - oDist) * 0.3 * temperature;
+                    var opx = (odx / oDist) * pushForce;
+                    var opy = (ody / oDist) * pushForce;
+                    nodes[i].fx -= opx;
+                    nodes[i].fy -= opy;
+                    nodes[j].fx += opx;
+                    nodes[j].fy += opy;
+                  }
+                }
+              }
+            } else {
+              // For very large graphs, skip full O(n²) overlap check
+              // The repulsion force from Barnes-Hut already separates nodes reasonably
+            }
+          }
+
           // ── Apply forces with damping and temperature ──
           totalEnergy = 0;
           for (var i = 0; i < nodes.length; i++) {

package/dist/visualize/graph-canvas/layout-worker.js.map

@@ -1 +1 @@
-{"version":3,"file":"layout-worker.js","sourceRoot":"","sources":["../../../src/visualize/graph-canvas/layout-worker.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;GAcG;;AAEH,sDAygBC;AAzgBD,SAAgB,qBAAqB;IACnC,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAugBR,CAAC;AACF,CAAC"}
+{"version":3,"file":"layout-worker.js","sourceRoot":"","sources":["../../../src/visualize/graph-canvas/layout-worker.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;GAcG;;AAEH,sDA6iBC;AA7iBD,SAAgB,qBAAqB;IACnC,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2iBR,CAAC;AACF,CAAC"}

package/dist/visualize/graph-canvas/renderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../../src/visualize/graph-canvas/renderer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,wBAAgB,iBAAiB,IAAI,MAAM,CA2pB1C"}
+{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../../src/visualize/graph-canvas/renderer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,wBAAgB,iBAAiB,IAAI,MAAM,CA8xB1C"}