@exaudeus/memory-mcp 1.1.0 → 1.3.0

package/dist/ephemeral.d.ts

@@ -1,4 +1,4 @@
-import type { TopicScope } from './types.js';
+import type { EphemeralSeverity, TopicScope } from './types.js';
 /** Run the TF-IDF classifier on a text. Returns probability 0-1 that content is ephemeral.
  *  Supports both v1 (unigrams only) and v2 (bigrams + engineered features) models. */
 export declare function classifyEphemeral(title: string, content: string, topic?: string): number | null;
@@ -15,6 +15,10 @@ export interface EphemeralSignal {
  *  Returns an array of matched signals, empty if content looks durable.
  *  Pure function — no side effects, no I/O. */
 export declare function detectEphemeralSignals(title: string, content: string, topic: TopicScope): readonly EphemeralSignal[];
-/** Format ephemeral signals into a human-readable warning string.
+/** Derive aggregate severity from a set of detected signals.
+ *  Single source of truth for the threshold logic — both formatEphemeralWarning
+ *  and store.ts call this so the thresholds can only diverge in one place. */
+export declare function getEphemeralSeverity(signals: readonly EphemeralSignal[]): EphemeralSeverity | null;
+/** Format ephemeral signals into a visually prominent warning block.
  *  Returns undefined if no signals were detected. */
-export declare function formatEphemeralWarning(signals: readonly EphemeralSignal[]): string | undefined;
+export declare function formatEphemeralWarning(signals: readonly EphemeralSignal[], entryId: string): string | undefined;

package/dist/ephemeral.js

@@ -18,6 +18,7 @@
 import { readFileSync } from 'fs';
 import { dirname, join } from 'path';
 import { fileURLToPath } from 'url';
+import { WARN_SEPARATOR } from './thresholds.js';
 let cachedModel = null;
 function loadModel() {
     if (cachedModel)
@@ -228,11 +229,66 @@ const SIGNALS = [
                 /\b(doesn'?t|don'?t) (handle|support|implement).*\byet\b/,
                 /\bis (underway|not finished|not complete)\b/,
                 /\bblocked on\b/,
+                // Work-remaining section markers (colon required to avoid matching prose)
+                /\bremaining\s*:/, /\bopen items?\s*:/, /\bstill to do\s*:/,
+                /\bpending (tasks?|items?|work)\s*:/,
             ];
             const m = firstMatch(content, patterns);
             return m ? `contains "${m[0]}" — task tracking doesn't belong in long-term memory` : undefined;
         },
     },
+    // ── Completed task / work summary ──────────────────────────────────────
+    // Catches session work summaries stored as permanent knowledge.
+    // "Documentation updates complete", "Completed the migration", "All X validated".
+    {
+        id: 'completed-task',
+        label: 'Completed task announcement',
+        confidence: 'high',
+        test: (title, content) => {
+            const titlePatterns = [
+                // "Documentation updates complete", "migration done", "task finished"
+                /\b(update|migration|refactor|implementation|task|feature|docs?|documentation|sync|work|changes?|setup)\s+(complete[d]?|done|finished?)\b/,
+                // "Complete: X" or "Done - X" as a status prefix in the title
+                /^(complete[d]?|done|finished?)\s*[-–—:]/,
+            ];
+            const contentPatterns = [
+                // Content that opens with a completion verb — strongest signal
+                /^completed?\s+\w/,
+                // "Successfully completed/deployed/merged/migrated..."
+                /\bsuccessfully\s+(completed?|deployed?|merged?|migrated?|updated?|implemented?|refactored?)\b/,
+                // "All cross-references validated", "All tests done"
+                // [\w-] (no \s) restricts to single-word or hyphenated nouns, preventing
+                // "Every code fix is validated" (a durable policy) from matching
+                /\b(all|every)\s+\S[\w-]{0,25}\s+(validated?|complete[d]?|verified?|done)\b/,
+                // "has been completed/finished/merged/deployed"
+                /\b(has|have)\s+been\s+(completed?|finished?|merged?|deployed?)\b/,
+            ];
+            const tm = firstMatch(title, titlePatterns);
+            if (tm)
+                return `title contains "${tm[0]}" — task completion announcements aren't durable knowledge`;
+            const cm = firstMatch(content, contentPatterns);
+            return cm ? `contains "${cm[0]}" — task completion announcements aren't durable knowledge` : undefined;
+        },
+    },
+    // ── Diff stats / work metrics ──────────────────────────────────────────
+    // Quantitative work summaries ("14 docs modified", "508 additions, 173 deletions")
+    // never appear in durable knowledge — they're always session activity reports.
+    {
+        id: 'diff-stats',
+        label: 'Diff stats or work metrics',
+        confidence: 'high',
+        test: (_title, _content, raw) => {
+            const content = raw.content.toLowerCase();
+            const patterns = [
+                // Git-style: "(508 additions, 173 deletions)" or "508 additions, 173 deletions"
+                /\b\d+\s+additions?,\s*\d+\s+deletions?\b/,
+                // Work quantity: "14 docs modified", "5 files changed"
+                /\b\d+\s+(docs?|files?|tests?|endpoints?|functions?|modules?|classes?|pages?)\s+(modified|changed|updated|added|created|deleted)\b/,
+            ];
+            const m = firstMatch(content, patterns);
+            return m ? `"${m[0]}" — quantitative work metrics are session activity, not lasting knowledge` : undefined;
+        },
+    },
     // ── Stack traces / debug logs ──────────────────────────────────────────
     {
         id: 'stack-trace',
@@ -386,6 +442,27 @@ const SIGNALS = [
             return m ? `"${m[0]}" — store the decision or fact, not the meeting reference` : undefined;
         },
     },
+    // ── Shipped / released / merged ────────────────────────────────────────
+    // Positive deployment/release language not already caught by temporal.
+    // ("just deployed" is caught by temporal; this catches statements without "just".)
+    {
+        id: 'shipped',
+        label: 'Deployed, released, or merged',
+        confidence: 'medium',
+        test: (_title, content) => {
+            const patterns = [
+                // "was/got/has been deployed to production/staging/main" — past-tense anchor prevents
+                // firing on policy conventions like "is deployed to production before release"
+                /\b(?:was|were|got|has been)\s+deployed?\s+(?:to|into)\s+(production|prod|staging|main|master)\b/,
+                // "was/got/has been merged into main/master/develop/trunk"
+                /\b(?:was|were|got|has been)\s+merged?\s+(?:to|into)\s+(main|master|develop|trunk)\b/,
+                // "released to production" or "released as v1.2" or "released as version 1.2"
+                /\breleased?\s+(?:to\s+(?:production|prod)|(?:as\s+)?(?:version\s+)?v?\d+\.\d+)\b/,
+            ];
+            const m = firstMatch(content, patterns);
+            return m ? `"${m[0]}" — deployment/release events are ephemeral; store the resulting behavior instead` : undefined;
+        },
+    },
     // ── Pending decision / under evaluation ─────────────────────────────────
     {
         id: 'pending-decision',
@@ -435,6 +512,31 @@ const SIGNALS = [
             return m ? `"${m[0]}" — metric changes are often transient observations` : undefined;
         },
     },
+    // ── Bundling conjunctions ──────────────────────────────────────────────
+    // Catches agents that put multiple unrelated facts in a single entry using
+    // explicit linking language. Only fires on sentence-boundary connectors
+    // (comma or start of new sentence) to avoid false positives on prose like
+    // "X and Y work together" or "also useful for Z".
+    {
+        id: 'bundling-conjunction',
+        label: 'Multiple facts bundled',
+        confidence: 'low',
+        test: (_title, content) => {
+            const patterns = [
+                /[,;]\s+also\b/i, // "X works this way, also Y does Z"
+                /[.!?]\s+also[,\s]/i, // ". Also, Y does Z" (sentence-start also)
+                /[.!?]\s+additionally,/i, // ". Additionally, ..."
+                /[.!?]\s+furthermore,/i, // ". Furthermore, ..."
+                /\bunrelated:/i, // "Unrelated: ..."
+                /\bseparately:/i, // "Separately: ..."
+                /[.!?]\s+on a (separate|different|unrelated) note[,:]?/i,
+            ];
+            const m = firstMatch(content, patterns);
+            return m
+                ? `"${m[0]}" — consider splitting into separate entries (one insight per entry)`
+                : undefined;
+        },
+    },
     // ── Very short content ─────────────────────────────────────────────────
     {
         id: 'too-short',
@@ -489,28 +591,71 @@ export function detectEphemeralSignals(title, content, topic) {
     }
     return signals;
 }
-/** Format ephemeral signals into a human-readable warning string.
- *  Returns undefined if no signals were detected. */
-export function formatEphemeralWarning(signals) {
+/** Derive aggregate severity from a set of detected signals.
+ *  Single source of truth for the threshold logic — both formatEphemeralWarning
+ *  and store.ts call this so the thresholds can only diverge in one place. */
+export function getEphemeralSeverity(signals) {
     if (signals.length === 0)
-        return undefined;
+        return null;
     const highCount = signals.filter(s => s.confidence === 'high').length;
-    const severity = highCount >= 2 ? 'likely contains' : highCount === 1 ? 'possibly contains' : 'may contain';
-    const lines = [
-        `This entry ${severity} ephemeral content:`,
-        ...signals.map(s => `  - ${s.label}: ${s.detail}`),
-        '',
-    ];
-    // Scale the guidance with confidence — high-confidence gets direct advice,
-    // low-confidence gets a softer suggestion to let the agent decide
-    if (highCount >= 2) {
-        lines.push('This is almost certainly session-specific. Consider deleting after your session.');
-    }
-    else if (highCount === 1) {
-        lines.push('If this is a lasting insight, keep it. If session-specific, consider deleting after your session.');
-    }
-    else {
-        lines.push('This might still be valid long-term knowledge — use your judgment.');
+    if (highCount >= 2)
+        return 'high';
+    if (highCount === 1)
+        return 'medium';
+    return 'low';
+}
+/** Format ephemeral signals into a visually prominent warning block.
+ *  Returns undefined if no signals were detected. */
+export function formatEphemeralWarning(signals, entryId) {
+    const severity = getEphemeralSeverity(signals);
+    if (severity === null)
+        return undefined;
+    const signalLines = signals.map(s => `  - ${s.label}: ${s.detail}`).join('\n');
+    // Delete command without leading spaces — callsites add their own indentation.
+    const deleteCmd = `memory_correct(id: "${entryId}", action: "delete")`;
+    // Scale both the header and guidance text with severity.
+    // high:   near-certain ephemeral → "ACTION REQUIRED" + prominent DELETE label.
+    // medium: likely ephemeral → "REVIEW NEEDED" + delete as an option.
+    // low:    uncertain → "CHECK BELOW" + softest framing.
+    switch (severity) {
+        case 'high':
+            return [
+                WARN_SEPARATOR,
+                '⚠  EPHEMERAL CONTENT — ACTION REQUIRED  ⚠',
+                WARN_SEPARATOR,
+                signalLines,
+                '',
+                'Will this still be true in 6 months? Almost certainly not.',
+                '',
+                `DELETE:  ${deleteCmd}`,
+                '',
+                'If there is a lasting insight here, extract and rephrase',
+                'it as a present-tense fact before deleting this entry.',
+                WARN_SEPARATOR,
+            ].join('\n');
+        case 'medium':
+            return [
+                WARN_SEPARATOR,
+                '⚠  POSSIBLY EPHEMERAL CONTENT — REVIEW NEEDED  ⚠',
+                WARN_SEPARATOR,
+                signalLines,
+                '',
+                'Will this still be true in 6 months?',
+                `  - If not:  ${deleteCmd}`,
+                `  - If so:   rephrase as a present-tense fact (what is now true)`,
+                WARN_SEPARATOR,
+            ].join('\n');
+        case 'low':
+            return [
+                WARN_SEPARATOR,
+                '⚠  POSSIBLY EPHEMERAL CONTENT — CHECK BELOW  ⚠',
+                WARN_SEPARATOR,
+                signalLines,
+                '',
+                'Ask: will this still be true in 6 months?',
+                `  - If not:  ${deleteCmd}`,
+                `  - If so:   rephrase as a present-tense fact if possible`,
+                WARN_SEPARATOR,
+            ].join('\n');
     }
-    return lines.join('\n');
 }

package/dist/formatters.js

@@ -2,7 +2,7 @@
 //
 // Pure functions — no side effects, no state. Each takes structured data
 // and returns a formatted string for the tool response.
-import { DEFAULT_STALE_DAYS_STANDARD, DEFAULT_STALE_DAYS_PREFERENCES, DEFAULT_MAX_STALE_IN_BRIEFING, DEFAULT_MAX_DEDUP_SUGGESTIONS, DEFAULT_MAX_CONFLICT_PAIRS, MAX_FOOTER_TAGS, } from './thresholds.js';
+import { DEFAULT_STALE_DAYS_STANDARD, DEFAULT_STALE_DAYS_PREFERENCES, DEFAULT_MAX_STALE_IN_BRIEFING, DEFAULT_MAX_DEDUP_SUGGESTIONS, DEFAULT_MAX_CONFLICT_PAIRS, MAX_FOOTER_TAGS, WARN_SEPARATOR, } from './thresholds.js';
 import { analyzeFilterGroups } from './text-analyzer.js';
 /** Format the stale entries section for briefing/context responses */
 export function formatStaleSection(staleDetails) {
@@ -17,23 +17,33 @@ export function formatStaleSection(staleDetails) {
 }
 /** Format the conflict detection warning for query/context responses */
 export function formatConflictWarning(conflicts) {
-    const lines = ['⚠ Potential conflicts detected:'];
+    const lines = [
+        WARN_SEPARATOR,
+        '⚠  CONFLICTING ENTRIES DETECTED — ACTION NEEDED  ⚠',
+        WARN_SEPARATOR,
+    ];
     for (const c of conflicts) {
-        lines.push(`  - ${c.a.id}: "${c.a.title}" (confidence: ${c.a.confidence}, created: ${c.a.created.substring(0, 10)})`);
-        lines.push(`    vs ${c.b.id}: "${c.b.title}" (confidence: ${c.b.confidence}, created: ${c.b.created.substring(0, 10)})`);
-        lines.push(`    Similarity: ${(c.similarity * 100).toFixed(0)}%`);
-        // Guide the agent on which entry to trust
+        lines.push(`  ${c.a.id}: "${c.a.title}" (confidence: ${c.a.confidence}, ${c.a.created.substring(0, 10)})`);
+        lines.push(`    vs`);
+        lines.push(`  ${c.b.id}: "${c.b.title}" (confidence: ${c.b.confidence}, ${c.b.created.substring(0, 10)})`);
+        lines.push(`  Similarity: ${(c.similarity * 100).toFixed(0)}%`);
+        lines.push('');
+        // Pre-fill which entry to delete so the agent can act immediately.
         if (c.a.confidence !== c.b.confidence) {
-            const higher = c.a.confidence > c.b.confidence ? c.a : c.b;
-            lines.push(`    Higher confidence: ${higher.id} (${higher.confidence})`);
+            const keep = c.a.confidence > c.b.confidence ? c.a : c.b;
+            const remove = c.a.confidence > c.b.confidence ? c.b : c.a;
+            lines.push(`  Trust ${keep.id} (higher confidence). Delete the lower-confidence entry:`);
+            lines.push(`  memory_correct(id: "${remove.id}", action: "delete")`);
         }
         else {
-            const newer = c.a.created > c.b.created ? c.a : c.b;
-            lines.push(`    More recent: ${newer.id} — may supersede the older entry`);
+            const keep = c.a.created > c.b.created ? c.a : c.b;
+            const remove = c.a.created > c.b.created ? c.b : c.a;
+            lines.push(`  ${keep.id} is more recent — may supersede ${remove.id}:`);
+            lines.push(`  memory_correct(id: "${remove.id}", action: "delete")`);
         }
+        lines.push('');
     }
-    lines.push('');
-    lines.push('Consider: memory_correct to consolidate or clarify the difference between these entries.');
+    lines.push(WARN_SEPARATOR);
     return lines.join('\n');
 }
 /** Format memory stats for a single lobe or global store */

package/dist/index.js

@@ -17,8 +17,9 @@ 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();
@@ -154,6 +155,43 @@ 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() {
+    const allLobeNames = configManager.getLobeNames();
+    // Short-circuit: single lobe is unambiguous
+    if (allLobeNames.length === 1) {
+        return buildLobeResolution(allLobeNames, allLobeNames);
+    }
+    // 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);
+            }
+        }
+        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, []);
+}
 /** 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 +200,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, only global knowledge (user/preferences) is returned — specify a lobe explicitly to access lobe-specific knowledge. Required for writes. Available: ${currentLobeNames.join(', ')}`,
         enum: currentLobeNames.length > 1 ? [...currentLobeNames] : undefined,
     };
 }
@@ -183,7 +221,10 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
             // and memory_stats. The handler still works if called directly.
             {
                 name: 'memory_store',
-                description: 'Store knowledge. "user" and "preferences" are global (no lobe needed). Use tags for exact-match categorization. Add a shared tag (e.g., "test-entry") for bulk operations. Example: memory_store(topic: "gotchas", title: "Build cache", content: "Must clean build after Tuist changes", tags: ["build", "ios"])',
+                // 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.',
                 inputSchema: {
                     type: 'object',
                     properties: {
@@ -196,13 +237,25 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                             description: 'Predefined: user | preferences | architecture | conventions | gotchas | recent-work. Custom namespace: modules/<name> (e.g. modules/brainstorm, modules/game-design, modules/api-notes). Use modules/<name> for any domain that doesn\'t fit the built-in topics.',
                             enum: ['user', 'preferences', 'architecture', 'conventions', 'gotchas', 'recent-work'],
                         },
-                        title: {
-                            type: 'string',
-                            description: 'Short title for this entry',
-                        },
-                        content: {
-                            type: 'string',
-                            description: 'The knowledge to store',
+                        entries: {
+                            type: 'array',
+                            // Type annotation first — agents trained on code read type signatures before prose.
+                            description: 'Array<{title: string, fact: string}> — not a string. One object per insight. title: short label (2-5 words). fact: codebase topics → present-tense state ("X uses Y", not "Completed X"); user/preferences → what the person expressed. Wrong: one object bundling two facts. Right: two objects.',
+                            items: {
+                                type: 'object',
+                                properties: {
+                                    title: {
+                                        type: 'string',
+                                        description: 'Short label for this insight (2-5 words)',
+                                    },
+                                    fact: {
+                                        type: 'string',
+                                        description: 'The insight itself — one focused fact or observation',
+                                    },
+                                },
+                                required: ['title', 'fact'],
+                            },
+                            minItems: 1,
                         },
                         sources: {
                             type: 'array',
@@ -229,7 +282,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                             default: [],
                         },
                     },
-                    required: ['topic', 'title', 'content'],
+                    required: ['topic', 'entries'],
                 },
             },
             {
@@ -287,7 +340,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: {
@@ -393,11 +446,16 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 };
             }
             case 'memory_store': {
-                const { lobe: rawLobe, topic: rawTopic, title, content, sources, references, trust: rawTrust, tags: rawTags } = z.object({
+                const { lobe: rawLobe, topic: rawTopic, entries: rawEntries, sources, references, trust: rawTrust, tags: rawTags } = z.object({
                     lobe: z.string().optional(),
                     topic: z.string(),
-                    title: z.string().min(1),
-                    content: z.string().min(1),
+                    // Accept a bare {title, fact} object in addition to the canonical array form.
+                    // Only objects are auto-wrapped — strings and other primitives still fail with
+                    // a type error, preserving the "validate at boundaries" invariant.
+                    entries: z.preprocess((val) => (val !== null && !Array.isArray(val) && typeof val === 'object' ? [val] : val), z.array(z.object({
+                        title: z.string().min(1),
+                        fact: z.string().min(1),
+                    })).min(1)),
                     sources: z.array(z.string()).default([]),
                     references: z.array(z.string()).default([]),
                     trust: z.enum(['user', 'agent-confirmed', 'agent-inferred']).default('agent-inferred'),
@@ -424,54 +482,87 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 const ctx = resolveToolContext(effectiveLobe, { isGlobal });
                 if (!ctx.ok)
                     return contextError(ctx);
-                const result = await ctx.store.store(topic, title, content, sources, 
-                // User/preferences default to 'user' trust unless explicitly set otherwise
-                isGlobal && trust === 'agent-inferred' ? 'user' : trust, references, rawTags);
-                if (!result.stored) {
-                    return {
-                        content: [{ type: 'text', text: `[${ctx.label}] Failed to store: ${result.warning}` }],
-                        isError: true,
-                    };
+                const effectiveTrust = isGlobal && 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) {
+                        return {
+                            content: [{ type: 'text', text: `[${ctx.label}] Failed to store "${title}": ${result.warning}` }],
+                            isError: true,
+                        };
+                    }
+                    storedResults.push({ title, result });
+                }
+                // 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];
+                    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}`);
+                }
+                else {
+                    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) {
+                        const ephemeralFlag = result.ephemeralSeverity === 'high' ? ' ⚠' : '';
+                        lines.push(`  - ${result.id}: "${title}"${ephemeralFlag}`);
+                    }
                 }
-                const lines = [
-                    `[${ctx.label}] Stored entry ${result.id} in ${result.topic} (confidence: ${result.confidence})`,
-                ];
-                if (result.warning)
-                    lines.push(`Note: ${result.warning}`);
                 // Limit to at most 2 hint sections per response to prevent hint fatigue.
                 // Priority: dedup > ephemeral > preferences (dedup is actionable and high-signal,
                 // ephemeral warnings affect entry quality, preferences are informational).
+                // For multi-entry batches, hints reference the first triggering entry.
                 let hintCount = 0;
-                // Dedup: surface related entries in the same topic
-                if (result.relatedEntries && result.relatedEntries.length > 0 && hintCount < 2) {
-                    hintCount++;
-                    lines.push('');
-                    lines.push('⚠ 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}`);
+                for (const { title, result } of storedResults) {
+                    const entryPrefix = storedResults.length > 1 ? `"${title}": ` : '';
+                    // 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(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('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);
                     }
-                    lines.push('');
-                    lines.push('To consolidate: memory_correct(id: "<old-id>", action: "replace", correction: "<merged content>") then memory_correct(id: "<new-id>", action: "delete")');
-                }
-                // Ephemeral content warning — soft nudge, never blocking
-                if (result.ephemeralWarning && hintCount < 2) {
-                    hintCount++;
-                    lines.push('');
-                    lines.push(`⏳ ${result.ephemeralWarning}`);
-                }
-                // Preference surfacing: show relevant preferences for non-preference entries
-                if (result.relevantPreferences && result.relevantPreferences.length > 0 && hintCount < 2) {
-                    hintCount++;
-                    lines.push('');
-                    lines.push('📌 Relevant preferences:');
-                    for (const p of result.relevantPreferences) {
-                        lines.push(`  - [pref] ${p.title}: ${p.content.length > 120 ? p.content.substring(0, 120) + '...' : p.content}`);
+                    // 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('');
+                        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) {
+                        hintCount++;
+                        lines.push('');
+                        lines.push(`📌 ${entryPrefix}Relevant preferences:`);
+                        for (const p of result.relevantPreferences) {
+                            lines.push(`  - [pref] ${p.title}: ${p.content.length > 120 ? p.content.substring(0, 120) + '...' : p.content}`);
+                        }
+                        lines.push('');
+                        lines.push('Review the stored entry against these preferences for potential conflicts.');
                     }
-                    lines.push('');
-                    lines.push('Review the stored entry against these preferences for potential conflicts.');
                 }
-                // Vocabulary echo: show existing tags to drive convergence
+                // Vocabulary echo: show existing tags to drive convergence (once per response)
                 if (hintCount < 2) {
                     const tagFreq = ctx.store.getTagFrequency();
                     if (tagFreq.size > 0) {
@@ -496,13 +587,13 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     branch: z.string().optional(),
                 }).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.
+                // Resolve which lobes to search.
+                // Global topics always route to globalStore. Lobe topics follow the degradation ladder.
                 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;
+                let queryGlobalOnlyHint;
                 if (isGlobalQuery) {
                     const ctx = resolveToolContext(rawLobe, { isGlobal: true });
                     if (!ctx.ok)
@@ -524,20 +615,30 @@ 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();
+                    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
@@ -559,22 +660,14 @@ 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 (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 (primaryStore)
+                        searchedStores.push(primaryStore);
                     if (scope === '*')
                         searchedStores.push(globalStore);
                 }
@@ -583,23 +676,25 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 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}`,
@@ -633,6 +728,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}`;
@@ -785,7 +884,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)
@@ -796,34 +895,29 @@ 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();
+                    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;
                         }
                     }
                 }
@@ -843,28 +937,23 @@ 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 (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);
-                    }
+                if (primaryStore && primaryStore !== globalStore) {
+                    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}`,
                             }],
                     };
                 }
@@ -882,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'
@@ -893,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}`);
                     }
@@ -920,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}`);
@@ -1032,8 +1126,8 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             const lobeNames = configManager.getLobeNames();
             hint = `\n\nHint: lobe is required. Use memory_list_lobes to see available lobes. Available: ${lobeNames.join(', ')}`;
         }
-        else if (message.includes('"topic"') || message.includes('"title"') || message.includes('"content"')) {
-            hint = '\n\nHint: memory_store requires: topic (architecture|conventions|gotchas|recent-work|modules/<name>), title, content. Use modules/<name> for custom namespaces (e.g. modules/brainstorm, modules/game-design).';
+        else if (message.includes('"topic"') || message.includes('"entries"')) {
+            hint = '\n\nHint: memory_store requires: topic (architecture|conventions|gotchas|recent-work|modules/<name>) and entries (Array<{title, fact}>). Example: entries: [{title: "Build cache", fact: "Must clean build after Tuist changes"}]. Use modules/<name> for custom namespaces.';
         }
         else if (message.includes('"scope"')) {
             hint = '\n\nHint: memory_query requires: lobe, scope (architecture|conventions|gotchas|recent-work|modules/<name>|* for all)';

package/dist/lobe-resolution.d.ts

@@ -0,0 +1,30 @@
+/** Outcome of resolving which lobes to search when the agent didn't specify one. */
+export type LobeResolution = {
+    readonly kind: 'resolved';
+    readonly lobes: readonly string[];
+    readonly label: string;
+} | {
+    readonly kind: 'global-only';
+    readonly hint: string;
+};
+/** A root URI from the MCP client (e.g. "file:///Users/me/projects/zillow"). */
+export interface ClientRoot {
+    readonly uri: string;
+}
+/** Minimal lobe config needed for matching — just the repo root path. */
+export interface LobeRootConfig {
+    readonly name: string;
+    readonly repoRoot: string;
+}
+/** Match MCP client workspace root URIs against known lobe repo roots.
+ *  Returns matched lobe names, or empty array if none match.
+ *
+ *  Matching rules:
+ *  - file:// URIs are stripped to filesystem paths
+ *  - Both paths are normalized via path.resolve
+ *  - A match occurs when either path is equal to or nested inside the other,
+ *    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;

package/dist/lobe-resolution.js

@@ -0,0 +1,67 @@
+// Pure lobe resolution logic — extracted for testability.
+//
+// When the agent doesn't specify a lobe, we determine which lobe(s) to search
+// via a degradation ladder:
+//   1. Single lobe configured → use it (unambiguous)
+//   2. Multiple lobes → match client workspace roots against lobe repo roots
+//   3. Fallback → global-only with a hint to specify the lobe
+//
+// This prevents cross-lobe leakage (e.g. game design lore surfacing in an Android MR review).
+import path from 'path';
+/** Check if `child` is equal to or nested under `parent` with path-boundary awareness.
+ *  Prevents false matches like "/projects/zillow-tools" matching "/projects/zillow". */
+function isPathPrefixOf(parent, child) {
+    if (child === parent)
+        return true;
+    // Ensure the prefix ends at a path separator boundary
+    const withSep = parent.endsWith(path.sep) ? parent : parent + path.sep;
+    return child.startsWith(withSep);
+}
+/** Match MCP client workspace root URIs against known lobe repo roots.
+ *  Returns matched lobe names, or empty array if none match.
+ *
+ *  Matching rules:
+ *  - file:// URIs are stripped to filesystem paths
+ *  - Both paths are normalized via path.resolve
+ *  - A match occurs when either path is equal to or nested inside the other,
+ *    checked at path-separator boundaries (no partial-name false positives) */
+export function matchRootsToLobeNames(clientRoots, lobeConfigs) {
+    if (clientRoots.length === 0 || lobeConfigs.length === 0)
+        return [];
+    const matchedLobes = new Set();
+    for (const root of clientRoots) {
+        // MCP roots use file:// URIs — strip the scheme to get the filesystem path
+        const rootPath = root.uri.startsWith('file://') ? root.uri.slice(7) : root.uri;
+        const normalizedRoot = path.resolve(rootPath);
+        for (const lobe of lobeConfigs) {
+            const normalizedLobe = path.resolve(lobe.repoRoot);
+            // Match if one path is equal to or nested inside the other
+            if (isPathPrefixOf(normalizedLobe, normalizedRoot) || isPathPrefixOf(normalizedRoot, normalizedLobe)) {
+                matchedLobes.add(lobe.name);
+            }
+        }
+    }
+    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) {
+    // Single lobe — always resolved, regardless of root matching
+    if (allLobeNames.length === 1) {
+        return { kind: 'resolved', lobes: allLobeNames, label: allLobeNames[0] };
+    }
+    // Multiple lobes with successful root match
+    if (matchedLobes.length > 0) {
+        return {
+            kind: 'resolved',
+            lobes: matchedLobes,
+            label: matchedLobes.length === 1 ? matchedLobes[0] : matchedLobes.join('+'),
+        };
+    }
+    // Fallback — no lobes could be determined
+    return {
+        kind: 'global-only',
+        hint: `Multiple lobes available (${allLobeNames.join(', ')}) but none could be inferred from client workspace roots. ` +
+            `Specify lobe parameter for lobe-specific results.`,
+    };
+}

package/dist/normalize.js

@@ -6,11 +6,6 @@
 /** Canonical param name aliases — maps guessed names to their correct form */
 const PARAM_ALIASES = {
     // memory_store aliases
-    key: 'title',
-    name: 'title',
-    value: 'content',
-    body: 'content',
-    text: 'content',
     refs: 'references',
     // memory_query aliases
     query: 'filter',

package/dist/store.js

@@ -10,7 +10,7 @@ import { DEFAULT_CONFIDENCE, realClock, parseTopicScope, parseTrustLevel, parseT
 import { DEDUP_SIMILARITY_THRESHOLD, CONFLICT_SIMILARITY_THRESHOLD_SAME_TOPIC, CONFLICT_SIMILARITY_THRESHOLD_CROSS_TOPIC, CONFLICT_MIN_CONTENT_CHARS, OPPOSITION_PAIRS, PREFERENCE_SURFACE_THRESHOLD, REFERENCE_BOOST_MULTIPLIER, TOPIC_BOOST, MODULE_TOPIC_BOOST, USER_ALWAYS_INCLUDE_SCORE_FRACTION, DEFAULT_STALE_DAYS_STANDARD, DEFAULT_STALE_DAYS_PREFERENCES, DEFAULT_MAX_STALE_IN_BRIEFING, DEFAULT_MAX_DEDUP_SUGGESTIONS, DEFAULT_MAX_CONFLICT_PAIRS, DEFAULT_MAX_PREFERENCE_SUGGESTIONS, TAG_MATCH_BOOST, } from './thresholds.js';
 import { realGitService } from './git-service.js';
 import { extractKeywords, stem, similarity, matchesFilter, computeRelevanceScore, } from './text-analyzer.js';
-import { detectEphemeralSignals, formatEphemeralWarning } from './ephemeral.js';
+import { detectEphemeralSignals, formatEphemeralWarning, getEphemeralSeverity } from './ephemeral.js';
 // Used only by bootstrap() for git log — not part of the GitService boundary
 // because bootstrap is a one-shot utility, not a recurring operation
 const execFileAsync = promisify(execFile);
@@ -89,9 +89,12 @@ export class MarkdownMemoryStore {
         const ephemeralSignals = topic !== 'recent-work'
             ? detectEphemeralSignals(title, content, topic)
             : [];
-        const ephemeralWarning = formatEphemeralWarning(ephemeralSignals);
+        // 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,
+            ephemeralSeverity: ephemeralSeverity ?? undefined,
             relatedEntries: relatedEntries.length > 0 ? relatedEntries : undefined,
             relevantPreferences: relevantPreferences && relevantPreferences.length > 0 ? relevantPreferences : undefined,
         };

package/dist/thresholds.d.ts

@@ -16,14 +16,6 @@ export declare const CONFLICT_MIN_CONTENT_CHARS = 50;
 export declare const OPPOSITION_PAIRS: ReadonlyArray<readonly [string, string]>;
 /** Score multiplier when a reference path basename matches the context keywords. */
 export declare const REFERENCE_BOOST_MULTIPLIER = 1.3;
-/** Score multiplier applied to weak cross-lobe results in multi-lobe context search.
- *  Prevents generic software terms (e.g. "codebase", "structure") from surfacing
- *  entries from unrelated repos with high confidence/topic-boost scores. */
-export declare const CROSS_LOBE_WEAK_SCORE_PENALTY = 0.5;
-/** Fraction of context keywords an entry must match to avoid the cross-lobe penalty.
- *  E.g. 0.40 means an entry must match at least 40% of the context keywords (minimum 2)
- *  to be treated as a strong cross-lobe match. */
-export declare const CROSS_LOBE_MIN_MATCH_RATIO = 0.4;
 /** Per-topic scoring boost factors for contextSearch().
  *  Higher = more likely to surface for any given context. */
 export declare const TOPIC_BOOST: Record<string, number>;
@@ -51,3 +43,6 @@ export declare const TAG_MATCH_BOOST = 1.5;
 export declare const VOCABULARY_ECHO_LIMIT = 8;
 /** Maximum tags shown in query/context footer. */
 export declare const MAX_FOOTER_TAGS = 12;
+/** Visual separator for warning blocks in tool responses.
+ *  Width chosen to stand out as a block boundary in any terminal or chat rendering. */
+export declare const WARN_SEPARATOR: string;

package/dist/thresholds.js

@@ -42,14 +42,6 @@ export const OPPOSITION_PAIRS = [
 ];
 /** Score multiplier when a reference path basename matches the context keywords. */
 export const REFERENCE_BOOST_MULTIPLIER = 1.30;
-/** Score multiplier applied to weak cross-lobe results in multi-lobe context search.
- *  Prevents generic software terms (e.g. "codebase", "structure") from surfacing
- *  entries from unrelated repos with high confidence/topic-boost scores. */
-export const CROSS_LOBE_WEAK_SCORE_PENALTY = 0.50;
-/** Fraction of context keywords an entry must match to avoid the cross-lobe penalty.
- *  E.g. 0.40 means an entry must match at least 40% of the context keywords (minimum 2)
- *  to be treated as a strong cross-lobe match. */
-export const CROSS_LOBE_MIN_MATCH_RATIO = 0.40;
 /** Per-topic scoring boost factors for contextSearch().
  *  Higher = more likely to surface for any given context. */
 export const TOPIC_BOOST = {
@@ -87,3 +79,7 @@ export const TAG_MATCH_BOOST = 1.5;
 export const VOCABULARY_ECHO_LIMIT = 8;
 /** Maximum tags shown in query/context footer. */
 export const MAX_FOOTER_TAGS = 12;
+// ─── Display formatting constants ───────────────────────────────────────────
+/** Visual separator for warning blocks in tool responses.
+ *  Width chosen to stand out as a block boundary in any terminal or chat rendering. */
+export const WARN_SEPARATOR = '='.repeat(52);

package/dist/types.d.ts

@@ -1,5 +1,8 @@
 /** Trust levels for knowledge sources, ordered by reliability */
 export type TrustLevel = 'user' | 'agent-confirmed' | 'agent-inferred';
+/** Ephemeral detection severity — three distinct levels so consumers can branch exhaustively.
+ *  Separated from EphemeralSignal.confidence to represent the aggregate outcome of all signals. */
+export type EphemeralSeverity = 'high' | 'medium' | 'low';
 /** Parse a raw string into a TrustLevel, returning null for invalid input */
 export declare function parseTrustLevel(raw: string): TrustLevel | null;
 /** Predefined topic scopes for organizing knowledge */
@@ -96,6 +99,8 @@ export type StoreResult = {
     readonly warning?: string;
     /** Soft warning when content looks ephemeral — informational, never blocking */
     readonly ephemeralWarning?: string;
+    /** Aggregate severity of all ephemeral signals that fired — absent when none fired */
+    readonly ephemeralSeverity?: EphemeralSeverity;
     readonly relatedEntries?: readonly RelatedEntry[];
     readonly relevantPreferences?: readonly RelatedEntry[];
 } | {

package/package.json

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