@exaudeus/memory-mcp 1.9.7 → 1.9.9

package/dist/config-manager.d.ts

@@ -1,4 +1,4 @@
-import type { MemoryConfig } from './types.js';
+import type { MemoryConfig, BehaviorConfig } from './types.js';
 import { type LoadedConfig, type ConfigOrigin } from './config.js';
 import { MarkdownMemoryStore } from './store.js';
 /** Health status for a lobe (matches existing LobeHealth in index.ts) */
@@ -27,6 +27,7 @@ export declare class ConfigManager {
     private stores;
     private lobeHealth;
     private configMtime;
+    private behaviorConfig?;
     /** Cached alwaysInclude lobe names — recomputed atomically on reload. */
     private cachedAlwaysIncludeLobes;
     protected statFile(path: string): Promise<{
@@ -55,6 +56,7 @@ export declare class ConfigManager {
     getLobeNames(): readonly string[];
     getLobeHealth(lobe: string): LobeHealth | undefined;
     getConfigOrigin(): ConfigOrigin;
+    getBehaviorConfig(): BehaviorConfig | undefined;
     getLobeConfig(lobe: string): MemoryConfig | undefined;
     /** Returns lobe names where alwaysInclude is true. Cached; rebuilt atomically on hot-reload. */
     getAlwaysIncludeLobes(): readonly string[];

package/dist/config-manager.js

@@ -28,6 +28,7 @@ export class ConfigManager {
         this.stores = initialStores;
         this.lobeHealth = initialHealth;
         this.configMtime = Date.now(); // Initial mtime (will be updated on first stat)
+        this.behaviorConfig = initial.behavior;
         this.cachedAlwaysIncludeLobes = ConfigManager.computeAlwaysIncludeLobes(this.lobeConfigs);
     }
     /** Derive alwaysInclude lobe names from config — pure, no side effects. */
@@ -114,6 +115,7 @@ export class ConfigManager {
             this.stores = newStores;
             this.lobeHealth = newHealth;
             this.configMtime = newMtime;
+            this.behaviorConfig = newConfig.behavior;
             this.cachedAlwaysIncludeLobes = ConfigManager.computeAlwaysIncludeLobes(newConfig.configs);
             const lobeCount = newConfig.configs.size;
             const degradedCount = Array.from(newHealth.values()).filter(h => h.status === 'degraded').length;
@@ -139,6 +141,9 @@ export class ConfigManager {
     getConfigOrigin() {
         return this.configOrigin;
     }
+    getBehaviorConfig() {
+        return this.behaviorConfig;
+    }
     getLobeConfig(lobe) {
         return this.lobeConfigs.get(lobe);
     }

package/dist/index.js

@@ -497,7 +497,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     lobes: lobeInfo,
                     alwaysIncludeLobes: alwaysIncludeNames,
                     configFile: configFileDisplay(),
-                    configSource: configOrigin.source,
+                    configSource: configManager.getConfigOrigin().source,
                     totalLobes: lobeInfo.length,
                     degradedLobes: lobeInfo.filter((l) => l.health === 'degraded').length,
                 };
@@ -778,8 +778,15 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 }
                 const ctx = resolveToolContext(effectiveLobe);
                 if (!ctx.ok) {
+                    const availableLobes = configManager.getLobeNames();
+                    if (availableLobes.length === 0) {
+                        return {
+                            content: [{ type: 'text', text: `No lobes configured for preferences. Run memory_bootstrap(lobe: "your-project-name", root: "/absolute/path/to/repo") first, then store the preference with prefer(rule: "...", lobe: "<your-lobe>").` }],
+                            isError: true,
+                        };
+                    }
                     return {
-                        content: [{ type: 'text', text: `No global lobe configured for preferences. Specify a lobe: prefer(rule: "...", lobe: "...").\nAvailable: ${configManager.getLobeNames().join(', ')}` }],
+                        content: [{ type: 'text', text: `No global lobe configured for preferences. Specify a lobe: prefer(rule: "...", lobe: "...").\nAvailable: ${availableLobes.join(', ')}` }],
                         isError: true,
                     };
                 }
@@ -825,8 +832,15 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     }
                 }
                 if (!effectiveFixLobe) {
+                    const availableLobes = configManager.getLobeNames();
+                    if (availableLobes.length === 0) {
+                        return {
+                            content: [{ type: 'text', text: `No lobes configured. Run memory_bootstrap(lobe: "your-project-name", root: "/absolute/path/to/repo") first, then retry fix with the entry ID.` }],
+                            isError: true,
+                        };
+                    }
                     return {
-                        content: [{ type: 'text', text: `Entry "${id}" not found in any lobe. Available: ${configManager.getLobeNames().join(', ')}` }],
+                        content: [{ type: 'text', text: `Entry "${id}" not found in any lobe. Available: ${availableLobes.join(', ')}` }],
                         isError: true,
                     };
                 }
@@ -1260,6 +1274,13 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                         sections.push(crashSection);
                     if (degradedSection)
                         sections.push(degradedSection);
+                    if (allBriefingLobeNames.length === 0) {
+                        sections.push('## No Lobes Configured\n\n' +
+                            'No memory lobes exist yet. Run **memory_bootstrap** to create one for this project:\n\n' +
+                            '```\nmemory_bootstrap(lobe: "your-project-name", root: "/absolute/path/to/repo")\n```\n\n' +
+                            'After bootstrapping, call **memory_context** again to load project context.');
+                        return { content: [{ type: 'text', text: sections.join('\n\n---\n\n') }] };
+                    }
                     // Collect briefing, stale entries, and entry counts across all lobes
                     // (alwaysInclude lobes are in the lobe list — no separate global store query needed)
                     const allStale = [];
@@ -1472,6 +1493,11 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 // Combined stats across all lobes
                 const sections = [];
                 const allLobeNames = configManager.getLobeNames();
+                if (allLobeNames.length === 0) {
+                    return {
+                        content: [{ type: 'text', text: 'No lobes configured. Run memory_bootstrap(lobe: "your-project-name", root: "/absolute/path/to/repo") first, then retry memory_stats.' }],
+                    };
+                }
                 const alwaysIncludeSet = new Set(configManager.getAlwaysIncludeLobes());
                 for (const lobeName of allLobeNames) {
                     const store = configManager.getStore(lobeName);
@@ -1487,7 +1513,8 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 const { lobe: rawLobe } = z.object({
                     lobe: z.string().optional(),
                 }).parse(args ?? {});
-                const lobeName = rawLobe ?? lobeNames[0];
+                const currentLobeNames = configManager.getLobeNames();
+                const lobeName = rawLobe ?? (currentLobeNames.length === 1 ? currentLobeNames[0] : undefined);
                 const ctx = resolveToolContext(lobeName);
                 if (!ctx.ok)
                     return contextError(ctx);
@@ -1550,10 +1577,31 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                         await configManager.ensureFresh();
                     }
                 }
-                // Resolve store — after this point, rawLobe is never used again
-                const ctx = resolveToolContext(rawLobe);
-                if (!ctx.ok)
-                    return contextError(ctx);
+                const effectiveLobe = rawLobe ?? (configManager.getLobeNames().length === 1 ? configManager.getLobeNames()[0] : undefined);
+                if (!effectiveLobe) {
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: `memory_bootstrap requires a lobe when multiple lobes exist. Available: ${configManager.getLobeNames().join(', ')}`,
+                            }],
+                        isError: true,
+                    };
+                }
+                const store = configManager.getStore(effectiveLobe);
+                if (!store) {
+                    const origin = configManager.getConfigOrigin();
+                    const hint = origin.source === 'file'
+                        ? `Check ${origin.path} and confirm lobe "${effectiveLobe}" exists and points at a valid repo root.`
+                        : `Run memory_bootstrap(lobe: "${effectiveLobe}", root: "/absolute/path/to/repo") again to create the lobe.`;
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: `Bootstrap could not resolve lobe "${effectiveLobe}" after config update. ${hint}`,
+                            }],
+                        isError: true,
+                    };
+                }
+                const ctx = { ok: true, store, label: effectiveLobe };
                 const results = await ctx.store.bootstrap();
                 const stored = results.filter((r) => r.kind === 'stored');
                 const failed = results.filter((r) => r.kind !== 'stored');
@@ -1701,7 +1749,7 @@ async function buildDiagnosticsText(showFullCrashHistory) {
     sections.push('');
     // Active behavior config — shows effective values and highlights user overrides
     sections.push('### Active Behavior Config');
-    sections.push(formatBehaviorConfigSection(configBehavior));
+    sections.push(formatBehaviorConfigSection(configManager.getBehaviorConfig()));
     sections.push('');
     const latestCrash = await readLatestCrash();
     if (latestCrash) {
@@ -1784,8 +1832,10 @@ async function main() {
             await writeCrashReport(report).catch(() => { });
         }
     }
-    // Determine server mode based on lobe health
-    if (healthyLobes === 0) {
+    // Determine server mode based on lobe health.
+    // Zero configured lobes is a valid operational state: tools should stay available
+    // so the agent can bootstrap the first project lobe.
+    if (lobeConfigs.size > 0 && healthyLobes === 0) {
         serverMode = {
             kind: 'safe-mode',
             error: `All ${lobeConfigs.size} lobes failed to initialize.`,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exaudeus/memory-mcp",
-  "version": "1.9.7",
+  "version": "1.9.9",
   "description": "Codebase memory MCP server - persistent, evolving knowledge for AI coding agents",
   "type": "module",
   "main": "dist/index.js",