@xultrax-web/agent-memory-mcp 0.6.0 → 0.7.0

package/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2026 xultrax-web
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+MIT License
+
+Copyright (c) 2026 xultrax-web
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -185,18 +185,30 @@ Custom path:
 
 ## Tools
 
-| Tool                | Purpose                                                                                                                                        |
-| ------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------- |
-| `save_memory`       | Create or update a memory. Atomic write + locked. Validates name + type. Updates the index.                                                    |
-| `search_memories`   | Fuzzy search (Fuse.js · typo-tolerant, word-order tolerant, partial matches). Returns top N with relevance 0-100 + body snippet.               |
-| `relevant_memories` | Same matching as search, but returns full memory bodies as one markdown doc. Built for LLM auto-context.                                       |
-| `get_memory`        | Fetch one memory by name. Returns frontmatter + body.                                                                                          |
-| `list_memories`     | List memories. Optional `type` filter. Paginated (default 50/page).                                                                            |
-| `delete_memory`     | Soft delete: moves the memory to `.trash/<ts>-<name>.md`. Recoverable until you empty `.trash/` by hand.                                       |
-| `restore_memory`    | Restore a soft-deleted memory from `.trash/`. Picks the most recent trash entry for the name.                                                  |
-| `doctor`            | Storage integrity check. Reports orphans, dangling index entries, unreadable files. Pass `rebuild-index=true` to repair `MEMORY.md` from disk. |
-| `stats`             | Dashboard: counts per type, total size, largest memory, audit-log size, trash count.                                                           |
-| `log_events`        | Read recent entries from the audit event log. Optional `tail` (default 20) + `action` filter.                                                  |
+| Tool                | Purpose                                                                                                                                                                     |
+| ------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `save_memory`       | Create or update a memory. Atomic write + locked. Validates name + type. Updates the index.                                                                                 |
+| `search_memories`   | Fuzzy search (Fuse.js · typo-tolerant, word-order tolerant, partial matches). Returns top N with relevance 0-100 + body snippet.                                            |
+| `relevant_memories` | Same matching as search, but returns full memory bodies as one markdown doc. Built for LLM auto-context.                                                                    |
+| `get_memory`        | Fetch one memory by name. Returns frontmatter + body.                                                                                                                       |
+| `list_memories`     | List memories. Optional `type` filter. Paginated (default 50/page).                                                                                                         |
+| `delete_memory`     | Soft delete: moves the memory to `.trash/<ts>-<name>.md`. Recoverable until you empty `.trash/` by hand.                                                                    |
+| `restore_memory`    | Restore a soft-deleted memory from `.trash/`. Picks the most recent trash entry for the name.                                                                               |
+| `doctor`            | Storage integrity check. Reports orphans, dangling index entries, unreadable files. Pass `rebuild-index=true` to repair `MEMORY.md` from disk.                              |
+| `stats`             | Dashboard: counts per type, total size, largest memory, audit-log size, trash count.                                                                                        |
+| `log_events`        | Read recent entries from the audit event log. Optional `tail` (default 20) + `action` filter.                                                                               |
+| `verify_memory`     | Re-evaluate a memory's claims. Extracts URLs/dates/file refs, flags stale-date signals, returns type-specific verification heuristics. Pairs with the `audit_stale` prompt. |
+
+### Prompts
+
+The server exposes 4 built-in MCP prompts that clients (Claude Desktop, Cursor, etc.) surface as slash-commands. These turn memory into an active workflow layer, not just a passive store:
+
+| Prompt             | Arguments            | What it does                                                                                                                            |
+| ------------------ | -------------------- | --------------------------------------------------------------------------------------------------------------------------------------- |
+| `extract_memories` | none                 | LLM scans the current conversation, proposes candidate memories, and calls `save_memory` for each one (with type + description chosen). |
+| `summarize_topic`  | `topic`              | LLM pulls memories relevant to the topic via `relevant_memories` and synthesizes them into a single summary with citations.             |
+| `prepare_handoff`  | `project` (optional) | LLM walks project-type memories matching the filter and assembles a structured handoff doc (current state, open items, watch-outs).     |
+| `audit_stale`      | none                 | LLM evaluates project + reference memories for staleness and produces a triage list (likely stale / worth verifying / still fresh).     |
 
 ### Memory types
 
@@ -229,6 +241,7 @@ agent-memory doctor --rebuild-index            # repair MEMORY.md from disk
 agent-memory stats                             # dashboard: counts, sizes, audit/trash
 agent-memory log                               # last 20 entries from the audit log
 agent-memory log --tail 50 --action delete     # filter by action, tail size
+agent-memory verify deploy-process             # extract URLs/dates/file refs + staleness heuristics
 ```
 
 ### Audit log + structured logging
@@ -326,15 +339,22 @@ This server is built to be used daily, not to demo well once.
 
 **Shipped in v0.6:**
 
-- **Vitest test suite** — 20+ blackbox tests covering CLI + MCP server paths.
-- **GitHub Actions CI** — runs tests on every push/PR across Node 18/20/22.
+- **Vitest test suite** — 25+ blackbox tests covering CLI + MCP server paths.
+- **GitHub Actions CI** — runs tests on every push/PR across Node 20/22/24.
 - **[COMPATIBILITY.md](COMPATIBILITY.md)** — known-working client matrix + quirks.
 
-**Landing in v0.7:**
+**Shipped in v0.7 · the active context layer:**
 
-- Read-only mode (`AGENT_MEMORY_READ_ONLY=1`)
-- Live multi-client verification (Cursor, Cline, Claude Desktop, Continue)
-- Demo GIF / screencast
+- **MCP Prompts capability** — 4 built-in workflows (`extract_memories`, `summarize_topic`, `prepare_handoff`, `audit_stale`) that the client surfaces as slash-commands.
+- **`verify_memory` tool** — static analysis of a memory's URLs/dates/file refs with type-specific staleness heuristics. Plus the matching `agent-memory verify <name>` CLI.
+- **Conflict detection on save** — fuzzy-matches new memories against existing ones; warns on near-duplicates without blocking the save (so the LLM can decide whether to merge, rename, or proceed).
+
+**Landing in v0.8 - v0.9:**
+
+- Tags + wiki-links + folder support + `find_related` (organization-at-scale)
+- TUI / web UI for browsing + editing memories in a clean interface
+- `agent-memory sync` for git-backed multi-machine memory (the moat)
+- Memory packs for shareable curated bundles
 
 ---
 

package/dist/index.js

@@ -23,7 +23,7 @@
  */
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { CallToolRequestSchema, ListResourcesRequestSchema, ListToolsRequestSchema, ReadResourceRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { CallToolRequestSchema, GetPromptRequestSchema, ListPromptsRequestSchema, ListResourcesRequestSchema, ListToolsRequestSchema, ReadResourceRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
 import Fuse from "fuse.js";
 import matter from "gray-matter";
 import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, writeFileSync, } from "node:fs";
@@ -255,13 +255,89 @@ function toolSaveMemory(args) {
         `---\n\n`;
     const fp = memoryFilePath(name);
     const isUpdate = existsSync(fp);
+    // Conflict detection · only when creating a NEW memory (updates are
+    // intentional re-saves and don't need a similarity warning). Fuzzy
+    // match against existing names + descriptions; if anything scores
+    // above the conflict threshold, warn but don't block — the LLM can
+    // decide whether to merge, rename, or proceed.
+    let conflictWarning = "";
+    if (!isUpdate) {
+        const conflicts = detectConflicts({ name, description, type });
+        if (conflicts.length > 0) {
+            const list = conflicts
+                .map((c) => `  - ${c.name} [${c.type}] (${c.similarity}% similar)`)
+                .join("\n");
+            conflictWarning =
+                `\n\nWARNING · potentially similar existing memory(ies):\n${list}\n` +
+                    `Consider merging or renaming. To proceed anyway, the save has already been completed.`;
+        }
+    }
     return withLock(() => {
         atomicWriteFile(fp, frontmatter + content + "\n");
         upsertIndexEntryUnlocked(name, description);
-        logEvent("save", { name, type, update: isUpdate, bytes: content.length });
+        logEvent("save", {
+            name,
+            type,
+            update: isUpdate,
+            bytes: content.length,
+            conflicts: conflictWarning ? "warned" : undefined,
+        });
         log("debug", "save_memory", { name, type, update: isUpdate });
-        return `${isUpdate ? "Updated" : "Saved"} memory "${name}" (${type}) at ${fp}`;
+        return `${isUpdate ? "Updated" : "Saved"} memory "${name}" (${type}) at ${fp}${conflictWarning}`;
+    });
+}
+function detectConflicts(candidate) {
+    const names = listMemoryFiles();
+    // Skip the candidate name itself (will be an update, not a conflict)
+    const others = names.filter((n) => n !== candidate.name);
+    if (others.length === 0)
+        return [];
+    const existing = others.map((n) => readMemory(n)).filter((m) => m !== null);
+    if (existing.length === 0)
+        return [];
+    // Two separate searches catch different conflict shapes:
+    //   - Name-based: matches when the new slug is very close to an
+    //     existing slug (e.g. "deploy-process" vs "deployment-strategy")
+    //   - Description-based: matches when descriptions are paraphrases
+    //     of each other regardless of name
+    // We merge results + dedupe. Threshold 0.5 here is intentionally
+    // looser than search (0.4) because we'd rather warn on a few false
+    // positives than miss an obvious duplicate.
+    // Threshold 0.6 catches paraphrases like "deployment-strategy" vs
+    // "deploy-process" (Fuse Bitap scores those around 0.5). The 45%
+    // similarity floor below then trims out the long tail.
+    const nameFuse = new Fuse(existing, {
+        includeScore: true,
+        threshold: 0.6,
+        ignoreLocation: true,
+        minMatchCharLength: 3,
+        keys: ["name"],
     });
+    const descFuse = new Fuse(existing, {
+        includeScore: true,
+        threshold: 0.6,
+        ignoreLocation: true,
+        minMatchCharLength: 3,
+        keys: ["description"],
+    });
+    const merged = new Map();
+    const addHit = (name, type, score) => {
+        const existingHit = merged.get(name);
+        const similarity = Math.round((1 - score) * 100);
+        if (!existingHit || similarity > existingHit.similarity) {
+            merged.set(name, { name, type, similarity });
+        }
+    };
+    for (const r of nameFuse.search(candidate.name, { limit: 3 })) {
+        addHit(r.item.name, r.item.type, r.score ?? 1);
+    }
+    for (const r of descFuse.search(candidate.description, { limit: 3 })) {
+        addHit(r.item.name, r.item.type, r.score ?? 1);
+    }
+    return Array.from(merged.values())
+        .filter((h) => h.similarity >= 45) // 45%+ similarity = worth surfacing
+        .sort((a, b) => b.similarity - a.similarity)
+        .slice(0, 3);
 }
 function toolGetMemory(args) {
     const name = String(args.name ?? "").trim();
@@ -558,6 +634,90 @@ function toolDoctor(args) {
     return formatDoctorReport(report, rebuild);
 }
 // -------------------------------------------------------------
+// verify_memory · re-evaluate a memory's claims
+// -------------------------------------------------------------
+//
+// Static analysis only (no network calls — MCP servers may run
+// offline). Extracts URLs + dates + file paths from the body and
+// returns a structured report the LLM can act on. Pairs with the
+// audit_stale prompt to triage memory hygiene.
+const URL_PATTERN = /\bhttps?:\/\/[^\s<>"')]+/g;
+const DATE_PATTERN = /\b(20\d{2})-(\d{2})-(\d{2})\b/g;
+const FILE_PATH_PATTERN = /\b(?:[A-Za-z]:\\|\/)?(?:[\w.-]+[\\/])+[\w.-]+\.\w+\b/g;
+function toolVerifyMemory(args) {
+    const name = String(args.name ?? "").trim();
+    if (!SLUG_PATTERN.test(name))
+        throw new Error(`Invalid name "${name}".`);
+    const mem = readMemory(name);
+    if (!mem)
+        return `Memory "${name}" not found.`;
+    const urls = Array.from(new Set(mem.body.match(URL_PATTERN) ?? []));
+    const dates = Array.from(new Set((mem.body.match(DATE_PATTERN) ?? []).map((d) => d)));
+    const filePaths = Array.from(new Set(mem.body.match(FILE_PATH_PATTERN) ?? []));
+    // Staleness heuristic: if any date in the body is more than 60 days
+    // old AND the memory type is project, flag it for review.
+    const now = Date.now();
+    const SIXTY_DAYS = 60 * 24 * 3600 * 1000;
+    const oldDates = dates.filter((d) => {
+        const parsed = Date.parse(d);
+        return !isNaN(parsed) && now - parsed > SIXTY_DAYS;
+    });
+    const lines = [];
+    lines.push(c(ANSI.bold, `verify_memory · ${mem.name}`));
+    lines.push(`type        : ${mem.type}`);
+    lines.push(`description : ${mem.description}`);
+    lines.push("");
+    lines.push(c(ANSI.bold, "Static signals:"));
+    lines.push(`  URLs found        : ${urls.length}`);
+    lines.push(`  Dates referenced  : ${dates.length}${oldDates.length > 0 ? ` (${oldDates.length} > 60 days old)` : ""}`);
+    lines.push(`  File-path refs    : ${filePaths.length}`);
+    if (urls.length > 0) {
+        lines.push("");
+        lines.push(c(ANSI.bold, "URLs to verify:"));
+        for (const u of urls.slice(0, 10))
+            lines.push(`  - ${u}`);
+        if (urls.length > 10)
+            lines.push(`  ... +${urls.length - 10} more`);
+    }
+    if (oldDates.length > 0) {
+        lines.push("");
+        lines.push(c(ANSI.yellow, "Stale-date signals (consider whether claims are still current):"));
+        for (const d of oldDates.slice(0, 5))
+            lines.push(`  - ${d}`);
+    }
+    if (filePaths.length > 0 && filePaths.length <= 10) {
+        lines.push("");
+        lines.push(c(ANSI.bold, "File paths referenced:"));
+        for (const fp of filePaths)
+            lines.push(`  - ${fp}`);
+    }
+    lines.push("");
+    lines.push(c(ANSI.bold, "Type-specific verification heuristics:"));
+    switch (mem.type) {
+        case "reference":
+            lines.push("  - HEAD-check each URL above (200 = alive, 404 = dead, 410 = gone)");
+            lines.push("  - Verify the resource still says what the memory claims it says");
+            break;
+        case "project":
+            lines.push("  - Check if any dates above are stale relative to current project state");
+            lines.push("  - Cross-reference any names/people mentioned against current org chart");
+            lines.push("  - Verify any deadlines or commitments haven't already passed");
+            break;
+        case "feedback":
+            lines.push("  - Confirm the rule still applies (operator hasn't changed their mind)");
+            lines.push("  - Check the **Why:** is still load-bearing — if the original reason is gone, the rule may be obsolete");
+            break;
+        case "user":
+            lines.push("  - User preferences drift over time; ask the operator if a 6+ month old memory still holds");
+            break;
+    }
+    lines.push("");
+    lines.push(c(ANSI.dim, "Memory body for review:"));
+    lines.push("");
+    lines.push(mem.body);
+    return lines.join("\n");
+}
+// -------------------------------------------------------------
 // Stats · operator dashboard
 // -------------------------------------------------------------
 function toolStats(_args) {
@@ -667,7 +827,7 @@ function actionColor(action) {
 // -------------------------------------------------------------
 // Server wiring
 // -------------------------------------------------------------
-const server = new Server({ name: "agent-memory", version: "0.2.0" }, { capabilities: { tools: {}, resources: {} } });
+const server = new Server({ name: "agent-memory", version: "0.7.0" }, { capabilities: { tools: {}, resources: {}, prompts: {} } });
 // -------------------------------------------------------------
 // Resource URI scheme
 // -------------------------------------------------------------
@@ -727,6 +887,169 @@ server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
     }
     throw new Error(`Unknown resource URI: ${uri}. Supported: ${URI_INDEX}, ${URI_MEMORY_PREFIX}{name}`);
 });
+const PROMPTS = [
+    {
+        name: "extract_memories",
+        description: "Scan the current conversation for things worth remembering. Returns a structured prompt asking the LLM to identify candidate memories and call save_memory for each one.",
+    },
+    {
+        name: "summarize_topic",
+        description: "Pull memories relevant to a topic and ask the LLM to synthesize them into a single coherent summary.",
+        arguments: [
+            { name: "topic", description: "What to summarize what's known about.", required: true },
+        ],
+    },
+    {
+        name: "prepare_handoff",
+        description: "Generate a project state snapshot from all project-type memories matching a filter. Useful for rotating on-call, end-of-day handoffs, or onboarding a collaborator.",
+        arguments: [
+            {
+                name: "project",
+                description: "Substring to filter project memories by (matches name + description + tags).",
+                required: false,
+            },
+        ],
+    },
+    {
+        name: "audit_stale",
+        description: "Walk recent project and reference memories and ask the LLM to flag which ones are likely stale or contradicted by current state. Pairs with verify_memory for follow-up.",
+    },
+];
+server.setRequestHandler(ListPromptsRequestSchema, async () => ({
+    prompts: PROMPTS,
+}));
+server.setRequestHandler(GetPromptRequestSchema, async (request) => {
+    const { name, arguments: args = {} } = request.params;
+    ensureStorage();
+    switch (name) {
+        case "extract_memories":
+            return {
+                description: PROMPTS[0].description,
+                messages: [
+                    {
+                        role: "user",
+                        content: {
+                            type: "text",
+                            text: [
+                                "Scan the current conversation for facts, rules, preferences, decisions, or context that would be useful to remember across future sessions. Focus on things that:",
+                                "",
+                                "- Reflect the operator's stable preferences or working style (type=user)",
+                                "- Represent rules the assistant should follow going forward (type=feedback)",
+                                "- Capture current-state context not derivable from code or docs (type=project)",
+                                "- Point at external resources the operator references (type=reference)",
+                                "",
+                                "For each candidate, call the save_memory tool with:",
+                                "  - name: a short kebab-case slug (a-z, 0-9, -, _)",
+                                "  - type: one of user | feedback | project | reference",
+                                "  - description: a one-line summary used in the index",
+                                "  - content: the memory body in markdown. For feedback/project, include `**Why:**` and `**How to apply:**` lines.",
+                                "",
+                                "Before saving each one, briefly explain why it's worth remembering. Skip anything that's already obvious from code or that's only relevant to the current session.",
+                                "",
+                                "If there's nothing worth saving, say so plainly and stop.",
+                            ].join("\n"),
+                        },
+                    },
+                ],
+            };
+        case "summarize_topic": {
+            const topic = String(args.topic ?? "").trim();
+            if (!topic)
+                throw new Error("summarize_topic requires a 'topic' argument");
+            return {
+                description: PROMPTS[1].description,
+                messages: [
+                    {
+                        role: "user",
+                        content: {
+                            type: "text",
+                            text: [
+                                `Call the relevant_memories tool with query="${topic}" (max=10).`,
+                                "",
+                                "Then synthesize the returned memories into a single coherent summary covering:",
+                                "",
+                                "1. What's established / known",
+                                "2. Open questions or unresolved tensions across the memories",
+                                "3. Any stale or contradicted claims worth flagging",
+                                "",
+                                "Keep it tight — aim for one paragraph per section unless the material is genuinely dense. Cite the source memory names inline as `[memory-name]`.",
+                            ].join("\n"),
+                        },
+                    },
+                ],
+            };
+        }
+        case "prepare_handoff": {
+            const project = String(args.project ?? "").trim();
+            const filterClause = project
+                ? `filtered to project memories matching "${project}"`
+                : "across all project memories";
+            return {
+                description: PROMPTS[2].description,
+                messages: [
+                    {
+                        role: "user",
+                        content: {
+                            type: "text",
+                            text: [
+                                `Generate a project handoff document ${filterClause}.`,
+                                "",
+                                project
+                                    ? `Start by calling list_memories with type="project", then filter the results by substring match against "${project}".`
+                                    : `Start by calling list_memories with type="project" to get the full set.`,
+                                "",
+                                "For each relevant memory, call get_memory to load its full body. Then produce a single handoff document with these sections:",
+                                "",
+                                "## Current state",
+                                "What's in flight or recently shipped, distilled from project memories.",
+                                "",
+                                "## Open items",
+                                "Anything explicitly noted as pending, waiting, or unresolved.",
+                                "",
+                                "## Watch-outs",
+                                "Constraints, deadlines, or hidden gotchas captured in memory.",
+                                "",
+                                "## Reference material",
+                                "Links and external resources the next person should know about (from reference memories if they're relevant to the project).",
+                                "",
+                                "Cite source memories inline as `[memory-name]`. Keep prose dense; this is meant to be read by an experienced operator, not explained from scratch.",
+                            ].join("\n"),
+                        },
+                    },
+                ],
+            };
+        }
+        case "audit_stale":
+            return {
+                description: PROMPTS[3].description,
+                messages: [
+                    {
+                        role: "user",
+                        content: {
+                            type: "text",
+                            text: [
+                                'Call list_memories with type="project", then list_memories with type="reference". For each memory returned, evaluate whether its claims are likely still true based on:',
+                                "",
+                                "- Dates in the body (anything more than 30 days old in a `project` memory deserves scrutiny)",
+                                "- References to people, dependencies, or systems that may have changed",
+                                "- Claims about external state (URLs, dashboards, APIs) that you can't verify without external access",
+                                "",
+                                "Produce a triage list with three buckets:",
+                                "",
+                                "**Likely stale** (high confidence they're outdated) — explain why, suggest action.",
+                                "**Worth verifying** (claims you can't evaluate without external access) — suggest using the verify_memory tool.",
+                                "**Still fresh** (nothing in the content suggests staleness).",
+                                "",
+                                "Be conservative on the 'likely stale' bucket — false positives there create work for the operator.",
+                            ].join("\n"),
+                        },
+                    },
+                ],
+            };
+        default:
+            throw new Error(`Unknown prompt: ${name}`);
+    }
+});
 server.setRequestHandler(ListToolsRequestSchema, async () => ({
     tools: [
         {
@@ -869,6 +1192,17 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
                 },
             },
         },
+        {
+            name: "verify_memory",
+            description: "Re-evaluate a memory's claims against signals in its content. Extracts URLs, dates, and file paths from the body; flags stale-date signals on project-type memories; returns type-specific verification heuristics for the LLM or operator to act on. Pairs with the audit_stale prompt.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    name: { type: "string", description: "The memory's name slug" },
+                },
+                required: ["name"],
+            },
+        },
     ],
 }));
 server.setRequestHandler(CallToolRequestSchema, async (request) => {
@@ -906,6 +1240,9 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             case "log_events":
                 result = toolLogEvents(args);
                 break;
+            case "verify_memory":
+                result = toolVerifyMemory(args);
+                break;
             default:
                 throw new Error(`Unknown tool: ${name}`);
         }
@@ -938,6 +1275,7 @@ const CLI_COMMANDS = new Set([
     "doctor",
     "stats",
     "log",
+    "verify",
     "import-claude-code",
     "help",
     "--help",
@@ -1067,6 +1405,13 @@ async function cliMain(command, rest) {
                 process.stdout.write(toolStats({}) + "\n");
                 return 0;
             }
+            case "verify": {
+                const name = positional[0];
+                if (!name)
+                    throw new Error("Usage: agent-memory verify <name>");
+                process.stdout.write(toolVerifyMemory({ name }) + "\n");
+                return 0;
+            }
             case "log": {
                 process.stdout.write(toolLogEvents({
                     tail: flags.tail ? Number(flags.tail) : undefined,
@@ -1117,6 +1462,9 @@ COMMANDS
   stats                                    Dashboard: counts per type, sizes, audit/trash counts.
   log [--tail N] [--action save|delete|restore]
                                            Recent audit-log entries.
+  verify <name>                            Re-evaluate a memory's claims (URLs, dates, file refs,
+                                           type-specific staleness heuristics). Static analysis;
+                                           no network calls.
   import-claude-code [--source <path>] [--project <pat>] [--overwrite] [--dry-run]
                                            Walk ~/.claude/projects/*/memory/ and
                                            import each memory into the current store.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xultrax-web/agent-memory-mcp",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "mcpName": "io.github.xultrax-web/agent-memory-mcp",
   "description": "Markdown memory for AI agents. Plain files you can read, edit, grep, and commit. The only MCP memory server that isn't a database.",
   "type": "module",