@andespindola/brainlink 1.0.5 → 1.0.7

package/dist/cli/main.js

@@ -3,17 +3,52 @@ import { Command } from 'commander';
 import { readFileSync } from 'node:fs';
 import { basename, dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { checkPackageUpdate } from '../application/check-package-update.js';
+import { loadBrainlinkConfig } from '../infrastructure/config.js';
 import { registerAgentCommands } from './commands/agent-commands.js';
 import { registerConfigCommands } from './commands/config-commands.js';
 import { registerPracticalCommands } from './commands/practical-commands.js';
 import { registerReadCommands } from './commands/read-commands.js';
 import { registerVaultCommands } from './commands/vault-commands.js';
 import { registerWriteCommands } from './commands/write-commands.js';
-const readPackageVersion = () => {
+const readPackageMetadata = () => {
     const packagePath = join(dirname(fileURLToPath(import.meta.url)), '../../package.json');
     const metadata = JSON.parse(readFileSync(packagePath, 'utf8'));
-    return metadata.version ?? '0.0.0';
+    return {
+        name: metadata.name ?? 'brainlink',
+        version: metadata.version ?? '0.0.0'
+    };
 };
+const shouldSkipUpdateCheck = () => process.env.BRAINLINK_NO_UPDATE_CHECK === '1' ||
+    process.env.BRAINLINK_NO_UPDATE_CHECK === 'true' ||
+    process.env.CI === 'true' ||
+    process.env.VITEST === 'true' ||
+    process.env.NODE_ENV === 'test' ||
+    process.argv.includes('--version') ||
+    process.argv.includes('-V') ||
+    process.argv.includes('--help') ||
+    process.argv.includes('-h');
+const maybePrintUpdateNotice = async (metadata) => {
+    if (shouldSkipUpdateCheck()) {
+        return;
+    }
+    try {
+        const config = await loadBrainlinkConfig();
+        const status = await checkPackageUpdate({
+            packageName: metadata.name,
+            currentVersion: metadata.version,
+            enabled: config.autoUpdateCheck,
+            intervalMs: config.updateCheckIntervalMs
+        });
+        if (!status.skipped && status.updateAvailable && status.latestVersion) {
+            console.error(`Brainlink ${status.latestVersion} is available. Current version: ${status.currentVersion}. Update with: ${status.installCommand}`);
+        }
+    }
+    catch {
+        // Update checks must never block normal CLI execution.
+    }
+};
+const packageMetadata = readPackageMetadata();
 const program = new Command();
 const cliName = basename(process.argv[1] ?? 'brainlink');
 const displayName = cliName === 'blink' ? 'blink' : 'brainlink';
@@ -22,13 +57,14 @@ program
     .name(displayName)
     .alias(aliasName)
     .description('Local-first knowledge memory for agents')
-    .version(readPackageVersion());
+    .version(packageMetadata.version);
 registerWriteCommands(program);
 registerReadCommands(program);
 registerPracticalCommands(program);
 registerConfigCommands(program);
 registerVaultCommands(program);
 registerAgentCommands(program);
+await maybePrintUpdateNotice(packageMetadata);
 program.parseAsync().catch((error) => {
     const message = error instanceof Error ? error.message : String(error);
     console.error(message);

package/dist/domain/context.js

@@ -1,5 +1,32 @@
 import { middleOutIndices } from './middle-out.js';
+import { estimateTokenCount } from './tokens.js';
+import { orderByMaximalMarginalRelevance } from './diversity.js';
+const contentTokenPattern = /[\p{L}\p{N}_-]+/gu;
+const tokenizeForDiversity = (text) => new Set((text.toLowerCase().match(contentTokenPattern) ?? []).filter((token) => token.length > 1));
 const maxSectionsPerDocument = 3;
+// Character budget used only for truncating an overflowing chunk back down to a
+// token target; the conservative per-token character ratio keeps the rendered
+// slice within budget even though estimateTokenCount is the source of truth for
+// counting.
+const truncationCharsPerToken = 4;
+const sectionSeparatorTokens = 1;
+const headerReserveTokens = 8;
+const truncateToTokens = (text, maxTokens) => {
+    const maxChars = Math.max(0, maxTokens) * truncationCharsPerToken;
+    return text.length <= maxChars ? text : text.slice(0, maxChars);
+};
+// Prefer the token count cached on the chunk at index time; fall back to a live
+// estimate when the result did not carry one (legacy indexes, pack fallback).
+const contentTokens = (result) => result.tokenCount ?? estimateTokenCount(result.content);
+// Mirror the per-section framing that formatContextPackage renders (heading,
+// Source/Tags/Score/Mode lines and the trailing separator) so the budget
+// reflects the package the agent actually receives, not just chunk content.
+const estimateFramingTokens = (result) => {
+    const tagsLine = result.tags.length > 0 ? `Tags: ${result.tags.map((tag) => `#${tag}`).join(' ')}\n` : '';
+    const framing = `## . ${result.title}\nSource: ${result.path}\n${tagsLine}Score: 0.000\nMode: ${result.searchMode}\n\n`;
+    return estimateTokenCount(framing) + sectionSeparatorTokens;
+};
+const estimateSectionTokens = (result) => contentTokens(result) + estimateFramingTokens(result);
 const byScore = (left, right) => right.score - left.score || left.title.localeCompare(right.title);
 const byOrdinal = (left, right) => (left.chunkOrdinal ?? Number.MAX_SAFE_INTEGER) - (right.chunkOrdinal ?? Number.MAX_SAFE_INTEGER);
 const middleOutDocumentResults = (results) => {
@@ -20,14 +47,16 @@ export const selectContextSections = (results, maxTokens) => {
         state.set(result.documentId, [...current, result]);
         return state;
     }, new Map());
-    const documentOrder = Array.from(results.reduce((state, result) => {
-        if (!state.has(result.documentId)) {
-            state.set(result.documentId, result.score);
-        }
-        return state;
-    }, new Map()).entries())
-        .sort((left, right) => right[1] - left[1] || left[0].localeCompare(right[0]))
-        .map(([documentId]) => documentId);
+    // Order documents by maximal marginal relevance so the budget is not spent on
+    // several near-duplicate notes: each pick trades its own relevance against how
+    // similar it is to documents already chosen. The strongest document still
+    // leads (no redundancy penalty on an empty selection).
+    const documentCandidates = Array.from(grouped.entries()).map(([documentId, group]) => ({
+        id: documentId,
+        relevance: group.reduce((max, result) => Math.max(max, result.score), Number.NEGATIVE_INFINITY),
+        tokens: tokenizeForDiversity(group.map((result) => result.content).join(' '))
+    }));
+    const documentOrder = orderByMaximalMarginalRelevance(documentCandidates);
     const selected = documentOrder.reduce((state, documentId) => {
         const ordered = middleOutDocumentResults(grouped.get(documentId) ?? []);
         let usedTokens = state.usedTokens;
@@ -38,7 +67,7 @@ export const selectContextSections = (results, maxTokens) => {
             if (seenChunks.has(result.chunkId)) {
                 continue;
             }
-            const tokenCost = Math.ceil(result.content.length / 4);
+            const tokenCost = estimateSectionTokens(result);
             if (usedTokens + tokenCost > maxTokens) {
                 break;
             }
@@ -62,11 +91,31 @@ export const selectContextSections = (results, maxTokens) => {
             seenChunks
         };
     }, {
-        usedTokens: 0,
+        usedTokens: headerReserveTokens,
         sections: [],
         seenChunks: new Set()
     });
-    return selected.sections;
+    if (selected.sections.length > 0 || results.length === 0) {
+        return selected.sections;
+    }
+    // Retrieval found matches but every chunk overflowed the token budget. Never
+    // surface an empty context in that case: include the highest-scored chunk,
+    // truncated so the rendered package still respects the budget. This keeps
+    // brainlink_context consistent with brainlink_search instead of reporting
+    // "No relevant context found." whenever the strongest chunk is large.
+    const topResult = [...results].sort(byScore)[0];
+    const framingTokens = estimateFramingTokens(topResult);
+    const contentTokenBudget = maxTokens - headerReserveTokens - framingTokens;
+    return [
+        {
+            title: topResult.title,
+            path: topResult.path,
+            content: truncateToTokens(topResult.content, contentTokenBudget),
+            score: topResult.score,
+            searchMode: topResult.searchMode,
+            tags: topResult.tags
+        }
+    ];
 };
 export const formatContextPackage = (query, sections) => {
     const body = sections

package/dist/domain/diversity.js

@@ -0,0 +1,64 @@
+// Maximal Marginal Relevance ordering. Greedily orders candidates so each pick
+// balances its own relevance against how redundant it is versus everything
+// already chosen, preventing a context window from filling with near-duplicate
+// material. Pure and deterministic: ties resolve by relevance then id.
+const jaccardSimilarity = (left, right) => {
+    if (left.size === 0 || right.size === 0) {
+        return 0;
+    }
+    let intersection = 0;
+    const [small, large] = left.size <= right.size ? [left, right] : [right, left];
+    for (const token of small) {
+        if (large.has(token)) {
+            intersection += 1;
+        }
+    }
+    const union = left.size + right.size - intersection;
+    return union === 0 ? 0 : intersection / union;
+};
+const normalizeRelevance = (candidates) => {
+    // Reduce instead of Math.min(...values): the candidate list can be as large as
+    // the caller's result limit, and spreading a very large array overflows the
+    // call stack.
+    const bounds = candidates.reduce((range, candidate) => ({
+        min: Math.min(range.min, candidate.relevance),
+        max: Math.max(range.max, candidate.relevance)
+    }), { min: Infinity, max: -Infinity });
+    const span = bounds.max - bounds.min;
+    return new Map(candidates.map((candidate) => [candidate.id, span === 0 ? 1 : (candidate.relevance - bounds.min) / span]));
+};
+// lambda in [0,1]: 1 ignores redundancy (pure relevance order), lower values
+// push diverse picks higher. The default balances relevance and diversity; the
+// strongest candidate still always leads (no redundancy penalty on an empty
+// selection).
+export const orderByMaximalMarginalRelevance = (candidates, lambda = 0.5) => {
+    if (candidates.length <= 1) {
+        return candidates.map((candidate) => candidate.id);
+    }
+    const relevanceById = normalizeRelevance(candidates);
+    const remaining = new Map(candidates.map((candidate) => [candidate.id, candidate]));
+    const selected = [];
+    const order = [];
+    while (remaining.size > 0) {
+        let best = null;
+        for (const candidate of remaining.values()) {
+            const relevance = relevanceById.get(candidate.id) ?? 0;
+            const redundancy = selected.reduce((max, picked) => Math.max(max, jaccardSimilarity(candidate.tokens, picked.tokens)), 0);
+            const score = lambda * relevance - (1 - lambda) * redundancy;
+            if (best === null ||
+                score > best.score ||
+                (score === best.score &&
+                    (relevance > best.relevance ||
+                        (relevance === best.relevance && candidate.id.localeCompare(best.candidate.id) < 0)))) {
+                best = { candidate, score, relevance };
+            }
+        }
+        if (best === null) {
+            break;
+        }
+        selected.push(best.candidate);
+        order.push(best.candidate.id);
+        remaining.delete(best.candidate.id);
+    }
+    return order;
+};

package/dist/domain/embeddings.js

@@ -67,8 +67,16 @@ const featureHash = (feature) => {
     const sign = value & 1 ? 1 : -1;
     return [index, sign];
 };
+const vectorMagnitude = (vector) => {
+    let sumSquares = 0;
+    for (let index = 0; index < vector.length; index += 1) {
+        const value = vector[index];
+        sumSquares += value * value;
+    }
+    return Math.sqrt(sumSquares);
+};
 const normalizeVector = (vector) => {
-    const magnitude = Math.hypot(...vector);
+    const magnitude = vectorMagnitude(vector);
     return magnitude === 0 ? vector : vector.map((value) => value / magnitude);
 };
 const applyFeature = (vector, feature, weight) => {
@@ -86,15 +94,33 @@ export const createLocalEmbedding = (input) => {
     const weighted = tokenFeatures(tokens).reduce((vector, feature) => applyFeature(vector, feature, feature.startsWith('b:') ? 0.65 : 1), initial);
     return normalizeVector(weighted);
 };
+// Dot product over the shared prefix. For L2-normalized vectors (every vector
+// from createLocalEmbedding is normalized) this equals cosine similarity, so
+// the hot retrieval loop can skip the per-comparison magnitude recompute.
+export const dotProduct = (left, right) => {
+    const length = Math.min(left.length, right.length);
+    let total = 0;
+    for (let index = 0; index < length; index += 1) {
+        total += left[index] * right[index];
+    }
+    return total;
+};
 export const cosineSimilarity = (left, right) => {
     const length = Math.min(left.length, right.length);
     if (length === 0) {
         return 0;
     }
-    const dot = left.slice(0, length).reduce((total, value, index) => total + value * (right[index] ?? 0), 0);
-    const leftMagnitude = Math.hypot(...left.slice(0, length));
-    const rightMagnitude = Math.hypot(...right.slice(0, length));
-    return leftMagnitude === 0 || rightMagnitude === 0 ? 0 : dot / (leftMagnitude * rightMagnitude);
+    let dot = 0;
+    let leftSumSquares = 0;
+    let rightSumSquares = 0;
+    for (let index = 0; index < length; index += 1) {
+        const leftValue = left[index];
+        const rightValue = right[index];
+        dot += leftValue * rightValue;
+        leftSumSquares += leftValue * leftValue;
+        rightSumSquares += rightValue * rightValue;
+    }
+    return leftSumSquares === 0 || rightSumSquares === 0 ? 0 : dot / Math.sqrt(leftSumSquares * rightSumSquares);
 };
 const bucketKey = (index, value) => `${value >= 0 ? 'p' : 'n'}:${index}`;
 export const createEmbeddingBuckets = (vector, bucketCount = defaultEmbeddingBucketCount) => vector
@@ -115,4 +141,120 @@ export const createLocalEmbeddingProvider = () => ({
     name: 'local',
     embed: async (input) => input.map(createLocalEmbedding)
 });
-export const createEmbeddingProvider = (name) => name === 'local' ? createLocalEmbeddingProvider() : createDisabledEmbeddingProvider();
+const defaultExternalTimeoutMs = 10_000;
+const defaultExternalBatchSize = 64;
+const ollamaDefaultUrl = 'http://127.0.0.1:11434';
+const ollamaDefaultModel = 'nomic-embed-text';
+const openAiDefaultUrl = 'https://api.openai.com/v1';
+const openAiDefaultModel = 'text-embedding-3-small';
+const trimTrailingSlash = (value) => value.replace(/\/+$/, '');
+const chunkBatches = (items, size) => {
+    const batchSize = Number.isFinite(size) && size > 0 ? Math.floor(size) : defaultExternalBatchSize;
+    const batches = [];
+    for (let index = 0; index < items.length; index += batchSize) {
+        batches.push(items.slice(index, index + batchSize));
+    }
+    return batches;
+};
+const isNumberArray = (value) => Array.isArray(value) && value.every((entry) => typeof entry === 'number' && Number.isFinite(entry));
+const fetchJson = async (url, init, timeoutMs, providerName) => {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), Math.max(1, timeoutMs));
+    try {
+        const response = await fetch(url, { ...init, signal: controller.signal });
+        if (!response.ok) {
+            throw new Error(`${providerName} embedding request failed with HTTP ${response.status}`);
+        }
+        return (await response.json());
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        throw new Error(`${providerName} embedding request to ${url} failed: ${reason}`);
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+};
+// External providers return vectors in their own space; L2-normalize so dot
+// product equals cosine similarity, matching the contract local embeddings rely
+// on across the retrieval and bucket-prefilter paths.
+const createOllamaEmbeddingProvider = (config) => {
+    const baseUrl = trimTrailingSlash(config.url?.trim() || ollamaDefaultUrl);
+    const model = config.model?.trim() || ollamaDefaultModel;
+    const timeoutMs = config.timeoutMs ?? defaultExternalTimeoutMs;
+    return {
+        name: 'ollama',
+        embed: async (input) => {
+            const vectors = [];
+            for (const batch of chunkBatches(input, config.batchSize ?? defaultExternalBatchSize)) {
+                const payload = await fetchJson(`${baseUrl}/api/embed`, {
+                    method: 'POST',
+                    headers: { 'content-type': 'application/json' },
+                    body: JSON.stringify({ model, input: batch })
+                }, timeoutMs, 'ollama');
+                const embeddings = payload.embeddings;
+                if (!Array.isArray(embeddings) || embeddings.length !== batch.length) {
+                    throw new Error('ollama embedding response shape was invalid');
+                }
+                for (const embedding of embeddings) {
+                    if (!isNumberArray(embedding) || embedding.length === 0) {
+                        throw new Error('ollama embedding response contained an invalid vector');
+                    }
+                    vectors.push(normalizeVector(embedding));
+                }
+            }
+            return vectors;
+        }
+    };
+};
+const createOpenAiEmbeddingProvider = (config) => {
+    const baseUrl = trimTrailingSlash(config.url?.trim() || openAiDefaultUrl);
+    const model = config.model?.trim() || openAiDefaultModel;
+    const timeoutMs = config.timeoutMs ?? defaultExternalTimeoutMs;
+    const apiKeyEnv = config.apiKeyEnv?.trim() || 'OPENAI_API_KEY';
+    return {
+        name: 'openai',
+        embed: async (input) => {
+            const apiKey = process.env[apiKeyEnv]?.trim();
+            if (!apiKey) {
+                throw new Error(`openai embedding requires the ${apiKeyEnv} environment variable to be set`);
+            }
+            const vectors = [];
+            for (const batch of chunkBatches(input, config.batchSize ?? defaultExternalBatchSize)) {
+                const payload = await fetchJson(`${baseUrl}/embeddings`, {
+                    method: 'POST',
+                    headers: {
+                        'content-type': 'application/json',
+                        authorization: `Bearer ${apiKey}`
+                    },
+                    body: JSON.stringify({ model, input: batch })
+                }, timeoutMs, 'openai');
+                const data = payload.data;
+                if (!Array.isArray(data) || data.length !== batch.length) {
+                    throw new Error('openai embedding response shape was invalid');
+                }
+                const ordered = [...data].sort((left, right) => (left.index ?? 0) - (right.index ?? 0));
+                for (const entry of ordered) {
+                    const embedding = entry.embedding;
+                    if (!isNumberArray(embedding) || embedding.length === 0) {
+                        throw new Error('openai embedding response contained an invalid vector');
+                    }
+                    vectors.push(normalizeVector(embedding));
+                }
+            }
+            return vectors;
+        }
+    };
+};
+export const createEmbeddingProvider = (name, config = {}) => {
+    switch (name) {
+        case 'local':
+            return createLocalEmbeddingProvider();
+        case 'ollama':
+            return createOllamaEmbeddingProvider(config);
+        case 'openai':
+            return createOpenAiEmbeddingProvider(config);
+        default:
+            return createDisabledEmbeddingProvider();
+    }
+};

package/dist/domain/graph-contexts.js

@@ -8,7 +8,59 @@ const context = (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 escapeRegExp = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+// Hub notes name their context as "<Context> Hub". These reserved hubs are
+// structural anchors of the graph, not visual contexts, so they never become
+// keyword rules.
+const reservedHubTitles = new Set(['memory hub', 'knowledge root']);
+const hubContextPattern = /^(.+?)\s+hub$/i;
+// Extra keywords can be declared in a hub note body via a "Keywords: a, b, c"
+// line so a context can match terms beyond its own name.
+const parseHubKeywords = (content) => {
+    const match = content.match(/^\s*keywords?\s*:\s*(.+)$/im);
+    if (!match) {
+        return [];
+    }
+    return match[1]
+        .split(',')
+        .map((keyword) => normalize(keyword))
+        .filter((keyword) => keyword.length > 0);
+};
+// Derive content-classification rules from the hub notes present in the graph.
+// A "<Context> Hub" note contributes the context, keyed by its normalized name
+// plus any declared extra keywords. This keeps vault-specific taxonomy in the
+// vault instead of hardcoding it in the engine.
+export const deriveVisualContextRules = (nodes) => {
+    const rules = new Map();
+    nodes.forEach((node) => {
+        const match = node.title.trim().match(hubContextPattern);
+        if (!match) {
+            return;
+        }
+        if (reservedHubTitles.has(normalize(node.title))) {
+            return;
+        }
+        const contextTitle = match[1].trim();
+        if (contextTitle.length === 0) {
+            return;
+        }
+        const keywords = rules.get(contextTitle) ?? new Set();
+        keywords.add(normalize(contextTitle));
+        parseHubKeywords(node.content).forEach((keyword) => keywords.add(keyword));
+        rules.set(contextTitle, keywords);
+    });
+    return Array.from(rules.entries(), ([contextTitle, keywords]) => ({
+        context: contextTitle,
+        keywords: Array.from(keywords)
+    }));
+};
+const matchRule = (text, rules) => {
+    const matched = rules.find((rule) => rule.keywords.some((keyword) => new RegExp(`\\b${escapeRegExp(keyword)}\\b`).test(text)));
+    return matched ? context(matched.context) : null;
+};
+// Structural, vault-agnostic classification. Named-hub phrases and path layout
+// are generic conventions; vault-specific contexts come from `rules`.
+export const inferExplicitVisualGraphContext = (node, rules = []) => {
     const text = nodeSearchText(node);
     const path = normalize(node.path);
     if (includesAny(text, [/\bgithub repositories hub\b/]))
@@ -25,80 +77,32 @@ export const inferExplicitVisualGraphContext = (node) => {
         return context('Git Workflow');
     if (includesAny(text, [/\bagent memory hub\b/]))
         return context('Agent Memory');
-    if (includesAny(text, [/pingu_ai_codding_pair_programming/, /\bpingu\b/]))
-        return context('Pingu');
     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, [
-        /\bpreference\b/,
-        /\bpreferences\b/,
-        /\bpreferencia\b/,
-        /\bpreferencias\b/,
-        /\bpreferência\b/,
-        /\bpreferências\b/,
-        /\bplaybook\b/,
-        /\bdirective\b/,
-        /\bdirectives\b/,
-        /\bdiretiva\b/,
-        /\bdiretivas\b/,
-        /\bengineering-style\b/,
-        /\bglobal-engineering\b/,
-        /\bcoding-identity\b/,
-        /\bagents\.md\b/,
-        /\bagents-md\b/,
-        /\bordem direta\b/,
-        /\bordem-direta\b/,
-        /\bman-in-the-loop\b/,
-        /\bconfig geral\b/,
-        /\bconfig-geral\b/,
-        /\bsync config_files\b/,
-        /\bsync-config-files\b/,
-        /\bregra operacional\b/,
-        /\bregras operacionais\b/,
-        /\boperational rule\b/,
-        /\boperational rules\b/,
-        /\boperational policy\b/
-    ])) {
-        return context('User Preferences');
+    const ruleMatch = matchRule(text, rules);
+    if (ruleMatch) {
+        return ruleMatch;
     }
-    if (includesAny(text, [/\binkdrop\b/]))
-        return context('Inkdrop');
-    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);
+export const inferVisualGraphContext = (node, rules = []) => {
+    const explicit = inferExplicitVisualGraphContext(node, rules);
     if (explicit) {
         return explicit;
     }
     const [root] = node.path.split('/').filter(Boolean);
     return context(root ? root.replace(/[-_]+/g, ' ') : 'Root');
 };
-export const groupNodesByVisualContext = (nodes) => {
+export const groupNodesByVisualContext = (nodes, rules = deriveVisualContextRules(nodes)) => {
     const groups = new Map();
     nodes.forEach((node) => {
-        const visualContext = inferVisualGraphContext(node);
+        const visualContext = inferVisualGraphContext(node, rules);
         const bucket = groups.get(visualContext.title);
         if (bucket) {
             bucket.push(node);
@@ -147,8 +151,9 @@ export const addVisualContextEdges = (graph) => {
         .filter((edge) => Boolean(edge.target))
         .map((edge) => edgeKey(edge.source, edge.target)));
     const degrees = countDegrees(graph.edges);
+    const rules = deriveVisualContextRules(graph.nodes);
     const derivedEdges = [];
-    for (const [contextTitle, nodes] of groupNodesByVisualContext(graph.nodes).entries()) {
+    for (const [contextTitle, nodes] of groupNodesByVisualContext(graph.nodes, rules).entries()) {
         if (nodes.length <= 1) {
             continue;
         }