@exaudeus/memory-mcp 1.3.0 → 1.4.0

package/dist/config-manager.d.ts

@@ -27,10 +27,14 @@ export declare class ConfigManager {
     private stores;
     private lobeHealth;
     private configMtime;
+    /** Cached alwaysInclude lobe names — recomputed atomically on reload. */
+    private cachedAlwaysIncludeLobes;
     protected statFile(path: string): Promise<{
         mtimeMs: number;
     }>;
     constructor(configPath: string, initial: LoadedConfig, initialStores: Map<string, MarkdownMemoryStore>, initialHealth: Map<string, LobeHealth>);
+    /** Derive alwaysInclude lobe names from config — pure, no side effects. */
+    private static computeAlwaysIncludeLobes;
     /**
      * Ensure config is fresh. Call at the start of every tool handler.
      * Stats config file, reloads if mtime changed. Graceful on all errors.
@@ -46,4 +50,6 @@ export declare class ConfigManager {
     getLobeHealth(lobe: string): LobeHealth | undefined;
     getConfigOrigin(): ConfigOrigin;
     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,13 @@ export class ConfigManager {
         this.stores = initialStores;
         this.lobeHealth = initialHealth;
         this.configMtime = Date.now(); // Initial mtime (will be updated on first stat)
+        this.cachedAlwaysIncludeLobes = ConfigManager.computeAlwaysIncludeLobes(this.lobeConfigs);
+    }
+    /** Derive alwaysInclude lobe names from config — pure, no side effects. */
+    static computeAlwaysIncludeLobes(configs) {
+        return Array.from(configs.entries())
+            .filter(([, config]) => config.alwaysInclude === true)
+            .map(([name]) => name);
     }
     /**
      * Ensure config is fresh. Call at the start of every tool handler.
@@ -90,12 +97,13 @@ export class ConfigManager {
                     });
                 }
             }
-            // Atomic swap
+            // Atomic swap — all derived state recomputed together
             this.configOrigin = newConfig.origin;
             this.lobeConfigs = newConfig.configs;
             this.stores = newStores;
             this.lobeHealth = newHealth;
             this.configMtime = newMtime;
+            this.cachedAlwaysIncludeLobes = ConfigManager.computeAlwaysIncludeLobes(newConfig.configs);
             const lobeCount = newConfig.configs.size;
             const degradedCount = Array.from(newHealth.values()).filter(h => h.status === 'degraded').length;
             const timestamp = new Date().toISOString();
@@ -123,4 +131,8 @@ export class ConfigManager {
     getLobeConfig(lobe) {
         return this.lobeConfigs.get(lobe);
     }
+    /** Returns lobe names where alwaysInclude is true. Cached; rebuilt atomically on hot-reload. */
+    getAlwaysIncludeLobes() {
+        return this.cachedAlwaysIncludeLobes;
+    }
 }

package/dist/config.js

@@ -2,7 +2,7 @@
 //
 // Priority: memory-config.json → env vars → single-repo default
 // Graceful degradation: each source falls through to the next on failure.
-import { readFileSync } from 'fs';
+import { readFileSync, existsSync, readdirSync } from 'fs';
 import { execFileSync } from 'child_process';
 import path from 'path';
 import os from 'os';
@@ -81,6 +81,42 @@ function resolveMemoryPath(repoRoot, workspaceName, explicitMemoryDir) {
     }
     return path.join(os.homedir(), '.memory-mcp', workspaceName);
 }
+/** If no lobe has alwaysInclude: true AND the legacy global store directory has actual entries,
+ *  auto-create a "global" lobe pointing to it. Protects existing users who haven't updated their config.
+ *  Only fires when the dir contains .md files — an empty dir doesn't trigger creation. */
+function ensureAlwaysIncludeLobe(configs, behavior) {
+    const hasAlwaysInclude = Array.from(configs.values()).some(c => c.alwaysInclude);
+    if (hasAlwaysInclude)
+        return;
+    // Don't overwrite a user-defined "global" lobe — warn instead.
+    // Philosophy: "Make illegal states unrepresentable" — silently replacing config is a hidden state.
+    if (configs.has('global')) {
+        process.stderr.write(`[memory-mcp] Lobe "global" exists but has no alwaysInclude flag. ` +
+            `Add "alwaysInclude": true to your global lobe config to include it in all reads.\n`);
+        return;
+    }
+    const globalPath = path.join(os.homedir(), '.memory-mcp', 'global');
+    if (!existsSync(globalPath))
+        return;
+    // Only auto-create if the dir has actual memory entries (not just an empty directory)
+    try {
+        const files = readdirSync(globalPath);
+        if (!files.some(f => f.endsWith('.md')))
+            return;
+    }
+    catch (err) {
+        process.stderr.write(`[memory-mcp] Warning: could not read legacy global store at ${globalPath}: ${err}\n`);
+        return;
+    }
+    configs.set('global', {
+        repoRoot: os.homedir(),
+        memoryPath: globalPath,
+        storageBudgetBytes: DEFAULT_STORAGE_BUDGET_BYTES,
+        alwaysInclude: true,
+        behavior,
+    });
+    process.stderr.write(`[memory-mcp] Auto-created "global" lobe (alwaysInclude) from existing ${globalPath}\n`);
+}
 /** Load lobe configs with priority: memory-config.json -> env vars -> single-repo default */
 export function getLobeConfigs() {
     const configs = new Map();
@@ -105,13 +141,15 @@ export function getLobeConfigs() {
                     repoRoot,
                     memoryPath: resolveMemoryPath(repoRoot, name, config.memoryDir),
                     storageBudgetBytes: (config.budgetMB ?? 2) * 1024 * 1024,
+                    alwaysInclude: config.alwaysInclude ?? false,
                     behavior,
                 });
             }
             if (configs.size > 0) {
+                // Reuse the already-parsed behavior config for the alwaysInclude fallback
+                const resolvedBehavior = external.behavior ? behavior : undefined;
+                ensureAlwaysIncludeLobe(configs, resolvedBehavior);
                 process.stderr.write(`[memory-mcp] Loaded ${configs.size} lobe(s) from memory-config.json\n`);
-                // Pass resolved behavior at the top-level so diagnostics can surface active values
-                const resolvedBehavior = external.behavior ? parseBehaviorConfig(external.behavior) : undefined;
                 return { configs, origin: { source: 'file', path: configPath }, behavior: resolvedBehavior };
             }
         }
@@ -137,9 +175,11 @@ export function getLobeConfigs() {
                     repoRoot,
                     memoryPath: resolveMemoryPath(repoRoot, name, explicitDir),
                     storageBudgetBytes: storageBudget,
+                    alwaysInclude: false,
                 });
             }
             if (configs.size > 0) {
+                ensureAlwaysIncludeLobe(configs);
                 process.stderr.write(`[memory-mcp] Loaded ${configs.size} lobe(s) from MEMORY_MCP_WORKSPACES env var\n`);
                 return { configs, origin: { source: 'env' } };
             }
@@ -156,7 +196,9 @@ export function getLobeConfigs() {
         repoRoot,
         memoryPath: resolveMemoryPath(repoRoot, 'default', explicitDir),
         storageBudgetBytes: storageBudget,
+        alwaysInclude: false,
     });
+    // No ensureAlwaysIncludeLobe here — single-repo default users have everything in one lobe
     process.stderr.write(`[memory-mcp] Using single-lobe default mode (cwd: ${repoRoot})\n`);
     return { configs, origin: { source: 'default' } };
 }

package/dist/index.js

@@ -7,11 +7,9 @@ import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
 import { CallToolRequestSchema, ListToolsRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
 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 { parseTopicScope, parseTrustLevel } from './types.js';
 import { getLobeConfigs } from './config.js';
 import { ConfigManager } from './config-manager.js';
 import { normalizeArgs } from './normalize.js';
@@ -72,21 +70,12 @@ const stores = new Map();
 const lobeNames = Array.from(lobeConfigs.keys());
 // ConfigManager will be initialized after stores are set up
 let configManager;
-// Global store for user identity + preferences (shared across all lobes)
-const GLOBAL_TOPICS = new Set(['user', 'preferences']);
-const globalMemoryPath = path.join(os.homedir(), '.memory-mcp', 'global');
-const globalStore = new MarkdownMemoryStore({
-    repoRoot: os.homedir(),
-    memoryPath: globalMemoryPath,
-    storageBudgetBytes: DEFAULT_STORAGE_BUDGET_BYTES,
-});
+/** Topics that auto-route to the first alwaysInclude lobe when no lobe is specified on writes.
+ *  This is a backwards-compat shim — agents historically wrote these without specifying a lobe. */
+const ALWAYS_INCLUDE_WRITE_TOPICS = new Set(['user', 'preferences']);
 /** Resolve a raw lobe name to a validated store + display label.
  *  After this call, consumers use ctx.label — the raw lobe is not in scope. */
-function resolveToolContext(rawLobe, opts) {
-    // Global topics always route to the global store
-    if (opts?.isGlobal) {
-        return { ok: true, store: globalStore, label: 'global' };
-    }
+function resolveToolContext(rawLobe) {
     const lobeNames = configManager.getLobeNames();
     // Default to single lobe when omitted
     const lobe = rawLobe || (lobeNames.length === 1 ? lobeNames[0] : undefined);
@@ -163,11 +152,13 @@ const server = new Server({ name: 'memory-mcp', version: '0.1.0' }, { capabiliti
 //   3. Fallback → global-only with a hint to specify the lobe
 /** Resolve which lobes to search for a read operation when the agent omitted the lobe param.
  *  Wires the MCP server's listRoots into the pure resolution logic. */
-async function resolveLobesForRead() {
+async function resolveLobesForRead(isFirstMemoryToolCall = true) {
     const allLobeNames = configManager.getLobeNames();
-    // Short-circuit: single lobe is unambiguous
+    const alwaysIncludeLobes = configManager.getAlwaysIncludeLobes();
+    // Short-circuit: single lobe is unambiguous — no need for root matching.
+    // Handles both plain single-lobe and single-lobe-that-is-alwaysInclude cases.
     if (allLobeNames.length === 1) {
-        return buildLobeResolution(allLobeNames, allLobeNames);
+        return buildLobeResolution(allLobeNames, allLobeNames, alwaysIncludeLobes, isFirstMemoryToolCall);
     }
     // Multiple lobes — try MCP client roots
     const clientCaps = server.getClientCapabilities();
@@ -182,7 +173,7 @@ async function resolveLobesForRead() {
                 })
                     .filter((c) => c !== undefined);
                 const matched = matchRootsToLobeNames(roots, lobeConfigs);
-                return buildLobeResolution(allLobeNames, matched);
+                return buildLobeResolution(allLobeNames, matched, alwaysIncludeLobes, isFirstMemoryToolCall);
             }
         }
         catch (err) {
@@ -190,7 +181,7 @@ async function resolveLobesForRead() {
         }
     }
     // Fallback — roots not available or no match
-    return buildLobeResolution(allLobeNames, []);
+    return buildLobeResolution(allLobeNames, [], alwaysIncludeLobes, isFirstMemoryToolCall);
 }
 /** 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. */
@@ -200,7 +191,7 @@ function buildLobeProperty(currentLobeNames) {
         type: 'string',
         description: isSingle
             ? `Memory lobe name (defaults to "${currentLobeNames[0]}" if omitted)`
-            : `Memory lobe name. When omitted for reads, the server uses the client's workspace roots to select the matching lobe. If roots are unavailable, only global knowledge (user/preferences) is returned — specify a lobe explicitly to access lobe-specific knowledge. Required for writes. Available: ${currentLobeNames.join(', ')}`,
+            : `Memory lobe name. When omitted for reads, the server uses the client's workspace roots to select the matching lobe. If roots are unavailable and no alwaysInclude lobes are configured, specify a lobe explicitly to access lobe-specific knowledge. Required for writes. Available: ${currentLobeNames.join(', ')}`,
         enum: currentLobeNames.length > 1 ? [...currentLobeNames] : undefined,
     };
 }
@@ -224,7 +215,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                 // Example comes first — agents form their call shape from the first concrete pattern they see.
                 // "entries" (not "content") signals a collection; fighting the "content = string" prior
                 // is an architectural fix rather than patching the description after the fact.
-                description: 'memory_store(topic: "gotchas", entries: [{title: "Build cache", fact: "Must clean build after Tuist changes"}, {title: "Tuist version", fact: "Project requires Tuist 4.x"}], tags: ["build"]). Stores enduring knowledge — (1) Codebase facts (architecture, conventions, gotchas, modules): what IS true now, not past actions. Wrong: "Completed migration to StateFlow." Right: "All ViewModels use StateFlow." (2) User knowledge (user, preferences): who the person is, how they work. "user" and "preferences" are global. One insight per object; use multiple objects instead of bundling.',
+                description: 'memory_store(topic: "gotchas", entries: [{title: "Build cache", fact: "Must clean build after Tuist changes"}, {title: "Tuist version", fact: "Project requires Tuist 4.x"}], tags: ["build"]). Stores enduring knowledge — (1) Codebase facts (architecture, conventions, gotchas, modules): what IS true now, not past actions. Wrong: "Completed migration to StateFlow." Right: "All ViewModels use StateFlow." (2) User knowledge (user, preferences): who the person is, how they work. "user" and "preferences" are stored in the alwaysInclude lobe (shared across projects). One insight per object; use multiple objects instead of bundling.',
                 inputSchema: {
                     type: 'object',
                     properties: {
@@ -310,6 +301,11 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                             type: 'string',
                             description: 'Branch for recent-work. Omit = current branch, "*" = all branches.',
                         },
+                        isFirstMemoryToolCall: {
+                            type: 'boolean',
+                            description: 'Set true on first memory call in a conversation to include identity/preferences from alwaysInclude lobes. Set false on subsequent calls to skip redundant global knowledge.',
+                            default: true,
+                        },
                     },
                     required: [],
                 },
@@ -359,6 +355,11 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                             description: 'Min keyword match ratio 0-1 (default: 0.2). Higher = stricter.',
                             default: 0.2,
                         },
+                        isFirstMemoryToolCall: {
+                            type: 'boolean',
+                            description: 'Set true on first memory call in a conversation to include identity/preferences from alwaysInclude lobes. Set false on subsequent calls to skip redundant global knowledge.',
+                            default: true,
+                        },
                     },
                     required: [],
                 },
@@ -426,16 +427,11 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             case 'memory_list_lobes': {
                 // Delegates to shared builder — same data as memory://lobes resource
                 const lobeInfo = await buildLobeInfo();
-                const globalStats = await globalStore.stats();
+                const alwaysIncludeNames = configManager.getAlwaysIncludeLobes();
                 const result = {
                     serverMode: serverMode.kind,
-                    globalStore: {
-                        memoryPath: globalMemoryPath,
-                        entries: globalStats.totalEntries,
-                        storageUsed: globalStats.storageSize,
-                        topics: 'user, preferences (shared across all lobes)',
-                    },
                     lobes: lobeInfo,
+                    alwaysIncludeLobes: alwaysIncludeNames,
                     configFile: configFileDisplay(),
                     configSource: configOrigin.source,
                     totalLobes: lobeInfo.length,
@@ -477,12 +473,25 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     const allPaths = [...sources, ...references];
                     effectiveLobe = inferLobeFromPaths(allPaths);
                 }
+                // Auto-route user/preferences writes to the first alwaysInclude lobe when no lobe specified.
+                // This preserves the previous behavior where these topics auto-routed to the global store.
+                if (!effectiveLobe && ALWAYS_INCLUDE_WRITE_TOPICS.has(topic)) {
+                    const alwaysIncludeLobes = configManager.getAlwaysIncludeLobes();
+                    if (alwaysIncludeLobes.length > 0) {
+                        effectiveLobe = alwaysIncludeLobes[0];
+                    }
+                }
                 // Resolve store — after this point, rawLobe is never used again
-                const isGlobal = GLOBAL_TOPICS.has(topic);
-                const ctx = resolveToolContext(effectiveLobe, { isGlobal });
+                const ctx = resolveToolContext(effectiveLobe);
                 if (!ctx.ok)
                     return contextError(ctx);
-                const effectiveTrust = isGlobal && trust === 'agent-inferred' ? 'user' : trust;
+                // Auto-promote trust for global topics: agents writing user/preferences without explicit
+                // trust: "user" still get full confidence. Preserves pre-unification behavior where the
+                // global store always stored these at user trust — removing this would silently downgrade
+                // identity entries to confidence 0.70 (see philosophy: "Observability as a constraint").
+                const effectiveTrust = ALWAYS_INCLUDE_WRITE_TOPICS.has(topic) && trust === 'agent-inferred'
+                    ? 'user'
+                    : trust;
                 const storedResults = [];
                 for (const { title, fact } of rawEntries) {
                     const result = await ctx.store.store(topic, title, fact, sources, effectiveTrust, references, rawTags);
@@ -579,33 +588,26 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 return { content: [{ type: 'text', text: lines.join('\n') }] };
             }
             case 'memory_query': {
-                const { lobe: rawLobe, scope, detail, filter, branch } = z.object({
+                const { lobe: rawLobe, scope, detail, filter, branch, isFirstMemoryToolCall: rawIsFirst } = z.object({
                     lobe: z.string().optional(),
                     scope: z.string().default('*'),
                     detail: z.enum(['brief', 'standard', 'full']).default('brief'),
                     filter: z.string().optional(),
                     branch: z.string().optional(),
+                    isFirstMemoryToolCall: z.boolean().default(true),
                 }).parse(args ?? {});
-                const isGlobalQuery = GLOBAL_TOPICS.has(scope);
-                // Resolve which lobes to search.
-                // Global topics always route to globalStore. Lobe topics follow the degradation ladder.
+                // Force-include alwaysInclude lobes when querying a global topic (user/preferences),
+                // regardless of isFirstMemoryToolCall — the agent explicitly asked for this data.
+                // Philosophy: "Determinism over cleverness" — same query produces same results.
+                const topicScope = parseTopicScope(scope);
+                const effectiveIsFirst = rawIsFirst || (topicScope !== null && ALWAYS_INCLUDE_WRITE_TOPICS.has(topicScope));
+                // Resolve which lobes to search — unified path for all topics.
                 let lobeEntries = [];
                 const entryLobeMap = new Map(); // entry id → lobe name
                 let label;
                 let primaryStore;
                 let queryGlobalOnlyHint;
-                if (isGlobalQuery) {
-                    const ctx = resolveToolContext(rawLobe, { isGlobal: true });
-                    if (!ctx.ok)
-                        return contextError(ctx);
-                    label = ctx.label;
-                    primaryStore = ctx.store;
-                    const result = await ctx.store.query(scope, detail, filter, branch);
-                    for (const e of result.entries)
-                        entryLobeMap.set(e.id, 'global');
-                    lobeEntries = [...result.entries];
-                }
-                else if (rawLobe) {
+                if (rawLobe) {
                     const ctx = resolveToolContext(rawLobe);
                     if (!ctx.ok)
                         return contextError(ctx);
@@ -615,7 +617,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     lobeEntries = [...result.entries];
                 }
                 else {
-                    const resolution = await resolveLobesForRead();
+                    const resolution = await resolveLobesForRead(effectiveIsFirst);
                     switch (resolution.kind) {
                         case 'resolved': {
                             label = resolution.label;
@@ -641,17 +643,9 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                         }
                     }
                 }
-                // For wildcard queries on non-global topics, also include global store entries
-                let globalEntries = [];
-                if (scope === '*' && !isGlobalQuery) {
-                    const globalResult = await globalStore.query('*', detail, filter);
-                    for (const e of globalResult.entries)
-                        entryLobeMap.set(e.id, 'global');
-                    globalEntries = [...globalResult.entries];
-                }
-                // Merge global + lobe entries, dedupe by id, sort by relevance score
+                // Dedupe by id, sort by relevance score
                 const seenQueryIds = new Set();
-                const allEntries = [...globalEntries, ...lobeEntries]
+                const allEntries = lobeEntries
                     .filter(e => {
                     if (seenQueryIds.has(e.id))
                         return false;
@@ -660,17 +654,9 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 })
                     .sort((a, b) => b.relevanceScore - a.relevanceScore);
                 // Build stores collection for tag frequency aggregation
-                // Only include stores that were actually searched
                 const searchedStores = [];
-                if (isGlobalQuery) {
-                    searchedStores.push(globalStore);
-                }
-                else {
-                    if (primaryStore)
-                        searchedStores.push(primaryStore);
-                    if (scope === '*')
-                        searchedStores.push(globalStore);
-                }
+                if (primaryStore)
+                    searchedStores.push(primaryStore);
                 const tagFreq = mergeTagFrequencies(searchedStores);
                 // Parse filter once for both filtering (already done) and footer display
                 const filterGroups = filter ? parseFilter(filter) : [];
@@ -758,26 +744,45 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                         isError: true,
                     };
                 }
-                // Resolve store — route global entries (user-*, pref-*) to global store
-                const isGlobalEntry = id.startsWith('user-') || id.startsWith('pref-');
-                const ctx = resolveToolContext(rawLobe, { isGlobal: isGlobalEntry });
+                // Resolve store — if no lobe specified, probe alwaysInclude lobes first (read-only)
+                // to find where user/pref entries live, then apply the correction only to the owning store.
+                // Philosophy: "Prefer atomicity for correctness" — never call correct() speculatively.
+                let effectiveCorrectLobe = rawLobe;
+                if (!effectiveCorrectLobe) {
+                    const alwaysIncludeLobes = configManager.getAlwaysIncludeLobes();
+                    for (const lobeName of alwaysIncludeLobes) {
+                        const store = configManager.getStore(lobeName);
+                        if (!store)
+                            continue;
+                        try {
+                            if (await store.hasEntry(id)) {
+                                effectiveCorrectLobe = lobeName;
+                                break;
+                            }
+                        }
+                        catch (err) {
+                            process.stderr.write(`[memory-mcp] Warning: hasEntry probe failed for lobe "${lobeName}": ${err instanceof Error ? err.message : String(err)}\n`);
+                        }
+                    }
+                }
+                // If we probed alwaysInclude lobes and didn't find the entry, provide a richer error
+                // than the generic "Lobe is required" from resolveToolContext.
+                if (!effectiveCorrectLobe && !rawLobe) {
+                    const searchedLobes = configManager.getAlwaysIncludeLobes();
+                    const allLobes = configManager.getLobeNames();
+                    const searchedNote = searchedLobes.length > 0
+                        ? `Searched alwaysInclude lobes (${searchedLobes.join(', ')}) — entry not found. `
+                        : '';
+                    return {
+                        content: [{ type: 'text', text: `Entry "${id}" not found. ${searchedNote}Specify the lobe that contains it. Available: ${allLobes.join(', ')}` }],
+                        isError: true,
+                    };
+                }
+                const ctx = resolveToolContext(effectiveCorrectLobe);
                 if (!ctx.ok)
                     return contextError(ctx);
                 const result = await ctx.store.correct(id, correction ?? '', action);
                 if (!result.corrected) {
-                    // If not found in the targeted store, try the other one as fallback
-                    if (isGlobalEntry) {
-                        const lobeCtx = resolveToolContext(rawLobe);
-                        if (lobeCtx.ok) {
-                            const lobeResult = await lobeCtx.store.correct(id, correction ?? '', action);
-                            if (lobeResult.corrected) {
-                                const text = action === 'delete'
-                                    ? `[${lobeCtx.label}] Deleted entry ${id}.`
-                                    : `[${lobeCtx.label}] Corrected entry ${id} (action: ${action}, confidence: ${lobeResult.newConfidence}, trust: ${lobeResult.trust}).`;
-                                return { content: [{ type: 'text', text }] };
-                            }
-                        }
-                    }
                     return {
                         content: [{ type: 'text', text: `[${ctx.label}] Failed to correct: ${result.error}` }],
                         isError: true,
@@ -799,11 +804,12 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 return { content: [{ type: 'text', text: lines.join('\n') }] };
             }
             case 'memory_context': {
-                const { lobe: rawLobe, context, maxResults, minMatch } = z.object({
+                const { lobe: rawLobe, context, maxResults, minMatch, isFirstMemoryToolCall: rawIsFirst } = z.object({
                     lobe: z.string().optional(),
                     context: z.string().optional(),
                     maxResults: z.number().optional(),
                     minMatch: z.number().min(0).max(1).optional(),
+                    isFirstMemoryToolCall: z.boolean().default(true),
                 }).parse(args ?? {});
                 // --- Briefing mode: no context provided → user + preferences + stale nudges ---
                 if (!context) {
@@ -820,22 +826,18 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     const degradedSection = degradedLobeNames.length > 0
                         ? `## ⚠ Degraded Lobes: ${degradedLobeNames.join(', ')}\nRun **memory_diagnose** for details.\n`
                         : '';
-                    // Global store holds user + preferences — always included
-                    const globalBriefing = await globalStore.briefing(300);
                     const sections = [];
                     if (crashSection)
                         sections.push(crashSection);
                     if (degradedSection)
                         sections.push(degradedSection);
-                    if (globalBriefing.entryCount > 0) {
-                        sections.push(globalBriefing.briefing);
-                    }
-                    // Collect stale entries and entry counts across all lobes
+                    // 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 = [];
-                    if (globalBriefing.staleDetails)
-                        allStale.push(...globalBriefing.staleDetails);
-                    let totalEntries = globalBriefing.entryCount;
-                    let totalStale = globalBriefing.staleEntries;
+                    let totalEntries = 0;
+                    let totalStale = 0;
+                    // Give alwaysInclude lobes a higher token budget (identity/preferences are high-value)
+                    const alwaysIncludeSet = new Set(configManager.getAlwaysIncludeLobes());
                     for (const lobeName of allBriefingLobeNames) {
                         const health = configManager.getLobeHealth(lobeName);
                         if (health?.status === 'degraded')
@@ -843,7 +845,11 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                         const store = configManager.getStore(lobeName);
                         if (!store)
                             continue;
-                        const lobeBriefing = await store.briefing(100); // just enough for stale data + counts
+                        const budget = alwaysIncludeSet.has(lobeName) ? 300 : 100;
+                        const lobeBriefing = await store.briefing(budget);
+                        if (alwaysIncludeSet.has(lobeName) && lobeBriefing.entryCount > 0) {
+                            sections.push(lobeBriefing.briefing);
+                        }
                         if (lobeBriefing.staleDetails)
                             allStale.push(...lobeBriefing.staleDetails);
                         totalEntries += lobeBriefing.entryCount;
@@ -856,7 +862,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                         sections.push('No knowledge stored yet. As you work, store observations with memory_store. Try memory_bootstrap to seed initial knowledge from the repo.');
                     }
                     // Tag primer: show tag vocabulary if tags exist across any lobe
-                    const briefingStores = [globalStore];
+                    const briefingStores = [];
                     for (const lobeName of allBriefingLobeNames) {
                         const store = configManager.getStore(lobeName);
                         if (store)
@@ -895,7 +901,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     allLobeResults.push(...lobeResults);
                 }
                 else {
-                    const resolution = await resolveLobesForRead();
+                    const resolution = await resolveLobesForRead(rawIsFirst);
                     switch (resolution.kind) {
                         case 'resolved': {
                             label = resolution.label;
@@ -921,13 +927,9 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                         }
                     }
                 }
-                // Always include global store (user + preferences)
-                const globalResults = await globalStore.contextSearch(context, max, undefined, threshold);
-                for (const r of globalResults)
-                    ctxEntryLobeMap.set(r.entry.id, 'global');
-                // Merge, dedupe by entry id, re-sort by score, take top N
+                // Dedupe by entry id, re-sort by score, take top N
                 const seenIds = new Set();
-                const results = [...globalResults, ...allLobeResults]
+                const results = allLobeResults
                     .sort((a, b) => b.score - a.score)
                     .filter(r => {
                     if (seenIds.has(r.entry.id))
@@ -937,11 +939,9 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 })
                     .slice(0, max);
                 // Build stores collection for tag frequency aggregation
-                // Only include stores that were actually searched (not all lobes)
-                const ctxSearchedStores = [globalStore];
-                if (primaryStore && primaryStore !== globalStore) {
+                const ctxSearchedStores = [];
+                if (primaryStore)
                     ctxSearchedStores.push(primaryStore);
-                }
                 const ctxTagFreq = mergeTagFrequencies(ctxSearchedStores);
                 // Parse filter for footer (context search has no filter, pass empty)
                 const ctxFilterGroups = [];
@@ -1023,24 +1023,27 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 const { lobe: rawLobe } = z.object({
                     lobe: z.string().optional(),
                 }).parse(args ?? {});
-                // Always include global stats
-                const globalStats = await globalStore.stats();
                 // Single lobe stats
                 if (rawLobe) {
                     const ctx = resolveToolContext(rawLobe);
                     if (!ctx.ok)
                         return contextError(ctx);
                     const result = await ctx.store.stats();
-                    const sections = [formatStats('global (user + preferences)', globalStats), formatStats(ctx.label, result)];
-                    return { content: [{ type: 'text', text: sections.join('\n\n---\n\n') }] };
+                    const alwaysIncludeSet = new Set(configManager.getAlwaysIncludeLobes());
+                    const label = alwaysIncludeSet.has(rawLobe) ? `${ctx.label} (alwaysInclude)` : ctx.label;
+                    return { content: [{ type: 'text', text: formatStats(label, result) }] };
                 }
                 // Combined stats across all lobes
-                const sections = [formatStats('global (user + preferences)', globalStats)];
+                const sections = [];
                 const allLobeNames = configManager.getLobeNames();
+                const alwaysIncludeSet = new Set(configManager.getAlwaysIncludeLobes());
                 for (const lobeName of allLobeNames) {
                     const store = configManager.getStore(lobeName);
+                    if (!store)
+                        continue;
                     const result = await store.stats();
-                    sections.push(formatStats(lobeName, result));
+                    const label = alwaysIncludeSet.has(lobeName) ? `${lobeName} (alwaysInclude)` : lobeName;
+                    sections.push(formatStats(label, result));
                 }
                 return { content: [{ type: 'text', text: sections.join('\n\n---\n\n') }] };
             }
@@ -1201,14 +1204,6 @@ async function buildDiagnosticsText(showFullCrashHistory) {
         }
     }
     sections.push('');
-    try {
-        const globalStats = await globalStore.stats();
-        sections.push(`- **global store**: ✅ healthy (${globalStats.totalEntries} entries, ${globalStats.storageSize})`);
-    }
-    catch (e) {
-        sections.push(`- **global store**: ❌ error — ${e instanceof Error ? e.message : e}`);
-    }
-    sections.push('');
     // Active behavior config — shows effective values and highlights user overrides
     sections.push('### Active Behavior Config');
     sections.push(formatBehaviorConfigSection(configBehavior));
@@ -1260,15 +1255,6 @@ async function main() {
         process.stderr.write(`[memory-mcp] Previous crash detected (${age}s ago): ${previousCrash.type} — ${previousCrash.error}\n`);
         process.stderr.write(`[memory-mcp] Crash report will be shown in memory_context and memory_diagnose.\n`);
     }
-    // Initialize global store (user + preferences, shared across all lobes)
-    try {
-        await globalStore.init();
-        process.stderr.write(`[memory-mcp] Global store → ${globalMemoryPath}\n`);
-    }
-    catch (error) {
-        const msg = error instanceof Error ? error.message : String(error);
-        process.stderr.write(`[memory-mcp] WARNING: Global store init failed: ${msg}\n`);
-    }
     // Initialize each lobe independently — a broken lobe shouldn't prevent others from working
     let healthyLobes = 0;
     for (const [name, config] of lobeConfigs) {
@@ -1326,46 +1312,6 @@ async function main() {
         };
         process.stderr.write(`[memory-mcp] ⚠ DEGRADED: ${healthyLobes}/${lobeConfigs.size} lobes healthy.\n`);
     }
-    // Migrate: move user + preferences entries from lobe stores to global store.
-    // State-driven guard: skip if already completed (marker file present).
-    const migrationMarker = path.join(globalMemoryPath, '.migrated');
-    if (!existsSync(migrationMarker)) {
-        let migrated = 0;
-        for (const [name, store] of stores) {
-            for (const topic of ['user', 'preferences']) {
-                try {
-                    const result = await store.query(topic, 'full');
-                    for (const entry of result.entries) {
-                        try {
-                            const globalResult = await globalStore.query(topic, 'full');
-                            const alreadyExists = globalResult.entries.some(g => g.title === entry.title);
-                            if (!alreadyExists && entry.content) {
-                                const trust = parseTrustLevel(entry.trust ?? 'user') ?? 'user';
-                                await globalStore.store(topic, entry.title, entry.content, [...(entry.sources ?? [])], trust);
-                                process.stderr.write(`[memory-mcp] Migrated ${entry.id} ("${entry.title}") from [${name}] → global\n`);
-                                migrated++;
-                            }
-                            await store.correct(entry.id, '', 'delete');
-                            process.stderr.write(`[memory-mcp] Removed ${entry.id} from [${name}] (now in global)\n`);
-                        }
-                        catch (entryError) {
-                            process.stderr.write(`[memory-mcp] Migration error for ${entry.id} in [${name}]: ${entryError}\n`);
-                        }
-                    }
-                }
-                catch (topicError) {
-                    process.stderr.write(`[memory-mcp] Migration error querying ${topic} in [${name}]: ${topicError}\n`);
-                }
-            }
-        }
-        // Write marker atomically — future startups skip this block entirely
-        try {
-            writeFileSync(migrationMarker, new Date().toISOString(), 'utf-8');
-            if (migrated > 0)
-                process.stderr.write(`[memory-mcp] Migration complete: ${migrated} entries moved to global store.\n`);
-        }
-        catch { /* marker write is best-effort */ }
-    }
     // Initialize ConfigManager with current config state
     configManager = new ConfigManager(configPath, { configs: lobeConfigs, origin: configOrigin }, stores, lobeHealth);
     const transport = new StdioServerTransport();
@@ -1393,7 +1339,12 @@ async function main() {
     });
     await server.connect(transport);
     const modeStr = serverMode.kind === 'running' ? '' : ` [${serverMode.kind.toUpperCase()}]`;
-    process.stderr.write(`[memory-mcp] Server started${modeStr} with ${healthyLobes}/${lobeConfigs.size} lobe(s) + global store\n`);
+    const alwaysIncludeNames = configManager.getAlwaysIncludeLobes();
+    const aiLabel = alwaysIncludeNames.length > 0 ? ` (alwaysInclude: ${alwaysIncludeNames.join(', ')})` : '';
+    if (alwaysIncludeNames.length > 1) {
+        process.stderr.write(`[memory-mcp] Warning: ${alwaysIncludeNames.length} lobes have alwaysInclude: true (${alwaysIncludeNames.join(', ')}). Writes to user/preferences will route to the first one ("${alwaysIncludeNames[0]}"). This is likely a misconfiguration — typically only one lobe should be alwaysInclude.\n`);
+    }
+    process.stderr.write(`[memory-mcp] Server started${modeStr} with ${healthyLobes}/${lobeConfigs.size} lobe(s)${aiLabel}\n`);
     // Graceful shutdown on signals
     const shutdown = () => {
         process.stderr.write('[memory-mcp] Shutting down gracefully.\n');

package/dist/lobe-resolution.d.ts

@@ -26,5 +26,9 @@ export interface LobeRootConfig {
  *    checked at path-separator boundaries (no partial-name false positives) */
 export declare function matchRootsToLobeNames(clientRoots: readonly ClientRoot[], lobeConfigs: readonly LobeRootConfig[]): readonly string[];
 /** Build a LobeResolution from the available lobe names and matched lobes.
- *  Encodes the degradation ladder as a pure function. */
-export declare function buildLobeResolution(allLobeNames: readonly string[], matchedLobes: readonly string[]): LobeResolution;
+ *  Encodes the degradation ladder as a pure function.
+ *
+ *  When isFirstMemoryToolCall is true (default), alwaysIncludeLobes are appended
+ *  to the resolved set (deduped). When false, they are excluded — the agent has
+ *  already loaded global knowledge in this conversation. */
+export declare function buildLobeResolution(allLobeNames: readonly string[], matchedLobes: readonly string[], alwaysIncludeLobes?: readonly string[], isFirstMemoryToolCall?: boolean): LobeResolution;

package/dist/lobe-resolution.js

@@ -44,18 +44,40 @@ export function matchRootsToLobeNames(clientRoots, lobeConfigs) {
     return Array.from(matchedLobes);
 }
 /** Build a LobeResolution from the available lobe names and matched lobes.
- *  Encodes the degradation ladder as a pure function. */
-export function buildLobeResolution(allLobeNames, matchedLobes) {
+ *  Encodes the degradation ladder as a pure function.
+ *
+ *  When isFirstMemoryToolCall is true (default), alwaysIncludeLobes are appended
+ *  to the resolved set (deduped). When false, they are excluded — the agent has
+ *  already loaded global knowledge in this conversation. */
+export function buildLobeResolution(allLobeNames, matchedLobes, alwaysIncludeLobes = [], isFirstMemoryToolCall = true) {
     // Single lobe — always resolved, regardless of root matching
-    if (allLobeNames.length === 1) {
+    if (allLobeNames.length === 1 && alwaysIncludeLobes.length === 0) {
         return { kind: 'resolved', lobes: allLobeNames, label: allLobeNames[0] };
     }
-    // Multiple lobes with successful root match
-    if (matchedLobes.length > 0) {
+    // Build the base resolved set
+    let baseLobes;
+    if (allLobeNames.length === 1) {
+        baseLobes = allLobeNames;
+    }
+    else if (matchedLobes.length > 0) {
+        baseLobes = matchedLobes;
+    }
+    else {
+        baseLobes = [];
+    }
+    // Append alwaysInclude lobes when isFirstMemoryToolCall is true (deduped)
+    const resolvedSet = new Set(baseLobes);
+    if (isFirstMemoryToolCall) {
+        for (const lobe of alwaysIncludeLobes) {
+            resolvedSet.add(lobe);
+        }
+    }
+    if (resolvedSet.size > 0) {
+        const lobes = Array.from(resolvedSet);
         return {
             kind: 'resolved',
-            lobes: matchedLobes,
-            label: matchedLobes.length === 1 ? matchedLobes[0] : matchedLobes.join('+'),
+            lobes,
+            label: lobes.length === 1 ? lobes[0] : lobes.join('+'),
         };
     }
     // Fallback — no lobes could be determined

package/dist/store.d.ts

@@ -18,6 +18,9 @@ export declare class MarkdownMemoryStore {
     query(scope: string, detail?: DetailLevel, filter?: string, branchFilter?: string): Promise<QueryResult>;
     /** Generate a session-start briefing */
     briefing(maxTokens?: number): Promise<BriefingResult>;
+    /** Check if an entry exists by ID — read-only, no side effects beyond disk reload.
+     *  Use this to probe for entry ownership before calling correct(). */
+    hasEntry(id: string): Promise<boolean>;
     /** Correct an existing entry */
     correct(id: string, correction: string, action: 'append' | 'replace' | 'delete'): Promise<CorrectResult>;
     /** Get memory health statistics */

package/dist/store.js

@@ -256,6 +256,12 @@ export class MarkdownMemoryStore {
             suggestion,
         };
     }
+    /** Check if an entry exists by ID — read-only, no side effects beyond disk reload.
+     *  Use this to probe for entry ownership before calling correct(). */
+    async hasEntry(id) {
+        await this.reloadFromDisk();
+        return this.entries.has(id);
+    }
     /** Correct an existing entry */
     async correct(id, correction, action) {
         // Reload to ensure we have the latest

package/dist/types.d.ts

@@ -195,6 +195,7 @@ export interface MemoryConfig {
     readonly repoRoot: string;
     readonly memoryPath: string;
     readonly storageBudgetBytes: number;
+    readonly alwaysInclude: boolean;
     readonly behavior?: BehaviorConfig;
     readonly clock?: Clock;
     readonly git?: GitService;

package/package.json

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