@exaudeus/memory-mcp 1.1.0 → 1.2.0

package/dist/ephemeral.js

@@ -228,11 +228,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 +441,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 +511,30 @@ 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+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',
@@ -502,15 +602,17 @@ export function formatEphemeralWarning(signals) {
         '',
     ];
     // Scale the guidance with confidence — high-confidence gets direct advice,
-    // low-confidence gets a softer suggestion to let the agent decide
+    // 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, keep it. If session-specific, consider deleting after your session.');
+        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('This might still be valid long-term knowledge — use your judgment.');
+        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.');
     }
     return lines.join('\n');
 }

package/dist/index.js

@@ -183,7 +183,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 +199,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 +244,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                             default: [],
                         },
                     },
-                    required: ['topic', 'title', 'content'],
+                    required: ['topic', 'entries'],
                 },
             },
             {
@@ -393,11 +408,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 +444,71 @@ 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
+                const lines = [];
+                if (storedResults.length === 1) {
+                    const { result } = storedResults[0];
+                    lines.push(`[${ctx.label}] Stored entry ${result.id} in ${result.topic} (confidence: ${result.confidence})`);
+                    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) {
+                        lines.push(`  - ${result.id}: "${title}"`);
+                    }
                 }
-                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
+                    if (result.relatedEntries && result.relatedEntries.length > 0 && hintCount < 2) {
+                        hintCount++;
+                        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('');
+                        lines.push('To consolidate: memory_correct(id: "<old-id>", action: "replace", correction: "<merged content>") then memory_correct(id: "<new-id>", action: "delete")');
                     }
-                    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 — soft nudge, never blocking
+                    if (result.ephemeralWarning && hintCount < 2) {
+                        hintCount++;
+                        lines.push('');
+                        lines.push(`⏳ ${entryPrefix}${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) {
@@ -1032,8 +1069,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/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/package.json

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