@exaudeus/memory-mcp 1.2.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)
@@ -523,6 +524,7 @@ const SIGNALS = [
         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: ..."
@@ -589,30 +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.
-    // Always include the positive redirect: store state, not events.
-    if (highCount >= 2) {
-        lines.push('This is almost certainly session-specific. Consider deleting after your session.');
-        lines.push('If there is a lasting insight here, rephrase it as a present-tense fact: what is now true about the codebase?');
-    }
-    else if (highCount === 1) {
-        lines.push('If this is a lasting insight, rephrase it as a present-tense fact (what is now true) rather than an action report (what you did). If session-specific, consider deleting after your session.');
-    }
-    else {
-        lines.push('If this is durable knowledge, rephrase as a present-tense fact: what is now true? If it describes what you did rather than what is, consider deleting after your session.');
+    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,
     };
 }
@@ -302,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: {
@@ -456,11 +494,14 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     }
                     storedResults.push({ title, result });
                 }
-                // Build response header
+                // Build response header.
+                // For high-severity ephemeral detections, flag the success line itself so agents
+                // who anchor on line 1 still see the problem before reading the block below.
                 const lines = [];
                 if (storedResults.length === 1) {
                     const { result } = storedResults[0];
-                    lines.push(`[${ctx.label}] Stored entry ${result.id} in ${result.topic} (confidence: ${result.confidence})`);
+                    const ephemeralFlag = result.ephemeralSeverity === 'high' ? ' (⚠ ephemeral — see below)' : '';
+                    lines.push(`[${ctx.label}] Stored entry ${result.id} in ${result.topic} (confidence: ${result.confidence})${ephemeralFlag}`);
                     if (result.warning)
                         lines.push(`Note: ${result.warning}`);
                 }
@@ -468,7 +509,8 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     const { result: first } = storedResults[0];
                     lines.push(`[${ctx.label}] Stored ${storedResults.length} entries in ${first.topic} (confidence: ${first.confidence}):`);
                     for (const { title, result } of storedResults) {
-                        lines.push(`  - ${result.id}: "${title}"`);
+                        const ephemeralFlag = result.ephemeralSeverity === 'high' ? ' ⚠' : '';
+                        lines.push(`  - ${result.id}: "${title}"${ephemeralFlag}`);
                     }
                 }
                 // Limit to at most 2 hint sections per response to prevent hint fatigue.
@@ -478,23 +520,35 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 let hintCount = 0;
                 for (const { title, result } of storedResults) {
                     const entryPrefix = storedResults.length > 1 ? `"${title}": ` : '';
-                    // Dedup: surface related entries in the same topic
+                    // Dedup: surface related entries in the same topic.
+                    // Fill in both actual IDs so the agent can act immediately without looking them up.
                     if (result.relatedEntries && result.relatedEntries.length > 0 && hintCount < 2) {
                         hintCount++;
+                        const top = result.relatedEntries[0];
                         lines.push('');
-                        lines.push(`⚠ ${entryPrefix}Similar entries found in the same topic:`);
-                        for (const r of result.relatedEntries) {
-                            lines.push(`  - ${r.id}: "${r.title}" (confidence: ${r.confidence})`);
-                            lines.push(`    Content: ${r.content.length > 120 ? r.content.substring(0, 120) + '...' : r.content}`);
+                        lines.push(WARN_SEPARATOR);
+                        lines.push(`⚠  ${entryPrefix}SIMILAR ENTRY ALREADY EXISTS — CONSOLIDATE  ⚠`);
+                        lines.push(WARN_SEPARATOR);
+                        lines.push(`  ${top.id}: "${top.title}" (confidence: ${top.confidence})`);
+                        lines.push(`  ${top.content.length > 120 ? top.content.substring(0, 120) + '...' : top.content}`);
+                        if (result.relatedEntries.length > 1) {
+                            const extra = result.relatedEntries.length - 1;
+                            lines.push(`  ... and ${extra} more similar ${extra === 1 ? 'entry' : 'entries'}`);
                         }
                         lines.push('');
-                        lines.push('To consolidate: memory_correct(id: "<old-id>", action: "replace", correction: "<merged content>") then memory_correct(id: "<new-id>", action: "delete")');
+                        lines.push('If these overlap, consolidate:');
+                        lines.push(`  KEEP+UPDATE: memory_correct(id: "${top.id}", action: "replace", correction: "<merged content>")`);
+                        lines.push(`  DELETE new:  memory_correct(id: "${result.id}", action: "delete")`);
+                        lines.push(WARN_SEPARATOR);
                     }
-                    // Ephemeral content warning — soft nudge, never blocking
+                    // Ephemeral content warning — the formatted block already contains visual borders
+                    // and pre-filled delete command from formatEphemeralWarning.
                     if (result.ephemeralWarning && hintCount < 2) {
                         hintCount++;
                         lines.push('');
-                        lines.push(`⏳ ${entryPrefix}${result.ephemeralWarning}`);
+                        if (entryPrefix)
+                            lines.push(`${entryPrefix}:`);
+                        lines.push(result.ephemeralWarning);
                     }
                     // Preference surfacing: show relevant preferences for non-preference entries
                     if (result.relevantPreferences && result.relevantPreferences.length > 0 && hintCount < 2) {
@@ -533,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)
@@ -561,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
@@ -596,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);
                 }
@@ -620,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}`,
@@ -670,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}`;
@@ -822,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)
@@ -833,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;
                         }
                     }
                 }
@@ -880,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}`,
                             }],
                     };
                 }
@@ -919,6 +971,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     ...topicOrder.filter(t => byTopic.has(t)),
                     ...Array.from(byTopic.keys()).filter(t => !topicOrder.includes(t)).sort(),
                 ];
+                const showCtxLobeLabels = ctxEntryLobeMap.size > 0;
                 for (const topic of orderedTopics) {
                     const topicResults = byTopic.get(topic);
                     const heading = topic === 'user' ? 'About You'
@@ -930,7 +983,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     for (const r of topicResults) {
                         const marker = topic === 'gotchas' ? '[!] ' : topic === 'preferences' ? '[pref] ' : '';
                         const keywords = r.matchedKeywords.length > 0 ? ` (matched: ${r.matchedKeywords.join(', ')})` : '';
-                        const lobeLabel = isCtxMultiLobe ? ` [${ctxEntryLobeMap.get(r.entry.id) ?? '?'}]` : '';
+                        const lobeLabel = showCtxLobeLabels ? ` [${ctxEntryLobeMap.get(r.entry.id) ?? '?'}]` : '';
                         const tagsSuffix = r.entry.tags?.length ? ` [tags: ${r.entry.tags.join(', ')}]` : '';
                         sections.push(`- **${marker}${r.entry.title}**${lobeLabel}: ${r.entry.content}${keywords}${tagsSuffix}`);
                     }
@@ -957,6 +1010,10 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     sections.push(`---\n*Context loaded for: ${kwList} (${topicList}). ` +
                         `This knowledge is now in your conversation — no need to call memory_context again for these terms this session.*`);
                 }
+                // Surface hint when we fell back to global-only
+                if (ctxGlobalOnlyHint) {
+                    sections.push(`> ${ctxGlobalOnlyHint}`);
+                }
                 // Build footer (context search has no filter — it's natural language keyword matching)
                 const ctxFooter = buildQueryFooter({ filterGroups: ctxFilterGroups, rawFilter: undefined, tagFreq: ctxTagFreq, resultCount: results.length, scope: 'context search' });
                 sections.push(`---\n${ctxFooter}`);

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/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.2.0",
+  "version": "1.3.0",
   "description": "Codebase memory MCP server - persistent, evolving knowledge for AI coding agents",
   "type": "module",
   "main": "dist/index.js",