@andespindola/brainlink 0.1.0-beta.8 → 0.1.0-beta.80

package/dist/cli/main.js

@@ -3,6 +3,8 @@ import { Command } from 'commander';
 import { readFileSync } from 'node:fs';
 import { basename, dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { registerAgentCommands } from './commands/agent-commands.js';
+import { registerConfigCommands } from './commands/config-commands.js';
 import { registerReadCommands } from './commands/read-commands.js';
 import { registerWriteCommands } from './commands/write-commands.js';
 const readPackageVersion = () => {
@@ -21,6 +23,8 @@ program
     .version(readPackageVersion());
 registerWriteCommands(program);
 registerReadCommands(program);
+registerConfigCommands(program);
+registerAgentCommands(program);
 program.parseAsync().catch((error) => {
     const message = error instanceof Error ? error.message : String(error);
     console.error(message);

package/dist/cli/runtime.js

@@ -1,4 +1,4 @@
-import { loadBrainlinkConfig } from '../infrastructure/config.js';
+import { loadBrainlinkConfig, resolveAgentRuntimeDefaults } from '../infrastructure/config.js';
 import { assertVaultAllowed } from '../infrastructure/file-system-vault.js';
 export const parsePositiveInteger = (value, fallback) => {
     const parsed = Number.parseInt(value, 10);
@@ -8,10 +8,13 @@ export const resolveOptions = async (options) => {
     const config = await loadBrainlinkConfig();
     const vault = options.vault ?? config.vault;
     const allowedVault = assertVaultAllowed(vault, config.allowedVaults);
+    const agent = options.agent ?? config.defaultAgent;
+    const defaults = resolveAgentRuntimeDefaults(config, agent);
     return {
         config,
         vault: allowedVault,
-        agent: options.agent ?? config.defaultAgent
+        agent,
+        defaults
     };
 };
 export const print = (json, value, human) => {

package/dist/domain/context.js

@@ -1,13 +1,50 @@
+import { middleOutIndices } from './middle-out.js';
+const maxSectionsPerDocument = 3;
+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) => {
+    if (results.length <= 1) {
+        return results;
+    }
+    const sortedByOrdinal = [...results].sort(byOrdinal);
+    const pivotChunkId = [...results].sort(byScore)[0]?.chunkId;
+    const pivotIndex = sortedByOrdinal.findIndex((result) => result.chunkId === pivotChunkId);
+    if (pivotIndex < 0) {
+        return [...results].sort(byScore);
+    }
+    return middleOutIndices(sortedByOrdinal.length, pivotIndex).map((index) => sortedByOrdinal[index]);
+};
 export const selectContextSections = (results, maxTokens) => {
-    const selected = results.reduce((state, result) => {
-        const tokenCost = Math.ceil(result.content.length / 4);
-        if (state.usedTokens + tokenCost > maxTokens || state.seenDocuments.has(result.documentId)) {
-            return state;
+    const grouped = results.reduce((state, result) => {
+        const current = state.get(result.documentId) ?? [];
+        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 {
-            usedTokens: state.usedTokens + tokenCost,
-            sections: [
-                ...state.sections,
+        return state;
+    }, new Map()).entries())
+        .sort((left, right) => right[1] - left[1] || left[0].localeCompare(right[0]))
+        .map(([documentId]) => documentId);
+    const selected = documentOrder.reduce((state, documentId) => {
+        const ordered = middleOutDocumentResults(grouped.get(documentId) ?? []);
+        let usedTokens = state.usedTokens;
+        let sections = state.sections;
+        let seenChunks = state.seenChunks;
+        for (let index = 0; index < ordered.length && index < maxSectionsPerDocument; index += 1) {
+            const result = ordered[index];
+            if (seenChunks.has(result.chunkId)) {
+                continue;
+            }
+            const tokenCost = Math.ceil(result.content.length / 4);
+            if (usedTokens + tokenCost > maxTokens) {
+                break;
+            }
+            usedTokens += tokenCost;
+            sections = [
+                ...sections,
                 {
                     title: result.title,
                     path: result.path,
@@ -16,13 +53,18 @@ export const selectContextSections = (results, maxTokens) => {
                     searchMode: result.searchMode,
                     tags: result.tags
                 }
-            ],
-            seenDocuments: new Set([...state.seenDocuments, result.documentId])
+            ];
+            seenChunks = new Set([...seenChunks, result.chunkId]);
+        }
+        return {
+            usedTokens,
+            sections,
+            seenChunks
         };
     }, {
         usedTokens: 0,
         sections: [],
-        seenDocuments: new Set()
+        seenChunks: new Set()
     });
     return selected.sections;
 };

package/dist/domain/embeddings.js

@@ -58,7 +58,8 @@ const tokenize = (input) => input
     .match(tokenPattern)
     ?.map(normalizeToken)
     .filter((token) => token.length > 1 && !stopWords.has(token)) ?? [];
-const expandTokens = (tokens) => tokens.flatMap((token) => [token, ...(aliases[token] ?? [])]);
+const getAliasesForToken = (token) => Object.hasOwn(aliases, token) ? aliases[token] ?? [] : [];
+const expandTokens = (tokens) => tokens.flatMap((token) => [token, ...getAliasesForToken(token)]);
 const hash = (value) => Array.from(value).reduce((state, char) => Math.imul(state ^ char.charCodeAt(0), 16777619), 2166136261) >>> 0;
 const featureHash = (feature) => {
     const value = hash(feature);

package/dist/domain/graph-layout.js

@@ -20,6 +20,7 @@ const segmentAngles = {
     Evaluation: 2.08,
     Security: 2.82
 };
+const hubTitlePattern = /\b(memory\s*hub|knowledge\s*root|moc|map)\b/i;
 const hashText = (value) => Array.from(value).reduce((hash, char) => ((hash << 5) - hash + char.charCodeAt(0)) | 0, 0);
 const jitter = (value, range) => {
     const normalized = Math.abs(hashText(value) % 1000) / 1000;
@@ -45,26 +46,61 @@ const countDegrees = (edges) => edges.reduce((degrees, edge) => {
         ? incrementDegreeBy(incrementDegreeBy(degrees, edge.source, weight), edge.target, weight)
         : incrementDegreeBy(degrees, edge.source, weight);
 }, new Map());
-const uniqueIds = (ids) => Array.from(new Set(ids));
 const createAdjacency = (nodes, edges) => {
     const nodeIds = new Set(nodes.map((node) => node.id));
-    const emptyAdjacency = new Map(nodes.map((node) => [node.id, []]));
-    return edges.reduce((adjacency, edge) => {
+    const adjacency = new Map(nodes.map((node) => [node.id, new Set()]));
+    edges.forEach((edge) => {
         if (!edge.target || !nodeIds.has(edge.source) || !nodeIds.has(edge.target)) {
-            return adjacency;
+            return;
         }
-        return new Map([
-            ...adjacency,
-            [edge.source, uniqueIds([...(adjacency.get(edge.source) ?? []), edge.target])],
-            [edge.target, uniqueIds([...(adjacency.get(edge.target) ?? []), edge.source])]
-        ]);
-    }, emptyAdjacency);
+        adjacency.get(edge.source)?.add(edge.target);
+        adjacency.get(edge.target)?.add(edge.source);
+    });
+    return new Map(Array.from(adjacency.entries(), ([id, neighbors]) => [id, Array.from(neighbors)]));
 };
 const byTitle = (left, right) => left.title.localeCompare(right.title);
 const byDegreeThenTitle = (degrees) => (left, right) => {
     const degreeDelta = (degrees.get(right.id) ?? 0) - (degrees.get(left.id) ?? 0);
     return degreeDelta === 0 ? byTitle(left, right) : degreeDelta;
 };
+const hubScore = (node) => {
+    const title = node.title.trim().toLowerCase();
+    if (title === 'memory hub')
+        return 5;
+    if (title === 'knowledge root')
+        return 4;
+    if (/\bmoc\b/i.test(node.title))
+        return 3;
+    return hubTitlePattern.test(node.title) ? 2 : 0;
+};
+const selectPrimaryHubId = (nodes, degrees) => {
+    const ranked = [...nodes]
+        .filter((node) => hubScore(node) > 0)
+        .sort((left, right) => {
+        const scoreDelta = hubScore(right) - hubScore(left);
+        if (scoreDelta !== 0)
+            return scoreDelta;
+        const degreeDelta = (degrees.get(right.id) ?? 0) - (degrees.get(left.id) ?? 0);
+        if (degreeDelta !== 0)
+            return degreeDelta;
+        return left.title.localeCompare(right.title);
+    });
+    return ranked[0]?.id ?? null;
+};
+const centerLayoutByNode = (nodes, nodeId) => {
+    if (!nodeId) {
+        return nodes;
+    }
+    const anchor = nodes.find((node) => node.id === nodeId);
+    if (!anchor) {
+        return nodes;
+    }
+    return nodes.map((node) => ({
+        ...node,
+        x: node.x - anchor.x,
+        y: node.y - anchor.y
+    }));
+};
 const naturalSegmentSeed = (node) => groupKey(node) === '00-maps' || /\b(moc|map)\b/i.test(node.title);
 const segmentName = (node) => node.title.replace(/^MOC\s+/i, '').replace(/\s+Memory Map$/i, '').trim() || node.title;
 const collectComponent = (adjacency, startId, visited) => {
@@ -117,18 +153,31 @@ const assignSegments = (nodes, edges, degrees) => {
     }
     return new Map(nodes.map((node) => [node.id, assignments.get(node.id) ?? groupLabel(groupKey(node))]));
 };
-const groupNodesBySegment = (nodes, segments) => nodes.reduce((groups, node) => {
-    const segment = segments.get(node.id) ?? groupLabel(groupKey(node));
-    return new Map([...groups, [segment, [...(groups.get(segment) ?? []), node]]]);
-}, new Map());
+const groupNodesBySegment = (nodes, segments) => {
+    const groups = new Map();
+    nodes.forEach((node) => {
+        const segment = segments.get(node.id) ?? groupLabel(groupKey(node));
+        const bucket = groups.get(segment);
+        if (bucket) {
+            bucket.push(node);
+            return;
+        }
+        groups.set(segment, [node]);
+    });
+    return new Map(groups);
+};
 const segmentAngle = (segment, index, count) => segmentAngles[segment] ?? (Math.PI * 2 * index) / Math.max(count, 1) - Math.PI / 2;
+const petalSpreadForSegmentSize = (size) => {
+    const safeSize = Math.max(size, 1);
+    return 180 + Math.log2(safeSize + 1) * 6;
+};
 const createSegmentNodes = (segments, degrees, segmentCount) => ([segment, nodes], segmentIndex) => {
     const sortedNodes = [...nodes].sort(byDegreeThenTitle(degrees));
     const angle = segmentAngle(segment, segmentIndex, segmentCount);
     const baseRadius = segmentCount === 1 ? 0 : 340 + Math.min(sortedNodes.length, 22) * 10;
     const centerX = Math.cos(angle) * baseRadius;
     const centerY = Math.sin(angle) * (baseRadius * 0.78);
-    const petalSpread = 40 + Math.sqrt(sortedNodes.length) * 14;
+    const petalSpread = petalSpreadForSegmentSize(sortedNodes.length);
     return sortedNodes.map((node, index) => {
         const localAngle = index * 2.399963 + jitter(node.title, 0.42);
         const localRadius = Math.sqrt(index + 1) * petalSpread;
@@ -240,8 +289,10 @@ export const createCauliflowerGraphLayout = (graph) => {
     const segmentGroups = Array.from(groupNodesBySegment(graph.nodes, segments).entries())
         .sort(([left], [right]) => left.localeCompare(right));
     const nodes = relaxCollisions(segmentGroups.flatMap(createSegmentNodes(segments, degrees, segmentGroups.length)));
+    const primaryHubId = selectPrimaryHubId(graph.nodes, degrees);
+    const centeredNodes = centerLayoutByNode(nodes, primaryHubId);
     return {
-        nodes,
+        nodes: centeredNodes,
         edges: graph.edges
     };
 };

package/dist/domain/markdown.js

@@ -77,11 +77,13 @@ export const extractWikiLinkReferences = (content) => visibleMarkdownLines(conte
     }));
 });
 const priorityFromWeight = (weight) => weight >= 8 ? 'critical' : weight >= 4 ? 'high' : 'normal';
+const normalizeAccumulatedWeight = (weight) => Math.max(1, Math.min(12, weight));
 export const extractWikiLinkWeights = (content) => {
     const weights = extractWikiLinkReferences(content).reduce((state, reference) => {
         const titleKey = reference.title.toLowerCase();
         const current = state.get(titleKey);
-        const weight = (current?.weight ?? 0) + reference.weight;
+        const rawWeight = (current?.weight ?? 0) + reference.weight;
+        const weight = normalizeAccumulatedWeight(rawWeight);
         const explicitPriority = reference.priority
             ? maxPriority(current?.priority ?? reference.priority, reference.priority)
             : current?.priority;
@@ -116,10 +118,38 @@ const normalizeChunkContent = (content) => content
     .join('\n')
     .replace(/\n{3,}/g, '\n\n')
     .trim();
+const splitLongParagraph = (paragraph, maxCharacters) => {
+    if (paragraph.length <= maxCharacters) {
+        return [paragraph];
+    }
+    const sentences = paragraph
+        .split(/(?<=[.!?])\s+/)
+        .map((sentence) => sentence.trim())
+        .filter(Boolean);
+    if (sentences.length <= 1) {
+        const chunks = [];
+        for (let index = 0; index < paragraph.length; index += maxCharacters) {
+            chunks.push(paragraph.slice(index, index + maxCharacters).trim());
+        }
+        return chunks.filter(Boolean);
+    }
+    return sentences.reduce((state, sentence) => {
+        const last = state.at(-1);
+        if (!last) {
+            return [sentence];
+        }
+        const merged = `${last} ${sentence}`;
+        if (merged.length <= maxCharacters) {
+            return [...state.slice(0, -1), merged];
+        }
+        return [...state, sentence];
+    }, []);
+};
 export const splitIntoChunks = (documentId, content, maxCharacters = 1200) => {
     const paragraphs = normalizeChunkContent(stripFrontmatter(content))
         .split(/\n{2,}/)
-        .filter(Boolean);
+        .filter(Boolean)
+        .flatMap((paragraph) => splitLongParagraph(paragraph, maxCharacters));
     const chunks = paragraphs.reduce((state, paragraph) => {
         const lastChunk = state.at(-1);
         if (!lastChunk) {
@@ -162,13 +192,15 @@ export const parseMarkdownDocument = (input) => {
 export const createIndexedDocument = (document, titleToDocumentId, maxChunkCharacters = 1200) => {
     const chunks = splitIntoChunks(document.id, document.content, maxChunkCharacters);
     const linkWeights = new Map(extractWikiLinkWeights(document.content).map((link) => [link.title.toLowerCase(), link]));
-    const links = document.links.map((toTitle) => ({
+    const links = document.links
+        .map((toTitle) => ({
         fromDocumentId: document.id,
         toTitle,
         toDocumentId: titleToDocumentId.get(toTitle.toLowerCase()) ?? null,
         weight: linkWeights.get(toTitle.toLowerCase())?.weight ?? 1,
         priority: linkWeights.get(toTitle.toLowerCase())?.priority ?? 'normal'
-    }));
+    }))
+        .filter((link) => link.toDocumentId !== document.id);
     return {
         document,
         chunks,

package/dist/domain/middle-out.js

@@ -0,0 +1,18 @@
+export const middleOutIndices = (size, pivotIndex) => {
+    if (!Number.isFinite(size) || size <= 0) {
+        return [];
+    }
+    const clampedPivot = Math.max(0, Math.min(Math.floor(pivotIndex), size - 1));
+    const indices = [clampedPivot];
+    for (let offset = 1; indices.length < size; offset += 1) {
+        const left = clampedPivot - offset;
+        const right = clampedPivot + offset;
+        if (left >= 0) {
+            indices.push(left);
+        }
+        if (right < size) {
+            indices.push(right);
+        }
+    }
+    return indices;
+};

package/dist/infrastructure/config.js

@@ -1,7 +1,8 @@
-import { readFile } from 'node:fs/promises';
-import { resolve } from 'node:path';
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { dirname, join, resolve } from 'node:path';
+import { homedir } from 'node:os';
 import { sanitizeAgentId } from '../domain/agents.js';
-import { getDefaultVaultPath } from './paths.js';
+import { getBrainlinkHomePath, getDefaultVaultPath } from './paths.js';
 export const defaultBrainlinkConfig = {
     vault: getDefaultVaultPath(),
     host: '127.0.0.1',
@@ -13,15 +14,98 @@ export const defaultBrainlinkConfig = {
     defaultContextTokens: 2000,
     embeddingProvider: 'local',
     defaultSearchMode: 'hybrid',
-    chunkSize: 1200
+    chunkSize: 1200,
+    searchPack: {
+        rowChunkSize: 5_000,
+        compressionLevel: 5,
+        useDictionary: true,
+        guardrailMinSavingsPercent: 8,
+        guardrailMaxLatencyRegressionPercent: 5
+    },
+    agentProfiles: {}
 };
 const configFilenames = ['brainlink.config.json', '.brainlink.json'];
+const localConfigFilename = 'brainlink.config.json';
+const globalConfigFilename = 'brainlink.config.json';
+const globalConfigDirectoryMode = 0o700;
+const globalConfigFileMode = 0o600;
+const safeCwd = () => {
+    try {
+        return process.cwd();
+    }
+    catch {
+        return homedir();
+    }
+};
 const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
 const embeddingProviders = new Set(['none', 'local']);
 const searchModes = new Set(['fts', 'semantic', 'hybrid']);
 const sanitizeEmbeddingProvider = (value) => typeof value === 'string' && embeddingProviders.has(value) ? value : defaultBrainlinkConfig.embeddingProvider;
 export const sanitizeSearchMode = (value, fallback = defaultBrainlinkConfig.defaultSearchMode) => typeof value === 'string' && searchModes.has(value) ? value : fallback;
 const sanitizeAllowedVaults = (value) => Array.isArray(value) ? value.filter((item) => typeof item === 'string' && item.trim().length > 0) : [];
+const sanitizePositiveNumber = (value) => typeof value === 'number' && Number.isFinite(value) && value > 0 ? value : undefined;
+const sanitizeIntegerInRange = (value, fallback, minimum, maximum) => {
+    if (typeof value !== 'number' || !Number.isFinite(value)) {
+        return fallback;
+    }
+    const rounded = Math.round(value);
+    if (rounded < minimum) {
+        return minimum;
+    }
+    if (rounded > maximum) {
+        return maximum;
+    }
+    return rounded;
+};
+const sanitizeSearchPackConfig = (value) => {
+    const fallback = defaultBrainlinkConfig.searchPack;
+    if (!isRecord(value)) {
+        return fallback;
+    }
+    return {
+        rowChunkSize: sanitizeIntegerInRange(value.rowChunkSize, fallback.rowChunkSize, 100, 100_000),
+        compressionLevel: sanitizeIntegerInRange(value.compressionLevel, fallback.compressionLevel, 0, 11),
+        useDictionary: typeof value.useDictionary === 'boolean' ? value.useDictionary : fallback.useDictionary,
+        guardrailMinSavingsPercent: typeof value.guardrailMinSavingsPercent === 'number' && Number.isFinite(value.guardrailMinSavingsPercent)
+            ? Math.max(0, Math.min(95, value.guardrailMinSavingsPercent))
+            : fallback.guardrailMinSavingsPercent,
+        guardrailMaxLatencyRegressionPercent: typeof value.guardrailMaxLatencyRegressionPercent === 'number' && Number.isFinite(value.guardrailMaxLatencyRegressionPercent)
+            ? Math.max(0, Math.min(300, value.guardrailMaxLatencyRegressionPercent))
+            : fallback.guardrailMaxLatencyRegressionPercent
+    };
+};
+const sanitizeAgentProfile = (value) => {
+    if (!isRecord(value)) {
+        return null;
+    }
+    const defaultSearchLimit = sanitizePositiveNumber(value.defaultSearchLimit);
+    const defaultContextTokens = sanitizePositiveNumber(value.defaultContextTokens);
+    const defaultSearchMode = typeof value.defaultSearchMode === 'string' && searchModes.has(value.defaultSearchMode)
+        ? value.defaultSearchMode
+        : undefined;
+    const profile = {
+        ...(defaultSearchLimit ? { defaultSearchLimit } : {}),
+        ...(defaultContextTokens ? { defaultContextTokens } : {}),
+        ...(defaultSearchMode ? { defaultSearchMode } : {})
+    };
+    return Object.keys(profile).length > 0 ? profile : null;
+};
+const sanitizeAgentProfiles = (value) => {
+    if (!isRecord(value)) {
+        return {};
+    }
+    return Object.entries(value).reduce((state, [key, profile]) => {
+        const normalizedKey = key === '*' ? '*' : sanitizeAgentId(key);
+        const sanitizedProfile = sanitizeAgentProfile(profile);
+        if (!sanitizedProfile || normalizedKey.length === 0) {
+            return state;
+        }
+        return {
+            ...state,
+            [normalizedKey]: sanitizedProfile
+        };
+    }, {});
+};
 const readAllowedVaultsFromEnv = () => (process.env.BRAINLINK_ALLOWED_VAULTS ?? '')
     .split(',')
     .map((value) => value.trim())
@@ -39,6 +123,34 @@ const readJsonConfig = async (path) => {
         throw error;
     }
 };
+export const getGlobalConfigPath = () => join(getBrainlinkHomePath(), globalConfigFilename);
+export const getLocalConfigPath = (cwd = safeCwd()) => resolve(cwd, localConfigFilename);
+export const resolveConfigPath = (scope, cwd = safeCwd()) => scope === 'global' ? getGlobalConfigPath() : getLocalConfigPath(cwd);
+export const loadRawConfig = async (scope, cwd = safeCwd()) => readJsonConfig(resolveConfigPath(scope, cwd));
+export const loadLegacyLocalRawConfig = async (cwd = safeCwd()) => readJsonConfig(resolve(cwd, '.brainlink.json'));
+export const detectVaultConfigSource = async (cwd = safeCwd()) => {
+    const [globalConfig, localConfig, legacyLocalConfig] = await Promise.all([
+        loadRawConfig('global', cwd),
+        loadRawConfig('local', cwd),
+        loadLegacyLocalRawConfig(cwd)
+    ]);
+    if (typeof legacyLocalConfig.vault === 'string' && legacyLocalConfig.vault.trim().length > 0) {
+        return 'local-legacy';
+    }
+    if (typeof localConfig.vault === 'string' && localConfig.vault.trim().length > 0) {
+        return 'local';
+    }
+    if (typeof globalConfig.vault === 'string' && globalConfig.vault.trim().length > 0) {
+        return 'global';
+    }
+    return 'default';
+};
+export const writeRawConfig = async (scope, value, cwd = safeCwd()) => {
+    const path = resolveConfigPath(scope, cwd);
+    await mkdir(dirname(path), { recursive: true, mode: globalConfigDirectoryMode });
+    await writeFile(path, `${JSON.stringify(value, null, 2)}\n`, { encoding: 'utf8', mode: globalConfigFileMode });
+    return path;
+};
 const sanitizeConfig = (value) => ({
     ...defaultBrainlinkConfig,
     ...value,
@@ -55,12 +167,24 @@ const sanitizeConfig = (value) => ({
         : defaultBrainlinkConfig.defaultContextTokens,
     allowedVaults: [...sanitizeAllowedVaults(value.allowedVaults), ...readAllowedVaultsFromEnv()],
     chunkSize: typeof value.chunkSize === 'number' && value.chunkSize > 0 ? value.chunkSize : defaultBrainlinkConfig.chunkSize,
+    searchPack: sanitizeSearchPackConfig(value.searchPack),
     embeddingProvider: sanitizeEmbeddingProvider(value.embeddingProvider),
-    defaultSearchMode: sanitizeSearchMode(value.defaultSearchMode)
+    defaultSearchMode: sanitizeSearchMode(value.defaultSearchMode),
+    agentProfiles: sanitizeAgentProfiles(value.agentProfiles)
 });
-export const loadBrainlinkConfig = async (cwd = process.cwd()) => {
-    const configs = await Promise.all(configFilenames.map((filename) => readJsonConfig(resolve(cwd, filename))));
-    const merged = configs.reduce((state, config) => ({
+export const resolveAgentRuntimeDefaults = (config, agent) => {
+    const normalizedAgent = agent?.trim().length ? sanitizeAgentId(agent) : undefined;
+    const profile = (normalizedAgent ? config.agentProfiles[normalizedAgent] : undefined) ?? config.agentProfiles['*'];
+    return {
+        defaultSearchLimit: profile?.defaultSearchLimit ?? config.defaultSearchLimit,
+        defaultContextTokens: profile?.defaultContextTokens ?? config.defaultContextTokens,
+        defaultSearchMode: profile?.defaultSearchMode ?? config.defaultSearchMode
+    };
+};
+export const loadBrainlinkConfig = async (cwd = safeCwd()) => {
+    const globalConfig = await readJsonConfig(getGlobalConfigPath());
+    const localConfigs = await Promise.all(configFilenames.map((filename) => readJsonConfig(resolve(cwd, filename))));
+    const merged = [globalConfig, ...localConfigs].reduce((state, config) => ({
         ...state,
         ...config
     }), {});