@andespindola/brainlink 0.1.0-beta.127 → 0.1.0-beta.129

package/README.md

@@ -84,11 +84,11 @@ Legacy `.jsonl.gz` packs are upgraded to `.blpk` automatically on first search/c
 - Graph renderer optimized for large datasets with viewport-driven node culling and edge lookup by visible nodes.
 - Canvas graph rendering uses the same batched node and edge pipeline for every graph size, reducing per-frame draw calls while keeping selected and hovered items highlighted.
 - WebGL acceleration is used when available for dense node and edge drawing, with Canvas 2D preserved as the interaction and fallback layer.
-- Graph rendering keeps the flat node scene and adds stable hierarchical mesh groups for vaults above 1000 notes, with every visible graph level capped at 1000 nodes, the macro level projected as its own graph, and recursive parent groups when a level itself exceeds 1000 groups.
+- Graph rendering keeps the flat node scene and adds stable hierarchical mesh groups for vaults above 1000 notes, with every visible graph level filled toward 1000 nodes, each group capped at 1000 child nodes, and recursive parent groups when a level itself exceeds 1000 groups.
 - Large graph layout API automatically uses compact payload encoding with link-coverage-aware edge selection to reduce initial client load without hiding major relationships.
 - Large-segment layout spacing now grows logarithmically to keep initial visual density consistent between medium and very large vaults (for example, ~1k vs ~50k notes).
 - Graph coordinates are visually compacted across graph sizes so reset starts from a stable fitted scene and zoom-in progressively reveals local detail.
-- Zoomed-out graph LOD renders hierarchy groups as normal mesh graph nodes and expands a group from the focused node's current viewport position only after it is framed, progressively hiding sibling groups in micro view.
+- Zoomed-out graph LOD renders hierarchy groups as sparse relationship graph nodes and expands a group from the focused node's current viewport position only after it is framed, progressively hiding sibling groups in micro view.
 - Graph reset fits the full graph scene instead of starting in a separate macro overview mode.
 - Graph filtering runs in a dedicated browser worker to keep the UI thread responsive during heavy datasets.
 - Edge rendering budgets adapt to zoom level to prevent frame spikes on large graph panoramas.
@@ -606,7 +606,7 @@ The graph UI shows:
 - graph rendering safeguards (batched canvas drawing across graph sizes, edge draw caps, lower redraw rate, zoom-aware interaction)
 - adaptive CPU safeguards for large graphs: idle frame pacing, throttled background physics updates and cached viewport dimensions to reduce redraw/layout overhead while preserving interaction responsiveness
 - WebGL node and edge acceleration when supported, falling back to Canvas 2D without changing graph behavior
-- large graph LOD keeps a recursive graph-of-graphs mesh model: zoom-out shows one projected graph level capped at 1000 group nodes, zoom-in expands the framed node from its current viewport position into its own radial child graph capped at 1000 nodes, micro view renders only that focused subgraph with dense-node label suppression in a local frame anchored to the rendered group node, and zoom-out restores sibling groups
+- large graph LOD keeps a recursive graph-of-graphs model: zoom-out fills the projected macro level toward 1000 lightweight group nodes with sparse strongest-link edges, zoom-in expands the framed node from its current viewport position into its own radial child graph capped at 1000 nodes, micro view renders only that focused subgraph with dense-node label suppression in a local frame anchored to the rendered group node, and zoom-out restores sibling groups
 
 The server indexes before starting by default. Use `--no-index` to skip that step:
 

package/dist/application/frontend/client-js.js

@@ -22,9 +22,7 @@ const worldCoordinateLimit = 5_000_000
 const transformCoordinateLimit = 20_000_000
 const hoverHitTestIntervalMs = 64
 const zoomRecoveryGuardMs = 4200
-const meshEdgeScaleThreshold = 0.09
-const meshEdgeMinBudget = 140
-const meshEdgeMaxBudget = 1400
+const hierarchyGroupEdgeLimit = 900
 const dragNeighborhoodMaxAffected = 180
 const dragSettleRounds = 3
 const wheelZoomExponent = 0.0009
@@ -1360,6 +1358,33 @@ const groupWithCoverage = (group, viewport) => ({
   coverage: groupViewportCoverage(group, viewport)
 })
 
+const distanceToViewportCenter = (item, viewport) => {
+  const centerX = (viewport.minX + viewport.maxX) / 2
+  const centerY = (viewport.minY + viewport.maxY) / 2
+  return Math.hypot(item.x - centerX, item.y - centerY)
+}
+
+const selectViewportItemsWithFill = (items, viewport, limit = renderNodeBudget) => {
+  const visible = items.filter(item =>
+    item.x + item.radius >= viewport.minX &&
+    item.x - item.radius <= viewport.maxX &&
+    item.y + item.radius >= viewport.minY &&
+    item.y - item.radius <= viewport.maxY
+  )
+
+  if (visible.length >= limit) {
+    return visible.slice(0, limit)
+  }
+
+  const selectedIds = new Set(visible.map(item => item.id))
+  const fill = items
+    .filter(item => !selectedIds.has(item.id))
+    .sort((left, right) => distanceToViewportCenter(left, viewport) - distanceToViewportCenter(right, viewport) || left.id.localeCompare(right.id))
+    .slice(0, Math.max(0, limit - visible.length))
+
+  return visible.concat(fill)
+}
+
 const updateHierarchyFocusGroup = (groups, viewport) => {
   const current = state.hierarchyFocusGroupId
     ? groups.find(group => group.id === state.hierarchyFocusGroupId) ?? null
@@ -1442,7 +1467,20 @@ const groupEdgesForRenderedGroups = (groupNodes) => {
     })
   }
 
-  return Array.from(selected.values()).slice(0, edgeBudgetForCurrentFrame())
+  const degreeCounts = new Map()
+  return Array.from(selected.values())
+    .sort((left, right) => edgeWeight(right) - edgeWeight(left) || left.source.localeCompare(right.source) || left.target.localeCompare(right.target))
+    .filter((edge) => {
+      const sourceCount = degreeCounts.get(edge.source) ?? 0
+      const targetCount = degreeCounts.get(edge.target) ?? 0
+      if (sourceCount >= 3 || targetCount >= 3) {
+        return false
+      }
+      degreeCounts.set(edge.source, sourceCount + 1)
+      degreeCounts.set(edge.target, targetCount + 1)
+      return true
+    })
+    .slice(0, Math.min(hierarchyGroupEdgeLimit, edgeBudgetForCurrentFrame()))
 }
 
 const computeHierarchyRenderVisibility = (viewport) => {
@@ -1451,14 +1489,7 @@ const computeHierarchyRenderVisibility = (viewport) => {
     return false
   }
 
-  const groups = hierarchyGroupsForScale()
-    .filter(group =>
-      group.x + group.radius >= viewport.minX &&
-      group.x - group.radius <= viewport.maxX &&
-      group.y + group.radius >= viewport.minY &&
-      group.y - group.radius <= viewport.maxY
-    )
-    .slice(0, renderNodeBudget)
+  const groups = selectViewportItemsWithFill(hierarchyGroupsForScale(), viewport, renderNodeBudget)
   const focus = updateHierarchyFocusGroup(groups, viewport)
   const progress = focus ? hierarchyViewportProgress(focus, viewport) : 0
   const groupNodes = groups.map(createGroupRenderNode)
@@ -1497,121 +1528,8 @@ const computeHierarchyRenderVisibility = (viewport) => {
   return true
 }
 
-const edgePairKey = (source, target) =>
-  source < target ? source + '|' + target : target + '|' + source
-
-const meshNeighborBuckets = (nodes, cellSize) => {
-  const buckets = new Map()
-
-  for (let index = 0; index < nodes.length; index += 1) {
-    const node = nodes[index]
-    const cellX = Math.floor(node.x / cellSize)
-    const cellY = Math.floor(node.y / cellSize)
-    const key = cellX + ':' + cellY
-    const bucket = buckets.get(key)
-    if (bucket) {
-      bucket.push(node)
-    } else {
-      buckets.set(key, [node])
-    }
-  }
-
-  return buckets
-}
-
-const meshCandidatesForNode = (node, buckets, cellSize) => {
-  const cellX = Math.floor(node.x / cellSize)
-  const cellY = Math.floor(node.y / cellSize)
-  const candidates = []
-
-  for (let offsetX = -1; offsetX <= 1; offsetX += 1) {
-    for (let offsetY = -1; offsetY <= 1; offsetY += 1) {
-      const bucket = buckets.get((cellX + offsetX) + ':' + (cellY + offsetY))
-      if (!bucket) continue
-      for (let index = 0; index < bucket.length; index += 1) {
-        const candidate = bucket[index]
-        if (candidate.id !== node.id) {
-          candidates.push(candidate)
-        }
-      }
-    }
-  }
-
-  return candidates
-}
-
-const buildMeshEdgesForNodes = (nodes, existingEdges) => {
-  if (nodes.length < 2 || state.transform.scale < meshEdgeScaleThreshold) {
-    return []
-  }
-
-  const existingKeys = new Set()
-  for (let index = 0; index < existingEdges.length; index += 1) {
-    const edge = existingEdges[index]
-    if (edge.target) {
-      existingKeys.add(edgePairKey(edge.source, edge.target))
-    }
-  }
-
-  const desiredBudget = Math.min(
-    meshEdgeMaxBudget,
-    Math.max(meshEdgeMinBudget, Math.floor(edgeBudgetForCurrentFrame() * 0.62))
-  )
-  const perNodeNeighborCount =
-    state.transform.scale >= 1.05 ? 4
-      : state.transform.scale >= 0.62 ? 3
-        : 2
-  const cellSize = Math.max(120, 280 / Math.max(state.transform.scale, 0.0001))
-  const maxDistance = 980
-  const maxDistanceSquared = maxDistance * maxDistance
-  const buckets = meshNeighborBuckets(nodes, cellSize)
-  const meshEdges = []
-  const meshKeys = new Set()
-
-  for (let index = 0; index < nodes.length && meshEdges.length < desiredBudget; index += 1) {
-    const node = nodes[index]
-    const candidates = meshCandidatesForNode(node, buckets, cellSize)
-      .map((candidate) => ({
-        node: candidate,
-        distanceSquared: (candidate.x - node.x) ** 2 + (candidate.y - node.y) ** 2
-      }))
-      .filter((candidate) => candidate.distanceSquared <= maxDistanceSquared)
-      .sort((left, right) => left.distanceSquared - right.distanceSquared)
-
-    let linked = 0
-    for (let candidateIndex = 0; candidateIndex < candidates.length && linked < perNodeNeighborCount && meshEdges.length < desiredBudget; candidateIndex += 1) {
-      const candidate = candidates[candidateIndex].node
-      const key = edgePairKey(node.id, candidate.id)
-      if (existingKeys.has(key) || meshKeys.has(key)) {
-        continue
-      }
-
-      meshKeys.add(key)
-      meshEdges.push({
-        source: node.id,
-        target: candidate.id,
-        targetTitle: candidate.title,
-        weight: 1,
-        priority: 'normal',
-        sourceNode: node,
-        targetNode: candidate,
-        inferred: true
-      })
-      linked += 1
-    }
-  }
-
-  return meshEdges
-}
-
-const withMeshEdges = (nodes, edges) => {
-  const isHierarchyGraphLevel = state.groups.length > 0 && (state.visibleNodes.length > 1000 || state.hierarchyFocusGroupId)
-  if (nodes.length === 0 || !isHierarchyGraphLevel || state.transform.scale < meshEdgeScaleThreshold) {
-    return edges
-  }
-
-  const meshEdges = buildMeshEdgesForNodes(nodes, edges)
-  return meshEdges.length > 0 ? edges.concat(meshEdges) : edges
+const limitRenderEdges = (nodes, edges) => {
+  return edges
 }
 
 const fallbackViewportNodes = () => {
@@ -2598,7 +2516,7 @@ const computeRenderVisibility = () => {
   if (state.visibleNodes.length <= 2000) {
     state.renderNodes = state.visibleNodes
     const ids = new Set(state.renderNodes.map((node) => node.id))
-    state.renderEdges = withMeshEdges(state.renderNodes, collectVisibleEdgesForNodes(ids))
+    state.renderEdges = limitRenderEdges(state.renderNodes, collectVisibleEdgesForNodes(ids))
     return
   }
 
@@ -2608,7 +2526,7 @@ const computeRenderVisibility = () => {
       const overviewNodes = sampleMassiveOverviewNodes(sampleLimit)
       const overviewIds = new Set(overviewNodes.map((node) => node.id))
       state.renderNodes = overviewNodes
-      state.renderEdges = withMeshEdges(overviewNodes, collectVisibleEdgesForNodes(overviewIds))
+      state.renderEdges = limitRenderEdges(overviewNodes, collectVisibleEdgesForNodes(overviewIds))
       return
     }
 
@@ -2665,7 +2583,7 @@ const computeRenderVisibility = () => {
       sampledEdges = collectVisibleEdgesForNodes(sampledWithHubsIds)
     }
     state.renderNodes = sampledNodes
-    state.renderEdges = withMeshEdges(sampledNodes, sampledEdges)
+    state.renderEdges = limitRenderEdges(sampledNodes, sampledEdges)
     return
   }
 
@@ -2673,7 +2591,7 @@ const computeRenderVisibility = () => {
     const sampled = sampleVisibleNodes(Math.min(renderNodeBudget, 900))
     const sampledIds = new Set(sampled.map((node) => node.id))
     state.renderNodes = sampled
-    state.renderEdges = withMeshEdges(sampled, collectVisibleEdgesForNodes(sampledIds))
+    state.renderEdges = limitRenderEdges(sampled, collectVisibleEdgesForNodes(sampledIds))
     return
   }
 
@@ -2700,7 +2618,7 @@ const computeRenderVisibility = () => {
     const fallbackNodes = fallbackViewportNodes()
     const fallbackIds = new Set(fallbackNodes.map((node) => node.id))
     state.renderNodes = fallbackNodes
-    state.renderEdges = withMeshEdges(fallbackNodes, collectVisibleEdgesForNodes(fallbackIds))
+    state.renderEdges = limitRenderEdges(fallbackNodes, collectVisibleEdgesForNodes(fallbackIds))
     return
   }
 
@@ -2709,13 +2627,13 @@ const computeRenderVisibility = () => {
   const edges = collectVisibleEdgesForNodes(nodeIds)
 
   state.renderNodes = normalizedNodes
-  state.renderEdges = withMeshEdges(normalizedNodes, edges)
+  state.renderEdges = limitRenderEdges(normalizedNodes, edges)
 
   if (state.renderNodes.length === 0 && state.visibleNodes.length > 0) {
     const fallbackNodes = sampleVisibleNodes(Math.min(renderNodeBudget, 260))
     const fallbackIds = new Set(fallbackNodes.map((node) => node.id))
     state.renderNodes = fallbackNodes
-    state.renderEdges = withMeshEdges(fallbackNodes, collectVisibleEdgesForNodes(fallbackIds))
+    state.renderEdges = limitRenderEdges(fallbackNodes, collectVisibleEdgesForNodes(fallbackIds))
   }
 }
 

package/dist/application/get-graph-layout.js

@@ -4,12 +4,13 @@ import { dirname, join } from 'node:path';
 import { createCauliflowerGraphLayout } from '../domain/graph-layout.js';
 import { indexStoragePath } from '../infrastructure/file-index.js';
 import { getGraphSummary } from './get-graph-summary.js';
+const graphLayoutVersion = 2;
 const graphLayoutCache = new Map();
 const graphLayoutStoragePath = (vaultPath, agentId) => join(vaultPath, '.brainlink', `graph-layout-${agentId?.replace(/[^a-zA-Z0-9_-]/g, '_') ?? 'all'}.json`);
 const readPersistedLayout = async (vaultPath, databaseSignature, agentId) => {
     try {
         const parsed = JSON.parse(await readFile(graphLayoutStoragePath(vaultPath, agentId), 'utf8'));
-        return parsed.databaseSignature === databaseSignature ? parsed : null;
+        return parsed.databaseSignature === databaseSignature && parsed.layoutVersion === graphLayoutVersion ? parsed : null;
     }
     catch {
         return null;
@@ -44,7 +45,7 @@ export const getGraphLayout = async (vaultPath, agentId) => {
     const databaseSignature = await readDatabaseSignature(vaultPath);
     const cacheKey = `${vaultPath}:${agentId ?? ''}`;
     const cached = graphLayoutCache.get(cacheKey);
-    if (cached?.databaseSignature === databaseSignature) {
+    if (cached?.databaseSignature === databaseSignature && cached.layoutVersion === graphLayoutVersion) {
         return {
             signature: cached.signature,
             layout: cached.layout
@@ -65,7 +66,7 @@ export const getGraphLayout = async (vaultPath, agentId) => {
         ...rawLayout,
         nodes: rawLayout.nodes.map((node) => ({ ...node, content: '' }))
     };
-    const nextCache = { databaseSignature, signature, layout };
+    const nextCache = { layoutVersion: graphLayoutVersion, databaseSignature, signature, layout };
     graphLayoutCache.set(cacheKey, nextCache);
     await writePersistedLayout(vaultPath, agentId, nextCache);
     return {

package/dist/application/get-graph-view.js

@@ -2,8 +2,8 @@ import { getGraphLayout } from './get-graph-layout.js';
 const macroScale = 0.24;
 const microCoverage = 0.72;
 const nodeLimit = 1000;
-const edgeLimit = 5000;
-const meshEdgeLimit = 2500;
+const edgeLimit = 1400;
+const groupEdgeLimit = 900;
 const inViewport = (item, input) => {
     const radius = item.radius ?? 48;
     return (item.x + radius >= input.x &&
@@ -58,6 +58,23 @@ const arrangeGraphLevelGroups = (groups) => {
     });
     return arranged;
 };
+const distanceToViewportCenter = (item, input) => {
+    const centerX = input.x + input.width / 2;
+    const centerY = input.y + input.height / 2;
+    return Math.hypot(item.x - centerX, item.y - centerY);
+};
+const selectViewportItemsWithFill = (items, input, limit = nodeLimit) => {
+    const visible = items.filter((item) => inViewport(item, input));
+    if (visible.length >= limit) {
+        return visible.slice(0, limit);
+    }
+    const selectedIds = new Set(visible.map((item) => item.id));
+    const fill = items
+        .filter((item) => !selectedIds.has(item.id))
+        .sort((left, right) => distanceToViewportCenter(left, input) - distanceToViewportCenter(right, input) || left.id.localeCompare(right.id))
+        .slice(0, Math.max(0, limit - visible.length));
+    return visible.concat(fill);
+};
 const groupNode = (group) => [
     `group:${group.id}`,
     group.title,
@@ -101,7 +118,20 @@ const aggregateGroupEdges = (groups, edges, groupById) => {
             return;
         selected.set(key, [source, target, edge.weight, edge.priority]);
     });
-    return Array.from(selected.values()).slice(0, edgeLimit);
+    const degreeCounts = new Map();
+    return Array.from(selected.values())
+        .sort((left, right) => right[2] - left[2] || left[0].localeCompare(right[0]) || left[1].localeCompare(right[1]))
+        .filter((edge) => {
+        const sourceCount = degreeCounts.get(edge[0]) ?? 0;
+        const targetCount = degreeCounts.get(edge[1]) ?? 0;
+        if (sourceCount >= 3 || targetCount >= 3) {
+            return false;
+        }
+        degreeCounts.set(edge[0], sourceCount + 1);
+        degreeCounts.set(edge[1], targetCount + 1);
+        return true;
+    })
+        .slice(0, groupEdgeLimit);
 };
 const realEdges = (edges, nodeIds) => edges
     .filter((edge) => Boolean(edge.target && nodeIds.has(edge.source) && nodeIds.has(edge.target)))
@@ -148,31 +178,7 @@ const arrangeChildGraphNodes = (nodes, group, degrees) => {
     });
     return arranged;
 };
-const edgePairKey = (left, right) => left < right ? `${left}|${right}` : `${right}|${left}`;
-const meshEdges = (nodes, existingEdges) => {
-    if (nodes.length < 2) {
-        return [];
-    }
-    const existing = new Set(existingEdges.map((edge) => edgePairKey(edge[0], edge[1])));
-    const selected = [];
-    const selectedKeys = new Set();
-    const maxNeighbors = nodes.length > 500 ? 2 : 3;
-    const byX = [...nodes].sort((left, right) => left[2] - right[2] || left[3] - right[3] || left[0].localeCompare(right[0]));
-    for (let index = 0; index < nodes.length && selected.length < meshEdgeLimit; index += 1) {
-        const node = byX[index];
-        const candidates = byX.slice(index + 1, index + 1 + maxNeighbors);
-        candidates.forEach((candidate) => {
-            const key = edgePairKey(node[0], candidate[0]);
-            if (existing.has(key) || selectedKeys.has(key) || selected.length >= meshEdgeLimit) {
-                return;
-            }
-            selectedKeys.add(key);
-            selected.push([node[0], candidate[0], 1, 'low']);
-        });
-    }
-    return selected;
-};
-const withMeshEdges = (nodes, edges) => [...edges, ...meshEdges(nodes, edges)].slice(0, edgeLimit);
+const limitEdges = (edges) => edges.slice(0, edgeLimit);
 export const getGraphView = async (vaultPath, input) => {
     const { signature, layout } = await getGraphLayout(vaultPath, input.agentId);
     const groups = layout.groups ?? [];
@@ -186,7 +192,7 @@ export const getGraphView = async (vaultPath, input) => {
             signature,
             mode: 'flat',
             nodes: viewNodes,
-            edges: withMeshEdges(viewNodes, realEdges(layout.edges, nodeIds)),
+            edges: limitEdges(realEdges(layout.edges, nodeIds)),
             totals: {
                 nodes: layout.nodes.length,
                 edges: layout.edges.length
@@ -195,7 +201,7 @@ export const getGraphView = async (vaultPath, input) => {
     }
     const rootGroups = arrangeGraphLevelGroups(groups.filter((group) => group.parentId === null));
     const leafGroups = arrangeGraphLevelGroups(groups.filter((group) => group.nodeIds.length > 0));
-    const visibleGroups = rootGroups.filter((group) => inViewport(group, input));
+    const visibleGroups = selectViewportItemsWithFill(rootGroups, input);
     const focused = leafGroups
         .filter((group) => group.nodeIds.length > 0 && inViewport(group, input))
         .map((group) => ({ group, coverage: groupCoverage(group, input) }))
@@ -215,20 +221,20 @@ export const getGraphView = async (vaultPath, input) => {
             signature,
             mode: 'micro',
             nodes: viewNodes,
-            edges: withMeshEdges(viewNodes, realEdges(layout.edges, visibleNodeIds)),
+            edges: limitEdges(realEdges(layout.edges, visibleNodeIds)),
             totals: {
                 nodes: layout.nodes.length,
                 edges: layout.edges.length
             }
         };
     }
-    const groupsToRender = (visibleGroups.length > 0 ? visibleGroups : rootGroups).slice(0, nodeLimit);
+    const groupsToRender = visibleGroups.slice(0, nodeLimit);
     const viewNodes = groupsToRender.map(groupNode);
     return {
         signature,
         mode: 'macro',
         nodes: viewNodes,
-        edges: withMeshEdges(viewNodes, aggregateGroupEdges(groupsToRender, layout.edges, groupById)),
+        edges: limitEdges(aggregateGroupEdges(groupsToRender, layout.edges, groupById)),
         totals: {
             nodes: layout.nodes.length,
             edges: layout.edges.length

package/dist/domain/graph-layout.js

@@ -231,9 +231,13 @@ const chunkNodes = (nodes, degrees, groupNodeLimit = hierarchyGroupNodeLimit) =>
             return degreeDelta;
         return left.title.localeCompare(right.title);
     });
+    const groupCountTarget = Math.min(groupNodeLimit, sortedNodes.length);
+    const chunkSize = sortedNodes.length <= groupNodeLimit * groupNodeLimit
+        ? Math.max(1, Math.ceil(sortedNodes.length / groupCountTarget))
+        : groupNodeLimit;
     const chunks = [];
-    for (let index = 0; index < sortedNodes.length; index += groupNodeLimit) {
-        chunks.push(sortedNodes.slice(index, index + groupNodeLimit));
+    for (let index = 0; index < sortedNodes.length; index += chunkSize) {
+        chunks.push(sortedNodes.slice(index, index + chunkSize));
     }
     return chunks;
 };

package/docs/AGENT_USAGE.md

@@ -607,7 +607,7 @@ Without `--vault`, the graph UI serves `$HOME/.brainlink/vault`.
 
 The frontend includes an agent selector that shows only the agent id. Selecting an agent calls the same read APIs with `agent=<agent-id>` and renders that namespace instead of merging every agent into one graph.
 
-Graph navigation controls include zoom in, zoom out, fit visible nodes and reset-to-fit-all nodes. Mouse wheel zoom (including `cmd+scroll` and `ctrl+scroll`) is anchored to the cursor. Keyboard shortcuts are `+` (zoom in), `-` (zoom out) and `0` (reset fit). Double-click on canvas zooms in at cursor position. Totals for notes, links and tags stay visible as floating metrics under the Brainlink title, and node details open on click in a modal (tags, outgoing links, backlinks and Markdown content). Vaults above 1000 notes also expose stable hierarchy mesh groups of up to 1000 direct nodes, with recursive parent groups when a level exceeds 1000 groups; zoom-out renders the macro level as a projected mesh graph of group nodes, zoom-in expands a group from the focused node's current viewport position only after it is framed, and micro view renders only the focused radial child graph with dense-node label suppression in a local frame anchored to the rendered group node until zoom-out restores sibling groups.
+Graph navigation controls include zoom in, zoom out, fit visible nodes and reset-to-fit-all nodes. Mouse wheel zoom (including `cmd+scroll` and `ctrl+scroll`) is anchored to the cursor. Keyboard shortcuts are `+` (zoom in), `-` (zoom out) and `0` (reset fit). Double-click on canvas zooms in at cursor position. Totals for notes, links and tags stay visible as floating metrics under the Brainlink title, and node details open on click in a modal (tags, outgoing links, backlinks and Markdown content). Vaults above 1000 notes also expose stable hierarchy groups that fill each visible graph level toward 1000 nodes while keeping every group capped at 1000 child nodes; zoom-out renders the macro level as a sparse strongest-link graph of group nodes, zoom-in expands a group from the focused node's current viewport position only after it is framed, and micro view renders only the focused radial child graph with dense-node label suppression in a local frame anchored to the rendered group node until zoom-out restores sibling groups.
 During graph filtering, Brainlink keeps hub context nodes visible (`Memory Hub`/`MOC`/high-degree fallback) so filtered views still show relationship anchors.
 
 The command reindexes by default, then serves:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@andespindola/brainlink",
-  "version": "0.1.0-beta.127",
+  "version": "0.1.0-beta.129",
   "description": "Local-first knowledge memory for agents with Markdown, backlinks, indexing and context retrieval.",
   "type": "module",
   "license": "MIT",