@exaudeus/memory-mcp 1.3.0 → 1.5.0

package/README.md

@@ -8,7 +8,7 @@ A Model Context Protocol (MCP) server that gives AI coding agents persistent, ev
 |------|-------------|
 | `memory_context` | Session start AND pre-task lookup. Call with no args for user + preferences + stale nudges; call with `context` for task-specific knowledge |
 | `memory_query` | Structured search with brief/standard/full detail levels and AND/OR/NOT filter syntax. Scope defaults to `"*"` (all topics) |
-| `memory_store` | Store a knowledge entry with dedup detection, preference surfacing, and lobe auto-detection from file paths |
+| `memory_store` | Store a knowledge entry with dedup detection, preference surfacing, lobe auto-detection, and a review-required gate for likely-ephemeral content |
 | `memory_correct` | Correct, update, or delete an existing entry (suggests storing as preference) |
 | `memory_bootstrap` | First-use scan to seed knowledge from repo structure, README, and build files |
 
@@ -33,6 +33,7 @@ A Model Context Protocol (MCP) server that gives AI coding agents persistent, ev
 
 - **Dedup detection**: When you store an entry, the response shows similar existing entries in the same topic (>35% keyword overlap) with consolidation instructions
 - **Preference surfacing**: Storing a non-preference entry shows relevant preferences that might conflict
+- **Ephemeral review gate**: Likely-ephemeral content is blocked before persistence by default. Re-run `memory_store(..., durabilityDecision: "store-anyway")` only when you intentionally want to keep it.
 - **Piggyback hints**: `memory_correct` suggests storing corrections as reusable preferences
 - **`memory_context`**: Describe your task in natural language and get ranked results across all topics with topic-based boosting (preferences 1.8x, gotchas 1.5x)
 
@@ -108,10 +109,12 @@ If no `memory-config.json` is found, the server falls back to environment variab
 1. **Edit `memory-config.json`** (create if it doesn't exist)
 2. **Add lobe entry:**
    ```json
+   {
    "my-project": {
      "root": "$HOME/git/my-project",
      "budgetMB": 2
    }
+   }
    ```
 3. **Restart the memory MCP server**
 4. **Verify:** Use `memory_list_lobes` to confirm it loaded

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. If content looks likely-ephemeral, the tool returns a review-required response; re-run with durabilityDecision: "store-anyway" only when deliberate.',
                 inputSchema: {
                     type: 'object',
                     properties: {
@@ -281,6 +272,12 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                             description: 'Category labels for exact-match retrieval (lowercase slugs). Query with filter: "#tag". Example: ["auth", "critical-path", "mite-combat"]',
                             default: [],
                         },
+                        durabilityDecision: {
+                            type: 'string',
+                            enum: ['default', 'store-anyway'],
+                            description: 'Write intent for content that may require review. Use "default" normally. Use "store-anyway" only when intentionally persisting content after a review-required response.',
+                            default: 'default',
+                        },
                     },
                     required: ['topic', 'entries'],
                 },
@@ -310,6 +307,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 +361,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 +433,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,
@@ -446,7 +448,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 };
             }
             case 'memory_store': {
-                const { lobe: rawLobe, topic: rawTopic, entries: rawEntries, sources, references, trust: rawTrust, tags: rawTags } = z.object({
+                const { lobe: rawLobe, topic: rawTopic, entries: rawEntries, sources, references, trust: rawTrust, tags: rawTags, durabilityDecision } = z.object({
                     lobe: z.string().optional(),
                     topic: z.string(),
                     // Accept a bare {title, fact} object in addition to the canonical array form.
@@ -460,6 +462,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     references: z.array(z.string()).default([]),
                     trust: z.enum(['user', 'agent-confirmed', 'agent-inferred']).default('agent-inferred'),
                     tags: z.array(z.string()).default([]),
+                    durabilityDecision: z.enum(['default', 'store-anyway']).default('default'),
                 }).parse(args);
                 // Validate topic at boundary
                 const topic = parseTopicScope(rawTopic);
@@ -477,16 +480,47 @@ 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);
-                    if (!result.stored) {
+                    const result = await ctx.store.store(topic, title, fact, sources, effectiveTrust, references, rawTags, durabilityDecision);
+                    if (result.kind === 'review-required') {
+                        const lines = [
+                            `[${ctx.label}] Review required before storing "${title}".`,
+                            '',
+                            `Severity: ${result.severity}`,
+                            'Signals:',
+                            ...result.signals.map(signal => `- ${signal.label}: ${signal.detail}`),
+                            '',
+                            result.warning,
+                            '',
+                            'If this knowledge is still worth persisting, re-run with:',
+                            `memory_store(topic: "${topic}", entries: [{title: "${title}", fact: "${fact.replace(/"/g, '\\"')}"}], trust: "${effectiveTrust}", durabilityDecision: "store-anyway"${rawTags.length > 0 ? `, tags: ${JSON.stringify(rawTags)}` : ''}${sources.length > 0 ? `, sources: ${JSON.stringify(sources)}` : ''}${references.length > 0 ? `, references: ${JSON.stringify(references)}` : ''})`,
+                        ];
+                        return {
+                            content: [{ type: 'text', text: lines.join('\n') }],
+                            isError: true,
+                        };
+                    }
+                    if (result.kind === 'rejected') {
                         return {
                             content: [{ type: 'text', text: `[${ctx.label}] Failed to store "${title}": ${result.warning}` }],
                             isError: true,
@@ -579,33 +613,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 +642,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 +668,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 +679,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 +769,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 +829,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 +851,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 +870,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 +887,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 +926,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 +952,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 +964,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 +1048,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') }] };
             }
@@ -1089,8 +1117,8 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 if (!ctx.ok)
                     return contextError(ctx);
                 const results = await ctx.store.bootstrap();
-                const stored = results.filter(r => r.stored);
-                const failed = results.filter(r => !r.stored);
+                const stored = results.filter((r) => r.kind === 'stored');
+                const failed = results.filter((r) => r.kind !== 'stored');
                 let text = `## [${ctx.label}] Bootstrap Complete\n\nStored ${stored.length} entries:`;
                 for (const r of stored) {
                     text += `\n- ${r.id}: ${r.topic} (${r.file})`;
@@ -1201,14 +1229,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 +1280,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 +1337,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 +1364,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

@@ -1,4 +1,4 @@
-import type { MemoryEntry, TopicScope, TrustLevel, DetailLevel, QueryResult, StoreResult, CorrectResult, MemoryStats, BriefingResult, ConflictPair, MemoryConfig } from './types.js';
+import type { MemoryEntry, TopicScope, TrustLevel, DetailLevel, DurabilityDecision, QueryResult, StoreResult, CorrectResult, MemoryStats, BriefingResult, ConflictPair, MemoryConfig } from './types.js';
 export declare class MarkdownMemoryStore {
     private readonly config;
     private readonly memoryPath;
@@ -13,11 +13,14 @@ export declare class MarkdownMemoryStore {
     /** Initialize the store: create memory dir and load existing entries */
     init(): Promise<void>;
     /** Store a new knowledge entry */
-    store(topic: TopicScope, title: string, content: string, sources?: string[], trust?: TrustLevel, references?: string[], rawTags?: string[]): Promise<StoreResult>;
+    store(topic: TopicScope, title: string, content: string, sources?: string[], trust?: TrustLevel, references?: string[], rawTags?: string[], durabilityDecision?: DurabilityDecision): Promise<StoreResult>;
     /** Query knowledge by scope and detail level */
     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

@@ -41,15 +41,35 @@ export class MarkdownMemoryStore {
         await this.reloadFromDisk();
     }
     /** Store a new knowledge entry */
-    async store(topic, title, content, sources = [], trust = 'agent-inferred', references = [], rawTags = []) {
+    async store(topic, title, content, sources = [], trust = 'agent-inferred', references = [], rawTags = [], durabilityDecision = 'default') {
         // Check storage budget — null means we can't measure, allow the write
         const currentSize = await this.getStorageSize();
         if (currentSize !== null && currentSize >= this.config.storageBudgetBytes) {
             return {
-                stored: false, topic,
+                kind: 'rejected', stored: false, topic,
                 warning: `Storage budget exceeded (${this.formatBytes(currentSize)} / ${this.formatBytes(this.config.storageBudgetBytes)}). Delete or correct existing entries to free space.`,
             };
         }
+        const ephemeralSignals = topic !== 'recent-work'
+            ? detectEphemeralSignals(title, content, topic)
+            : [];
+        const ephemeralSeverity = getEphemeralSeverity(ephemeralSignals);
+        const requiresReview = ephemeralSeverity === 'medium' || ephemeralSeverity === 'high';
+        if (durabilityDecision === 'default' && requiresReview) {
+            return {
+                kind: 'review-required',
+                stored: false,
+                topic,
+                severity: ephemeralSeverity,
+                warning: `Likely ephemeral content detected. Review the signals and re-run with durabilityDecision: "store-anyway" if this knowledge should still be persisted.`,
+                signals: ephemeralSignals.map(signal => ({
+                    id: signal.id,
+                    label: signal.label,
+                    detail: signal.detail,
+                    confidence: signal.confidence,
+                })),
+            };
+        }
         const id = this.generateId(topic);
         const now = this.clock.isoNow();
         const confidence = DEFAULT_CONFIDENCE[trust];
@@ -85,15 +105,9 @@ export class MarkdownMemoryStore {
         const relevantPreferences = (topic !== 'preferences' && topic !== 'user')
             ? this.findRelevantPreferences(entry)
             : undefined;
-        // Soft ephemeral detection — warn but never block
-        const ephemeralSignals = topic !== 'recent-work'
-            ? detectEphemeralSignals(title, content, topic)
-            : [];
-        // getEphemeralSeverity is the single source of threshold logic shared with formatEphemeralWarning.
-        const ephemeralSeverity = getEphemeralSeverity(ephemeralSignals);
         const ephemeralWarning = formatEphemeralWarning(ephemeralSignals, id);
         return {
-            stored: true, id, topic, file, confidence, warning, ephemeralWarning,
+            kind: 'stored', stored: true, id, topic, file, confidence, warning, ephemeralWarning,
             ephemeralSeverity: ephemeralSeverity ?? undefined,
             relatedEntries: relatedEntries.length > 0 ? relatedEntries : undefined,
             relevantPreferences: relevantPreferences && relevantPreferences.length > 0 ? relevantPreferences : undefined,
@@ -256,6 +270,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
@@ -378,7 +398,7 @@ export class MarkdownMemoryStore {
         catch { /* not a git repo or git not available */ }
         // 5. Fallback: if nothing was detected, store a minimal overview so the lobe
         //    is never left completely empty after bootstrap (makes memory_context useful immediately).
-        const storedCount = results.filter(r => r.stored).length;
+        const storedCount = results.filter(r => r.kind === 'stored').length;
         if (storedCount === 0) {
             try {
                 const topLevel = await fs.readdir(repoRoot, { withFileTypes: true });

package/dist/types.d.ts

@@ -89,8 +89,21 @@ export interface RelatedEntry {
     readonly confidence: number;
     readonly trust: TrustLevel;
 }
+/** Caller intent for writes that may require a durability decision.
+ *  Explicit domain type avoids booleanly-typed override semantics. */
+export type DurabilityDecision = 'default' | 'store-anyway';
+/** Structured signal attached to a review-required store outcome.
+ *  Duplicated here (rather than importing from ephemeral.ts) to keep the store
+ *  result contract independent of a concrete detection implementation. */
+export interface ReviewSignal {
+    readonly id: string;
+    readonly label: string;
+    readonly detail: string;
+    readonly confidence: 'high' | 'medium' | 'low';
+}
 /** Result of a memory store operation — discriminated union eliminates impossible states */
 export type StoreResult = {
+    readonly kind: 'stored';
     readonly stored: true;
     readonly id: string;
     readonly topic: TopicScope;
@@ -104,6 +117,14 @@ export type StoreResult = {
     readonly relatedEntries?: readonly RelatedEntry[];
     readonly relevantPreferences?: readonly RelatedEntry[];
 } | {
+    readonly kind: 'review-required';
+    readonly stored: false;
+    readonly topic: TopicScope;
+    readonly severity: EphemeralSeverity;
+    readonly warning: string;
+    readonly signals: readonly ReviewSignal[];
+} | {
+    readonly kind: 'rejected';
     readonly stored: false;
     readonly topic: TopicScope;
     readonly warning: string;
@@ -195,6 +216,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.5.0",
   "description": "Codebase memory MCP server - persistent, evolving knowledge for AI coding agents",
   "type": "module",
   "main": "dist/index.js",