@exaudeus/memory-mcp 1.2.0 → 1.4.0

package/dist/config-manager.d.ts

@@ -27,10 +27,14 @@ export declare class ConfigManager {
     private stores;
     private lobeHealth;
     private configMtime;
+    /** Cached alwaysInclude lobe names — recomputed atomically on reload. */
+    private cachedAlwaysIncludeLobes;
     protected statFile(path: string): Promise<{
         mtimeMs: number;
     }>;
     constructor(configPath: string, initial: LoadedConfig, initialStores: Map<string, MarkdownMemoryStore>, initialHealth: Map<string, LobeHealth>);
+    /** Derive alwaysInclude lobe names from config — pure, no side effects. */
+    private static computeAlwaysIncludeLobes;
     /**
      * Ensure config is fresh. Call at the start of every tool handler.
      * Stats config file, reloads if mtime changed. Graceful on all errors.
@@ -46,4 +50,6 @@ export declare class ConfigManager {
     getLobeHealth(lobe: string): LobeHealth | undefined;
     getConfigOrigin(): ConfigOrigin;
     getLobeConfig(lobe: string): MemoryConfig | undefined;
+    /** Returns lobe names where alwaysInclude is true. Cached; rebuilt atomically on hot-reload. */
+    getAlwaysIncludeLobes(): readonly string[];
 }

package/dist/config-manager.js

@@ -28,6 +28,13 @@ export class ConfigManager {
         this.stores = initialStores;
         this.lobeHealth = initialHealth;
         this.configMtime = Date.now(); // Initial mtime (will be updated on first stat)
+        this.cachedAlwaysIncludeLobes = ConfigManager.computeAlwaysIncludeLobes(this.lobeConfigs);
+    }
+    /** Derive alwaysInclude lobe names from config — pure, no side effects. */
+    static computeAlwaysIncludeLobes(configs) {
+        return Array.from(configs.entries())
+            .filter(([, config]) => config.alwaysInclude === true)
+            .map(([name]) => name);
     }
     /**
      * Ensure config is fresh. Call at the start of every tool handler.
@@ -90,12 +97,13 @@ export class ConfigManager {
                     });
                 }
             }
-            // Atomic swap
+            // Atomic swap — all derived state recomputed together
             this.configOrigin = newConfig.origin;
             this.lobeConfigs = newConfig.configs;
             this.stores = newStores;
             this.lobeHealth = newHealth;
             this.configMtime = newMtime;
+            this.cachedAlwaysIncludeLobes = ConfigManager.computeAlwaysIncludeLobes(newConfig.configs);
             const lobeCount = newConfig.configs.size;
             const degradedCount = Array.from(newHealth.values()).filter(h => h.status === 'degraded').length;
             const timestamp = new Date().toISOString();
@@ -123,4 +131,8 @@ export class ConfigManager {
     getLobeConfig(lobe) {
         return this.lobeConfigs.get(lobe);
     }
+    /** Returns lobe names where alwaysInclude is true. Cached; rebuilt atomically on hot-reload. */
+    getAlwaysIncludeLobes() {
+        return this.cachedAlwaysIncludeLobes;
+    }
 }

package/dist/config.js

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

package/dist/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 */