@astramindapp/mcp-server 0.3.1 → 0.4.0

package/dist/server.js

@@ -5,13 +5,22 @@
  * Exposes the MIND knowledge graph as MCP tools that any LLM agent can use.
  * This is the universal AI memory layer.
  *
- * Tools:
+ * Tools (15):
  *   mind_query     — Semantic search across the knowledge graph
- *   mind_remember  — Store content to the graph (auto-categorized)
+ *   mind_remember  — Store/manage content in the graph (auto-categorized)
  *   mind_context   — Get structured always-loaded context (soul/user/rules)
- *   mind_life      — Read/write goals, projects, tasks
- *   mind_crm       — Read/write contacts and interactions
- *   mind_graph     — Get graph statistics and health
+ *   mind_life      — Read/write goals, projects, tasks, calendar events, stats
+ *   mind_crm       — Read/write contacts, interactions, and activities
+ *   mind_graph     — Get graph statistics, diagnostics, and labels
+ *   mind_admin     — Admin-only user and featured mind management
+ *   mind_sense     — MINDsense emotional intelligence layer
+ *   mind_research  — Deep research agent jobs
+ *   mind_train     — Self-training and chat-to-KG sessions
+ *   mind_social    — Thoughts, communities, and feed
+ *   mind_profile   — Profile, prompts, and model preferences
+ *   mind_insights  — ALE insights and analytics
+ *   mind_automate  — Automations and triggers
+ *   mind_notify    — Notifications management
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createMindMcpServer = createMindMcpServer;
@@ -20,7 +29,7 @@ const zod_1 = require("zod");
 function createMindMcpServer(client) {
     const server = new mcp_js_1.McpServer({
         name: "mind",
-        version: "0.1.0",
+        version: "0.2.0",
     });
     // ─── mind_query ─────────────────────────────────────────
     // Semantic search across the user's knowledge graph.
@@ -56,10 +65,15 @@ function createMindMcpServer(client) {
         }
     });
     // ─── mind_remember ──────────────────────────────────────
-    // Store content to the knowledge graph. Auto-categorized by type.
-    // Replaces manual memory file writes.
-    server.tool("mind_remember", "Store something in your MIND knowledge graph. Use for facts, decisions, learnings, research, notes — anything worth remembering. Auto-categorized. Always log outcomes here after completing tasks.", {
-        content: zod_1.z.string().describe("What to remember — the actual content to store"),
+    // Store/manage content in the knowledge graph. Auto-categorized by type.
+    // Enhanced: now supports create, delete, search, get, list actions.
+    server.tool("mind_remember", "Store and manage content in your MIND knowledge graph. Use for facts, decisions, learnings, research, notes — anything worth remembering. Auto-categorized. Always log outcomes here after completing tasks. Supports create (default), delete, search, get, and list.", {
+        action: zod_1.z
+            .enum(["create", "delete", "search", "get", "list"])
+            .optional()
+            .default("create")
+            .describe("Action: create (store new content — default), delete (remove by ID), search (find entries), get (retrieve by ID), list (paginated listing)"),
+        content: zod_1.z.string().optional().describe("What to remember — the actual content to store (required for create)"),
         type: zod_1.z
             .enum(["document", "entry", "thought"])
             .optional()
@@ -78,44 +92,157 @@ function createMindMcpServer(client) {
             .optional()
             .default("mcp-agent")
             .describe("Source identifier (e.g. 'claude-code', 'openclaw', 'cursor')"),
-    }, async ({ content, type, title, tags, source }) => {
+        item_id: zod_1.z
+            .string()
+            .optional()
+            .describe("Item ID for delete/get actions"),
+        query: zod_1.z
+            .string()
+            .optional()
+            .describe("Search query for search action"),
+        page: zod_1.z
+            .number()
+            .optional()
+            .describe("Page number for list action"),
+        limit: zod_1.z
+            .number()
+            .optional()
+            .describe("Max items to return for list/search"),
+    }, async ({ action, content, type, title, tags, source, item_id, query, page, limit }) => {
         try {
-            let result;
-            let storedAs;
-            switch (type) {
-                case "document":
-                    result = await client.createDocument({
-                        title: title ?? `Agent Document — ${new Date().toISOString().slice(0, 10)}`,
-                        content,
-                        source: source ?? "mcp-agent",
-                        tags,
-                    });
-                    storedAs = "document";
-                    break;
-                case "thought":
-                    result = await client.createThought({ content });
-                    storedAs = "thought";
-                    break;
-                case "entry":
-                default:
-                    result = await client.createEntry({
-                        title,
-                        content,
-                        entry_type: "text",
-                        tags,
-                    });
-                    storedAs = "entry";
-                    break;
+            switch (action) {
+                case "create": {
+                    if (!content) {
+                        return {
+                            content: [{ type: "text", text: "Error: content is required to create" }],
+                            isError: true,
+                        };
+                    }
+                    let result;
+                    let storedAs;
+                    switch (type) {
+                        case "document":
+                            result = await client.createDocument({
+                                title: title ?? `Agent Document — ${new Date().toISOString().slice(0, 10)}`,
+                                content,
+                                source: source ?? "mcp-agent",
+                                tags,
+                            });
+                            storedAs = "document";
+                            break;
+                        case "thought":
+                            result = await client.createThought({ content });
+                            storedAs = "thought";
+                            break;
+                        case "entry":
+                        default:
+                            result = await client.createEntry({
+                                title,
+                                content,
+                                entry_type: "text",
+                                tags,
+                            });
+                            storedAs = "entry";
+                            break;
+                    }
+                    const id = result.id ?? result.entry_id ?? result.thought_id ?? "unknown";
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `✅ Stored to MIND as ${storedAs} (id: ${id})${title ? ` — "${title}"` : ""}`,
+                            },
+                        ],
+                    };
+                }
+                case "delete": {
+                    if (!item_id) {
+                        return {
+                            content: [{ type: "text", text: "Error: item_id is required for delete" }],
+                            isError: true,
+                        };
+                    }
+                    switch (type) {
+                        case "document":
+                            await client.deleteDocument(item_id);
+                            break;
+                        case "thought":
+                            await client.deleteThought(item_id);
+                            break;
+                        case "entry":
+                        default:
+                            await client.deleteEntry(item_id);
+                            break;
+                    }
+                    return {
+                        content: [{ type: "text", text: `✅ Deleted ${type} ${item_id}` }],
+                    };
+                }
+                case "search": {
+                    if (!query) {
+                        return {
+                            content: [{ type: "text", text: "Error: query is required for search" }],
+                            isError: true,
+                        };
+                    }
+                    const result = await client.searchEntries(query, limit);
+                    const items = result.entries ?? [];
+                    if (items.length === 0) {
+                        return { content: [{ type: "text", text: `No results for "${query}".` }] };
+                    }
+                    const lines = items.map((e) => `• ${e.title ?? "Untitled"} — ${e.content?.slice(0, 120) ?? ""}... (id: ${e.entry_id})`);
+                    return { content: [{ type: "text", text: lines.join("\n") }] };
+                }
+                case "get": {
+                    if (!item_id) {
+                        return {
+                            content: [{ type: "text", text: "Error: item_id is required for get" }],
+                            isError: true,
+                        };
+                    }
+                    const result = await client.getEntry(item_id);
+                    const lines = [
+                        `**${result.title ?? "Untitled"}**`,
+                        `Type: ${result.entry_type ?? type} | Created: ${result.created_at ?? "unknown"}`,
+                        `Tags: ${result.tags?.join(", ") ?? "none"}`,
+                        "",
+                        result.content ?? "",
+                    ];
+                    return { content: [{ type: "text", text: lines.join("\n") }] };
+                }
+                case "list": {
+                    switch (type) {
+                        case "document": {
+                            const result = await client.listDocuments(page ?? 1, limit ?? 20);
+                            const docs = result.documents ?? [];
+                            if (docs.length === 0) {
+                                return { content: [{ type: "text", text: "No documents found." }] };
+                            }
+                            const lines = docs.map((d) => `• ${d.title} (status: ${d.status}, source: ${d.source}) — id: ${d.id}`);
+                            return { content: [{ type: "text", text: lines.join("\n") }] };
+                        }
+                        case "thought": {
+                            const result = await client.listThoughts();
+                            const thoughts = result.thoughts ?? [];
+                            if (thoughts.length === 0) {
+                                return { content: [{ type: "text", text: "No thoughts found." }] };
+                            }
+                            const lines = thoughts.map((t) => `• ${t.content?.slice(0, 100)}... — id: ${t.id ?? t.thought_id}`);
+                            return { content: [{ type: "text", text: lines.join("\n") }] };
+                        }
+                        case "entry":
+                        default: {
+                            const result = await client.listEntries(limit ?? 20);
+                            const entries = result.entries ?? [];
+                            if (entries.length === 0) {
+                                return { content: [{ type: "text", text: "No entries found." }] };
+                            }
+                            const lines = entries.map((e) => `• ${e.title ?? "Untitled"} (${e.entry_type ?? "text"}) — id: ${e.id ?? e.entry_id}`);
+                            return { content: [{ type: "text", text: lines.join("\n") }] };
+                        }
+                    }
+                }
             }
-            const id = result.id ?? result.entry_id ?? result.thought_id ?? "unknown";
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `✅ Stored to MIND as ${storedAs} (id: ${id})${title ? ` — "${title}"` : ""}`,
-                    },
-                ],
-            };
         }
         catch (err) {
             return {
@@ -160,12 +287,17 @@ function createMindMcpServer(client) {
         }
     });
     // ─── mind_life ──────────────────────────────────────────
-    // Read/write goals, projects, and tasks.
-    server.tool("mind_life", "Manage goals, projects, and tasks in MIND Life. Use for tracking work, creating action items, updating progress, and completing tasks.", {
+    // Read/write goals, projects, tasks, calendar events, stats.
+    // Enhanced: calendar CRUD, stats, move, get.
+    server.tool("mind_life", "Manage goals, projects, tasks, and calendar events in MIND Life. Use for tracking work, creating action items, updating progress, completing tasks, managing calendar, and viewing stats.", {
         action: zod_1.z
-            .enum(["list", "create", "update", "complete", "delete"])
-            .describe("What to do: list (view items), create (new item), update (modify), complete (mark done), delete (remove)"),
-        title: zod_1.z.string().optional().describe("Title for new items"),
+            .enum([
+            "list", "create", "update", "complete", "delete", "move", "get",
+            "calendar_list", "calendar_create", "calendar_update", "calendar_delete",
+            "stats",
+        ])
+            .describe("What to do: list/create/update/complete/delete/move/get items, calendar_list/calendar_create/calendar_update/calendar_delete events, stats (productivity overview)"),
+        title: zod_1.z.string().optional().describe("Title for new items or calendar events"),
         description: zod_1.z.string().optional().describe("Description for new items"),
         status: zod_1.z
             .string()
@@ -176,8 +308,12 @@ function createMindMcpServer(client) {
             .optional()
             .describe("Priority: low, medium, high, urgent"),
         due_date: zod_1.z.string().optional().describe("Due date in YYYY-MM-DD format"),
-        item_id: zod_1.z.string().optional().describe("Item ID for update/complete/delete actions"),
-    }, async ({ action, title, description, status, priority, due_date, item_id }) => {
+        item_id: zod_1.z.string().optional().describe("Item ID for update/complete/delete/move/get actions"),
+        start_time: zod_1.z.string().optional().describe("Start time for calendar events (ISO 8601)"),
+        end_time: zod_1.z.string().optional().describe("End time for calendar events (ISO 8601)"),
+        event_id: zod_1.z.string().optional().describe("Event ID for calendar_update/calendar_delete"),
+        all_day: zod_1.z.boolean().optional().describe("Whether the calendar event is all-day"),
+    }, async ({ action, title, description, status, priority, due_date, item_id, start_time, end_time, event_id, all_day }) => {
         try {
             switch (action) {
                 case "list": {
@@ -259,6 +395,114 @@ function createMindMcpServer(client) {
                         content: [{ type: "text", text: `✅ Deleted life item ${item_id}` }],
                     };
                 }
+                case "move": {
+                    if (!item_id || !status) {
+                        return {
+                            content: [{ type: "text", text: "Error: item_id and status are required for move" }],
+                            isError: true,
+                        };
+                    }
+                    const result = await client.moveLifeItem(item_id, status);
+                    return {
+                        content: [{ type: "text", text: `✅ Moved "${result.title}" to ${result.status}` }],
+                    };
+                }
+                case "get": {
+                    if (!item_id) {
+                        return {
+                            content: [{ type: "text", text: "Error: item_id is required for get" }],
+                            isError: true,
+                        };
+                    }
+                    const result = await client.getLifeItem(item_id);
+                    const lines = [
+                        `**${result.title}**`,
+                        `Status: ${result.status ?? "—"} | Priority: ${result.priority ?? "—"} | Due: ${result.due_date ?? "none"}`,
+                        result.description ? `\n${result.description}` : "",
+                    ];
+                    return { content: [{ type: "text", text: lines.join("\n") }] };
+                }
+                case "calendar_list": {
+                    const result = await client.listCalendarEvents();
+                    const events = result.events ?? [];
+                    if (events.length === 0) {
+                        return { content: [{ type: "text", text: "No calendar events found." }] };
+                    }
+                    const lines = events.map((e) => `• ${e.title}${e.all_day ? " (all day)" : ""} — ${e.start_time ?? ""}${e.end_time ? ` to ${e.end_time}` : ""} — id: ${e.event_id}`);
+                    return { content: [{ type: "text", text: lines.join("\n") }] };
+                }
+                case "calendar_create": {
+                    if (!title || !start_time) {
+                        return {
+                            content: [{ type: "text", text: "Error: title and start_time are required for calendar_create" }],
+                            isError: true,
+                        };
+                    }
+                    const result = await client.createCalendarEvent({
+                        title,
+                        description,
+                        start_time,
+                        end_time,
+                        all_day,
+                    });
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `✅ Created calendar event: "${result.title}" (id: ${result.event_id})`,
+                            },
+                        ],
+                    };
+                }
+                case "calendar_update": {
+                    if (!event_id) {
+                        return {
+                            content: [{ type: "text", text: "Error: event_id is required for calendar_update" }],
+                            isError: true,
+                        };
+                    }
+                    const patch = {};
+                    if (title)
+                        patch.title = title;
+                    if (description)
+                        patch.description = description;
+                    if (start_time)
+                        patch.start_time = start_time;
+                    if (end_time)
+                        patch.end_time = end_time;
+                    if (all_day !== undefined)
+                        patch.all_day = all_day;
+                    const result = await client.updateCalendarEvent(event_id, patch);
+                    return {
+                        content: [{ type: "text", text: `✅ Updated calendar event: "${result.title}"` }],
+                    };
+                }
+                case "calendar_delete": {
+                    if (!event_id) {
+                        return {
+                            content: [{ type: "text", text: "Error: event_id is required for calendar_delete" }],
+                            isError: true,
+                        };
+                    }
+                    await client.deleteCalendarEvent(event_id);
+                    return {
+                        content: [{ type: "text", text: `✅ Deleted calendar event ${event_id}` }],
+                    };
+                }
+                case "stats": {
+                    const result = await client.lifeStats();
+                    const lines = [
+                        "📊 MIND Life Stats",
+                        `• Total items: ${result.total_items}`,
+                        `• Completion rate: ${(result.completion_rate * 100).toFixed(1)}%`,
+                    ];
+                    if (result.status_counts) {
+                        for (const [status, count] of Object.entries(result.status_counts)) {
+                            lines.push(`• ${status}: ${count}`);
+                        }
+                    }
+                    return { content: [{ type: "text", text: lines.join("\n") }] };
+                }
             }
         }
         catch (err) {
@@ -269,11 +513,12 @@ function createMindMcpServer(client) {
         }
     });
     // ─── mind_crm ───────────────────────────────────────────
-    // Read/write contacts and interactions.
-    server.tool("mind_crm", "Manage contacts and relationships in MIND CRM. Use for tracking people, companies, leads, and interaction history.", {
+    // Read/write contacts, interactions, and activities.
+    // Enhanced: delete, get, log_activity, list_activities.
+    server.tool("mind_crm", "Manage contacts and relationships in MIND CRM. Use for tracking people, companies, leads, interaction history, and activity logging.", {
         action: zod_1.z
-            .enum(["list", "create", "update"])
-            .describe("What to do: list contacts, create new contact, update existing"),
+            .enum(["list", "create", "update", "delete", "get", "log_activity", "list_activities"])
+            .describe("What to do: list/create/update/delete/get contacts, log_activity (record interaction), list_activities (view interaction history)"),
         name: zod_1.z.string().optional().describe("Contact name (required for create)"),
         email: zod_1.z.string().optional().describe("Contact email"),
         company: zod_1.z.string().optional().describe("Company/organization"),
@@ -281,8 +526,10 @@ function createMindMcpServer(client) {
         stage: zod_1.z.string().optional().describe("Pipeline stage: new, qualified, proposal, closed, lost"),
         source: zod_1.z.string().optional().describe("How you found them"),
         notes: zod_1.z.string().optional().describe("Notes about this contact"),
-        contact_id: zod_1.z.string().optional().describe("Contact ID for updates"),
-    }, async ({ action, name, email, company, type, stage, source, notes, contact_id }) => {
+        contact_id: zod_1.z.string().optional().describe("Contact ID for update/delete/get/log_activity/list_activities"),
+        activity_type: zod_1.z.string().optional().describe("Activity type for log_activity: call, email, meeting, note"),
+        activity_notes: zod_1.z.string().optional().describe("Notes for the activity being logged"),
+    }, async ({ action, name, email, company, type, stage, source, notes, contact_id, activity_type, activity_notes }) => {
         try {
             switch (action) {
                 case "list": {
@@ -344,6 +591,70 @@ function createMindMcpServer(client) {
                         content: [{ type: "text", text: `✅ Updated contact: "${result.name}"` }],
                     };
                 }
+                case "delete": {
+                    if (!contact_id) {
+                        return {
+                            content: [{ type: "text", text: "Error: contact_id is required for delete" }],
+                            isError: true,
+                        };
+                    }
+                    await client.deleteContact(contact_id);
+                    return {
+                        content: [{ type: "text", text: `✅ Deleted contact ${contact_id}` }],
+                    };
+                }
+                case "get": {
+                    if (!contact_id) {
+                        return {
+                            content: [{ type: "text", text: "Error: contact_id is required for get" }],
+                            isError: true,
+                        };
+                    }
+                    const result = await client.getContact(contact_id);
+                    const lines = [
+                        `**${result.name}**`,
+                        `Email: ${result.email ?? "—"} | Company: ${result.company ?? "—"}`,
+                        `Type: ${result.type ?? "—"} | Stage: ${result.stage ?? "—"}`,
+                        `Created: ${result.created_at ?? "—"}`,
+                    ];
+                    return { content: [{ type: "text", text: lines.join("\n") }] };
+                }
+                case "log_activity": {
+                    if (!contact_id || !activity_type) {
+                        return {
+                            content: [{ type: "text", text: "Error: contact_id and activity_type are required for log_activity" }],
+                            isError: true,
+                        };
+                    }
+                    const result = await client.logActivity(contact_id, {
+                        type: activity_type,
+                        title: activity_type,
+                        description: activity_notes,
+                    });
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `✅ Logged ${activity_type} activity for contact ${contact_id} (id: ${result.activity_id})`,
+                            },
+                        ],
+                    };
+                }
+                case "list_activities": {
+                    if (!contact_id) {
+                        return {
+                            content: [{ type: "text", text: "Error: contact_id is required for list_activities" }],
+                            isError: true,
+                        };
+                    }
+                    const result = await client.listContactActivities(contact_id);
+                    const activities = result.activities ?? [];
+                    if (activities.length === 0) {
+                        return { content: [{ type: "text", text: "No activities found for this contact." }] };
+                    }
+                    const lines = activities.map((a) => `• [${a.type}] ${a.title ?? "—"} — ${a.description ?? "—"} — ${a.created_at ?? "—"}`);
+                    return { content: [{ type: "text", text: lines.join("\n") }] };
+                }
             }
         }
         catch (err) {
@@ -354,29 +665,73 @@ function createMindMcpServer(client) {
         }
     });
     // ─── mind_graph ─────────────────────────────────────────
-    // Get graph statistics and health.
-    server.tool("mind_graph", "Get MIND knowledge graph statistics — how many entities, relationships, documents, and entries exist. Use to check graph health and growth.", {}, async () => {
+    // Get graph statistics, diagnostics, and labels.
+    // Enhanced: action param with stats (default), diagnostics, labels.
+    server.tool("mind_graph", "Get MIND knowledge graph statistics, diagnostics, and label details. Use to check graph health, growth, and entity breakdown.", {
+        action: zod_1.z
+            .enum(["stats", "diagnostics", "labels"])
+            .optional()
+            .default("stats")
+            .describe("Action: stats (default — overview), diagnostics (health check), labels (entity label breakdown)"),
+    }, async ({ action }) => {
         try {
-            const [graph, profile] = await Promise.all([
-                client.graphInfo(),
-                client.credits().catch(() => null),
-            ]);
-            const lines = [
-                "📊 MIND Graph Status",
-                `• Entities: ${graph.total_entities}`,
-                `• Relationships: ${graph.total_relationships}`,
-                `• Storage: ${graph.storage_status?.status ?? "unknown"}`,
-            ];
-            if (graph.popular_labels?.length) {
-                const docCount = graph.popular_labels.reduce((sum, l) => sum + l.count, 0);
-                lines.push(`• Items in graph: ${docCount}`);
-            }
-            if (profile) {
-                lines.push(`• Credits: ${profile.credits_balance}/${profile.credits_limit}`);
-                lines.push(`• Tier: ${profile.tier}`);
-                lines.push(`• Documents: ${profile.documents_used}/${profile.documents_limit}`);
+            switch (action) {
+                case "stats":
+                default: {
+                    const [graph, profile] = await Promise.all([
+                        client.graphInfo(),
+                        client.credits().catch(() => null),
+                    ]);
+                    const lines = [
+                        "📊 MIND Graph Status",
+                        `• Entities: ${graph.total_entities}`,
+                        `• Relationships: ${graph.total_relationships}`,
+                        `• Storage: ${graph.storage_status?.status ?? "unknown"}`,
+                    ];
+                    if (graph.popular_labels?.length) {
+                        const docCount = graph.popular_labels.reduce((sum, l) => sum + l.count, 0);
+                        lines.push(`• Items in graph: ${docCount}`);
+                    }
+                    if (profile) {
+                        lines.push(`• Credits: ${profile.credits_balance}/${profile.credits_limit}`);
+                        lines.push(`• Tier: ${profile.tier}`);
+                        lines.push(`• Documents: ${profile.documents_used}/${profile.documents_limit}`);
+                    }
+                    return { content: [{ type: "text", text: lines.join("\n") }] };
+                }
+                case "diagnostics": {
+                    const result = await client.graphDiagnostics();
+                    const lines = [
+                        "🔍 MIND Graph Diagnostics",
+                        `• Status: ${result.status ?? "unknown"}`,
+                        `• Entity count: ${result.entity_count ?? "—"}`,
+                        `• Relationship count: ${result.relationship_count ?? "—"}`,
+                        `• Orphaned entities: ${result.orphaned_entities ?? "—"}`,
+                        `• Storage health: ${result.storage_health ?? "—"}`,
+                    ];
+                    const issues = result.issues;
+                    if (issues?.length) {
+                        lines.push("", "Issues:");
+                        for (const issue of issues) {
+                            lines.push(`  ⚠ ${issue}`);
+                        }
+                    }
+                    return { content: [{ type: "text", text: lines.join("\n") }] };
+                }
+                case "labels": {
+                    // Use graphInfo and extract popular_labels
+                    const result = await client.graphInfo();
+                    const labels = result.popular_labels ?? [];
+                    if (labels.length === 0) {
+                        return { content: [{ type: "text", text: "No labels found in graph." }] };
+                    }
+                    const lines = ["🏷️ MIND Graph Labels", ""];
+                    for (const l of labels) {
+                        lines.push(`• ${l.label ?? "unlabeled"}: ${l.count} entities`);
+                    }
+                    return { content: [{ type: "text", text: lines.join("\n") }] };
+                }
             }
-            return { content: [{ type: "text", text: lines.join("\n") }] };
         }
         catch (err) {
             return {
@@ -405,6 +760,8 @@ function createMindMcpServer(client) {
         email: zod_1.z.string().optional().describe("Email for new user"),
         password: zod_1.z.string().optional().describe("Password for new user (min 8 chars)"),
         source: zod_1.z.string().optional().describe("Source app/partner that created this user (e.g. 'myapp')"),
+        generate_api_key: zod_1.z.boolean().optional().describe("If true, also generate a developer API key (mind_...) for the new user"),
+        api_key_name: zod_1.z.string().optional().describe("Name for the generated API key (defaults to '{source} integration')"),
         // featured mind fields
         mind_id: zod_1.z.string().optional().describe("Featured mind ID for update operations"),
         title: zod_1.z.string().optional().describe("Display title for the featured mind"),
@@ -421,7 +778,7 @@ function createMindMcpServer(client) {
         // list fields
         query: zod_1.z.string().optional().describe("Search query for list_users"),
         page: zod_1.z.number().optional().describe("Page number for paginated results"),
-    }, async ({ action, username, email, password, source, mind_id, title, description, tags, price, featured, display_order, is_public, avatar_url, tier, credits, query, page }) => {
+    }, async ({ action, username, email, password, source, generate_api_key, api_key_name, mind_id, title, description, tags, price, featured, display_order, is_public, avatar_url, tier, credits, query, page }) => {
         try {
             switch (action) {
                 case "create_user": {
@@ -431,14 +788,13 @@ function createMindMcpServer(client) {
                             isError: true,
                         };
                     }
-                    const result = await client.adminCreateUser({ username, email, password, source, tier });
+                    const result = await client.adminCreateUser({ username, email, password, source, tier, generate_api_key, api_key_name });
+                    let text = `✅ User created: @${result.user?.username} (workspace: ${result.user?.workspace_id}, tier: ${result.user?.tier})`;
+                    if (result.api_key) {
+                        text += `\n🔑 API key: ${result.api_key.key}\n   Name: ${result.api_key.name}\n   Scopes: ${result.api_key.scopes.length} (full access)`;
+                    }
                     return {
-                        content: [
-                            {
-                                type: "text",
-                                text: `✅ User created: @${result.user?.username} (workspace: ${result.user?.workspace_id}, tier: ${result.user?.tier})`,
-                            },
-                        ],
+                        content: [{ type: "text", text }],
                     };
                 }
                 case "create_featured_mind": {
@@ -559,6 +915,901 @@ function createMindMcpServer(client) {
             };
         }
     });
+    // ═══════════════════════════════════════════════════════════
+    // NEW TOOLS (Phase 2 + Phase 3)
+    // ═══════════════════════════════════════════════════════════
+    // ─── mind_sense ─────────────────────────────────────────
+    // MINDsense emotional intelligence layer.
+    server.tool("mind_sense", "Access MINDsense emotional intelligence — the user's living emotional state, signal history, emotional timeline, and KG entity weights. Use this to understand how the user is feeling and what emotionally significant events have occurred.", {
+        action: zod_1.z
+            .enum(["state", "signals", "timeline", "kg_weights", "spikes", "acknowledge", "summary"])
+            .describe("Action: state (current emotion), signals (recent signals), timeline (historical), kg_weights (emotionally weighted entities), spikes (recent spikes), acknowledge (ack a spike), summary (AI emotional summary)"),
+        signal_id: zod_1.z.string().optional().describe("Signal ID for acknowledge action"),
+        days: zod_1.z.number().optional().default(7).describe("Lookback days for timeline/signals"),
+        limit: zod_1.z.number().optional().default(20).describe("Max items to return"),
+    }, async ({ action, signal_id, days, limit }) => {
+        try {
+            switch (action) {
+                case "state": {
+                    const result = await client.mindsenseState();
+                    const lines = [
+                        "🧠 MINDsense Emotional State",
+                        `• Label: ${result.label ?? "neutral"}`,
+                        `• Valence: ${result.valence ?? "—"} (positive/negative)`,
+                        `• Arousal: ${result.arousal ?? "—"} (intensity)`,
+                        `• Trend: ${result.trend ?? "stable"}`,
+                        `• Sensitivity: ${result.sensitivity ?? "—"}`,
+                    ];
+                    if (result.dominant_emotion) {
+                        lines.push(`• Dominant emotion: ${result.dominant_emotion}`);
+                    }
+                    return { content: [{ type: "text", text: lines.join("\n") }] };
+                }
+                case "signals": {
+                    const result = await client.mindsenseSignals(days, limit);
+                    const signals = result.signals ?? [];
+                    if (signals.length === 0) {
+                        return { content: [{ type: "text", text: "No emotional signals in the specified period." }] };
+                    }
+                    const lines = signals.map((s) => `• [${s.label ?? "—"}] valence: ${s.valence ?? "—"}, arousal: ${s.arousal ?? "—"} — ${s.created_at ?? "—"} (id: ${s.signal_id ?? s.id})`);
+                    return { content: [{ type: "text", text: lines.join("\n") }] };
+                }
+                case "timeline": {
+                    const result = await client.mindsenseTimeline(days);
+                    const points = result.timeline ?? [];
+                    if (points.length === 0) {
+                        return { content: [{ type: "text", text: "No timeline data for the specified period." }] };
+                    }
+                    const lines = ["📈 Emotional Timeline", ""];
+                    for (const p of points) {
+                        lines.push(`• ${p.date ?? p.timestamp}: ${p.label ?? "—"} (v: ${p.valence ?? "—"}, a: ${p.arousal ?? "—"})`);
+                    }
+                    return { content: [{ type: "text", text: lines.join("\n") }] };
+                }
+                case "kg_weights": {
+                    const result = await client.mindsenseKgWeights(limit);
+                    const entities = result.entities ?? [];
+                    if (entities.length === 0) {
+                        return { content: [{ type: "text", text: "No emotionally weighted entities found." }] };
+                    }
+                    const lines = ["🎯 Emotionally Weighted KG Entities", ""];
+                    for (const e of entities) {
+                        lines.push(`• ${e.entity ?? e.name}: weight ${e.weight ?? e.score ?? "—"} (${e.emotion ?? "—"})`);
+                    }
+                    return { content: [{ type: "text", text: lines.join("\n") }] };
+                }
+                case "spikes": {
+                    const result = await client.mindsenseSpikes(days, limit);
+                    const spikes = result.spikes ?? [];
+                    if (spikes.length === 0) {
+                        return { content: [{ type: "text", text: "No emotional spikes detected." }] };
+                    }
+                    const lines = ["⚡ Emotional Spikes", ""];
+                    for (const s of spikes) {
+                        lines.push(`• [${s.acknowledged ? "ack" : "NEW"}] ${s.label ?? "—"} — valence: ${s.valence ?? "—"}, arousal: ${s.arousal ?? "—"} — ${s.created_at ?? "—"} (id: ${s.signal_id ?? s.id})`);
+                    }
+                    return { content: [{ type: "text", text: lines.join("\n") }] };
+                }
+                case "acknowledge": {
+                    if (!signal_id) {
+                        return {
+                            content: [{ type: "text", text: "Error: signal_id is required for acknowledge" }],
+                            isError: true,
+                        };
+                    }
+                    await client.mindsenseAcknowledge(signal_id);
+                    return {
+                        content: [{ type: "text", text: `✅ Acknowledged spike signal ${signal_id}` }],
+                    };
+                }
+                case "summary": {
+                    const result = await client.mindsenseSummary(days);
+                    return {
+                        content: [{ type: "text", text: result.summary ?? "No emotional summary available." }],
+                    };
+                }
+            }
+        }
+        catch (err) {
+            return {
+                content: [{ type: "text", text: `Error in mind_sense: ${err}` }],
+                isError: true,
+            };
+        }
+    });
+    // ─── mind_research ──────────────────────────────────────
+    // Deep research agent jobs.
+    server.tool("mind_research", "Launch and manage deep research jobs. Research runs autonomously — it gathers information, analyzes it, and stores findings in the knowledge graph. Use for competitive analysis, market research, technical deep-dives.", {
+        action: zod_1.z
+            .enum(["start", "status", "list"])
+            .describe("Action: start (launch research), status (check job progress), list (view all jobs)"),
+        topic: zod_1.z.string().optional().describe("Research topic/question for start action"),
+        job_id: zod_1.z.string().optional().describe("Job ID for status action"),
+        limit: zod_1.z.number().optional().default(10).describe("Max jobs to return for list"),
+    }, async ({ action, topic, job_id, limit }) => {
+        try {
+            switch (action) {
+                case "start": {
+                    if (!topic) {
+                        return {
+                            content: [{ type: "text", text: "Error: topic is required to start research" }],
+                            isError: true,
+                        };
+                    }
+                    const result = await client.startResearch(topic);
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `✅ Research started: "${topic}" (job_id: ${result.job_id})`,
+                            },
+                        ],
+                    };
+                }
+                case "status": {
+                    if (!job_id) {
+                        return {
+                            content: [{ type: "text", text: "Error: job_id is required for status" }],
+                            isError: true,
+                        };
+                    }
+                    const result = await client.getResearch(job_id);
+                    const lines = [
+                        `📋 Research Job: ${result.topic ?? result.title ?? job_id}`,
+                        `• Status: ${result.status}`,
+                        `• Papers found: ${result.papers_count ?? "—"}`,
+                        `• Credits used: ${result.credits_used ?? "—"}`,
+                        `• Started: ${result.created_at ?? "—"}`,
+                    ];
+                    if (result.research_summary) {
+                        lines.push("", `Summary: ${result.research_summary}`);
+                    }
+                    return { content: [{ type: "text", text: lines.join("\n") }] };
+                }
+                case "list": {
+                    const result = await client.listResearch(limit);
+                    const jobs = result.jobs ?? [];
+                    if (jobs.length === 0) {
+                        return { content: [{ type: "text", text: "No research jobs found." }] };
+                    }
+                    const lines = jobs.map((j) => `• [${j.status}] "${j.topic ?? j.title}" — ${j.created_at ?? "—"} (id: ${j.job_id})`);
+                    return { content: [{ type: "text", text: lines.join("\n") }] };
+                }
+            }
+        }
+        catch (err) {
+            return {
+                content: [{ type: "text", text: `Error in mind_research: ${err}` }],
+                isError: true,
+            };
+        }
+    });
+    // ─── mind_train ─────────────────────────────────────────
+    // Self-training and chat-to-KG sessions.
+    server.tool("mind_train", "Train MIND's knowledge graph. Start guided training sessions to teach it about yourself, or save existing chat conversations into the knowledge graph for persistent memory.", {
+        action: zod_1.z
+            .enum(["start", "chat", "status", "list_sessions", "pause", "resume", "save_chat"])
+            .describe("Action: start (begin training), chat (send message), status (check progress), list_sessions (view past), pause/resume (control session), save_chat (save chat to KG)"),
+        message: zod_1.z.string().optional().describe("Training message for chat action"),
+        session_type: zod_1.z
+            .string()
+            .optional()
+            .describe("Training type: basics, network, expertise, history, goals, freeform"),
+        session_id: zod_1.z.string().optional().describe("Session ID for save_chat/pause/resume actions"),
+    }, async ({ action, message, session_type, session_id }) => {
+        try {
+            switch (action) {
+                case "start": {
+                    const result = await client.trainingStart(session_type);
+                    const sid = String(result.session_id ?? result.id ?? "unknown");
+                    const prompt = String(result.prompt ?? result.message ?? "Ready to train.");
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `✅ Training session started (type: ${session_type ?? "freeform"}, id: ${sid})\n\n${prompt}`,
+                            },
+                        ],
+                    };
+                }
+                case "chat": {
+                    if (!message) {
+                        return {
+                            content: [{ type: "text", text: "Error: message is required for chat" }],
+                            isError: true,
+                        };
+                    }
+                    const result = await client.trainingChat(message);
+                    return {
+                        content: [{ type: "text", text: String(result.response ?? result.message ?? "Received.") }],
+                    };
+                }
+                case "status": {
+                    const result = await client.trainingStatus();
+                    const lines = [
+                        "📋 Training Status",
+                        `• Active: ${result.active ? "yes" : "no"}`,
+                        `• Type: ${String(result.session_type ?? "—")}`,
+                        `• Progress: ${String(result.progress ?? "—")}`,
+                        `• Items learned: ${String(result.items_learned ?? 0)}`,
+                    ];
+                    return { content: [{ type: "text", text: lines.join("\n") }] };
+                }
+                case "list_sessions": {
+                    const result = await client.trainingSessions();
+                    const sessions = result.sessions ?? [];
+                    if (sessions.length === 0) {
+                        return { content: [{ type: "text", text: "No training sessions found." }] };
+                    }
+                    const lines = sessions.map((s) => `• [${String(s.status ?? "—")}] ${String(s.session_type ?? "freeform")} — ${String(s.created_at ?? "—")} (id: ${String(s.session_id ?? s.id)})`);
+                    return { content: [{ type: "text", text: lines.join("\n") }] };
+                }
+                case "pause": {
+                    await client.trainingPause();
+                    return {
+                        content: [{ type: "text", text: "✅ Training session paused." }],
+                    };
+                }
+                case "resume": {
+                    const result = await client.trainingResume();
+                    const prompt = String(result.prompt ?? result.message ?? "");
+                    return {
+                        content: [{ type: "text", text: `✅ Training session resumed.\n\n${prompt}` }],
+                    };
+                }
+                case "save_chat": {
+                    if (!session_id) {
+                        return {
+                            content: [{ type: "text", text: "Error: session_id is required for save_chat" }],
+                            isError: true,
+                        };
+                    }
+                    const result = await client.saveChatToMind(session_id);
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `✅ Chat session saved to knowledge graph (${String(result.items_saved ?? result.count ?? 0)} items extracted)`,
+                            },
+                        ],
+                    };
+                }
+            }
+        }
+        catch (err) {
+            return {
+                content: [{ type: "text", text: `Error in mind_train: ${err}` }],
+                isError: true,
+            };
+        }
+    });
+    // ─── mind_social ────────────────────────────────────────
+    // Thoughts, communities, and feed.
+    server.tool("mind_social", "Interact with MIND's social layer — create thoughts (posts), browse the feed, manage communities, and engage with other users' content.", {
+        action: zod_1.z
+            .enum([
+            "create_thought", "get_thought", "delete_thought", "like_thought",
+            "feed", "user_feed", "search_feed",
+            "create_community", "list_communities", "get_community",
+            "join_community", "leave_community",
+            "create_post", "list_posts",
+        ])
+            .describe("Social action — thoughts, feed browsing, community management"),
+        content: zod_1.z.string().optional().describe("Content for thoughts or posts"),
+        thought_id: zod_1.z.string().optional().describe("Thought ID for get/delete/like"),
+        community_id: zod_1.z.string().optional().describe("Community ID for community actions and posts"),
+        post_id: zod_1.z.string().optional().describe("Post ID for post actions"),
+        username: zod_1.z.string().optional().describe("Username for user_feed"),
+        name: zod_1.z.string().optional().describe("Community name for create_community"),
+        description: zod_1.z.string().optional().describe("Community description"),
+        page: zod_1.z.number().optional().describe("Page number for paginated results"),
+        limit: zod_1.z.number().optional().describe("Max items per page"),
+    }, async ({ action, content, thought_id, community_id, post_id, username, name, description, page, limit: lim }) => {
+        try {
+            switch (action) {
+                case "create_thought": {
+                    if (!content) {
+                        return {
+                            content: [{ type: "text", text: "Error: content is required for create_thought" }],
+                            isError: true,
+                        };
+                    }
+                    const result = await client.socialCreateThought(content);
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `✅ Thought posted (id: ${result.thought_id ?? result.id})`,
+                            },
+                        ],
+                    };
+                }
+                case "get_thought": {
+                    if (!thought_id) {
+                        return {
+                            content: [{ type: "text", text: "Error: thought_id is required for get_thought" }],
+                            isError: true,
+                        };
+                    }
+                    const result = await client.socialGetThought(thought_id);
+                    const lines = [
+                        `@${result.username ?? "—"}: ${result.content}`,
+                        `Likes: ${result.likes ?? 0} | Reposts: ${result.reposts ?? 0} | ${result.created_at ?? ""}`,
+                    ];
+                    return { content: [{ type: "text", text: lines.join("\n") }] };
+                }
+                case "delete_thought": {
+                    if (!thought_id) {
+                        return {
+                            content: [{ type: "text", text: "Error: thought_id is required for delete_thought" }],
+                            isError: true,
+                        };
+                    }
+                    await client.socialDeleteThought(thought_id);
+                    return {
+                        content: [{ type: "text", text: `✅ Deleted thought ${thought_id}` }],
+                    };
+                }
+                case "like_thought": {
+                    if (!thought_id) {
+                        return {
+                            content: [{ type: "text", text: "Error: thought_id is required for like_thought" }],
+                            isError: true,
+                        };
+                    }
+                    await client.socialLikeThought(thought_id);
+                    return {
+                        content: [{ type: "text", text: `✅ Liked thought ${thought_id}` }],
+                    };
+                }
+                case "feed": {
+                    const result = await client.socialFeed(page, lim);
+                    const items = result.thoughts ?? [];
+                    if (items.length === 0) {
+                        return { content: [{ type: "text", text: "Feed is empty." }] };
+                    }
+                    const lines = items.map((t) => `• @${String(t.username ?? "—")}: ${String(t.content ?? "").slice(0, 120)} (❤ ${String(t.likes ?? 0)}) — id: ${String(t.thought_id ?? t.id)}`);
+                    return { content: [{ type: "text", text: lines.join("\n") }] };
+                }
+                case "user_feed": {
+                    if (!username) {
+                        return {
+                            content: [{ type: "text", text: "Error: username is required for user_feed" }],
+                            isError: true,
+                        };
+                    }
+                    const result = await client.socialUserFeed(username, page, lim);
+                    const items = result.thoughts ?? [];
+                    if (items.length === 0) {
+                        return { content: [{ type: "text", text: `No thoughts from @${username}.` }] };
+                    }
+                    const lines = items.map((t) => `• ${String(t.content ?? "").slice(0, 120)} (❤ ${String(t.likes ?? 0)}) — id: ${String(t.thought_id ?? t.id)}`);
+                    return { content: [{ type: "text", text: `@${username}'s thoughts:\n${lines.join("\n")}` }] };
+                }
+                case "search_feed": {
+                    if (!content) {
+                        return {
+                            content: [{ type: "text", text: "Error: content (search query) is required for search_feed" }],
+                            isError: true,
+                        };
+                    }
+                    const result = await client.socialSearchFeed(content, page, lim);
+                    const items = result.thoughts ?? [];
+                    if (items.length === 0) {
+                        return { content: [{ type: "text", text: `No results for "${content}".` }] };
+                    }
+                    const lines = items.map((t) => `• @${String(t.username ?? "—")}: ${String(t.content ?? "").slice(0, 120)} — id: ${String(t.thought_id ?? t.id)}`);
+                    return { content: [{ type: "text", text: lines.join("\n") }] };
+                }
+                case "create_community": {
+                    if (!name) {
+                        return {
+                            content: [{ type: "text", text: "Error: name is required for create_community" }],
+                            isError: true,
+                        };
+                    }
+                    const result = await client.socialCreateCommunity(name, description);
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `✅ Community created: "${result.name}" (id: ${result.community_id ?? result.id})`,
+                            },
+                        ],
+                    };
+                }
+                case "list_communities": {
+                    const result = await client.socialListCommunities(page, lim);
+                    const communities = result.communities ?? [];
+                    if (communities.length === 0) {
+                        return { content: [{ type: "text", text: "No communities found." }] };
+                    }
+                    const lines = communities.map((c) => `• ${c.name} — ${c.member_count ?? 0} members (id: ${c.community_id ?? c.id})`);
+                    return { content: [{ type: "text", text: lines.join("\n") }] };
+                }
+                case "get_community": {
+                    if (!community_id) {
+                        return {
+                            content: [{ type: "text", text: "Error: community_id is required for get_community" }],
+                            isError: true,
+                        };
+                    }
+                    const result = await client.socialGetCommunity(community_id);
+                    const lines = [
+                        `**${result.name}**`,
+                        result.description ?? "",
+                        `Members: ${result.member_count ?? 0} | Posts: ${result.post_count ?? 0}`,
+                    ];
+                    return { content: [{ type: "text", text: lines.join("\n") }] };
+                }
+                case "join_community": {
+                    if (!community_id) {
+                        return {
+                            content: [{ type: "text", text: "Error: community_id is required for join_community" }],
+                            isError: true,
+                        };
+                    }
+                    await client.socialJoinCommunity(community_id);
+                    return {
+                        content: [{ type: "text", text: `✅ Joined community ${community_id}` }],
+                    };
+                }
+                case "leave_community": {
+                    if (!community_id) {
+                        return {
+                            content: [{ type: "text", text: "Error: community_id is required for leave_community" }],
+                            isError: true,
+                        };
+                    }
+                    await client.socialLeaveCommunity(community_id);
+                    return {
+                        content: [{ type: "text", text: `✅ Left community ${community_id}` }],
+                    };
+                }
+                case "create_post": {
+                    if (!community_id || !content) {
+                        return {
+                            content: [{ type: "text", text: "Error: community_id and content are required for create_post" }],
+                            isError: true,
+                        };
+                    }
+                    const result = await client.socialCreatePost(community_id, content);
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `✅ Post created in community ${community_id} (id: ${result.post_id ?? result.id})`,
+                            },
+                        ],
+                    };
+                }
+                case "list_posts": {
+                    if (!community_id) {
+                        return {
+                            content: [{ type: "text", text: "Error: community_id is required for list_posts" }],
+                            isError: true,
+                        };
+                    }
+                    const result = await client.socialListPosts(community_id, page, lim);
+                    const posts = result.posts ?? [];
+                    if (posts.length === 0) {
+                        return { content: [{ type: "text", text: "No posts in this community." }] };
+                    }
+                    const lines = posts.map((p) => `• @${p.username ?? "—"}: ${p.content?.slice(0, 120) ?? ""} — id: ${p.post_id ?? p.id}`);
+                    return { content: [{ type: "text", text: lines.join("\n") }] };
+                }
+            }
+        }
+        catch (err) {
+            return {
+                content: [{ type: "text", text: `Error in mind_social: ${err}` }],
+                isError: true,
+            };
+        }
+    });
+    // ─── mind_profile ───────────────────────────────────────
+    // Profile, prompts, and model preferences.
+    server.tool("mind_profile", "Manage your MIND profile, AI prompt settings, and model preferences. Update your bio, set custom system prompts for chat and thought generation, and choose your preferred LLM model.", {
+        action: zod_1.z
+            .enum([
+            "get", "update",
+            "get_chat_prompt", "set_chat_prompt",
+            "get_thought_prompt", "set_thought_prompt",
+            "get_model", "set_model", "list_models",
+        ])
+            .describe("Action: get/update profile, get/set chat/thought prompts, get/set/list LLM models"),
+        username: zod_1.z.string().optional().describe("Username for get action (defaults to current user)"),
+        bio: zod_1.z.string().optional().describe("Bio for update action"),
+        display_name: zod_1.z.string().optional().describe("Display name for update action"),
+        prompt: zod_1.z.string().optional().describe("System prompt content for set_chat_prompt/set_thought_prompt"),
+        model_id: zod_1.z.string().optional().describe("Model ID for set_model"),
+    }, async ({ action, username, bio, display_name, prompt, model_id }) => {
+        try {
+            switch (action) {
+                case "get": {
+                    const result = await client.profileGet(username);
+                    const lines = [
+                        `**@${result.username}**`,
+                        result.display_name ? `Name: ${result.display_name}` : "",
+                        result.bio ? `Bio: ${result.bio}` : "",
+                        `Tier: ${result.tier ?? "free"}`,
+                        `Joined: ${result.created_at ?? "—"}`,
+                    ].filter(Boolean);
+                    return { content: [{ type: "text", text: lines.join("\n") }] };
+                }
+                case "update": {
+                    const patch = {};
+                    if (bio)
+                        patch.bio = bio;
+                    if (display_name)
+                        patch.display_name = display_name;
+                    if (username)
+                        patch.username = username;
+                    const result = await client.profileUpdate(patch);
+                    return {
+                        content: [{ type: "text", text: `✅ Profile updated: @${result.username}` }],
+                    };
+                }
+                case "get_chat_prompt": {
+                    const result = await client.getChatPrompt();
+                    return {
+                        content: [{ type: "text", text: `Chat system prompt:\n\n${result.prompt ?? "No custom prompt set."}` }],
+                    };
+                }
+                case "set_chat_prompt": {
+                    if (!prompt) {
+                        return {
+                            content: [{ type: "text", text: "Error: prompt is required for set_chat_prompt" }],
+                            isError: true,
+                        };
+                    }
+                    await client.setChatPrompt(prompt);
+                    return {
+                        content: [{ type: "text", text: "✅ Chat system prompt updated." }],
+                    };
+                }
+                case "get_thought_prompt": {
+                    const result = await client.getThoughtPrompt();
+                    return {
+                        content: [{ type: "text", text: `Thought generation prompt:\n\n${result.prompt ?? "No custom prompt set."}` }],
+                    };
+                }
+                case "set_thought_prompt": {
+                    if (!prompt) {
+                        return {
+                            content: [{ type: "text", text: "Error: prompt is required for set_thought_prompt" }],
+                            isError: true,
+                        };
+                    }
+                    await client.setThoughtPrompt(prompt);
+                    return {
+                        content: [{ type: "text", text: "✅ Thought generation prompt updated." }],
+                    };
+                }
+                case "get_model": {
+                    const result = await client.getModel();
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `Current model: ${result.model_id ?? result.model ?? "default"} (${result.provider ?? "—"})`,
+                            },
+                        ],
+                    };
+                }
+                case "set_model": {
+                    if (!model_id) {
+                        return {
+                            content: [{ type: "text", text: "Error: model_id is required for set_model" }],
+                            isError: true,
+                        };
+                    }
+                    const result = await client.setModel(model_id);
+                    return {
+                        content: [{ type: "text", text: `✅ Model set to: ${result.model_id ?? model_id}` }],
+                    };
+                }
+                case "list_models": {
+                    const result = await client.listModels();
+                    const models = result.models ?? [];
+                    if (models.length === 0) {
+                        return { content: [{ type: "text", text: "No models available." }] };
+                    }
+                    const lines = models.map((m) => `• ${m.name ?? m.model_id} (${m.provider ?? "—"}) — ${m.description ?? ""}${m.is_free ? " [FREE]" : ""}`);
+                    return { content: [{ type: "text", text: lines.join("\n") }] };
+                }
+            }
+        }
+        catch (err) {
+            return {
+                content: [{ type: "text", text: `Error in mind_profile: ${err}` }],
+                isError: true,
+            };
+        }
+    });
+    // ─── mind_insights ──────────────────────────────────────
+    // ALE insights and analytics.
+    server.tool("mind_insights", "Access insights from MIND's Autonomous Learning Engine — patterns detected in your knowledge graph, weekly summaries, and proactive intelligence. Also trigger on-demand analysis.", {
+        action: zod_1.z
+            .enum(["list", "unread_count", "view", "feedback", "analyze", "weekly_summary", "context"])
+            .describe("Action: list (recent insights), unread_count, view (mark seen), feedback (rate), analyze (trigger analysis), weekly_summary, context (ALE context)"),
+        insight_id: zod_1.z.string().optional().describe("Insight ID for view/feedback actions"),
+        rating: zod_1.z
+            .enum(["helpful", "not_helpful"])
+            .optional()
+            .describe("Rating for feedback action"),
+        limit: zod_1.z.number().optional().default(10).describe("Max insights to return"),
+    }, async ({ action, insight_id, rating, limit }) => {
+        try {
+            switch (action) {
+                case "list": {
+                    const result = await client.insightsList(limit);
+                    const insights = result.insights ?? [];
+                    if (insights.length === 0) {
+                        return { content: [{ type: "text", text: "No insights available." }] };
+                    }
+                    const lines = insights.map((i) => `• [${i.type ?? "insight"}] ${i.title ?? i.content?.slice(0, 100) ?? "—"} — ${i.created_at ?? ""} (id: ${i.insight_id ?? i.id})`);
+                    return { content: [{ type: "text", text: lines.join("\n") }] };
+                }
+                case "unread_count": {
+                    const result = await client.insightsUnreadCount();
+                    return {
+                        content: [{ type: "text", text: `Unread insights: ${result.count ?? 0}` }],
+                    };
+                }
+                case "view": {
+                    if (!insight_id) {
+                        return {
+                            content: [{ type: "text", text: "Error: insight_id is required for view" }],
+                            isError: true,
+                        };
+                    }
+                    const result = await client.insightsView(insight_id);
+                    const lines = [
+                        `**${result.title ?? "Insight"}**`,
+                        `Type: ${result.type ?? "—"} | Created: ${result.created_at ?? "—"}`,
+                        "",
+                        result.content ?? "No content.",
+                    ];
+                    return { content: [{ type: "text", text: lines.join("\n") }] };
+                }
+                case "feedback": {
+                    if (!insight_id || !rating) {
+                        return {
+                            content: [{ type: "text", text: "Error: insight_id and rating are required for feedback" }],
+                            isError: true,
+                        };
+                    }
+                    await client.insightsFeedback(insight_id, rating);
+                    return {
+                        content: [{ type: "text", text: `✅ Feedback recorded for insight ${insight_id}: ${rating}` }],
+                    };
+                }
+                case "analyze": {
+                    const result = await client.insightsAnalyze();
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `✅ Analysis triggered. ${result.message ?? result.status ?? "Processing..."}`,
+                            },
+                        ],
+                    };
+                }
+                case "weekly_summary": {
+                    const result = await client.insightsWeeklySummary();
+                    return {
+                        content: [{ type: "text", text: result.summary ?? "No weekly summary available." }],
+                    };
+                }
+                case "context": {
+                    const result = await client.insightsContext();
+                    return {
+                        content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+                    };
+                }
+            }
+        }
+        catch (err) {
+            return {
+                content: [{ type: "text", text: `Error in mind_insights: ${err}` }],
+                isError: true,
+            };
+        }
+    });
+    // ─── mind_automate ──────────────────────────────────────
+    // Automations and triggers.
+    server.tool("mind_automate", "Create and manage automations in MIND — scheduled workflows, event triggers, and rules that run automatically. Connect CRM events to actions, schedule recurring tasks, and build custom pipelines.", {
+        action: zod_1.z
+            .enum(["list", "create", "update", "delete", "run_now", "history"])
+            .describe("Action: list/create/update/delete automations, run_now (trigger immediately), history (execution log)"),
+        automation_id: zod_1.z.string().optional().describe("Automation ID for update/delete/run_now/history"),
+        name: zod_1.z.string().optional().describe("Automation name for create/update"),
+        trigger_type: zod_1.z
+            .string()
+            .optional()
+            .describe("Trigger type: schedule, webhook, event"),
+        trigger_config: zod_1.z
+            .string()
+            .optional()
+            .describe("JSON config string for the trigger (e.g. cron expression, event name)"),
+        action_type: zod_1.z.string().optional().describe("Action type to execute when triggered"),
+        action_config: zod_1.z
+            .string()
+            .optional()
+            .describe("JSON config string for the action"),
+        enabled: zod_1.z.boolean().optional().describe("Whether the automation is enabled"),
+    }, async ({ action, automation_id, name, trigger_type, trigger_config, action_type, action_config, enabled }) => {
+        try {
+            switch (action) {
+                case "list": {
+                    const result = await client.automationsList();
+                    const automations = result.automations ?? [];
+                    if (automations.length === 0) {
+                        return { content: [{ type: "text", text: "No automations found." }] };
+                    }
+                    const lines = automations.map((a) => `• [${a.enabled ? "ON" : "OFF"}] ${a.task} — interval: ${a.interval} (runs: ${a.total_runs}, id: ${a.id})`);
+                    return { content: [{ type: "text", text: lines.join("\n") }] };
+                }
+                case "create": {
+                    if (!name || !trigger_type || !action_type) {
+                        return {
+                            content: [{ type: "text", text: "Error: name, trigger_type, and action_type are required for create" }],
+                            isError: true,
+                        };
+                    }
+                    const result = await client.automationsCreate({
+                        name,
+                        trigger_type,
+                        trigger_config: trigger_config ? JSON.parse(trigger_config) : undefined,
+                        action_type,
+                        action_config: action_config ? JSON.parse(action_config) : undefined,
+                        enabled: enabled ?? true,
+                    });
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `✅ Automation created: "${result.name}" (id: ${result.automation_id ?? result.id})`,
+                            },
+                        ],
+                    };
+                }
+                case "update": {
+                    if (!automation_id) {
+                        return {
+                            content: [{ type: "text", text: "Error: automation_id is required for update" }],
+                            isError: true,
+                        };
+                    }
+                    const patch = {};
+                    if (name)
+                        patch.name = name;
+                    if (trigger_type)
+                        patch.trigger_type = trigger_type;
+                    if (trigger_config)
+                        patch.trigger_config = JSON.parse(trigger_config);
+                    if (action_type)
+                        patch.action_type = action_type;
+                    if (action_config)
+                        patch.action_config = JSON.parse(action_config);
+                    if (enabled !== undefined)
+                        patch.enabled = enabled;
+                    const result = await client.automationsUpdate(automation_id, patch);
+                    return {
+                        content: [{ type: "text", text: `✅ Updated automation: "${result.name}"` }],
+                    };
+                }
+                case "delete": {
+                    if (!automation_id) {
+                        return {
+                            content: [{ type: "text", text: "Error: automation_id is required for delete" }],
+                            isError: true,
+                        };
+                    }
+                    await client.automationsDelete(automation_id);
+                    return {
+                        content: [{ type: "text", text: `✅ Deleted automation ${automation_id}` }],
+                    };
+                }
+                case "run_now": {
+                    if (!automation_id) {
+                        return {
+                            content: [{ type: "text", text: "Error: automation_id is required for run_now" }],
+                            isError: true,
+                        };
+                    }
+                    const result = await client.automationsRunNow(automation_id);
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `✅ Automation triggered: ${result.status ?? "running"} (execution_id: ${result.execution_id ?? result.id ?? "—"})`,
+                            },
+                        ],
+                    };
+                }
+                case "history": {
+                    if (!automation_id) {
+                        return {
+                            content: [{ type: "text", text: "Error: automation_id is required for history" }],
+                            isError: true,
+                        };
+                    }
+                    const result = await client.automationsHistory(automation_id);
+                    const executions = result.executions ?? [];
+                    if (executions.length === 0) {
+                        return { content: [{ type: "text", text: "No execution history found." }] };
+                    }
+                    const lines = executions.map((e) => `• [${e.status}] ${e.started_at ?? "—"}${e.completed_at ? ` → ${e.completed_at}` : ""} (id: ${e.execution_id ?? e.id})`);
+                    return { content: [{ type: "text", text: lines.join("\n") }] };
+                }
+            }
+        }
+        catch (err) {
+            return {
+                content: [{ type: "text", text: `Error in mind_automate: ${err}` }],
+                isError: true,
+            };
+        }
+    });
+    // ─── mind_notify ────────────────────────────────────────
+    // Notifications management.
+    server.tool("mind_notify", "Read and manage MIND notifications — alerts, reminders, insight notifications, and system messages.", {
+        action: zod_1.z
+            .enum(["list", "mark_read", "mark_all_read", "stats"])
+            .describe("Action: list (view notifications), mark_read (single), mark_all_read (all), stats (overview)"),
+        notification_id: zod_1.z.string().optional().describe("Notification ID for mark_read"),
+        limit: zod_1.z.number().optional().default(20).describe("Max notifications to return"),
+    }, async ({ action, notification_id, limit }) => {
+        try {
+            switch (action) {
+                case "list": {
+                    const result = await client.notificationsList(limit);
+                    const notifications = result.notifications ?? [];
+                    if (notifications.length === 0) {
+                        return { content: [{ type: "text", text: "No notifications." }] };
+                    }
+                    const lines = notifications.map((n) => `• [${n.read ? "read" : "NEW"}] ${n.title ?? n.message ?? "—"} — ${n.created_at ?? ""} (id: ${n.notification_id})`);
+                    return { content: [{ type: "text", text: lines.join("\n") }] };
+                }
+                case "mark_read": {
+                    if (!notification_id) {
+                        return {
+                            content: [{ type: "text", text: "Error: notification_id is required for mark_read" }],
+                            isError: true,
+                        };
+                    }
+                    await client.notificationsMarkRead(notification_id);
+                    return {
+                        content: [{ type: "text", text: `✅ Marked notification ${notification_id} as read.` }],
+                    };
+                }
+                case "mark_all_read": {
+                    const result = await client.notificationsMarkAllRead();
+                    return {
+                        content: [{ type: "text", text: `✅ Marked ${result.count ?? "all"} notifications as read.` }],
+                    };
+                }
+                case "stats": {
+                    const result = await client.notificationsStats();
+                    const lines = [
+                        "🔔 Notification Stats",
+                        `• Total: ${result.total ?? 0}`,
+                        `• Unread: ${result.unread ?? 0}`,
+                        `• Read: ${result.read ?? 0}`,
+                    ];
+                    return { content: [{ type: "text", text: lines.join("\n") }] };
+                }
+            }
+        }
+        catch (err) {
+            return {
+                content: [{ type: "text", text: `Error in mind_notify: ${err}` }],
+                isError: true,
+            };
+        }
+    });
     return server;
 }
 //# sourceMappingURL=server.js.map