@exaudeus/memory-mcp 1.0.0 → 1.0.1

package/dist/index.js

@@ -9,6 +9,7 @@ import { z } from 'zod';
 import path from 'path';
 import os from 'os';
 import { existsSync, writeFileSync } from 'fs';
+import { readFile, writeFile } from 'fs/promises';
 import { MarkdownMemoryStore } from './store.js';
 import { DEFAULT_STORAGE_BUDGET_BYTES, parseTopicScope, parseTrustLevel } from './types.js';
 import { getLobeConfigs } from './config.js';
@@ -16,6 +17,8 @@ import { ConfigManager } from './config-manager.js';
 import { normalizeArgs } from './normalize.js';
 import { buildCrashReport, writeCrashReport, writeCrashReportSync, readLatestCrash, readCrashHistory, clearLatestCrash, formatCrashReport, formatCrashSummary, markServerStarted, } from './crash-journal.js';
 import { formatStaleSection, formatConflictWarning, formatStats, formatBehaviorConfigSection } from './formatters.js';
+import { extractKeywords } from './text-analyzer.js';
+import { CROSS_LOBE_WEAK_SCORE_PENALTY, CROSS_LOBE_MIN_MATCH_RATIO } from './thresholds.js';
 let serverMode = { kind: 'running' };
 const lobeHealth = new Map();
 const serverStartTime = Date.now();
@@ -105,10 +108,9 @@ function resolveToolContext(rawLobe, opts) {
         const configOrigin = configManager.getConfigOrigin();
         let hint = '';
         if (configOrigin.source === 'file') {
-            hint = `\n\nTo add lobe "${lobe}":\n` +
-                `1. Edit ${configOrigin.path}\n` +
-                `2. Add: "${lobe}": { "root": "$HOME/git/.../repo", "memoryDir": ".memory", "budgetMB": 2 }\n` +
-                `3. Restart the memory MCP server`;
+            hint = `\n\nTo add lobe "${lobe}", either:\n` +
+                `A) Call memory_bootstrap(lobe: "${lobe}", root: "/absolute/path/to/repo") — auto-adds it in one step.\n` +
+                `B) Edit ${configOrigin.path}, add: "${lobe}": { "root": "/absolute/path/to/repo", "budgetMB": 2 }, then retry (no restart needed — the server hot-reloads automatically).`;
         }
         else if (configOrigin.source === 'env') {
             hint = `\n\nTo add lobe "${lobe}", update MEMORY_MCP_WORKSPACES env var or create memory-config.json`;
@@ -152,163 +154,186 @@ function inferLobeFromPaths(paths) {
     return matchedLobes.size === 1 ? matchedLobes.values().next().value : undefined;
 }
 const server = new Server({ name: 'memory-mcp', version: '0.1.0' }, { capabilities: { tools: {} } });
-// Shared lobe property for tool schemas
-const isSingleLobe = lobeNames.length === 1;
-const lobeProperty = {
-    type: 'string',
-    description: isSingleLobe
-        ? `Memory lobe name (defaults to "${lobeNames[0]}" if omitted)`
-        : `Memory lobe name. Optional for reads (query/context/briefing/stats search all lobes when omitted). Required for writes (store/correct/bootstrap). Available: ${lobeNames.join(', ')}`,
-    enum: lobeNames.length > 1 ? lobeNames : undefined,
-};
+/** Build the shared lobe property for tool schemas — called on each ListTools request
+ *  so the description and enum stay in sync after a hot-reload adds or removes lobes. */
+function buildLobeProperty(currentLobeNames) {
+    const isSingle = currentLobeNames.length === 1;
+    return {
+        type: 'string',
+        description: isSingle
+            ? `Memory lobe name (defaults to "${currentLobeNames[0]}" if omitted)`
+            : `Memory lobe name. Optional for reads (query/context/briefing/stats search all lobes when omitted). Required for writes (store/correct/bootstrap). Available: ${currentLobeNames.join(', ')}`,
+        enum: currentLobeNames.length > 1 ? [...currentLobeNames] : undefined,
+    };
+}
 /** Helper to format config file path for display */
 function configFileDisplay() {
     const origin = configManager.getConfigOrigin();
     return origin.source === 'file' ? origin.path : '(not using config file)';
 }
 // --- Tool definitions ---
-server.setRequestHandler(ListToolsRequestSchema, async () => ({
-    tools: [
-        // memory_list_lobes is hidden — lobe info is surfaced in memory_context() hints
-        // and memory_stats. The handler still works if called directly.
-        {
-            name: 'memory_store',
-            description: 'Store knowledge. "user" and "preferences" are global (no lobe needed). Example: memory_store(topic: "gotchas", title: "Build cache", content: "Must clean build after Tuist changes")',
-            inputSchema: {
-                type: 'object',
-                properties: {
-                    lobe: lobeProperty,
-                    topic: {
-                        type: 'string',
-                        description: 'user | preferences | architecture | conventions | gotchas | recent-work | modules/<name>',
-                        enum: ['user', 'preferences', 'architecture', 'conventions', 'gotchas', 'recent-work'],
-                    },
-                    title: {
-                        type: 'string',
-                        description: 'Short title for this entry',
-                    },
-                    content: {
-                        type: 'string',
-                        description: 'The knowledge to store',
-                    },
-                    sources: {
-                        type: 'array',
-                        items: { type: 'string' },
-                        description: 'File paths that informed this (provenance, for freshness tracking)',
-                        default: [],
-                    },
-                    references: {
-                        type: 'array',
-                        items: { type: 'string' },
-                        description: 'Files, classes, or symbols this knowledge is about (semantic pointers). Example: ["features/messaging/impl/MessagingReducer.kt"]',
-                        default: [],
-                    },
-                    trust: {
-                        type: 'string',
-                        enum: ['user', 'agent-confirmed', 'agent-inferred'],
-                        description: 'user (from human) > agent-confirmed > agent-inferred',
-                        default: 'agent-inferred',
+// Handler is async so it can call configManager.ensureFresh() and return a fresh
+// lobe list. This ensures the enum and descriptions stay correct after hot-reload.
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+    await configManager.ensureFresh();
+    const currentLobeNames = configManager.getLobeNames();
+    const lobeProperty = buildLobeProperty(currentLobeNames);
+    return { tools: [
+            // memory_list_lobes is hidden — lobe info is surfaced in memory_context() hints
+            // and memory_stats. The handler still works if called directly.
+            {
+                name: 'memory_store',
+                description: 'Store knowledge. "user" and "preferences" are global (no lobe needed). Example: memory_store(topic: "gotchas", title: "Build cache", content: "Must clean build after Tuist changes")',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        lobe: lobeProperty,
+                        topic: {
+                            type: 'string',
+                            // modules/<name> is intentionally excluded from the enum so the MCP schema
+                            // doesn't restrict it — agents can pass any "modules/foo" value and it works.
+                            // The description makes this explicit.
+                            description: 'Predefined: user | preferences | architecture | conventions | gotchas | recent-work. Custom namespace: modules/<name> (e.g. modules/brainstorm, modules/game-design, modules/api-notes). Use modules/<name> for any domain that doesn\'t fit the built-in topics.',
+                            enum: ['user', 'preferences', 'architecture', 'conventions', 'gotchas', 'recent-work'],
+                        },
+                        title: {
+                            type: 'string',
+                            description: 'Short title for this entry',
+                        },
+                        content: {
+                            type: 'string',
+                            description: 'The knowledge to store',
+                        },
+                        sources: {
+                            type: 'array',
+                            items: { type: 'string' },
+                            description: 'File paths that informed this (provenance, for freshness tracking)',
+                            default: [],
+                        },
+                        references: {
+                            type: 'array',
+                            items: { type: 'string' },
+                            description: 'Files, classes, or symbols this knowledge is about (semantic pointers). Example: ["features/messaging/impl/MessagingReducer.kt"]',
+                            default: [],
+                        },
+                        trust: {
+                            type: 'string',
+                            enum: ['user', 'agent-confirmed', 'agent-inferred'],
+                            description: 'user (from human) > agent-confirmed > agent-inferred',
+                            default: 'agent-inferred',
+                        },
                     },
+                    required: ['topic', 'title', 'content'],
                 },
-                required: ['topic', 'title', 'content'],
             },
-        },
-        {
-            name: 'memory_query',
-            description: 'Search stored knowledge. Searches all lobes when lobe is omitted. Example: memory_query(scope: "*", filter: "reducer sealed", detail: "full"). Use scope "*" to search everything. Use detail "full" for complete content.',
-            inputSchema: {
-                type: 'object',
-                properties: {
-                    lobe: lobeProperty,
-                    scope: {
-                        type: 'string',
-                        description: 'Optional. Defaults to "*" (all topics). Options: * | user | preferences | architecture | conventions | gotchas | recent-work | modules/<name>',
-                    },
-                    detail: {
-                        type: 'string',
-                        enum: ['brief', 'standard', 'full'],
-                        description: 'brief = titles only, standard = summaries, full = complete content + metadata',
-                        default: 'brief',
-                    },
-                    filter: {
-                        type: 'string',
-                        description: 'Search terms. "A B" = AND, "A|B" = OR, "-A" = NOT. Example: "reducer sealed -deprecated"',
-                    },
-                    branch: {
-                        type: 'string',
-                        description: 'Branch for recent-work. Omit = current branch, "*" = all branches.',
+            {
+                name: 'memory_query',
+                description: 'Search stored knowledge. Searches all lobes when lobe is omitted. Example: memory_query(scope: "*", filter: "reducer sealed", detail: "full"). Use scope "*" to search everything. Use detail "full" for complete content.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        lobe: lobeProperty,
+                        scope: {
+                            type: 'string',
+                            description: 'Optional. Defaults to "*" (all topics). Options: * | user | preferences | architecture | conventions | gotchas | recent-work | modules/<name>',
+                        },
+                        detail: {
+                            type: 'string',
+                            enum: ['brief', 'standard', 'full'],
+                            description: 'brief = titles only, standard = summaries, full = complete content + metadata',
+                            default: 'brief',
+                        },
+                        filter: {
+                            type: 'string',
+                            description: 'Search terms. "A B" = AND, "A|B" = OR, "-A" = NOT. Example: "reducer sealed -deprecated"',
+                        },
+                        branch: {
+                            type: 'string',
+                            description: 'Branch for recent-work. Omit = current branch, "*" = all branches.',
+                        },
                     },
+                    required: [],
                 },
-                required: [],
             },
-        },
-        {
-            name: 'memory_correct',
-            description: 'Fix or delete an entry. Example: memory_correct(id: "arch-3f7a", action: "replace", correction: "updated content")',
-            inputSchema: {
-                type: 'object',
-                properties: {
-                    lobe: lobeProperty,
-                    id: {
-                        type: 'string',
-                        description: 'Entry ID (e.g. arch-3f7a, pref-5c9b)',
-                    },
-                    correction: {
-                        type: 'string',
-                        description: 'New text (for append/replace). Not needed for delete.',
-                    },
-                    action: {
-                        type: 'string',
-                        enum: ['append', 'replace', 'delete'],
-                        description: 'append | replace | delete',
+            {
+                name: 'memory_correct',
+                description: 'Fix or delete an entry. Example: memory_correct(id: "arch-3f7a", action: "replace", correction: "updated content")',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        lobe: lobeProperty,
+                        id: {
+                            type: 'string',
+                            description: 'Entry ID (e.g. arch-3f7a, pref-5c9b)',
+                        },
+                        correction: {
+                            type: 'string',
+                            description: 'New text (for append/replace). Not needed for delete.',
+                        },
+                        action: {
+                            type: 'string',
+                            enum: ['append', 'replace', 'delete'],
+                            description: 'append | replace | delete',
+                        },
                     },
+                    required: ['id', 'action'],
                 },
-                required: ['id', 'action'],
             },
-        },
-        {
-            name: 'memory_context',
-            description: 'Session start AND pre-task lookup. Call with no args at session start to get user identity, preferences, and stale entries. Call with context to get task-specific knowledge. Searches all lobes when lobe is omitted. Example: memory_context() or memory_context(context: "writing a Kotlin reducer")',
-            inputSchema: {
-                type: 'object',
-                properties: {
-                    lobe: lobeProperty,
-                    context: {
-                        type: 'string',
-                        description: 'Optional. What you are about to do, in natural language. Omit for session-start briefing (user + preferences + stale entries).',
-                    },
-                    maxResults: {
-                        type: 'number',
-                        description: 'Max results (default: 10)',
-                        default: 10,
-                    },
-                    minMatch: {
-                        type: 'number',
-                        description: 'Min keyword match ratio 0-1 (default: 0.2). Higher = stricter.',
-                        default: 0.2,
+            {
+                name: 'memory_context',
+                description: 'Session start AND pre-task lookup. Call with no args at session start to get user identity, preferences, and stale entries. Call with context to get task-specific knowledge. Searches all lobes when lobe is omitted. Example: memory_context() or memory_context(context: "writing a Kotlin reducer")',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        lobe: lobeProperty,
+                        context: {
+                            type: 'string',
+                            description: 'Optional. What you are about to do, in natural language. Omit for session-start briefing (user + preferences + stale entries).',
+                        },
+                        maxResults: {
+                            type: 'number',
+                            description: 'Max results (default: 10)',
+                            default: 10,
+                        },
+                        minMatch: {
+                            type: 'number',
+                            description: 'Min keyword match ratio 0-1 (default: 0.2). Higher = stricter.',
+                            default: 0.2,
+                        },
                     },
+                    required: [],
                 },
-                required: [],
             },
-        },
-        // memory_stats is hidden — agents rarely need it proactively. Mentioned in
-        // hints when storage is running low. The handler still works if called directly.
-        {
-            name: 'memory_bootstrap',
-            description: 'First-time setup: scan repo structure, README, and build system to seed initial knowledge. Run once per new codebase.',
-            inputSchema: {
-                type: 'object',
-                properties: {
-                    lobe: lobeProperty,
+            // memory_stats is hidden — agents rarely need it proactively. Mentioned in
+            // hints when storage is running low. The handler still works if called directly.
+            {
+                name: 'memory_bootstrap',
+                description: 'First-time setup: scan repo structure, README, and build system to seed initial knowledge. Run once per new codebase. If the lobe does not exist yet, provide "root" to auto-add it to memory-config.json and proceed without a manual restart.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        lobe: {
+                            type: 'string',
+                            // No enum restriction: agents pass new lobe names not yet in the config
+                            description: `Memory lobe name. If the lobe doesn't exist yet, also pass "root" to auto-create it. Available lobes: ${currentLobeNames.join(', ')}`,
+                        },
+                        root: {
+                            type: 'string',
+                            description: 'Absolute path to the repo root. Required only when the lobe does not exist yet — the server will add it to memory-config.json automatically.',
+                        },
+                        budgetMB: {
+                            type: 'number',
+                            description: 'Storage budget in MB for the new lobe (default: 2). Only used when auto-creating a lobe via "root".',
+                        },
+                    },
+                    required: [],
                 },
-                required: [],
             },
-        },
-        // memory_diagnose is intentionally hidden from the tool list — it clutters
-        // agent tool discovery and should only be called when directed by error messages
-        // or crash reports. The handler still works if called directly.
-    ],
-}));
+            // memory_diagnose is intentionally hidden from the tool list — it clutters
+            // agent tool discovery and should only be called when directed by error messages
+            // or crash reports. The handler still works if called directly.
+        ] };
+});
 // --- Tool handlers ---
 server.setRequestHandler(CallToolRequestSchema, async (request) => {
     const { name, arguments: rawArgs } = request.params;
@@ -564,7 +589,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 // Nudge: when searching all lobes, remind the agent to specify one for targeted results
                 const allQueryLobeNames = configManager.getLobeNames();
                 if (!rawLobe && !isGlobalQuery && allQueryLobeNames.length > 1) {
-                    hints.push(`Searched all lobes. For targeted results use lobe: "${allQueryLobeNames[0]}" (available: ${allQueryLobeNames.join(', ')}).`);
+                    hints.push(`Searched all lobes (${allQueryLobeNames.join(', ')}). Specify lobe: "<name>" for targeted results.`);
                 }
                 if (detail !== 'full') {
                     hints.push('Use detail: "full" to see complete entry content.');
@@ -742,6 +767,21 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                         allLobeResults.push(...lobeResults);
                     }
                 }
+                // Cross-lobe weak-match penalty: demote results from other repos that only matched
+                // on generic software terms (e.g. "codebase", "structure"). Without this, a high-
+                // confidence entry from an unrelated repo can outrank genuinely relevant knowledge
+                // simply because popular terms appear in it.
+                // Applied only in multi-lobe mode; single-lobe and global results are never penalized.
+                if (isCtxMultiLobe) {
+                    const contextKwCount = extractKeywords(context).size;
+                    // Minimum keyword matches required to avoid the penalty (at least 40% of context, min 2)
+                    const minMatchCount = Math.max(2, Math.ceil(contextKwCount * CROSS_LOBE_MIN_MATCH_RATIO));
+                    for (let i = 0; i < allLobeResults.length; i++) {
+                        if (allLobeResults[i].matchedKeywords.length < minMatchCount) {
+                            allLobeResults[i] = { ...allLobeResults[i], score: allLobeResults[i].score * CROSS_LOBE_WEAK_SCORE_PENALTY };
+                        }
+                    }
+                }
                 // Always include global store (user + preferences)
                 const globalResults = await globalStore.contextSearch(context, max, undefined, threshold);
                 for (const r of globalResults)
@@ -812,10 +852,14 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 }
                 // Hints
                 const ctxHints = [];
-                // Nudge: when searching all lobes, remind the agent to specify one for targeted results
+                // Nudge: when searching all lobes, infer the most relevant lobe from context keywords
+                // matching lobe names (e.g. "minion-miner" in context → suggest lobe "minion-miner"),
+                // falling back to the first lobe when no name overlap is found.
                 const allCtxLobeNames = configManager.getLobeNames();
                 if (!rawLobe && allCtxLobeNames.length > 1) {
-                    ctxHints.push(`Searched all lobes. For faster, targeted results use lobe: "${allCtxLobeNames[0]}" (available: ${allCtxLobeNames.join(', ')}).`);
+                    const contextKws = extractKeywords(context);
+                    const inferredLobe = allCtxLobeNames.find(name => [...extractKeywords(name)].some(kw => contextKws.has(kw))) ?? allCtxLobeNames[0];
+                    ctxHints.push(`Searched all lobes. For faster, targeted results use lobe: "${inferredLobe}" (available: ${allCtxLobeNames.join(', ')}).`);
                 }
                 if (results.length >= max) {
                     ctxHints.push(`Showing top ${max} results. Increase maxResults or raise minMatch to refine.`);
@@ -861,9 +905,45 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 return { content: [{ type: 'text', text: sections.join('\n\n---\n\n') }] };
             }
             case 'memory_bootstrap': {
-                const { lobe: rawLobe } = z.object({
+                const { lobe: rawLobe, root, budgetMB } = z.object({
                     lobe: z.string().optional(),
+                    root: z.string().optional(),
+                    budgetMB: z.number().positive().optional(),
                 }).parse(args);
+                // Auto-create lobe: if the lobe is unknown AND root is provided AND config is
+                // file-based, write the new lobe entry into memory-config.json and hot-reload.
+                // This lets the agent bootstrap a brand-new repo in a single tool call.
+                if (rawLobe && root && !configManager.getStore(rawLobe)) {
+                    const origin = configManager.getConfigOrigin();
+                    if (origin.source !== 'file') {
+                        return {
+                            content: [{
+                                    type: 'text',
+                                    text: `Cannot auto-add lobe "${rawLobe}": config is not file-based (source: ${origin.source}).\n\n` +
+                                        `Create memory-config.json next to the memory MCP server with a "lobes" block, then retry.`,
+                                }],
+                            isError: true,
+                        };
+                    }
+                    try {
+                        const raw = await readFile(origin.path, 'utf-8');
+                        const config = JSON.parse(raw);
+                        if (!config.lobes || typeof config.lobes !== 'object')
+                            config.lobes = {};
+                        config.lobes[rawLobe] = { root, budgetMB: budgetMB ?? 2 };
+                        await writeFile(origin.path, JSON.stringify(config, null, 2) + '\n', 'utf-8');
+                        process.stderr.write(`[memory-mcp] Auto-added lobe "${rawLobe}" (root: ${root}) to memory-config.json\n`);
+                    }
+                    catch (err) {
+                        const message = err instanceof Error ? err.message : String(err);
+                        return {
+                            content: [{ type: 'text', text: `Failed to auto-add lobe "${rawLobe}" to memory-config.json: ${message}` }],
+                            isError: true,
+                        };
+                    }
+                    // Reload config to pick up the new lobe (hot-reload detects the updated mtime)
+                    await configManager.ensureFresh();
+                }
                 // Resolve store — after this point, rawLobe is never used again
                 const ctx = resolveToolContext(rawLobe);
                 if (!ctx.ok)
@@ -907,7 +987,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             hint = `\n\nHint: lobe is required. Use memory_list_lobes to see available lobes. Available: ${lobeNames.join(', ')}`;
         }
         else if (message.includes('"topic"') || message.includes('"title"') || message.includes('"content"')) {
-            hint = '\n\nHint: memory_store requires: lobe, topic (architecture|conventions|gotchas|recent-work), title, content';
+            hint = '\n\nHint: memory_store requires: topic (architecture|conventions|gotchas|recent-work|modules/<name>), title, content. Use modules/<name> for custom namespaces (e.g. modules/brainstorm, modules/game-design).';
         }
         else if (message.includes('"scope"')) {
             hint = '\n\nHint: memory_query requires: lobe, scope (architecture|conventions|gotchas|recent-work|modules/<name>|* for all)';

package/dist/store.js

@@ -344,6 +344,7 @@ export class MarkdownMemoryStore {
             { file: 'go.mod', meaning: 'Go module' },
             { file: 'pyproject.toml', meaning: 'Python project' },
             { file: 'Tuist.swift', meaning: 'iOS project managed by Tuist' },
+            { file: 'project.godot', meaning: 'Godot Engine project (GDScript/C#)' },
         ];
         const detected = [];
         for (const { file, meaning } of buildFiles) {
@@ -362,6 +363,22 @@ export class MarkdownMemoryStore {
             results.push(await this.store('recent-work', 'Recent Git History', `Last 5 commits:\n${stdout.trim()}`, [], 'agent-inferred'));
         }
         catch { /* not a git repo or git not available */ }
+        // 5. Fallback: if nothing was detected, store a minimal overview so the lobe
+        //    is never left completely empty after bootstrap (makes memory_context useful immediately).
+        const storedCount = results.filter(r => r.stored).length;
+        if (storedCount === 0) {
+            try {
+                const topLevel = await fs.readdir(repoRoot, { withFileTypes: true });
+                const items = topLevel
+                    .filter(d => !d.name.startsWith('.') && d.name !== 'node_modules')
+                    .map(d => `${d.isDirectory() ? '[dir]' : '[file]'} ${d.name}`)
+                    .join(', ');
+                results.push(await this.store('architecture', 'Repo Overview', items.length > 0
+                    ? `Minimal repository. Top-level contents: ${items}.`
+                    : `Empty or newly initialized repository at ${repoRoot}.`, [], 'agent-inferred'));
+            }
+            catch { /* ignore */ }
+        }
         return results;
     }
     // --- Contextual search (memory_context) ---

package/dist/thresholds.d.ts

@@ -16,6 +16,14 @@ export declare const CONFLICT_MIN_CONTENT_CHARS = 50;
 export declare const OPPOSITION_PAIRS: ReadonlyArray<readonly [string, string]>;
 /** Score multiplier when a reference path basename matches the context keywords. */
 export declare const REFERENCE_BOOST_MULTIPLIER = 1.3;
+/** Score multiplier applied to weak cross-lobe results in multi-lobe context search.
+ *  Prevents generic software terms (e.g. "codebase", "structure") from surfacing
+ *  entries from unrelated repos with high confidence/topic-boost scores. */
+export declare const CROSS_LOBE_WEAK_SCORE_PENALTY = 0.5;
+/** Fraction of context keywords an entry must match to avoid the cross-lobe penalty.
+ *  E.g. 0.40 means an entry must match at least 40% of the context keywords (minimum 2)
+ *  to be treated as a strong cross-lobe match. */
+export declare const CROSS_LOBE_MIN_MATCH_RATIO = 0.4;
 /** Per-topic scoring boost factors for contextSearch().
  *  Higher = more likely to surface for any given context. */
 export declare const TOPIC_BOOST: Record<string, number>;

package/dist/thresholds.js

@@ -42,6 +42,14 @@ export const OPPOSITION_PAIRS = [
 ];
 /** Score multiplier when a reference path basename matches the context keywords. */
 export const REFERENCE_BOOST_MULTIPLIER = 1.30;
+/** Score multiplier applied to weak cross-lobe results in multi-lobe context search.
+ *  Prevents generic software terms (e.g. "codebase", "structure") from surfacing
+ *  entries from unrelated repos with high confidence/topic-boost scores. */
+export const CROSS_LOBE_WEAK_SCORE_PENALTY = 0.50;
+/** Fraction of context keywords an entry must match to avoid the cross-lobe penalty.
+ *  E.g. 0.40 means an entry must match at least 40% of the context keywords (minimum 2)
+ *  to be treated as a strong cross-lobe match. */
+export const CROSS_LOBE_MIN_MATCH_RATIO = 0.40;
 /** Per-topic scoring boost factors for contextSearch().
  *  Higher = more likely to surface for any given context. */
 export const TOPIC_BOOST = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exaudeus/memory-mcp",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "Codebase memory MCP server - persistent, evolving knowledge for AI coding agents",
   "type": "module",
   "main": "dist/index.js",
@@ -47,7 +47,7 @@
     "@semantic-release/github": "^12.0.6",
     "@types/node": "^20.0.0",
     "conventional-changelog-conventionalcommits": "^9.1.0",
-    "semantic-release": "^24.2.9",
+    "semantic-release": "^25.0.3",
     "tsx": "^4.0.0",
     "typescript": "^5.0.0"
   },