@andespindola/brainlink 0.1.0-beta.153 → 0.1.0-beta.155

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

@@ -16,6 +16,7 @@ const state = {
   radius: new Float32Array(0),
   visible: new Uint8Array(0),
   highlighted: new Uint8Array(0),
+  focused: new Uint8Array(0),
   selected: new Uint8Array(0),
   edgeSource: new Uint32Array(0),
   edgeTarget: new Uint32Array(0),
@@ -23,6 +24,7 @@ const state = {
 }
 const nodeIndexById = new Map()
 const highlightedIds = new Set()
+const focusedIds = new Set()
 let selectedNodeId = null
 let dirty = true
 let renderScheduled = false
@@ -179,6 +181,7 @@ const ensureNodeCapacity = (count) => {
   state.radius = new Float32Array(nextCapacity)
   state.visible = new Uint8Array(nextCapacity)
   state.highlighted = new Uint8Array(nextCapacity)
+  state.focused = new Uint8Array(nextCapacity)
   state.selected = new Uint8Array(nextCapacity)
 }
 
@@ -230,6 +233,7 @@ const loadChunk = (chunk) => {
     state.radius[index] = nodeRadius(relevance, kind)
     state.visible[index] = 0
     state.highlighted[index] = highlightedIds.has(id) ? 1 : 0
+    state.focused[index] = focusedIds.has(id) ? 1 : 0
     state.selected[index] = selectedNodeId === id ? 1 : 0
     nodeIndexById.set(id, index)
   }
@@ -390,6 +394,12 @@ const renderFrame = (now) => {
     1.22
   )
 
+  drawNodeLayer(
+    (index) => state.visible[index] === 1 && state.focused[index] === 1,
+    theme.nodeHighlight,
+    1.12
+  )
+
   drawNodeLayer(
     (index) => state.visible[index] === 1 && state.selected[index] === 1,
     theme.nodeSelected,
@@ -489,6 +499,23 @@ const setHighlights = (ids) => {
   requestRender()
 }
 
+const setFocus = (ids) => {
+  focusedIds.clear()
+  const list = Array.isArray(ids) ? ids : []
+  for (let index = 0; index < list.length; index += 1) {
+    const id = list[index]
+    if (typeof id === 'string' && id.length > 0) {
+      focusedIds.add(id)
+    }
+  }
+
+  for (let index = 0; index < state.nodeCount; index += 1) {
+    state.focused[index] = focusedIds.has(state.ids[index]) ? 1 : 0
+  }
+  dirty = true
+  requestRender()
+}
+
 const setSelected = (id) => {
   selectedNodeId = typeof id === 'string' && id.length > 0 ? id : null
   for (let index = 0; index < state.nodeCount; index += 1) {
@@ -498,6 +525,22 @@ const setSelected = (id) => {
   requestRender()
 }
 
+const moveNode = (id, x, y) => {
+  if (typeof id !== 'string' || !Number.isFinite(x) || !Number.isFinite(y)) {
+    return
+  }
+
+  const index = nodeIndexById.get(id)
+  if (index === undefined) {
+    return
+  }
+
+  state.x[index] = x
+  state.y[index] = y
+  dirty = true
+  requestRender()
+}
+
 self.onmessage = (event) => {
   const payload = event.data
   if (!payload || typeof payload !== 'object') {
@@ -542,11 +585,21 @@ self.onmessage = (event) => {
     return
   }
 
+  if (payload.type === 'focus') {
+    setFocus(payload.ids)
+    return
+  }
+
   if (payload.type === 'select') {
     setSelected(payload.id)
     return
   }
 
+  if (payload.type === 'move-node') {
+    moveNode(payload.id, Number(payload.x), Number(payload.y))
+    return
+  }
+
   if (payload.type === 'pick') {
     const node = pickNode(
       Number.isFinite(payload.x) ? Number(payload.x) : 0,

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

@@ -1,10 +1,11 @@
 import { createHash } from 'node:crypto';
 import { mkdir, readFile, rename, stat, writeFile } from 'node:fs/promises';
 import { dirname, join } from 'node:path';
+import { addVisualContextEdges } from '../domain/graph-contexts.js';
 import { createStarGraphLayout } from '../domain/graph-layout.js';
 import { indexStoragePath } from '../infrastructure/file-index.js';
 import { getGraphSummary } from './get-graph-summary.js';
-const graphLayoutVersion = 4;
+const graphLayoutVersion = 6;
 const graphLayoutCache = new Map();
 const safeCacheSegment = (value, fallback) => value?.replace(/[^a-zA-Z0-9_-]/g, '_') || fallback;
 const graphLayoutStoragePath = (vaultPath, options) => {
@@ -82,7 +83,7 @@ export const getGraphLayout = async (vaultPath, optionsOrAgentId) => {
             layout: persisted.layout
         };
     }
-    const graph = await getGraphSummary(vaultPath, options.agentId);
+    const graph = addVisualContextEdges(await getGraphSummary(vaultPath, options.agentId));
     const scopedGraph = options.context ? filterGraphByContext(graph, options.context) : graph;
     const signature = createGraphSignature(scopedGraph);
     const layout = createLayout(scopedGraph);

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

@@ -0,0 +1,66 @@
+import { mkdir, readFile, rename, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+const stateVersion = 1;
+const graphViewStatePath = (vaultPath) => join(vaultPath, '.brainlink', 'graph-view-state.json');
+const stateKey = (input) => [input.signature, input.agentId ?? 'all-agents', input.context ?? 'all-contexts'].join(':');
+const emptyPersistedState = () => ({
+    version: stateVersion,
+    states: {}
+});
+const readPersistedState = async (vaultPath) => {
+    try {
+        const parsed = JSON.parse(await readFile(graphViewStatePath(vaultPath), 'utf8'));
+        return parsed.version === stateVersion && parsed.states && typeof parsed.states === 'object' ? parsed : emptyPersistedState();
+    }
+    catch {
+        return emptyPersistedState();
+    }
+};
+const writePersistedState = async (vaultPath, state) => {
+    const target = graphViewStatePath(vaultPath);
+    const temp = `${target}.tmp`;
+    await mkdir(dirname(target), { recursive: true, mode: 0o700 });
+    await writeFile(temp, `${JSON.stringify(state)}\n`, { encoding: 'utf8', mode: 0o600 });
+    await rename(temp, target);
+};
+const normalizePositions = (positions) => positions.flatMap((position) => {
+    const id = typeof position.id === 'string' ? position.id.trim() : '';
+    const x = Number(position.x);
+    const y = Number(position.y);
+    return id && Number.isFinite(x) && Number.isFinite(y) ? [{ id, x, y }] : [];
+});
+export const getGraphViewState = async (vaultPath, input) => {
+    const persisted = await readPersistedState(vaultPath);
+    const state = persisted.states[stateKey(input)];
+    return state ?? {
+        ...input,
+        positions: []
+    };
+};
+export const saveGraphViewState = async (vaultPath, input) => {
+    const persisted = await readPersistedState(vaultPath);
+    const nextState = {
+        ...input,
+        positions: normalizePositions(input.positions)
+    };
+    await writePersistedState(vaultPath, {
+        version: stateVersion,
+        states: {
+            ...persisted.states,
+            [stateKey(input)]: nextState
+        }
+    });
+    return nextState;
+};
+export const deleteGraphViewState = async (vaultPath, input) => {
+    const persisted = await readPersistedState(vaultPath);
+    const { [stateKey(input)]: _removed, ...states } = persisted.states;
+    await writePersistedState(vaultPath, {
+        version: stateVersion,
+        states
+    });
+    return {
+        ...input,
+        positions: []
+    };
+};

package/dist/application/search-graph-node-ids.js

@@ -1,6 +1,7 @@
 import { stat } from 'node:fs/promises';
 import { ensureVault } from '../infrastructure/file-system-vault.js';
 import { indexStoragePath, openFileIndex } from '../infrastructure/file-index.js';
+import { getGraphLayout } from './get-graph-layout.js';
 const graphSearchCacheTtlMs = 20_000;
 const graphSearchCacheMaxEntries = 120;
 const graphSearchCache = new Map();
@@ -13,11 +14,12 @@ const readIndexSignature = async (vaultPath) => {
         return '0:0';
     }
 };
-const cacheKey = (vaultPath, query, limit, agentId) => JSON.stringify({
+const cacheKey = (vaultPath, query, limit, agentId, context) => JSON.stringify({
     vaultPath,
     query: query.trim().toLowerCase(),
     limit,
-    agentId: agentId?.trim().toLowerCase() ?? '*'
+    agentId: agentId?.trim().toLowerCase() ?? '*',
+    context: context?.trim().toLowerCase() ?? '*'
 });
 const readCached = (key, indexSignature) => {
     const entry = graphSearchCache.get(key);
@@ -39,17 +41,24 @@ const writeCached = (key, entry) => {
     const overflow = graphSearchCache.size - graphSearchCacheMaxEntries;
     Array.from(graphSearchCache.keys()).slice(0, overflow).forEach((cacheKey) => graphSearchCache.delete(cacheKey));
 };
-export const searchGraphNodeIds = async (vaultPath, query, limit, agentId) => {
+export const searchGraphNodeIds = async (vaultPath, query, limit, agentId, context) => {
     const absoluteVaultPath = await ensureVault(vaultPath);
     const indexSignature = await readIndexSignature(absoluteVaultPath);
-    const key = cacheKey(absoluteVaultPath, query, limit, agentId);
+    const key = cacheKey(absoluteVaultPath, query, limit, agentId, context);
     const cached = readCached(key, indexSignature);
     if (cached) {
         return cached;
     }
+    const contextNodeIds = context
+        ? new Set((await getGraphLayout(absoluteVaultPath, { agentId, context })).layout.nodes.map((node) => node.id))
+        : new Set();
     const index = openFileIndex(absoluteVaultPath);
     try {
-        const nodeIds = await index.searchGraphNodeIds(query, limit, agentId);
+        const searchLimit = context ? Math.max(limit, 5000) : limit;
+        const foundNodeIds = await index.searchGraphNodeIds(query, searchLimit, agentId);
+        const nodeIds = context
+            ? foundNodeIds.filter((nodeId) => contextNodeIds.has(nodeId)).slice(0, limit)
+            : foundNodeIds;
         writeCached(key, {
             createdAt: Date.now(),
             indexSignature,

package/dist/application/server/routes.js

@@ -6,6 +6,7 @@ import { getGraphNode } from '../get-graph-node.js';
 import { getGraphLayout } from '../get-graph-layout.js';
 import { getGraphView } from '../get-graph-view.js';
 import { getGraphStreamChunk } from '../get-graph-stream-chunk.js';
+import { deleteGraphViewState, getGraphViewState, saveGraphViewState } from '../graph-view-state.js';
 import { listAgents } from '../list-agents.js';
 import { listBacklinks, listLinks } from '../list-links.js';
 import { searchGraphNodeIds } from '../search-graph-node-ids.js';
@@ -64,6 +65,21 @@ const parseNumber = (value, fallback) => {
     const parsed = Number(value);
     return Number.isFinite(parsed) ? parsed : fallback;
 };
+const readJsonBody = async (request, limitBytes = 1_000_000) => {
+    let body = '';
+    for await (const chunk of request) {
+        body += String(chunk);
+        if (Buffer.byteLength(body, 'utf8') > limitBytes) {
+            throw Object.assign(new Error('Request body too large'), { statusCode: 413 });
+        }
+    }
+    return body.trim().length > 0 ? JSON.parse(body) : {};
+};
+const readGraphViewStateInput = (url) => ({
+    signature: url.searchParams.get('signature')?.trim() ?? '',
+    agentId: readAgentQuery(url),
+    context: readContextQuery(url)
+});
 const compactGraphLayoutThreshold = 12_000;
 const compactGraphLayoutEdgeLimit = 60_000;
 const graphLayoutBodyCacheLimit = 8;
@@ -285,6 +301,35 @@ export const route = async (request, url, vaultPath) => {
             context: readContextQuery(url)
         })), 200, contentTypes['.json']);
     }
+    if (isReadMethod(request) && url.pathname === '/api/graph-view-state') {
+        const input = readGraphViewStateInput(url);
+        if (!input.signature) {
+            return createResponse(createJsonResponse({ error: 'Missing signature query parameter' }), 400, contentTypes['.json']);
+        }
+        return createResponse(createJsonResponse(await getGraphViewState(vaultPath, input)), 200, contentTypes['.json']);
+    }
+    if (request.method === 'POST' && url.pathname === '/api/graph-view-state') {
+        const input = readGraphViewStateInput(url);
+        if (!input.signature) {
+            return createResponse(createJsonResponse({ error: 'Missing signature query parameter' }), 400, contentTypes['.json']);
+        }
+        const body = await readJsonBody(request);
+        const positions = Array.isArray(body.positions)
+            ? body.positions.map((position) => ({
+                id: String(position.id ?? ''),
+                x: Number(position.x),
+                y: Number(position.y)
+            }))
+            : [];
+        return createResponse(createJsonResponse(await saveGraphViewState(vaultPath, { ...input, positions })), 200, contentTypes['.json']);
+    }
+    if (request.method === 'DELETE' && url.pathname === '/api/graph-view-state') {
+        const input = readGraphViewStateInput(url);
+        if (!input.signature) {
+            return createResponse(createJsonResponse({ error: 'Missing signature query parameter' }), 400, contentTypes['.json']);
+        }
+        return createResponse(createJsonResponse(await deleteGraphViewState(vaultPath, input)), 200, contentTypes['.json']);
+    }
     if (isReadMethod(request) && url.pathname === '/api/graph-node') {
         const id = url.searchParams.get('id')?.trim() ?? '';
         if (!id) {
@@ -302,7 +347,7 @@ export const route = async (request, url, vaultPath) => {
         if (!query) {
             return createResponse(createJsonResponse({ query, nodeIds: [] }), 200, contentTypes['.json']);
         }
-        const nodeIds = await searchGraphNodeIds(vaultPath, query, limit, readAgentQuery(url));
+        const nodeIds = await searchGraphNodeIds(vaultPath, query, limit, readAgentQuery(url), readContextQuery(url));
         return createResponse(createJsonResponse({ query, nodeIds }), 200, contentTypes['.json']);
     }
     if (isReadMethod(request) && url.pathname === '/api/agents') {

package/dist/cli/commands/write-commands.js

@@ -9,6 +9,7 @@ import { resolveDuplicateNotes, scanDuplicateNotes } from '../../application/ded
 import { importLegacySqliteDatabase } from '../../application/import-legacy-sqlite.js';
 import { indexVault, indexVaultWithOptions } from '../../application/index-vault.js';
 import { migrateContextLinks } from '../../application/migrate-context-links.js';
+import { canonicalizeContextLinks } from '../../application/canonical-context-links.js';
 import { migrateVaultContent, planVaultMigration, previewVaultMigration, shouldMigrateDefaultVault } from '../../application/migrate-vault.js';
 import { createOfflinePackBackup } from '../../application/offline-pack-backup.js';
 import { startServer } from '../../application/start-server.js';
@@ -16,7 +17,7 @@ import { startVaultWatcher } from '../../application/watch-vault.js';
 import { doctorVault, getStats, validateVault } from '../../application/analyze-vault.js';
 import { defaultBrainlinkConfig, sanitizeSearchMode } from '../../infrastructure/config.js';
 import { loadBrainlinkConfig } from '../../infrastructure/config.js';
-import { assertVaultAllowed, ensureVault } from '../../infrastructure/file-system-vault.js';
+import { assertVaultAllowed, ensureVault, isBucketVaultPath } from '../../infrastructure/file-system-vault.js';
 import { getBootstrapPolicy, getBootstrapSessionStatus, touchBootstrapSession } from '../../infrastructure/session-state.js';
 import { addVolatileMemory, clearVolatileMemory } from '../../infrastructure/volatile-memory.js';
 import { installAgentIntegration } from './agent-commands.js';
@@ -731,6 +732,37 @@ export const registerWriteCommands = (program) => {
             return `${mode} ${result.scanned} notes: changed=${result.changed}, skipped=${result.skipped}, limit=${result.limit}.${indexMessage}`;
         });
     });
+    program
+        .command('canonicalize-context-links')
+        .option('-v, --vault <vault>', 'vault directory')
+        .option('-a, --agent <agent>', 'agent memory namespace')
+        .option('--dry-run', 'preview canonical context links without writing files')
+        .option('--no-create-hubs', 'do not create missing context hub notes')
+        .option('--no-index', 'skip reindexing after canonicalization')
+        .option('--json', 'print machine-readable JSON')
+        .description('ensure notes have canonical Context Links to their inferred context hubs')
+        .action(async (options) => {
+        const resolved = await resolveOptions(options);
+        const result = await canonicalizeContextLinks(resolved.vault, {
+            dryRun: options.dryRun === true,
+            agentId: resolved.agent,
+            createMissingHubs: options.createHubs !== false
+        });
+        const shouldIndex = options.index !== false && !result.dryRun && result.changed > 0;
+        const index = shouldIndex ? await indexVault(resolved.vault, { full: true }) : undefined;
+        print(options.json, {
+            vault: resolved.vault,
+            agent: resolved.agent ?? 'shared',
+            ...result,
+            ...(index ? { index } : {})
+        }, () => {
+            const mode = result.dryRun ? 'Previewed' : 'Canonicalized';
+            const indexMessage = index
+                ? ` Fully reindexed ${index.documentCount} documents, ${index.chunkCount} chunks and ${index.linkCount} context links.`
+                : '';
+            return `${mode} ${result.scanned} notes: changed=${result.changed}, createdHubs=${result.createdHubs}, skipped=${result.skipped}.${indexMessage}`;
+        });
+    });
     program
         .command('db-import')
         .option('-v, --vault <vault>', 'vault directory')
@@ -793,6 +825,7 @@ export const registerWriteCommands = (program) => {
         .option('-v, --vault <vault>', 'vault directory')
         .option('-a, --agent <agent>', 'agent memory namespace')
         .option('--allow-sensitive', 'allow writing content that looks like a secret')
+        .option('--no-auto-context-links', 'skip canonical Context Links for this note')
         .option('--no-auto-index', 'skip reindexing after add')
         .option('--json', 'print machine-readable JSON')
         .description('add a markdown note to the vault')
@@ -800,7 +833,8 @@ export const registerWriteCommands = (program) => {
         const resolved = await resolveOptions(options);
         const content = resolveAddContent(options);
         const added = await addNoteWithMetadata(resolved.vault, title, content, resolved.agent, {
-            allowSensitive: Boolean(options.allowSensitive)
+            allowSensitive: Boolean(options.allowSensitive),
+            autoContextLinks: options.autoContextLinks !== false && resolved.config.autoCanonicalContextLinks
         });
         const shouldAutoIndex = options.autoIndex !== false && resolved.config.autoIndexOnWrite;
         const index = shouldAutoIndex ? await indexVault(resolved.vault) : undefined;
@@ -824,7 +858,9 @@ export const registerWriteCommands = (program) => {
             writeConnectivity: {
                 autoLinked: added.autoLinked,
                 linkTarget: added.linkTarget,
-                guaranteedEdge: false
+                context: added.context,
+                hubCreated: added.hubCreated,
+                guaranteedEdge: added.autoLinked
             },
             possibleDuplicates,
             ...(index ? { index } : {})
@@ -832,7 +868,8 @@ export const registerWriteCommands = (program) => {
             const duplicateMessage = possibleDuplicates.length > 0
                 ? `\nPotential duplicates: ${possibleDuplicates.length}. Use "blink dedupe --json" or "blink dedupe-resolve".`
                 : '';
-            return `Created note at ${added.path}${duplicateMessage}`;
+            const linkMessage = added.autoLinked ? ` Linked to [[${added.linkTarget}]].` : '';
+            return `Created note at ${added.path}.${linkMessage}${duplicateMessage}`;
         });
     });
     program
@@ -1037,26 +1074,28 @@ export const registerWriteCommands = (program) => {
         .option('-p, --port <port>', 'server port', '4321')
         .option('--no-index', 'skip indexing before starting the server')
         .option('--no-open', 'do not open the graph UI automatically')
-        .option('-w, --watch', 'watch markdown files and reindex on changes')
+        .option('-w, --watch', 'watch markdown files and reindex on changes', true)
+        .option('--no-watch', 'disable markdown file watching')
         .option('--json', 'print machine-readable JSON')
         .description('start a local web UI for the knowledge graph')
         .action(async (options) => {
         const resolved = await resolveOptions(options);
+        const shouldWatch = options.watch !== false && !isBucketVaultPath(resolved.vault);
         const server = await startServer({
             vaultPath: resolved.vault,
             host: options.host ?? resolved.config.host,
             port: parsePositiveInteger(options.port ?? String(resolved.config.port), resolved.config.port),
             shouldIndex: options.index,
-            shouldWatch: Boolean(options.watch)
+            shouldWatch
         });
         const openResult = options.open !== false ? openUrlInUi(server.url, process.pid) : { opened: false, mode: 'none' };
         print(options.json, {
             url: server.url,
-            watch: Boolean(options.watch),
+            watch: shouldWatch,
             readonly: true,
             openedUi: openResult.opened,
             openMode: openResult.mode
-        }, () => `Brainlink graph server running at ${server.url}${openResult.opened
+        }, () => `Brainlink graph server running at ${server.url} (${shouldWatch ? 'watching for changes' : 'watch disabled'})${openResult.opened
             ? openResult.mode === 'native-gui'
                 ? ' (opened in native desktop GUI)'
                 : openResult.mode === 'app-window'

package/dist/domain/graph-contexts.js

@@ -0,0 +1,159 @@
+const normalize = (value) => value.trim().toLowerCase();
+const includesAny = (value, patterns) => patterns.some((pattern) => pattern.test(value));
+const contextId = (title) => title.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
+const context = (title) => ({
+    id: contextId(title),
+    title
+});
+const byTitle = (left, right) => left.title.localeCompare(right.title);
+const edgeKey = (source, target) => source < target ? `${source}|${target}` : `${target}|${source}`;
+const nodeSearchText = (node) => normalize([node.title, node.path, ...node.tags].join(' '));
+export const inferExplicitVisualGraphContext = (node) => {
+    const text = nodeSearchText(node);
+    const path = normalize(node.path);
+    if (includesAny(text, [/\bgithub repositories hub\b/]))
+        return context('GitHub Repositories');
+    if (includesAny(text, [/\bgithub organizations hub\b/]))
+        return context('GitHub Organizations');
+    if (includesAny(text, [/\bmachine configuration hub\b/]))
+        return context('Machine Configuration');
+    if (includesAny(text, [/\buser preferences hub\b/]))
+        return context('User Preferences');
+    if (includesAny(text, [/\bneovim lazyvim hub\b/]))
+        return context('Neovim LazyVim');
+    if (includesAny(text, [/\bgit workflow hub\b/]))
+        return context('Git Workflow');
+    if (includesAny(text, [/\bagent memory hub\b/]))
+        return context('Agent Memory');
+    if (path.startsWith('github-repos/'))
+        return context('GitHub Repositories');
+    if (path.startsWith('github-org-repos/'))
+        return context('GitHub Organizations');
+    if (path.startsWith('machine-config/'))
+        return context('Machine Configuration');
+    if (includesAny(text, [/\bbrainlink\b/]))
+        return context('Brainlink');
+    if (includesAny(text, [/\banonspace\b/]))
+        return context('AnonSpace');
+    if (includesAny(text, [/\bsubstructa\b/]))
+        return context('Substructa');
+    if (includesAny(text, [/\bnebula\b/]))
+        return context('Nebula');
+    if (includesAny(text, [/\bsnippets?\b/, /\bupgrader\b/, /\bversion-map\b/]))
+        return context('Snippets');
+    if (includesAny(text, [/\binkdrop\b/]))
+        return context('Inkdrop');
+    if (includesAny(text, [
+        /\bpreference\b/,
+        /\bpreferencia\b/,
+        /\bpreferencias\b/,
+        /\bplaybook\b/,
+        /\bdirective\b/,
+        /\bengineering-style\b/,
+        /\bglobal-engineering\b/,
+        /\bcoding-identity\b/,
+        /\bagents\.md\b/
+    ])) {
+        return context('User Preferences');
+    }
+    if (includesAny(text, [/\blazyvim\b/, /\bneovim\b/, /\bnvim\b/, /\bmason\b/, /\bwrapper\b/]))
+        return context('Neovim LazyVim');
+    if (includesAny(text, [/\bgit-flow\b/, /\borigin-sync\b/, /\bgit-identidade\b/, /\bcommit\b/, /\bpush\b/]))
+        return context('Git Workflow');
+    if (includesAny(text, [/\bdocker\b/, /\bkubernetes\b/, /\bdeploy\b/, /\bredeploy\b/]))
+        return context('Operations');
+    if (path.startsWith('agents/'))
+        return context('Agent Memory');
+    return null;
+};
+export const inferVisualGraphContext = (node) => {
+    const explicit = inferExplicitVisualGraphContext(node);
+    if (explicit) {
+        return explicit;
+    }
+    const [root] = node.path.split('/').filter(Boolean);
+    return context(root ? root.replace(/[-_]+/g, ' ') : 'Root');
+};
+export const groupNodesByVisualContext = (nodes) => {
+    const groups = new Map();
+    nodes.forEach((node) => {
+        const visualContext = inferVisualGraphContext(node);
+        const bucket = groups.get(visualContext.title);
+        if (bucket) {
+            bucket.push(node);
+            return;
+        }
+        groups.set(visualContext.title, [node]);
+    });
+    return new Map(Array.from(groups.entries(), ([title, groupedNodes]) => [title, [...groupedNodes].sort(byTitle)]));
+};
+const countDegrees = (edges) => edges.reduce((degrees, edge) => {
+    degrees.set(edge.source, (degrees.get(edge.source) ?? 0) + edge.weight);
+    if (edge.target) {
+        degrees.set(edge.target, (degrees.get(edge.target) ?? 0) + edge.weight);
+    }
+    return degrees;
+}, new Map());
+const selectVisualHub = (contextTitle, nodes, degrees) => {
+    const normalizedContext = normalize(contextTitle).replace(/\s+/g, ' ');
+    const ranked = [...nodes].sort((left, right) => {
+        const leftTitle = normalize(left.title);
+        const rightTitle = normalize(right.title);
+        const leftHubScore = leftTitle === normalizedContext || leftTitle === `${normalizedContext} hub`
+            ? 4
+            : leftTitle.includes(normalizedContext) && /\bhub\b/.test(leftTitle)
+                ? 3
+                : /\b(memory hub|knowledge root|moc|map|hub)\b/.test(leftTitle)
+                    ? 2
+                    : 0;
+        const rightHubScore = rightTitle === normalizedContext || rightTitle === `${normalizedContext} hub`
+            ? 4
+            : rightTitle.includes(normalizedContext) && /\bhub\b/.test(rightTitle)
+                ? 3
+                : /\b(memory hub|knowledge root|moc|map|hub)\b/.test(rightTitle)
+                    ? 2
+                    : 0;
+        const hubDelta = rightHubScore - leftHubScore;
+        if (hubDelta !== 0)
+            return hubDelta;
+        const degreeDelta = (degrees.get(right.id) ?? 0) - (degrees.get(left.id) ?? 0);
+        return degreeDelta === 0 ? left.title.localeCompare(right.title) : degreeDelta;
+    });
+    return ranked[0] ?? null;
+};
+export const addVisualContextEdges = (graph) => {
+    const existingPairs = new Set(graph.edges
+        .filter((edge) => Boolean(edge.target))
+        .map((edge) => edgeKey(edge.source, edge.target)));
+    const degrees = countDegrees(graph.edges);
+    const derivedEdges = [];
+    for (const [contextTitle, nodes] of groupNodesByVisualContext(graph.nodes).entries()) {
+        if (nodes.length <= 1) {
+            continue;
+        }
+        const hub = selectVisualHub(contextTitle, nodes, degrees);
+        if (!hub) {
+            continue;
+        }
+        nodes
+            .filter((node) => node.id !== hub.id)
+            .forEach((node) => {
+            const key = edgeKey(hub.id, node.id);
+            if (existingPairs.has(key)) {
+                return;
+            }
+            existingPairs.add(key);
+            derivedEdges.push({
+                source: hub.id,
+                target: node.id,
+                targetTitle: node.title,
+                weight: 0.5,
+                priority: 'low'
+            });
+        });
+    }
+    return {
+        nodes: graph.nodes,
+        edges: [...graph.edges, ...derivedEdges]
+    };
+};