@exaudeus/memory-mcp 1.2.0 → 1.4.0

package/dist/index.js

@@ -7,18 +7,17 @@ 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';
 import { buildCrashReport, writeCrashReport, writeCrashReportSync, readLatestCrash, readCrashHistory, clearLatestCrash, formatCrashReport, formatCrashSummary, markServerStarted, } from './crash-journal.js';
 import { formatStaleSection, formatConflictWarning, formatStats, formatBehaviorConfigSection, mergeTagFrequencies, buildQueryFooter, buildTagPrimerSection } from './formatters.js';
-import { extractKeywords, parseFilter } from './text-analyzer.js';
-import { CROSS_LOBE_WEAK_SCORE_PENALTY, CROSS_LOBE_MIN_MATCH_RATIO, VOCABULARY_ECHO_LIMIT } from './thresholds.js';
+import { parseFilter } from './text-analyzer.js';
+import { VOCABULARY_ECHO_LIMIT, WARN_SEPARATOR } from './thresholds.js';
+import { matchRootsToLobeNames, buildLobeResolution } from './lobe-resolution.js';
 let serverMode = { kind: 'running' };
 const lobeHealth = new Map();
 const serverStartTime = Date.now();
@@ -71,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);
@@ -154,6 +144,45 @@ 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: {} } });
+// --- Lobe resolution for read operations ---
+// When the agent doesn't specify a lobe, we determine which lobe(s) to search
+// via a degradation ladder (see lobe-resolution.ts for the pure logic):
+//   1. Single lobe configured → use it (unambiguous)
+//   2. Multiple lobes → ask client for workspace roots via MCP roots/list
+//   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(isFirstMemoryToolCall = true) {
+    const allLobeNames = configManager.getLobeNames();
+    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, alwaysIncludeLobes, isFirstMemoryToolCall);
+    }
+    // Multiple lobes — try MCP client roots
+    const clientCaps = server.getClientCapabilities();
+    if (clientCaps?.roots) {
+        try {
+            const { roots } = await server.listRoots();
+            if (roots && roots.length > 0) {
+                const lobeConfigs = allLobeNames
+                    .map(name => {
+                    const config = configManager.getLobeConfig(name);
+                    return config ? { name, repoRoot: config.repoRoot } : undefined;
+                })
+                    .filter((c) => c !== undefined);
+                const matched = matchRootsToLobeNames(roots, lobeConfigs);
+                return buildLobeResolution(allLobeNames, matched, alwaysIncludeLobes, isFirstMemoryToolCall);
+            }
+        }
+        catch (err) {
+            process.stderr.write(`[memory-mcp] listRoots failed: ${err instanceof Error ? err.message : String(err)}\n`);
+        }
+    }
+    // Fallback — roots not available or no match
+    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. */
 function buildLobeProperty(currentLobeNames) {
@@ -162,7 +191,7 @@ function buildLobeProperty(currentLobeNames) {
         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(', ')}`,
+            : `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,
     };
 }
@@ -186,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: {
@@ -272,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: [],
                 },
@@ -302,7 +336,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
             },
             {
                 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")',
+                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. When lobe is omitted, uses client workspace roots to select the matching lobe; falls back to global-only if roots are unavailable. Example: memory_context() or memory_context(context: "writing a Kotlin reducer")',
                 inputSchema: {
                     type: 'object',
                     properties: {
@@ -321,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: [],
                 },
@@ -388,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,
@@ -439,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);
@@ -456,11 +503,14 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     }
                     storedResults.push({ title, result });
                 }
-                // Build response header
+                // Build response header.
+                // For high-severity ephemeral detections, flag the success line itself so agents
+                // who anchor on line 1 still see the problem before reading the block below.
                 const lines = [];
                 if (storedResults.length === 1) {
                     const { result } = storedResults[0];
-                    lines.push(`[${ctx.label}] Stored entry ${result.id} in ${result.topic} (confidence: ${result.confidence})`);
+                    const ephemeralFlag = result.ephemeralSeverity === 'high' ? ' (⚠ ephemeral — see below)' : '';
+                    lines.push(`[${ctx.label}] Stored entry ${result.id} in ${result.topic} (confidence: ${result.confidence})${ephemeralFlag}`);
                     if (result.warning)
                         lines.push(`Note: ${result.warning}`);
                 }
@@ -468,7 +518,8 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     const { result: first } = storedResults[0];
                     lines.push(`[${ctx.label}] Stored ${storedResults.length} entries in ${first.topic} (confidence: ${first.confidence}):`);
                     for (const { title, result } of storedResults) {
-                        lines.push(`  - ${result.id}: "${title}"`);
+                        const ephemeralFlag = result.ephemeralSeverity === 'high' ? ' ⚠' : '';
+                        lines.push(`  - ${result.id}: "${title}"${ephemeralFlag}`);
                     }
                 }
                 // Limit to at most 2 hint sections per response to prevent hint fatigue.
@@ -478,23 +529,35 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 let hintCount = 0;
                 for (const { title, result } of storedResults) {
                     const entryPrefix = storedResults.length > 1 ? `"${title}": ` : '';
-                    // Dedup: surface related entries in the same topic
+                    // Dedup: surface related entries in the same topic.
+                    // Fill in both actual IDs so the agent can act immediately without looking them up.
                     if (result.relatedEntries && result.relatedEntries.length > 0 && hintCount < 2) {
                         hintCount++;
+                        const top = result.relatedEntries[0];
                         lines.push('');
-                        lines.push(`⚠ ${entryPrefix}Similar entries found in the same topic:`);
-                        for (const r of result.relatedEntries) {
-                            lines.push(`  - ${r.id}: "${r.title}" (confidence: ${r.confidence})`);
-                            lines.push(`    Content: ${r.content.length > 120 ? r.content.substring(0, 120) + '...' : r.content}`);
+                        lines.push(WARN_SEPARATOR);
+                        lines.push(`⚠  ${entryPrefix}SIMILAR ENTRY ALREADY EXISTS — CONSOLIDATE  ⚠`);
+                        lines.push(WARN_SEPARATOR);
+                        lines.push(`  ${top.id}: "${top.title}" (confidence: ${top.confidence})`);
+                        lines.push(`  ${top.content.length > 120 ? top.content.substring(0, 120) + '...' : top.content}`);
+                        if (result.relatedEntries.length > 1) {
+                            const extra = result.relatedEntries.length - 1;
+                            lines.push(`  ... and ${extra} more similar ${extra === 1 ? 'entry' : 'entries'}`);
                         }
                         lines.push('');
-                        lines.push('To consolidate: memory_correct(id: "<old-id>", action: "replace", correction: "<merged content>") then memory_correct(id: "<new-id>", action: "delete")');
+                        lines.push('If these overlap, consolidate:');
+                        lines.push(`  KEEP+UPDATE: memory_correct(id: "${top.id}", action: "replace", correction: "<merged content>")`);
+                        lines.push(`  DELETE new:  memory_correct(id: "${result.id}", action: "delete")`);
+                        lines.push(WARN_SEPARATOR);
                     }
-                    // Ephemeral content warning — soft nudge, never blocking
+                    // Ephemeral content warning — the formatted block already contains visual borders
+                    // and pre-filled delete command from formatEphemeralWarning.
                     if (result.ephemeralWarning && hintCount < 2) {
                         hintCount++;
                         lines.push('');
-                        lines.push(`⏳ ${entryPrefix}${result.ephemeralWarning}`);
+                        if (entryPrefix)
+                            lines.push(`${entryPrefix}:`);
+                        lines.push(result.ephemeralWarning);
                     }
                     // Preference surfacing: show relevant preferences for non-preference entries
                     if (result.relevantPreferences && result.relevantPreferences.length > 0 && hintCount < 2) {
@@ -525,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);
-                // For global topics (user, preferences), always route to global store.
-                // For lobe topics: if lobe specified → single lobe. If omitted → ALL healthy lobes.
+                // 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 (for cross-lobe labeling)
+                const entryLobeMap = new Map(); // entry id → lobe name
                 let label;
                 let primaryStore;
-                let isMultiLobe = false;
-                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) {
+                let queryGlobalOnlyHint;
+                if (rawLobe) {
                     const ctx = resolveToolContext(rawLobe);
                     if (!ctx.ok)
                         return contextError(ctx);
@@ -561,33 +617,35 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     lobeEntries = [...result.entries];
                 }
                 else {
-                    // Search all healthy lobes — read operations shouldn't require lobe selection
-                    const allLobeNames = configManager.getLobeNames();
-                    isMultiLobe = allLobeNames.length > 1;
-                    label = allLobeNames.length === 1 ? allLobeNames[0] : 'all';
-                    for (const lobeName of allLobeNames) {
-                        const store = configManager.getStore(lobeName);
-                        if (!store)
-                            continue;
-                        if (!primaryStore)
-                            primaryStore = store;
-                        const result = await store.query(scope, detail, filter, branch);
-                        for (const e of result.entries)
-                            entryLobeMap.set(e.id, lobeName);
-                        lobeEntries.push(...result.entries);
+                    const resolution = await resolveLobesForRead(effectiveIsFirst);
+                    switch (resolution.kind) {
+                        case 'resolved': {
+                            label = resolution.label;
+                            for (const lobeName of resolution.lobes) {
+                                const store = configManager.getStore(lobeName);
+                                if (!store)
+                                    continue;
+                                if (!primaryStore)
+                                    primaryStore = store;
+                                const result = await store.query(scope, detail, filter, branch);
+                                if (resolution.lobes.length > 1) {
+                                    for (const e of result.entries)
+                                        entryLobeMap.set(e.id, lobeName);
+                                }
+                                lobeEntries.push(...result.entries);
+                            }
+                            break;
+                        }
+                        case 'global-only': {
+                            label = 'global';
+                            queryGlobalOnlyHint = resolution.hint;
+                            break;
+                        }
                     }
                 }
-                // 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;
@@ -597,46 +655,32 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     .sort((a, b) => b.relevanceScore - a.relevanceScore);
                 // Build stores collection for tag frequency aggregation
                 const searchedStores = [];
-                if (isGlobalQuery) {
-                    searchedStores.push(globalStore);
-                }
-                else if (rawLobe) {
-                    const store = configManager.getStore(rawLobe);
-                    if (store)
-                        searchedStores.push(store);
-                }
-                else {
-                    // All lobes + global when doing wildcard search
-                    for (const lobeName of configManager.getLobeNames()) {
-                        const store = configManager.getStore(lobeName);
-                        if (store)
-                            searchedStores.push(store);
-                    }
-                    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) : [];
                 if (allEntries.length === 0) {
                     const footer = buildQueryFooter({ filterGroups, rawFilter: filter, tagFreq, resultCount: 0, scope });
+                    const noResultHint = queryGlobalOnlyHint ? `\n\n> ${queryGlobalOnlyHint}` : '';
                     return {
                         content: [{
                                 type: 'text',
-                                text: `[${label}] No entries found for scope "${scope}"${filter ? ` with filter "${filter}"` : ''}.\n\n---\n${footer}`,
+                                text: `[${label}] No entries found for scope "${scope}"${filter ? ` with filter "${filter}"` : ''}.${noResultHint}\n\n---\n${footer}`,
                             }],
                     };
                 }
+                const showQueryLobeLabels = entryLobeMap.size > 0;
                 const lines = allEntries.map(e => {
                     const freshIndicator = e.fresh ? '' : ' [stale]';
-                    const lobeTag = isMultiLobe ? ` [${entryLobeMap.get(e.id) ?? '?'}]` : '';
+                    const lobeTag = showQueryLobeLabels ? ` [${entryLobeMap.get(e.id) ?? '?'}]` : '';
                     if (detail === 'brief') {
                         return `- **${e.title}** (${e.id}${lobeTag}, confidence: ${e.confidence})${freshIndicator}\n  ${e.summary}`;
                     }
                     if (detail === 'full') {
                         const meta = [
                             `ID: ${e.id}`,
-                            isMultiLobe ? `Lobe: ${entryLobeMap.get(e.id) ?? '?'}` : null,
+                            showQueryLobeLabels ? `Lobe: ${entryLobeMap.get(e.id) ?? '?'}` : null,
                             `Confidence: ${e.confidence}`,
                             `Trust: ${e.trust}`,
                             `Fresh: ${e.fresh}`,
@@ -670,6 +714,10 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                         text += '\n\n' + formatConflictWarning(conflicts);
                     }
                 }
+                // Surface hint when we fell back to global-only
+                if (queryGlobalOnlyHint) {
+                    text += `\n\n> ${queryGlobalOnlyHint}`;
+                }
                 // Build footer with query mode, tag vocabulary, and syntax reference
                 const footer = buildQueryFooter({ filterGroups, rawFilter: filter, tagFreq, resultCount: allEntries.length, scope });
                 text += `\n\n---\n${footer}`;
@@ -696,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,
@@ -737,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) {
@@ -758,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')
@@ -781,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;
@@ -794,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)
@@ -822,7 +890,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 const ctxEntryLobeMap = new Map(); // entry id → lobe name
                 let label;
                 let primaryStore;
-                let isCtxMultiLobe = false;
+                let ctxGlobalOnlyHint;
                 if (rawLobe) {
                     const ctx = resolveToolContext(rawLobe);
                     if (!ctx.ok)
@@ -833,44 +901,35 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     allLobeResults.push(...lobeResults);
                 }
                 else {
-                    // Search all healthy lobes — read operations shouldn't require lobe selection
-                    const allLobeNames = configManager.getLobeNames();
-                    isCtxMultiLobe = allLobeNames.length > 1;
-                    label = allLobeNames.length === 1 ? allLobeNames[0] : 'all';
-                    for (const lobeName of allLobeNames) {
-                        const store = configManager.getStore(lobeName);
-                        if (!store)
-                            continue;
-                        if (!primaryStore)
-                            primaryStore = store;
-                        const lobeResults = await store.contextSearch(context, max, undefined, threshold);
-                        for (const r of lobeResults)
-                            ctxEntryLobeMap.set(r.entry.id, lobeName);
-                        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 };
+                    const resolution = await resolveLobesForRead(rawIsFirst);
+                    switch (resolution.kind) {
+                        case 'resolved': {
+                            label = resolution.label;
+                            for (const lobeName of resolution.lobes) {
+                                const store = configManager.getStore(lobeName);
+                                if (!store)
+                                    continue;
+                                if (!primaryStore)
+                                    primaryStore = store;
+                                const lobeResults = await store.contextSearch(context, max, undefined, threshold);
+                                if (resolution.lobes.length > 1) {
+                                    for (const r of lobeResults)
+                                        ctxEntryLobeMap.set(r.entry.id, lobeName);
+                                }
+                                allLobeResults.push(...lobeResults);
+                            }
+                            break;
+                        }
+                        case 'global-only': {
+                            label = 'global';
+                            ctxGlobalOnlyHint = resolution.hint;
+                            break;
                         }
                     }
                 }
-                // 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))
@@ -880,28 +939,21 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 })
                     .slice(0, max);
                 // Build stores collection for tag frequency aggregation
-                const ctxSearchedStores = [globalStore];
-                if (rawLobe) {
-                    const store = configManager.getStore(rawLobe);
-                    if (store)
-                        ctxSearchedStores.push(store);
-                }
-                else {
-                    for (const lobeName of configManager.getLobeNames()) {
-                        const store = configManager.getStore(lobeName);
-                        if (store)
-                            ctxSearchedStores.push(store);
-                    }
-                }
+                const ctxSearchedStores = [];
+                if (primaryStore)
+                    ctxSearchedStores.push(primaryStore);
                 const ctxTagFreq = mergeTagFrequencies(ctxSearchedStores);
                 // Parse filter for footer (context search has no filter, pass empty)
                 const ctxFilterGroups = [];
                 if (results.length === 0) {
                     const ctxFooter = buildQueryFooter({ filterGroups: ctxFilterGroups, rawFilter: undefined, tagFreq: ctxTagFreq, resultCount: 0, scope: 'context search' });
+                    const noResultHint = ctxGlobalOnlyHint
+                        ? `\n\n> ${ctxGlobalOnlyHint}`
+                        : '\n\nThis is fine — proceed without prior context. As you learn things worth remembering, store them with memory_store.';
                     return {
                         content: [{
                                 type: 'text',
-                                text: `[${label}] No relevant knowledge found for: "${context}"\n\nThis is fine — proceed without prior context. As you learn things worth remembering, store them with memory_store.\n\n---\n${ctxFooter}`,
+                                text: `[${label}] No relevant knowledge found for: "${context}"${noResultHint}\n\n---\n${ctxFooter}`,
                             }],
                     };
                 }
@@ -919,6 +971,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     ...topicOrder.filter(t => byTopic.has(t)),
                     ...Array.from(byTopic.keys()).filter(t => !topicOrder.includes(t)).sort(),
                 ];
+                const showCtxLobeLabels = ctxEntryLobeMap.size > 0;
                 for (const topic of orderedTopics) {
                     const topicResults = byTopic.get(topic);
                     const heading = topic === 'user' ? 'About You'
@@ -930,7 +983,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     for (const r of topicResults) {
                         const marker = topic === 'gotchas' ? '[!] ' : topic === 'preferences' ? '[pref] ' : '';
                         const keywords = r.matchedKeywords.length > 0 ? ` (matched: ${r.matchedKeywords.join(', ')})` : '';
-                        const lobeLabel = isCtxMultiLobe ? ` [${ctxEntryLobeMap.get(r.entry.id) ?? '?'}]` : '';
+                        const lobeLabel = showCtxLobeLabels ? ` [${ctxEntryLobeMap.get(r.entry.id) ?? '?'}]` : '';
                         const tagsSuffix = r.entry.tags?.length ? ` [tags: ${r.entry.tags.join(', ')}]` : '';
                         sections.push(`- **${marker}${r.entry.title}**${lobeLabel}: ${r.entry.content}${keywords}${tagsSuffix}`);
                     }
@@ -957,6 +1010,10 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     sections.push(`---\n*Context loaded for: ${kwList} (${topicList}). ` +
                         `This knowledge is now in your conversation — no need to call memory_context again for these terms this session.*`);
                 }
+                // Surface hint when we fell back to global-only
+                if (ctxGlobalOnlyHint) {
+                    sections.push(`> ${ctxGlobalOnlyHint}`);
+                }
                 // Build footer (context search has no filter — it's natural language keyword matching)
                 const ctxFooter = buildQueryFooter({ filterGroups: ctxFilterGroups, rawFilter: undefined, tagFreq: ctxTagFreq, resultCount: results.length, scope: 'context search' });
                 sections.push(`---\n${ctxFooter}`);
@@ -966,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') }] };
             }
@@ -1144,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));
@@ -1203,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) {
@@ -1269,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();
@@ -1336,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');