memoryai-mcp 1.5.0 → 2.2.0

package/dist/index.js

@@ -11,6 +11,10 @@ import { z } from "zod";
 const API_URL = process.env.HM_ENDPOINT || "http://localhost:8420";
 const API_KEY = process.env.HM_API_KEY || "";
 const REQUEST_TIMEOUT_MS = 30_000; // P2 #6: 30s default timeout for API requests
+// Context Guard — per-IDE settings via env vars
+const CG_CONTEXT_CAP = parseInt(process.env.HM_CONTEXT_CAP || "0", 10); // IDE's context window (0 = let server detect)
+const CG_COMPACT_PCT = parseInt(process.env.HM_COMPACT_AT || "0", 10); // % to warn (e.g. 30 = 30%)
+const CG_CRITICAL_PCT = parseInt(process.env.HM_CRITICAL_AT || "0", 10); // % to force compact (e.g. 50 = 50%)
 // --- HTTP helper ---
 async function api(method, path, body) {
     const resp = await fetch(`${API_URL}${path}`, {
@@ -36,19 +40,21 @@ function err(e) {
     return { content: [{ type: "text", text: `Error: ${msg}` }], isError: true };
 }
 // --- MCP Server ---
-const server = new McpServer({ name: "memoryai", version: "0.9.0" }, { capabilities: { tools: {} } });
+const server = new McpServer({ name: "memoryai", version: "1.0.0" }, { capabilities: { tools: {} } });
 // 1. memory_store
-server.tool("memory_store", "Store information in persistent memory. Use when you learn something important — project context, user preferences, architectural decisions, patterns, or bugs.", {
+server.tool("memory_store", "Store information in persistent memory. Use when you learn something important — project context, user preferences, architectural decisions, patterns, bugs, pricing/cost discussions, business plans, financial calculations, credit/billing info, revenue models, partnership details, or ANY information the user might ask about later. When in doubt, STORE — MemoryAI handles dedup automatically, so storing too much is always better than forgetting.", {
     content: z.string().describe("What to remember"),
     source: z.string().optional().describe("Source context (e.g. file path, conversation)"),
     tags: z.array(z.string()).optional().describe("Categories: preferences, architecture, bugs, patterns, decisions"),
     priority: z.enum(["hot", "warm", "cold"]).optional().describe("Memory priority (default: warm)"),
-    memory_type: z.enum(["fact", "decision", "preference", "error", "goal", "episodic", "identity"]).optional().describe("Memory type. 'preference', 'decision', 'identity' are DNA-protected — never decay, 1.5x recall boost. Default: fact"),
+    memory_type: z.enum(["fact", "decision", "preference", "error", "goal", "episodic", "identity", "pitfall", "life_event", "procedure"]).optional().describe("Memory type. 'preference', 'decision', 'identity', 'procedure' are DNA-protected — never decay, 1.5x recall boost. 'pitfall' for failure memories. 'procedure' for learned workflows/steps. Default: fact"),
     retention: z.enum(["auto", "forever", "6m", "1y"]).optional().describe("Retention policy. 'forever' = never deleted. Default: auto"),
     content_type: z.enum(["conversation", "code", "decision", "preference", "architecture", "lesson_learned", "todo", "entity", "pattern", "environment", "bug_fix", "action_log"]).optional().describe("Content type — helps with filtering and recall accuracy"),
     metadata: z.record(z.string(), z.unknown()).optional().describe("Additional metadata (JSONB)"),
     zone: z.enum(["critical", "important", "standard", "ephemeral"]).optional().describe("Memory zone (default: standard). critical=never evict, ephemeral=auto-expire"),
     importance: z.number().min(0).max(1).optional().describe("Importance score 0.0-1.0 (default: 0.5). Higher = slower decay, prioritized in recall"),
+    project_id: z.string().optional().describe("Scope memory to a project/workspace. DNA memories (preference/decision/identity/pitfall) are always cross-project visible."),
+    thread_id: z.string().optional().describe("Scope memory to a conversation thread. Memories without thread_id are visible in all threads. Use for parallel topics (e.g. 'relationship', 'career')."),
 }, async (args) => {
     try {
         const r = (await api("POST", "/v1/store", {
@@ -62,6 +68,8 @@ server.tool("memory_store", "Store information in persistent memory. Use when yo
             metadata: args.metadata,
             zone: args.zone || "standard",
             importance: args.importance ?? 0.5,
+            project_id: args.project_id,
+            thread_id: args.thread_id,
         }));
         let msg = `Stored (id=${r.id}, type=${args.memory_type || "fact"})`;
         if (r.deduplicated) {
@@ -81,12 +89,14 @@ server.tool("memory_store", "Store information in persistent memory. Use when yo
 // 2. memory_recall
 server.tool("memory_recall", "Search persistent memory for relevant context. Use before starting work to check what you already know about the project or task.", {
     query: z.string().describe("What to search for"),
-    depth: z.enum(["fast", "deep", "exhaustive"]).optional().describe("Search depth (default: deep)"),
+    depth: z.enum(["fast", "instant", "deep", "exhaustive"]).optional().describe("Search depth. 'instant'=vector only (~50ms), 'fast'=FTS only, 'deep'=full fusion (default), 'exhaustive'=deep+more results"),
     limit: z.number().optional().describe("Max results (default: 5)"),
     min_score: z.number().optional().describe("Minimum relevance score 0-1 (default: 0)"),
     tags: z.array(z.string()).optional().describe("Filter by tags"),
     max_tokens: z.number().optional().describe("Token budget limit — results truncated to fit within this budget"),
     priority_min: z.enum(["critical", "important", "standard", "ephemeral"]).optional().describe("Minimum zone priority filter (default: all zones)"),
+    project_id: z.string().optional().describe("Scope recall to a project/workspace. DNA memories are always visible cross-project."),
+    thread_id: z.string().optional().describe("Scope recall to a conversation thread. Memories without thread_id are always visible."),
 }, async (args) => {
     try {
         const body = {
@@ -100,6 +110,10 @@ server.tool("memory_recall", "Search persistent memory for relevant context. Use
             body.max_tokens = args.max_tokens;
         if (args.priority_min)
             body.priority_min = args.priority_min;
+        if (args.project_id)
+            body.project_id = args.project_id;
+        if (args.thread_id)
+            body.thread_id = args.thread_id;
         const r = (await api("POST", "/v1/recall", body));
         if (!r.results?.length)
             return ok("No relevant memories found.");
@@ -804,15 +818,23 @@ server.tool("session_handoff_status", "Check current session handoff status —
 // context_guard_check — universal guard check with DNA count
 server.tool("context_guard_check", "Check context window health using Context Guard v6 — dynamic thresholds, DNA memory count, bootstrap readiness. Replaces memory_health with richer data.", {
     estimated_tokens: z.number().describe("Current token count in context window"),
-    max_tokens: z.number().optional().describe("Max context window size (auto-detected from model if omitted)"),
+    max_tokens: z.number().optional().describe("Max context window size (uses HM_CONTEXT_CAP env if omitted)"),
     model: z.string().optional().describe("Model name for auto-detecting context window size (e.g. claude-sonnet-4-6)"),
 }, async (args) => {
     try {
-        const r = (await api("POST", "/v1/context/guard/check", {
+        // Use env var HM_CONTEXT_CAP as default if max_tokens not provided
+        const maxTokens = args.max_tokens || CG_CONTEXT_CAP || 0;
+        const payload = {
             estimated_tokens: args.estimated_tokens,
-            max_tokens: args.max_tokens || 0,
+            max_tokens: maxTokens,
             model: args.model || null,
-        }));
+        };
+        // Send per-IDE threshold overrides if configured via env vars
+        if (CG_COMPACT_PCT > 0)
+            payload.compact_pct = CG_COMPACT_PCT / 100;
+        if (CG_CRITICAL_PCT > 0)
+            payload.critical_pct = CG_CRITICAL_PCT / 100;
+        const r = (await api("POST", "/v1/context/guard/check", payload));
         const pct = r.usage_percent;
         const barLen = 20;
         const filled = Math.round(pct / 100 * barLen);
@@ -831,8 +853,8 @@ server.tool("context_guard_check", "Check context window health using Context Gu
     }
 });
 // context_guard_compact — compact with DNA protection
-server.tool("context_guard_compact", "Compact session context with DNA protection — DNA memories are never overwritten. Returns task_id for async polling or result for blocking mode.", {
-    content: z.string().describe("Session transcript or content to compact"),
+server.tool("context_guard_compact", "Compact session context with DNA protection — DNA memories are never overwritten. IMPORTANT: Send a REAL summary of the conversation (>500 chars) including topics discussed, decisions made, key numbers/facts, and current status. Do NOT send just a status string like 'context guard - 132%'. If you send useless content, the server will use its internal buffer as fallback, but a good summary from you produces better memories.", {
+    content: z.string().describe("Conversation summary — include topics, decisions, key facts, numbers. Must be >500 chars of real content."),
     task_context: z.string().optional().describe("Task description for tagging"),
     blocking: z.boolean().optional().describe("Wait for result (true) or return task_id (false, default)"),
 }, async (args) => {
@@ -852,9 +874,9 @@ server.tool("context_guard_compact", "Compact session context with DNA protectio
         return err(e);
     }
 });
-// context_guard_bootstrap — DNA-first session bootstrap
-server.tool("context_guard_bootstrap", "Bootstrap a new session with DNA-first context — identity/preferences first, then recent activity, then task-relevant memories.", {
-    task: z.string().describe("Task description for the new session"),
+// context_guard_bootstrap — DNA-first session bootstrap (IDE)
+server.tool("context_guard_bootstrap", "Load context from previous sessions at session start. Returns preferences, recent activity, and task-relevant memories. Call once at the beginning of a session to restore context.", {
+    task: z.string().describe("Task description for context relevance"),
     limit: z.number().optional().describe("Max memories to include (default: 10)"),
 }, async (args) => {
     try {
@@ -862,7 +884,7 @@ server.tool("context_guard_bootstrap", "Bootstrap a new session with DNA-first c
             task: args.task,
             limit: args.limit || 10,
         }));
-        return ok(`Bootstrap complete: ${r.memories_restored} memories (${r.dna_memories} DNA)\n` +
+        return ok(`Context restored: ${r.memories_restored || r.memories_included || 0} memories (${r.dna_memories || 0} DNA)\n` +
             `Tokens used: ${r.tokens_used}\n\n` +
             r.context_block);
     }
@@ -870,6 +892,583 @@ server.tool("context_guard_bootstrap", "Bootstrap a new session with DNA-first c
         return err(e);
     }
 });
+// bot_guard_bootstrap — 3-tier wake-up for bots (800 tokens)
+server.tool("bot_guard_bootstrap", "Bot-specific bootstrap — 3-tier wake-up (Identity→Context→Details) with 800 token budget. Use for chatbots, not IDEs.", {
+    task: z.string().describe("Task description for the new session"),
+    limit: z.number().optional().describe("Max memories to include (default: 10)"),
+    mode: z.enum(["default", "deep"]).optional().describe("'default' = 800 token 3-tier, 'deep' = full context with L2 chunks"),
+    token_budget: z.number().optional().describe("Token budget (default: 800)"),
+}, async (args) => {
+    try {
+        const r = (await api("POST", "/v1/bot/guard/bootstrap", {
+            task: args.task,
+            limit: args.limit || 10,
+            mode: args.mode || "default",
+            token_budget: args.token_budget,
+        }));
+        return ok(`Bootstrap complete: ${r.memories_included} memories\n` +
+            `Tokens used: ${r.tokens_used}\n` +
+            `L2 sessions: ${r.l2_sessions_included || 0}\n\n` +
+            r.context_block);
+    }
+    catch (e) {
+        return err(e);
+    }
+});
+// bot_session_message — Rolling 3-session tracking (60 msg raw context)
+server.tool("bot_session_message", "Track a message in the rolling session (rolling 3: keeps 60 messages raw in LLM context). Call on EVERY message (user + assistant). Returns rotate=true when session hits 20 messages. When should_compress=true, compress the oldest session via bot_session_compress.", {
+    message: z.object({
+        role: z.enum(["user", "assistant"]).describe("Message role"),
+        content: z.string().describe("Message content"),
+    }).describe("The message to track"),
+    rotation_size: z.number().optional().describe("Messages per session before rotation (default: 20, range: 5-50)"),
+}, async (args) => {
+    try {
+        const r = (await api("POST", "/v1/bot/session/message", {
+            message: args.message,
+            rotation_size: args.rotation_size || 20,
+        }));
+        if (r.rotate) {
+            let output = `🔄 SESSION ROTATED\n` +
+                `New session: ${r.session_id} (msg ${r.message_count})\n` +
+                `Context: ${r.context_message_count} messages raw in LLM\n`;
+            if (r.should_compress) {
+                output += `\n⚠️ COMPRESS: session ${r.compress_session_id} (${r.compress_message_count} msgs)\n` +
+                    `Action: Call bot_session_compress with session_id="${r.compress_session_id}"`;
+            }
+            return ok(output);
+        }
+        return ok(`Session ${r.session_id}: ${r.message_count}/20 messages | context: ${r.context_message_count} msgs`);
+    }
+    catch (e) {
+        return err(e);
+    }
+});
+// bot_guard_check — Bot-specific guard with spawn signal
+server.tool("bot_guard_check", "Bot context guard — checks context pressure AND returns spawn signal. When should_spawn_new_session=true, bot should spawn a new session and compress the old one later. Use this instead of context_guard_check for bot/chatbot clients.", {
+    estimated_tokens: z.number().describe("Current token count in context window"),
+    max_tokens: z.number().optional().describe("Max context window size (default: 200000)"),
+    model: z.string().optional().describe("Model name for auto-detecting context window size"),
+    compress_threshold: z.number().optional().describe("Custom spawn threshold in tokens (default: 70% of max_tokens)"),
+}, async (args) => {
+    try {
+        const payload = {
+            estimated_tokens: args.estimated_tokens,
+            max_tokens: args.max_tokens || CG_CONTEXT_CAP || 200000,
+            model: args.model || null,
+        };
+        if (args.compress_threshold)
+            payload.compress_threshold = args.compress_threshold;
+        const r = (await api("POST", "/v1/bot/guard/check", payload));
+        const pct = r.usage_percent;
+        const barLen = 20;
+        const filled = Math.round(pct / 100 * barLen);
+        const bar = "\u2588".repeat(filled) + "\u2591".repeat(barLen - filled);
+        let output = `Bot Guard:\n` +
+            `[${bar}] ${pct.toFixed(1)}%\n` +
+            `Recommendation: ${r.recommendation.toUpperCase()}${r.should_compact ? " — compact now" : ""}\n` +
+            `Urgency: ${r.urgency}\n` +
+            `Spawn threshold: ${r.compress_threshold.toLocaleString()} tokens\n` +
+            `DNA memories: ${r.dna_memories} | Bootstrap ready: ${r.bootstrap_ready ? "yes" : "no"}\n`;
+        if (r.should_spawn_new_session) {
+            output += `\n⚠️ SPAWN NEW SESSION: ${r.spawn_reason}\n`;
+            output += `Action: Start new session → when new session reaches 20K tokens → compress old session via /v1/bot/session/compress`;
+        }
+        return ok(output);
+    }
+    catch (e) {
+        return err(e);
+    }
+});
+// ── Self-Thinking Tools ──────────────────────────────────────────────
+// brain_thoughts — Get current active thoughts
+server.tool("brain_thoughts", "Get the brain's current active thoughts — what it's thinking about autonomously.", {
+    limit: z.number().optional().describe("Max thoughts to return (default: 10)"),
+}, async (args) => {
+    try {
+        const r = (await api("GET", `/v1/brain/thoughts?limit=${args.limit || 10}`));
+        if (!r.thoughts || r.thoughts.length === 0)
+            return ok("Brain has no active thoughts right now.");
+        const lines = r.thoughts.map((t) => `[${t.thought_type}] ${t.content} (confidence: ${t.confidence}, urgency: ${t.urgency})`);
+        return ok(`Active thoughts (${r.count}):\n${lines.join("\n")}`);
+    }
+    catch (e) {
+        return err(e);
+    }
+});
+// brain_think_about — Request brain to think about a topic
+server.tool("brain_think_about", "Request the brain to think about a specific topic. The brain will deliberate on it in its next thinking cycle.", {
+    topic: z.string().describe("What should the brain think about?"),
+}, async (args) => {
+    try {
+        const r = (await api("POST", "/v1/brain/think-about", { topic: args.topic }));
+        return ok(`Queued for thinking: "${args.topic}"\nQueue size: ${r.queue_size}`);
+    }
+    catch (e) {
+        return err(e);
+    }
+});
+// brain_hypotheses — Get active hypotheses
+server.tool("brain_hypotheses", "Get hypotheses the brain is currently testing — predictions about user behavior patterns.", {
+    limit: z.number().optional().describe("Max hypotheses to return (default: 10)"),
+}, async (args) => {
+    try {
+        const r = (await api("GET", `/v1/brain/hypotheses?limit=${args.limit || 10}`));
+        if (!r.hypotheses || r.hypotheses.length === 0)
+            return ok("No active hypotheses being tested.");
+        const lines = r.hypotheses.map((h) => `[${h.status}] ${h.hypothesis} (confidence: ${h.confidence})`);
+        return ok(`Hypotheses (${r.count}):\n${lines.join("\n")}`);
+    }
+    catch (e) {
+        return err(e);
+    }
+});
+// brain_feedback — Rate a thought
+server.tool("brain_feedback", "Rate a thought as useful or not — helps the brain learn what's worth thinking about.", {
+    thought_id: z.number().describe("ID of the thought to rate"),
+    useful: z.boolean().describe("Was this thought useful?"),
+}, async (args) => {
+    try {
+        await api("POST", "/v1/brain/thoughts/feedback", {
+            thought_id: args.thought_id,
+            useful: args.useful,
+        });
+        return ok(`Feedback recorded: thought #${args.thought_id} marked as ${args.useful ? "useful" : "not useful"}`);
+    }
+    catch (e) {
+        return err(e);
+    }
+});
+// brain_thinking_stats — Budget and efficiency
+server.tool("brain_thinking_stats", "Get thinking system statistics — token budget, efficiency, queue size, and meta-cognition report.", {}, async () => {
+    try {
+        const r = (await api("GET", "/v1/brain/thinking-stats"));
+        return ok(`Budget: ${r.budget.remaining_tokens} tokens remaining (limit: ${r.budget.limit_per_hour}/hr)\n` +
+            `Efficiency: ${(r.budget.efficiency * 100).toFixed(1)}%\n` +
+            `Queue size: ${r.queue_size}\n` +
+            `Total thoughts: ${r.meta.total_thoughts} (${r.meta.useful_thoughts} useful)\n` +
+            `Interval: ${r.meta.recommended_interval_seconds}s\n` +
+            `Best types: ${r.meta.best_types.join(", ") || "none yet"}\n` +
+            `Suppressed: ${r.meta.suppressed_types.join(", ") || "none"}`);
+    }
+    catch (e) {
+        return err(e);
+    }
+});
+// ── Session Settings Tools ──────────────────────────────────────────
+// memory_auto_extract — LLM-based fact extraction from conversation
+server.tool("memory_auto_extract", "CRITICAL: Call this at the END of every conversation session to extract and store important facts automatically. Uses LLM analysis to identify pricing, decisions, plans, technical details, and anything worth remembering. This is MORE reliable than manual memory_store because it catches things you might forget to store. ALWAYS call this before the conversation ends — especially after discussions about money, pricing, plans, decisions, or business.", {
+    conversation: z.string().describe("The conversation text to extract facts from (include both user and assistant messages)"),
+    source: z.string().optional().describe("Source context (e.g. 'discord chat', 'slack thread')"),
+    store: z.boolean().optional().describe("Whether to store extracted facts (default: true). Set false to preview what would be extracted."),
+}, async (args) => {
+    try {
+        const r = (await api("POST", "/v1/memory/auto-extract", {
+            conversation: args.conversation,
+            source: args.source || "auto-extract",
+            store: args.store !== false,
+        }));
+        if (!r.facts?.length)
+            return ok("No extractable facts found in conversation.");
+        const factList = r.facts
+            .map((f, i) => `${i + 1}. [${f.memory_type || 'fact'}] ${f.content}`)
+            .join("\n");
+        return ok(`Extracted ${r.facts.length} facts (added: ${r.added}, updated: ${r.updated}, skipped: ${r.skipped}):\n\n${factList}`);
+    }
+    catch (e) {
+        return err(e);
+    }
+});
+// ── IDE Upgrade Tools ──────────────────────────────────────────────
+// memory_pitfall_check — Check pitfalls before risky actions
+server.tool("memory_pitfall_check", "IMPORTANT: Call this BEFORE executing risky actions (deploy, rm, git push, database changes). Returns known pitfalls (past failures + lessons) so you can avoid repeating mistakes. Pitfalls are DNA-protected and never expire.", {
+    intent: z.string().describe("What you're about to do (e.g. 'deploy to production', 'delete user table')"),
+    tags: z.array(z.string()).optional().describe("Filter by tags"),
+    limit: z.number().optional().describe("Max results (default 5)"),
+}, async (args) => {
+    try {
+        const r = (await api("POST", "/v1/bot/pitfall/check", {
+            intent: args.intent,
+            tags: args.tags,
+            limit: args.limit || 5,
+        }));
+        if (!r.has_pitfalls)
+            return ok("No known pitfalls for this action. Proceed safely.");
+        const list = r.pitfalls
+            .map((p, i) => `${i + 1}. [score: ${p.score}] ${p.content}`)
+            .join("\n");
+        return ok(`⚠️ ${r.pitfalls.length} pitfall(s) found:\n\n${list}\n\nReview before proceeding.`);
+    }
+    catch (e) {
+        return err(e);
+    }
+});
+// memory_plan_save — Save current plan/state for session resumption
+server.tool("memory_plan_save", "Save your current work state (plan steps, cursor position, active goals) so you can resume exactly where you left off in the next session. Call before session ends or when switching tasks.", {
+    session_id: z.string().optional().describe("Session identifier (default: 'default')"),
+    state: z.record(z.string(), z.unknown()).describe("State to save: {plan: [...], cursor: 3, active_goal: '...', last_action: '...', files_read: [...]}"),
+}, async (args) => {
+    try {
+        const r = (await api("POST", "/v1/bot/state/save", {
+            session_id: args.session_id || "default",
+            state: args.state,
+        }));
+        return ok(`State saved for session '${r.session_id}'. Will be restored on next bootstrap.`);
+    }
+    catch (e) {
+        return err(e);
+    }
+});
+// memory_plan_resume — Restore saved state from previous session
+server.tool("memory_plan_resume", "Restore your work state from a previous session. Returns plan steps, cursor position, active goals — everything needed to continue where you left off.", {
+    session_id: z.string().optional().describe("Session identifier (default: 'default')"),
+}, async (args) => {
+    try {
+        const r = (await api("GET", `/v1/bot/state/restore?session_id=${args.session_id || "default"}`));
+        if (r.status === "not_found")
+            return ok("No saved state found for this session. Starting fresh.");
+        return ok(`State restored (saved at ${r.saved_at}):\n\n${JSON.stringify(r.state, null, 2)}`);
+    }
+    catch (e) {
+        return err(e);
+    }
+});
+// memory_goal_track — Create/update/query goals
+server.tool("memory_goal_track", "Track goals across sessions. Create new goals, update progress, or query active goals. Goals with status='active' are DNA-protected (never decay).", {
+    action: z.enum(["create", "update", "list"]).describe("Action to perform"),
+    title: z.string().optional().describe("Goal title (for create)"),
+    progress: z.number().optional().describe("Progress 0.0-1.0 (for update)"),
+    goal_id: z.number().optional().describe("Goal ID (for update)"),
+    status: z.enum(["active", "achieved", "abandoned"]).optional().describe("New status (for update)"),
+}, async (args) => {
+    try {
+        if (args.action === "create") {
+            const r = (await api("POST", "/v1/store", {
+                content: args.title,
+                memory_type: "goal",
+                zone: "important",
+                tags: ["goal", "active"],
+            }));
+            return ok(`Goal created: "${args.title}" (id: ${r.id}). DNA-protected while active.`);
+        }
+        else if (args.action === "list") {
+            const r = (await api("POST", "/v1/recall", {
+                query: "active goals and objectives",
+                memory_type: "goal",
+                depth: "deep",
+                limit: 10,
+            }));
+            if (!r.results?.length)
+                return ok("No active goals found.");
+            const list = r.results.map((g, i) => `${i + 1}. ${g.content}`).join("\n");
+            return ok(`Active goals:\n\n${list}`);
+        }
+        else {
+            return ok("Goal update: use memory_store with memory_type='goal' to update goal content.");
+        }
+    }
+    catch (e) {
+        return err(e);
+    }
+});
+// memory_thought_log — Query what the brain has been thinking about
+server.tool("memory_thought_log", "See what the brain has been thinking about autonomously. Returns recent thoughts, hypotheses, and insights generated during idle time.", {
+    limit: z.number().optional().describe("Max thoughts to return (default 5)"),
+}, async (args) => {
+    try {
+        const r = (await api("GET", `/v1/brain/thoughts?limit=${args.limit || 5}`));
+        if (!r.thoughts?.length)
+            return ok("No recent thoughts. The brain thinks during idle periods.");
+        const list = r.thoughts
+            .map((t, i) => `${i + 1}. [${t.thought_type}] ${t.content} (urgency: ${t.urgency})`)
+            .join("\n");
+        return ok(`Recent brain thoughts:\n\n${list}`);
+    }
+    catch (e) {
+        return err(e);
+    }
+});
+// memory_feedback — Report recall quality for self-improvement
+server.tool("memory_feedback", "Report whether recall results were helpful. This feeds the neuroplasticity system — over time, the brain learns what works for YOUR specific patterns and improves recall quality.", {
+    query: z.string().describe("The recall query that was made"),
+    chunk_ids: z.array(z.number()).describe("IDs of chunks that were returned"),
+    helpful: z.boolean().describe("Were the results helpful for your task?"),
+    action_succeeded: z.boolean().optional().describe("Did the action using these memories succeed? (default: true)"),
+}, async (args) => {
+    try {
+        const r = (await api("POST", "/v1/bot/feedback", {
+            query: args.query,
+            chunk_ids: args.chunk_ids,
+            helpful: args.helpful,
+            action_succeeded: args.action_succeeded !== false,
+        }));
+        return ok(r.message || "Feedback recorded. Brain will adapt over time.");
+    }
+    catch (e) {
+        return err(e);
+    }
+});
+// memory_predict — Predictive recall (push intent, get predicted memories)
+server.tool("memory_predict", "Predictive recall — tell the brain what you're about to do and get relevant memories pre-loaded. Call this when you can anticipate what context will be needed next.", {
+    intent: z.string().describe("What you/user are about to do"),
+    context: z.string().optional().describe("Current conversation context (helps prediction accuracy)"),
+    limit: z.number().optional().describe("Max predictions (default 5)"),
+}, async (args) => {
+    try {
+        const r = (await api("POST", "/v1/bot/predict", {
+            intent: args.intent,
+            context: args.context || "",
+            limit: args.limit || 5,
+        }));
+        if (!r.predictions?.length)
+            return ok("No relevant predictions for this intent.");
+        const list = r.predictions
+            .map((p, i) => `${i + 1}. [${p.memory_type || 'memory'}] ${p.content}\n   (score: ${p.score}, reason: ${p.reason})`)
+            .join("\n\n");
+        return ok(`Predicted ${r.count} relevant memories:\n\n${list}`);
+    }
+    catch (e) {
+        return err(e);
+    }
+});
+// memory_changelog — What changed since last session
+server.tool("memory_changelog", "See what changed in your memory since your last session. Shows new memories, updates, invalidations, and insights from overnight consolidation. Call at session start after bootstrap to understand what the brain learned while you were away.", {
+    since: z.string().describe("ISO datetime — show changes after this time (e.g. '2026-05-20T10:00:00Z')"),
+    project_id: z.string().optional().describe("Filter to specific project"),
+    limit: z.number().optional().describe("Max changes to return (default 50)"),
+}, async (args) => {
+    try {
+        const r = (await api("POST", "/v1/memory/changelog", {
+            since: args.since,
+            project_id: args.project_id,
+            limit: args.limit || 50,
+        }));
+        if (!r.changes?.length)
+            return ok("No changes since last session. Memory is up to date.");
+        const list = r.changes
+            .map((c, i) => `${i + 1}. [${c.type}] ${c.content}${c.source ? ` (source: ${c.source})` : ""}`)
+            .join("\n");
+        return ok(`${r.count} changes since ${args.since}:\n\n${list}`);
+    }
+    catch (e) {
+        return err(e);
+    }
+});
+// memory_cognitive_profile — Complete self-model (metacognition)
+server.tool("memory_cognitive_profile", "Get the brain's complete self-model: who the user is, their mood, active goals, top entities (people/places), learned procedures, and recent topics. Use for complete context awareness. No LLM cost — pure aggregation (~50ms).", {}, async () => {
+    try {
+        const r = (await api("GET", "/v1/personality/cognitive-profile"));
+        let out = `## Cognitive Profile\n\n`;
+        if (r.persona)
+            out += `**Persona:** ${r.persona}\n\n`;
+        if (r.mood)
+            out += `**Mood:** ${r.mood.current} (trend: ${r.mood.trend})\n\n`;
+        if (r.active_goals?.length)
+            out += `**Active Goals:**\n${r.active_goals.map((g) => `- ${g}`).join("\n")}\n\n`;
+        if (r.top_entities?.length)
+            out += `**Top Entities:** ${r.top_entities.map((e) => e.name || e).join(", ")}\n\n`;
+        if (r.procedures?.length)
+            out += `**Procedures:**\n${r.procedures.map((p) => `- ${p.slice(0, 100)}`).join("\n")}\n\n`;
+        if (r.recent_topics?.length)
+            out += `**Recent Topics:**\n${r.recent_topics.map((t) => `- ${t}`).join("\n")}\n`;
+        return ok(out.trim());
+    }
+    catch (e) {
+        return err(e);
+    }
+});
+// memory_entity_profile — Get everything known about an entity
+server.tool("memory_entity_profile", "Get complete profile for a specific entity (person, place, concept). Returns: frequency stats, linked memories, and relationships. Use when you need context about a specific person or topic the user has discussed.", {
+    name: z.string().describe("Entity name to look up (e.g. 'Sarah', 'React', 'AuthService')"),
+}, async (args) => {
+    try {
+        const r = (await api("GET", `/v1/entities/${encodeURIComponent(args.name)}/profile`));
+        if (!r.stats && !r.memories?.length)
+            return ok(`No information found about "${args.name}".`);
+        let out = `## Entity: ${args.name}\n\n`;
+        if (r.stats) {
+            out += `**Stats:** mentioned ${r.stats.frequency}x, recalled ${r.stats.recall_count}x`;
+            if (r.stats.first_seen)
+                out += `, first seen ${r.stats.first_seen.slice(0, 10)}`;
+            out += `\n\n`;
+        }
+        if (r.memories?.length) {
+            out += `**Linked Memories (${r.memory_count}):**\n`;
+            out += r.memories.map((m) => `- [${m.memory_type}] ${m.content}`).join("\n");
+            out += `\n\n`;
+        }
+        if (r.relationships?.length) {
+            out += `**Relationships (${r.relationship_count}):**\n`;
+            out += r.relationships.map((rel) => `- ${rel.source} → ${rel.relationship} → ${rel.target}`).join("\n");
+        }
+        return ok(out.trim());
+    }
+    catch (e) {
+        return err(e);
+    }
+});
+// ═══════════════════════════════════════════════════════════════════════════
+// PHASE 5 (2026-05-28) — DNA-aligned tools:
+//   • brain_export / brain_import   — DNA #3 vendor neutrality
+//   • benchmark_recall_vs_full      — DNA #2 retina (measurable moat)
+//   • benchmark_pricing             — public model pricing reference
+//   • trust_agents / trust_chunk    — DNA #1.5 trust graph
+//   • twin_respond / twin_status    — Cognitive Twin (promax+ tier)
+// ═══════════════════════════════════════════════════════════════════════════
+// brain_export
+server.tool("brain_export", "Export the entire brain to a portable JSON bundle (vendor-neutral). Use when the user wants to back up their brain, migrate to another instance (e.g. lite-build on-prem), or comply with data-portability rights. The bundle is self-contained — chunks, edges, entities, L2 sessions, mood, agents — and includes a sha256 checksum. Returns the bundle JSON.", {
+    scope: z.enum(["full", "dna_only", "since"]).optional().describe("'full'=everything (default), 'dna_only'=just preferences/decisions/identity (lightweight portable identity), 'since'=incremental (requires `since` ISO datetime)"),
+    since: z.string().optional().describe("ISO8601 datetime, only used when scope='since'"),
+}, async (args) => {
+    try {
+        const r = (await api("POST", "/v1/brain/export", {
+            scope: args.scope || "full",
+            since: args.since,
+        }));
+        const counts = r?.manifest?.counts || {};
+        const summary = `Exported brain bundle (format=${r.format} v${r.version}):\n` +
+            `- chunks: ${counts.chunks ?? 0}\n` +
+            `- memory_edges: ${counts.memory_edges ?? 0}\n` +
+            `- entities: ${counts.entities ?? 0}\n` +
+            `- l2_sessions: ${counts.l2_sessions ?? 0}\n` +
+            `- agents: ${counts.agents ?? 0}\n` +
+            `- checksum: ${r?.manifest?.checksum?.slice(0, 16)}...\n\n` +
+            `Bundle JSON ready (truncated preview):\n\`\`\`json\n${JSON.stringify(r, null, 2).slice(0, 1200)}...\n\`\`\``;
+        return ok(summary);
+    }
+    catch (e) {
+        return err(e);
+    }
+});
+// brain_import
+server.tool("brain_import", "Import a MemoryAI bundle (from brain_export) into the current tenant. Idempotent — chunks deduped by content_hash; edges/entities upserted. Embeddings are reused if the bundle's embedding_model matches the local one; otherwise dropped (chunks re-embed lazily).", {
+    bundle: z.record(z.string(), z.unknown()).describe("The bundle JSON produced by brain_export (must contain format='memoryai-bundle', version, manifest, etc.)"),
+    keep_embeddings: z.boolean().optional().describe("Reuse bundle embeddings if model matches (default: true)"),
+}, async (args) => {
+    try {
+        const r = (await api("POST", `/v1/brain/import?keep_embeddings=${args.keep_embeddings === false ? "false" : "true"}`, args.bundle));
+        const rep = r?.report || {};
+        const out = `Brain import complete (format=${rep.bundle_format} v${rep.bundle_version}):\n` +
+            `- chunks: ${rep.chunks?.inserted ?? 0} inserted, ${rep.chunks?.skipped_duplicate ?? 0} skipped (dup), ${rep.chunks?.skipped_invalid ?? 0} invalid\n` +
+            `- memory_edges: ${rep.memory_edges?.upserted ?? 0} upserted (${rep.memory_edges?.skipped ?? 0} skipped)\n` +
+            `- entities: ${rep.entities?.upserted ?? 0} upserted\n` +
+            `- l2_sessions: ${rep.l2_sessions?.inserted ?? 0} inserted\n` +
+            `- agents: ${rep.agents?.upserted ?? 0} upserted\n` +
+            `- embedding_model_match: ${rep.embedding_model_match}\n` +
+            (rep.warnings?.length ? `\nWarnings:\n  ${rep.warnings.join("\n  ")}` : "");
+        return ok(out);
+    }
+    catch (e) {
+        return err(e);
+    }
+});
+// benchmark_recall_vs_full
+server.tool("benchmark_recall_vs_full", "Run a public benchmark: smart recall vs full-context dump on the calling brain. DNA #2 — proves the 'retina for AI' moat with measurable numbers (cost, latency, signal density). Available on every tier; safe to share results publicly.", {
+    query: z.string().describe("The query to benchmark (e.g. 'what does the user prefer?')"),
+    model: z.string().optional().describe("Model whose pricing to apply (default: claude-opus-4-6). Affects $cost only."),
+    naive_budget_tokens: z.number().optional().describe("Cap on full-context dump (default: 200K = Claude window)"),
+    smart_top_k: z.number().optional().describe("Top-K chunks for smart mode (default: 8)"),
+    smart_depth: z.enum(["instant", "fast", "deep"]).optional().describe("Smart recall depth (default: deep)"),
+}, async (args) => {
+    try {
+        const r = (await api("POST", "/v1/benchmark/recall-vs-fullcontext", {
+            query: args.query,
+            model: args.model || "claude-opus-4-6",
+            naive_budget_tokens: args.naive_budget_tokens,
+            smart_top_k: args.smart_top_k,
+            smart_depth: args.smart_depth,
+        }));
+        const out = `Benchmark — query: ${JSON.stringify(r.query)}\n` +
+            `Model: ${r.model} ($${r.price_per_m_tokens_usd}/M tokens)\n\n` +
+            `NAIVE: ${r.naive.chunks_used} chunks · ${r.naive.input_tokens} tok · $${r.naive.estimated_cost_usd} · ${r.naive.latency_ms}ms\n` +
+            `SMART: ${r.smart.chunks_used} chunks · ${r.smart.input_tokens} tok · $${r.smart.estimated_cost_usd} · ${r.smart.latency_ms}ms\n\n` +
+            `→ ${r.headline}`;
+        return ok(out);
+    }
+    catch (e) {
+        return err(e);
+    }
+});
+// benchmark_pricing
+server.tool("benchmark_pricing", "Get the assumed $/1M-input-tokens pricing for each LLM (used by benchmark_recall_vs_full). No auth required; list prices only.", {}, async () => {
+    try {
+        const r = (await api("GET", "/v1/benchmark/pricing"));
+        const lines = Object.entries(r.prices || {}).map(([k, v]) => `- ${k}: $${v}`);
+        return ok(`Model pricing (${r.currency} ${r.unit}, as of ${r.as_of}):\n${lines.join("\n")}\n\nNote: ${r.note}`);
+    }
+    catch (e) {
+        return err(e);
+    }
+});
+// trust_agents
+server.tool("trust_agents", "Get the agent reputation leaderboard (sorted by reputation_score desc). DNA #1.5 — when 20 agents share memory and disagree, this tells you whose claims to trust. Requires team+ plan.", {
+    limit: z.number().optional().describe("Max agents to return (default: 50, max: 500)"),
+}, async (args) => {
+    try {
+        const r = (await api("GET", `/v1/trust/agents?limit=${args.limit ?? 50}`));
+        if (!r.agents?.length)
+            return ok("No agent reputation snapshots yet. Run /v1/trust/recompute-all to populate.");
+        const lines = r.agents.map((a) => `- ${a.agent_id}: ${a.reputation_score.toFixed(3)} [${a.label}] — V=${a.verified_count}/C=${a.contradicted_count}/N=${a.feedback_n}`);
+        return ok(`Agent reputation (${r.agents.length} agents):\n${lines.join("\n")}`);
+    }
+    catch (e) {
+        return err(e);
+    }
+});
+// trust_chunk
+server.tool("trust_chunk", "Get per-chunk trust info: which agent claimed it, that agent's reputation, helpful/unhelpful counts. Use after a recall to decide whether to trust a specific result. Available on every paid tier.", {
+    chunk_id: z.number().describe("The chunk ID returned by recall"),
+}, async (args) => {
+    try {
+        const r = (await api("GET", `/v1/trust/chunks/${args.chunk_id}`));
+        const stats = r.agent_stats || {};
+        const fb = r.feedback || {};
+        return ok(`Chunk #${r.chunk_id} (${r.memory_type})\n` +
+            `Source agent: ${r.source_agent_id ?? "(none)"}\n` +
+            `Agent trust: ${r.agent_trust?.toFixed(3) ?? "(none)"} — V=${stats.verified_count ?? 0}/C=${stats.contradicted_count ?? 0}/total=${stats.claim_count ?? 0}\n` +
+            `Per-chunk trust: ${r.chunk_trust_score?.toFixed(3) ?? "(none)"} (helpful=${fb.helpful ?? 0}, unhelpful=${fb.unhelpful ?? 0})`);
+    }
+    catch (e) {
+        return err(e);
+    }
+});
+// twin_respond
+server.tool("twin_respond", "Ask the Cognitive Twin to predict how the user would respond to a given query. The twin uses the user's personality + mood + DNA + procedures to simulate their voice. Returns the predicted response, a confidence score 0-1, and the chunk IDs that informed it (provenance trail). Auto-refuses with confidence=0 if the brain has fewer than 5 DNA memories. Requires promax+ plan.", {
+    query: z.string().describe("The free-form question to ask the twin (e.g. 'what database for a chat app?')"),
+    operation: z.enum(["respond", "decide"]).optional().describe("'respond'=free-form answer (default), 'decide'=pick one option from the query"),
+}, async (args) => {
+    try {
+        const path = args.operation === "decide" ? "/v1/twin/decide" : "/v1/twin/respond";
+        const r = (await api("POST", path, { query: args.query }));
+        const out = `Cognitive Twin (${r.operation}, confidence ${r.confidence}):\n` +
+            `Persona: ${r.persona_summary || "(not synthesized)"}\n` +
+            `Mood: ${r.mood || "unknown"}\n` +
+            `Provenance chunks: ${r.provenance_chunks?.length ?? 0}\n\n` +
+            `Response:\n${r.response}\n\n` +
+            `(reason: ${r.confidence_reason})`;
+        return ok(out);
+    }
+    catch (e) {
+        return err(e);
+    }
+});
+// twin_status
+server.tool("twin_status", "Check whether the Cognitive Twin is ready for the calling tenant. Cheap — no LLM call. Returns DNA count, personality/mood presence, and a `ready` boolean. Useful before invoking twin_respond.", {}, async () => {
+    try {
+        const r = (await api("GET", "/v1/twin/status"));
+        return ok(`Twin ready: ${r.ready ? "YES" : "NO"} (need ≥${r.min_dna_required} DNA, have ${r.dna_count})\n` +
+            `- has_personality: ${r.has_personality}\n` +
+            `- has_mood: ${r.has_mood}\n` +
+            `- procedures: ${r.procedures_count}\n` +
+            `- active_goals: ${r.active_goals_count}\n` +
+            `- top_entities: ${r.top_entities_count}\n` +
+            (r.persona_summary ? `\nPersona: ${r.persona_summary}\n` : "") +
+            (r.mood ? `Mood: ${r.mood}\n` : ""));
+    }
+    catch (e) {
+        return err(e);
+    }
+});
 async function main() {
     const transport = new StdioServerTransport();
     await server.connect(transport);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "memoryai-mcp",
-  "version": "1.5.0",
-  "description": "MCP server for MemoryAI v1.5 — Living Brain for AI Agents. 5 biological behaviors (Remember, Forget, Connect, Sleep, Shield), DNA-protected memories, Hebbian learning, Multi-Agent Mesh, Personality synthesis, Causal reasoning.",
+  "version": "2.2.0",
+  "description": "MCP server for MemoryAI v2.0 — One brain. ∞ agents. Forever. Adds Brain Export/Import (vendor-neutral bundles), Public Benchmark (smart recall vs full context), Trust Graph (per-agent reputation), Cognitive Twin (simulate user voice). Plus the v1.5 base: 11 biological behaviors, DNA-protected memories, Multi-Agent Mesh.",
   "homepage": "https://memoryai.dev",
   "repository": {
     "type": "git",