@astramindapp/mcp-server 0.6.0 → 0.8.2

package/dist/server.js

@@ -5,7 +5,7 @@
  * Exposes the MIND knowledge graph as MCP tools that any LLM agent can use.
  * This is the universal AI memory layer.
  *
- * Tools (15):
+ * Tools (17):
  *   mind_query     — Semantic search across the knowledge graph
  *   mind_remember  — Store/manage content in the graph (auto-categorized)
  *   mind_context   — Get structured always-loaded context (soul/user/rules)
@@ -21,6 +21,10 @@
  *   mind_insights  — ALE insights and analytics
  *   mind_automate  — Automations and triggers
  *   mind_notify    — Notifications management
+ *   mind_agents    — Admin-only Agent Command Center (registry, heartbeat,
+ *                    probe, status — for Anthony's agent fleet)
+ *   mind_accounts  — Multi-MIND accounts: discover/create MINDs, manage
+ *                    owners and viewers, send invitations
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createMindMcpServer = createMindMcpServer;
@@ -290,11 +294,11 @@ function createMindMcpServer(client) {
     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", "move", "get",
+            "list", "create", "update", "complete", "delete", "bulk_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)"),
+            .describe("What to do: list/create/update/complete/delete/bulk_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
@@ -307,11 +311,12 @@ function createMindMcpServer(client) {
             .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/move/get actions"),
+        item_ids: zod_1.z.array(zod_1.z.string()).optional().describe("Item IDs for bulk_delete (1–200 IDs deleted in one call)"),
         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 }) => {
+    }, async ({ action, title, description, status, priority, due_date, item_id, item_ids, start_time, end_time, event_id, all_day }) => {
         try {
             switch (action) {
                 case "list": {
@@ -393,6 +398,22 @@ function createMindMcpServer(client) {
                         content: [{ type: "text", text: `✅ Deleted life item ${item_id}` }],
                     };
                 }
+                case "bulk_delete": {
+                    if (!item_ids || item_ids.length === 0) {
+                        return {
+                            content: [{ type: "text", text: "Error: item_ids (a non-empty array of IDs) is required for bulk_delete" }],
+                            isError: true,
+                        };
+                    }
+                    const result = await client.bulkDeleteLifeItems(item_ids);
+                    const lines = [
+                        `✅ Bulk delete complete — ${result.deleted_count} life item(s) deleted.`,
+                    ];
+                    if (result.not_found.length > 0) {
+                        lines.push(`⚠️ ${result.not_found.length} id(s) skipped (not found / not yours): ${result.not_found.join(", ")}`);
+                    }
+                    return { content: [{ type: "text", text: lines.join("\n") }] };
+                }
                 case "move": {
                     if (!item_id || !status) {
                         return {
@@ -510,6 +531,212 @@ function createMindMcpServer(client) {
             };
         }
     });
+    // ─── mind_tasks ─────────────────────────────────────────
+    // Site-wide tasks: assignable, completable work items that attach to a
+    // Life project, a CRM contact, an agent, or stand alone.
+    server.tool("mind_tasks", "Manage site-wide tasks in MIND — assignable, completable, reportable work items. A task can attach to a Life project (parent_type=life_item), a CRM contact (parent_type=contact), an agent (parent_type=agent), or stand alone. Assign tasks to a MIND member, an agent, or an external email. Use action=reports for completion analytics.", {
+        action: zod_1.z
+            .enum([
+            "list", "create", "get", "update", "complete", "reopen",
+            "assign", "delete", "reports",
+        ])
+            .describe("What to do: list/create/get/update/complete/reopen/assign/delete tasks, or reports (completion analytics)"),
+        task_id: zod_1.z.string().optional().describe("Task ID — required for get/update/complete/reopen/assign/delete"),
+        title: zod_1.z.string().optional().describe("Task title (required for create)"),
+        description: zod_1.z.string().optional().describe("Task description"),
+        status: zod_1.z.string().optional().describe("Filter (list) or new status: open, in_progress, blocked, done"),
+        priority: zod_1.z.string().optional().describe("Priority: none, low, medium, high, urgent"),
+        due_date: zod_1.z.string().optional().describe("Due date YYYY-MM-DD"),
+        parent_type: zod_1.z.string().optional().describe("Attach to: life_item, contact, agent, or none"),
+        parent_id: zod_1.z.string().optional().describe("ID of the parent project / contact / agent"),
+        assignee_type: zod_1.z.string().optional().describe("Assignee: user, agent, external, or unassigned"),
+        assignee_id: zod_1.z.string().optional().describe("Username, agent slug, or email of the assignee"),
+        dispatch_agent: zod_1.z.boolean().optional().describe("When assigning to an agent, also fire it now"),
+        note: zod_1.z.string().optional().describe("Completion note (for complete)"),
+        overdue: zod_1.z.boolean().optional().describe("List only overdue tasks"),
+    }, async ({ action, task_id, title, description, status, priority, due_date, parent_type, parent_id, assignee_type, assignee_id, dispatch_agent, note, overdue }) => {
+        try {
+            const fmt = (t) => `• [${t.status}] ${t.title}${t.priority && t.priority !== "none" ? ` (${t.priority})` : ""}` +
+                `${t.due_date ? `, due ${t.due_date}` : ""}${t.is_overdue ? " ⚠️ OVERDUE" : ""}` +
+                `${t.assignee_label ? `, → ${t.assignee_label}` : ""}` +
+                `${t.parent_label ? `, on ${t.parent_label}` : ""} — id: ${t.task_id}`;
+            switch (action) {
+                case "list": {
+                    const params = {};
+                    if (status)
+                        params.status = status;
+                    if (priority)
+                        params.priority = priority;
+                    if (parent_type)
+                        params.parent_type = parent_type;
+                    if (parent_id)
+                        params.parent_id = parent_id;
+                    if (assignee_type)
+                        params.assignee_type = assignee_type;
+                    if (assignee_id)
+                        params.assignee_id = assignee_id;
+                    if (overdue)
+                        params.overdue = "true";
+                    const result = await client.listTasks(params);
+                    const tasks = result.tasks ?? [];
+                    if (tasks.length === 0) {
+                        return { content: [{ type: "text", text: "No tasks found." }] };
+                    }
+                    return {
+                        content: [{
+                                type: "text",
+                                text: `${result.total} task(s):\n` + tasks.map(fmt).join("\n"),
+                            }],
+                    };
+                }
+                case "create": {
+                    if (!title) {
+                        return {
+                            content: [{ type: "text", text: "Error: title is required to create a task" }],
+                            isError: true,
+                        };
+                    }
+                    const t = await client.createTask({
+                        title, description, status, priority, due_date,
+                        parent_type, parent_id, assignee_type, assignee_id,
+                        dispatch_agent,
+                    });
+                    return {
+                        content: [{ type: "text", text: `✅ Created task: ${fmt(t)}` }],
+                    };
+                }
+                case "get": {
+                    if (!task_id) {
+                        return {
+                            content: [{ type: "text", text: "Error: task_id is required for get" }],
+                            isError: true,
+                        };
+                    }
+                    const t = await client.getTask(task_id);
+                    const extra = t.agent_run_status ? `\nAgent run: ${t.agent_run_status}` : "";
+                    return {
+                        content: [{
+                                type: "text",
+                                text: `${fmt(t)}${t.description ? `\n${t.description}` : ""}${extra}`,
+                            }],
+                    };
+                }
+                case "update": {
+                    if (!task_id) {
+                        return {
+                            content: [{ type: "text", text: "Error: task_id is required for update" }],
+                            isError: true,
+                        };
+                    }
+                    const patch = {};
+                    if (title !== undefined)
+                        patch.title = title;
+                    if (description !== undefined)
+                        patch.description = description;
+                    if (status !== undefined)
+                        patch.status = status;
+                    if (priority !== undefined)
+                        patch.priority = priority;
+                    if (due_date !== undefined)
+                        patch.due_date = due_date;
+                    if (parent_type !== undefined)
+                        patch.parent_type = parent_type;
+                    if (parent_id !== undefined)
+                        patch.parent_id = parent_id;
+                    const t = await client.updateTask(task_id, patch);
+                    return {
+                        content: [{ type: "text", text: `✅ Updated task: ${fmt(t)}` }],
+                    };
+                }
+                case "complete": {
+                    if (!task_id) {
+                        return {
+                            content: [{ type: "text", text: "Error: task_id is required for complete" }],
+                            isError: true,
+                        };
+                    }
+                    const t = await client.completeTask(task_id, true, note);
+                    return {
+                        content: [{ type: "text", text: `✅ Completed task: "${t.title}"` }],
+                    };
+                }
+                case "reopen": {
+                    if (!task_id) {
+                        return {
+                            content: [{ type: "text", text: "Error: task_id is required for reopen" }],
+                            isError: true,
+                        };
+                    }
+                    const t = await client.completeTask(task_id, false);
+                    return {
+                        content: [{ type: "text", text: `↩️ Reopened task: "${t.title}"` }],
+                    };
+                }
+                case "assign": {
+                    if (!task_id || !assignee_type) {
+                        return {
+                            content: [{ type: "text", text: "Error: task_id and assignee_type are required for assign" }],
+                            isError: true,
+                        };
+                    }
+                    const t = await client.assignTask(task_id, {
+                        assignee_type, assignee_id, dispatch_agent: dispatch_agent ?? false,
+                    });
+                    return {
+                        content: [{
+                                type: "text",
+                                text: `✅ Assigned "${t.title}" → ${t.assignee_label ?? t.assignee_id ?? "unassigned"}`,
+                            }],
+                    };
+                }
+                case "delete": {
+                    if (!task_id) {
+                        return {
+                            content: [{ type: "text", text: "Error: task_id is required for delete" }],
+                            isError: true,
+                        };
+                    }
+                    await client.deleteTask(task_id);
+                    return {
+                        content: [{ type: "text", text: `🗑️ Deleted task ${task_id}` }],
+                    };
+                }
+                case "reports": {
+                    const params = {};
+                    if (parent_type)
+                        params.parent_type = parent_type;
+                    if (parent_id)
+                        params.parent_id = parent_id;
+                    const r = await client.taskReports(params);
+                    const lines = [
+                        `📊 Task report (${r.total} total)`,
+                        `  open ${r.open} · in progress ${r.in_progress} · blocked ${r.blocked} · done ${r.done}`,
+                        `  completion rate: ${r.completion_rate}%`,
+                        `  overdue: ${r.overdue} · due soon: ${r.due_soon} · unassigned: ${r.unassigned}`,
+                        `  avg completion: ${r.avg_completion_days} days`,
+                    ];
+                    if (r.by_assignee && r.by_assignee.length) {
+                        lines.push("  By assignee:");
+                        for (const a of r.by_assignee.slice(0, 10)) {
+                            lines.push(`    ${a.assignee_label ?? a.assignee_id ?? "unassigned"}: ${a.done}/${a.total} done (${a.completion_rate}%)`);
+                        }
+                    }
+                    return { content: [{ type: "text", text: lines.join("\n") }] };
+                }
+                default:
+                    return {
+                        content: [{ type: "text", text: `Unknown action: ${action}` }],
+                        isError: true,
+                    };
+            }
+        }
+        catch (err) {
+            return {
+                content: [{ type: "text", text: `mind_tasks error: ${err instanceof Error ? err.message : String(err)}` }],
+                isError: true,
+            };
+        }
+    });
     // ─── mind_crm ───────────────────────────────────────────
     // Read/write contacts, interactions, and activities.
     // Enhanced: delete, get, log_activity, list_activities.
@@ -1912,6 +2139,633 @@ function createMindMcpServer(client) {
             };
         }
     });
+    // ─── mind_agents ────────────────────────────────────────
+    // Admin-only registry of every agent across MINDapp + the VPS fleet.
+    // Surface UI: https://m-i-n-d.ai/agents · Backend: /admin/agents/*
+    // Use this BEFORE creating a new agent so you don't collide with an
+    // existing slug, and AFTER any non-trivial work to update status,
+    // current_job, or responsibilities.
+    server.tool("mind_agents", "Admin-only Agent Command Center — canonical registry of every Astra AI agent (running on VPS, planned, archived). Query before scaffolding a new agent. Update status / current_job / responsibilities after non-trivial work. Backed by /admin/agents on the MIND backend; admin API key required.", {
+        action: zod_1.z
+            .enum([
+            "list",
+            "get",
+            "create",
+            "update",
+            "delete",
+            "heartbeat",
+            "probe",
+            "log_activity",
+            "list_activities",
+            "import_from_mind",
+            "seed_known",
+            "set_status",
+            "set_current_job",
+            "list_invoices",
+            "link_invoice",
+            "unlink_invoice",
+            "create_invoice",
+        ])
+            .describe("Action: list (filter+stats), get (detail+recent activities), create, update (partial), delete (soft archive; pass hard=true to remove), heartbeat (push from agent runtime), probe (HTTP/OpenClaw liveness probe), log_activity (manual note), list_activities, import_from_mind (enrich from agent-identity docs), seed_known (idempotent upsert of canonical seed), set_status (shortcut update), set_current_job (shortcut update), list_invoices (invoices linked to an agent), link_invoice (attach an existing invoice id), unlink_invoice (detach an invoice id), create_invoice (create a new Invoice Agent draft + link it)"),
+        slug: zod_1.z.string().optional().describe("Agent slug (lowercase, dashes). Required for get/update/delete/heartbeat/probe/activities/set_*."),
+        // create / update fields
+        name: zod_1.z.string().optional().describe("Display name."),
+        description: zod_1.z.string().optional().describe("One-paragraph description of the agent."),
+        status: zod_1.z
+            .enum(["running", "paused", "planned", "archived", "error"])
+            .optional()
+            .describe("Lifecycle status."),
+        cadence: zod_1.z
+            .enum(["continuous", "scheduled", "on-demand"])
+            .optional()
+            .describe("How the agent runs."),
+        host: zod_1.z.string().optional().describe("Host: DO1 / DO2-LEO / local / render / vercel / atlas-droplet / other."),
+        host_address: zod_1.z.string().optional().describe("IP or hostname (e.g. 45.55.233.204)."),
+        port: zod_1.z.number().optional().describe("TCP port if applicable."),
+        health_url: zod_1.z.string().optional().describe("Optional HTTP health endpoint for the probe action."),
+        source_path: zod_1.z.string().optional().describe("Local path to the agent directory (e.g. /Users/anthonyjconti/Documents/Agents/Foo)."),
+        source_repo: zod_1.z.string().optional().describe("Git repo URL when applicable."),
+        mind_identity_doc_id: zod_1.z.string().optional().describe("MIND document id for the agent-identity record."),
+        responsibilities: zod_1.z.array(zod_1.z.string()).optional().describe("Bullet list of what the agent does."),
+        triggers: zod_1.z.array(zod_1.z.string()).optional().describe("Canonical phrases that should invoke this agent."),
+        tags: zod_1.z.array(zod_1.z.string()).optional().describe("Domain tags for filtering."),
+        owner_email: zod_1.z.string().optional().describe("Owner contact (defaults to anthony@theastraway.com)."),
+        expected_interval_seconds: zod_1.z
+            .number()
+            .optional()
+            .describe("Expected heartbeat cadence in seconds; live_status thresholds compute against 2× / 4× this value."),
+        authority_can_autonomous: zod_1.z.array(zod_1.z.string()).optional().describe("Things this agent can do without asking."),
+        authority_requires_approval: zod_1.z.array(zod_1.z.string()).optional().describe("Things that need Anthony's sign-off."),
+        // delete options
+        hard: zod_1.z.boolean().optional().describe("If true with action=delete, permanently remove. Default soft-archives."),
+        // heartbeat fields
+        current_job: zod_1.z.string().optional().describe("What the agent is doing right now (set on heartbeat or set_current_job)."),
+        metrics: zod_1.z.record(zod_1.z.string(), zod_1.z.any()).optional().describe("Arbitrary metrics blob attached to a heartbeat."),
+        note: zod_1.z.string().optional().describe("Free-form note attached to a heartbeat."),
+        source: zod_1.z.string().optional().describe("Source attribution for heartbeats / activities."),
+        // log_activity fields
+        activity_type: zod_1.z.string().optional().describe("Activity type for log_activity (e.g. job_done, job_start, error, note)."),
+        activity_payload: zod_1.z.record(zod_1.z.string(), zod_1.z.any()).optional().describe("Activity payload for log_activity."),
+        // list / list_activities filters
+        list_status: zod_1.z
+            .enum(["running", "paused", "planned", "archived", "error"])
+            .optional()
+            .describe("Filter by status when listing."),
+        list_host: zod_1.z.string().optional().describe("Filter by host when listing."),
+        list_tag: zod_1.z.string().optional().describe("Filter by tag when listing."),
+        include_archived: zod_1.z.boolean().optional().describe("Include archived records when listing (default false)."),
+        limit: zod_1.z.number().optional().describe("Max activities to return for list_activities (default 50)."),
+        // seed_known
+        overwrite: zod_1.z.boolean().optional().describe("If true with action=seed_known, reset existing records to seed defaults."),
+        // invoice linking
+        invoice_id: zod_1.z.string().optional().describe("Invoice id — required for link_invoice / unlink_invoice."),
+        bill_to_name: zod_1.z.string().optional().describe("Recipient name for create_invoice (required)."),
+        bill_to_company: zod_1.z.string().optional().describe("Recipient company for create_invoice."),
+        bill_to_email: zod_1.z.string().optional().describe("Recipient email for create_invoice."),
+        line_item_description: zod_1.z.string().optional().describe("Single line-item description for create_invoice."),
+        quantity: zod_1.z.number().optional().describe("Line-item quantity for create_invoice (default 1)."),
+        unit_price: zod_1.z.number().optional().describe("Line-item unit price for create_invoice (default 0)."),
+        currency: zod_1.z.string().optional().describe("Invoice currency for create_invoice (default USD)."),
+        invoice_notes: zod_1.z.string().optional().describe("Notes shown on the invoice for create_invoice."),
+    }, async (args) => {
+        const { action, slug, name, description, status, cadence, host, host_address, port, health_url, source_path, source_repo, mind_identity_doc_id, responsibilities, triggers, tags, owner_email, expected_interval_seconds, authority_can_autonomous, authority_requires_approval, hard, current_job, metrics, note, source, activity_type, activity_payload, list_status, list_host, list_tag, include_archived, limit, overwrite, invoice_id, bill_to_name, bill_to_company, bill_to_email, line_item_description, quantity, unit_price, currency, invoice_notes, } = args;
+        const requireSlug = (label) => {
+            if (!slug) {
+                return `Error: 'slug' is required for action=${label}.`;
+            }
+            return null;
+        };
+        const buildPayload = () => {
+            const payload = {};
+            if (name !== undefined)
+                payload.name = name;
+            if (description !== undefined)
+                payload.description = description;
+            if (status !== undefined)
+                payload.status = status;
+            if (cadence !== undefined)
+                payload.cadence = cadence;
+            if (host !== undefined)
+                payload.host = host;
+            if (host_address !== undefined)
+                payload.host_address = host_address;
+            if (port !== undefined)
+                payload.port = port;
+            if (health_url !== undefined)
+                payload.health_url = health_url;
+            if (source_path !== undefined)
+                payload.source_path = source_path;
+            if (source_repo !== undefined)
+                payload.source_repo = source_repo;
+            if (mind_identity_doc_id !== undefined)
+                payload.mind_identity_doc_id = mind_identity_doc_id;
+            if (responsibilities !== undefined)
+                payload.responsibilities = responsibilities;
+            if (triggers !== undefined)
+                payload.triggers = triggers;
+            if (tags !== undefined)
+                payload.tags = tags;
+            if (owner_email !== undefined)
+                payload.owner_email = owner_email;
+            if (expected_interval_seconds !== undefined)
+                payload.expected_interval_seconds = expected_interval_seconds;
+            if (current_job !== undefined)
+                payload.current_job = current_job;
+            if (authority_can_autonomous !== undefined || authority_requires_approval !== undefined) {
+                payload.authority = {
+                    can_autonomous: authority_can_autonomous ?? [],
+                    requires_approval: authority_requires_approval ?? [],
+                };
+            }
+            return payload;
+        };
+        try {
+            switch (action) {
+                case "list": {
+                    const result = await client.listAgents({
+                        status: list_status,
+                        host: list_host,
+                        tag: list_tag,
+                        include_archived,
+                    });
+                    const lines = [];
+                    const s = result.stats;
+                    lines.push(`Agent fleet: ${s.total} total · ${s.running} running · ${s.planned} planned · ${s.paused} paused · ${s.error} errored`, `Live: ${s.online} online · ${s.stale} stale · ${s.offline} offline`, "");
+                    for (const a of result.agents) {
+                        const host = a.host ?? "—";
+                        lines.push(`• [${a.status.padEnd(8)}] ${a.slug.padEnd(28)} ${a.live_status.padEnd(7)} host=${host} — ${a.name}`);
+                    }
+                    return { content: [{ type: "text", text: lines.join("\n") }] };
+                }
+                case "get": {
+                    const err = requireSlug("get");
+                    if (err)
+                        return { content: [{ type: "text", text: err }], isError: true };
+                    const detail = await client.getAgent(slug);
+                    const lines = [
+                        `${detail.name} (${detail.slug})`,
+                        `  status=${detail.status} · cadence=${detail.cadence} · live=${detail.live_status}`,
+                        `  host=${detail.host ?? "—"}${detail.host_address ? ` (${detail.host_address})` : ""}`,
+                        `  last_heartbeat=${detail.last_heartbeat ?? "never"} · current_job=${detail.current_job ?? "—"}`,
+                        detail.description ? `  ${detail.description}` : "",
+                        detail.responsibilities.length
+                            ? `  Responsibilities:\n    - ${detail.responsibilities.join("\n    - ")}`
+                            : "",
+                        detail.tags.length ? `  Tags: ${detail.tags.join(", ")}` : "",
+                        detail.recent_activities?.length
+                            ? `  Recent activity: ${detail.recent_activities
+                                .slice(0, 5)
+                                .map((e) => `${e.type}@${e.ts.slice(0, 19)}`)
+                                .join(" · ")}`
+                            : "",
+                    ].filter(Boolean);
+                    return { content: [{ type: "text", text: lines.join("\n") }] };
+                }
+                case "create": {
+                    if (!slug || !name) {
+                        return {
+                            content: [
+                                { type: "text", text: "Error: 'slug' and 'name' are required for create." },
+                            ],
+                            isError: true,
+                        };
+                    }
+                    const payload = { slug, name, ...buildPayload() };
+                    const created = await client.createAgent(payload);
+                    return {
+                        content: [
+                            { type: "text", text: `✅ Created agent: ${created.slug} (status=${created.status})` },
+                        ],
+                    };
+                }
+                case "update": {
+                    const err = requireSlug("update");
+                    if (err)
+                        return { content: [{ type: "text", text: err }], isError: true };
+                    const payload = buildPayload();
+                    if (Object.keys(payload).length === 0) {
+                        return {
+                            content: [
+                                { type: "text", text: "Error: provide at least one field to update." },
+                            ],
+                            isError: true,
+                        };
+                    }
+                    const updated = await client.updateAgent(slug, payload);
+                    return {
+                        content: [
+                            { type: "text", text: `✅ Updated ${updated.slug} (status=${updated.status}, live=${updated.live_status})` },
+                        ],
+                    };
+                }
+                case "delete": {
+                    const err = requireSlug("delete");
+                    if (err)
+                        return { content: [{ type: "text", text: err }], isError: true };
+                    const result = await client.deleteAgent(slug, !!hard);
+                    return {
+                        content: [
+                            { type: "text", text: `✅ ${result.hard ? "Deleted" : "Archived"} ${result.deleted}` },
+                        ],
+                    };
+                }
+                case "heartbeat": {
+                    const err = requireSlug("heartbeat");
+                    if (err)
+                        return { content: [{ type: "text", text: err }], isError: true };
+                    const updated = await client.agentHeartbeat(slug, {
+                        current_job,
+                        metrics,
+                        note,
+                        source: source ?? "mcp-agent",
+                    });
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `💓 heartbeat ${updated.slug} → live=${updated.live_status}${updated.current_job ? ` · job="${updated.current_job}"` : ""}`,
+                            },
+                        ],
+                    };
+                }
+                case "probe": {
+                    const err = requireSlug("probe");
+                    if (err)
+                        return { content: [{ type: "text", text: err }], isError: true };
+                    const result = await client.agentProbe(slug);
+                    const p = result.probe;
+                    const summary = p.ok
+                        ? `✅ ${p.probe_kind ?? "probe"} OK · ${p.status_code ?? ""} · ${p.latency_ms ?? "?"}ms${p.endpoint ? ` · ${p.endpoint}` : ""}`
+                        : `❌ ${p.probe_kind ?? "probe"} failed: ${p.error ?? "no signal"}`;
+                    return { content: [{ type: "text", text: summary }] };
+                }
+                case "log_activity": {
+                    const err = requireSlug("log_activity");
+                    if (err)
+                        return { content: [{ type: "text", text: err }], isError: true };
+                    const activity = await client.logAgentActivity(slug, {
+                        type: activity_type ?? "note",
+                        payload: activity_payload,
+                        source: source ?? "mcp-agent",
+                    });
+                    return {
+                        content: [
+                            { type: "text", text: `📝 ${activity.type} logged for ${slug} (${activity.activity_id})` },
+                        ],
+                    };
+                }
+                case "list_activities": {
+                    const err = requireSlug("list_activities");
+                    if (err)
+                        return { content: [{ type: "text", text: err }], isError: true };
+                    const result = await client.listAgentActivities(slug, limit ?? 50);
+                    if (!result.activities.length) {
+                        return { content: [{ type: "text", text: `No activity for ${slug}.` }] };
+                    }
+                    const lines = result.activities.map((e) => `  ${e.ts} · ${e.type.padEnd(15)} · src=${e.source}`);
+                    return { content: [{ type: "text", text: lines.join("\n") }] };
+                }
+                case "import_from_mind": {
+                    const result = await client.importAgentsFromMind();
+                    if (result.error) {
+                        return {
+                            content: [{ type: "text", text: `⚠️ import-from-mind: ${result.error}` }],
+                            isError: true,
+                        };
+                    }
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `✅ Enriched ${result.enriched} agent(s) from MIND identity docs (${result.skipped} skipped). Slugs: ${result.matched_slugs.join(", ") || "—"}`,
+                            },
+                        ],
+                    };
+                }
+                case "seed_known": {
+                    const result = await client.seedKnownAgents(!!overwrite);
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `✅ Seed: +${result.inserted} new · ${result.updated} updated · ${result.skipped} unchanged · ${result.total_known} canonical`,
+                            },
+                        ],
+                    };
+                }
+                case "set_status": {
+                    const err = requireSlug("set_status");
+                    if (err)
+                        return { content: [{ type: "text", text: err }], isError: true };
+                    if (!status) {
+                        return {
+                            content: [{ type: "text", text: "Error: 'status' is required for set_status." }],
+                            isError: true,
+                        };
+                    }
+                    const updated = await client.updateAgent(slug, { status });
+                    return {
+                        content: [
+                            { type: "text", text: `✅ ${updated.slug} → status=${updated.status}` },
+                        ],
+                    };
+                }
+                case "set_current_job": {
+                    const err = requireSlug("set_current_job");
+                    if (err)
+                        return { content: [{ type: "text", text: err }], isError: true };
+                    if (current_job === undefined) {
+                        return {
+                            content: [
+                                { type: "text", text: "Error: 'current_job' is required for set_current_job." },
+                            ],
+                            isError: true,
+                        };
+                    }
+                    const updated = await client.updateAgent(slug, { current_job });
+                    return {
+                        content: [
+                            { type: "text", text: `✅ ${updated.slug} → current_job="${updated.current_job ?? ""}"` },
+                        ],
+                    };
+                }
+                case "list_invoices": {
+                    const err = requireSlug("list_invoices");
+                    if (err)
+                        return { content: [{ type: "text", text: err }], isError: true };
+                    const result = await client.listAgentInvoices(slug);
+                    if (!result.invoices.length) {
+                        return { content: [{ type: "text", text: `No invoices linked to ${slug}.` }] };
+                    }
+                    const lines = result.invoices.map((i) => `  ${i.invoice_number.padEnd(10)} ${i.status.padEnd(8)} ${i.currency} ${i.total
+                        .toFixed(2)
+                        .padStart(10)} — ${i.bill_to_company ?? i.bill_to_name ?? "—"}`);
+                    return {
+                        content: [
+                            { type: "text", text: `Invoices linked to ${slug}:\n${lines.join("\n")}` },
+                        ],
+                    };
+                }
+                case "link_invoice": {
+                    const err = requireSlug("link_invoice");
+                    if (err)
+                        return { content: [{ type: "text", text: err }], isError: true };
+                    if (!invoice_id) {
+                        return {
+                            content: [{ type: "text", text: "Error: 'invoice_id' is required for link_invoice." }],
+                            isError: true,
+                        };
+                    }
+                    const updated = await client.linkAgentInvoice(slug, invoice_id);
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `🔗 Linked invoice ${invoice_id} to ${updated.slug} (${updated.linked_invoices.length} total).`,
+                            },
+                        ],
+                    };
+                }
+                case "unlink_invoice": {
+                    const err = requireSlug("unlink_invoice");
+                    if (err)
+                        return { content: [{ type: "text", text: err }], isError: true };
+                    if (!invoice_id) {
+                        return {
+                            content: [{ type: "text", text: "Error: 'invoice_id' is required for unlink_invoice." }],
+                            isError: true,
+                        };
+                    }
+                    const updated = await client.unlinkAgentInvoice(slug, invoice_id);
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `✂️ Unlinked invoice ${invoice_id} from ${updated.slug} (${updated.linked_invoices.length} remain).`,
+                            },
+                        ],
+                    };
+                }
+                case "create_invoice": {
+                    const err = requireSlug("create_invoice");
+                    if (err)
+                        return { content: [{ type: "text", text: err }], isError: true };
+                    if (!bill_to_name) {
+                        return {
+                            content: [
+                                { type: "text", text: "Error: 'bill_to_name' is required for create_invoice." },
+                            ],
+                            isError: true,
+                        };
+                    }
+                    const invoicePayload = {
+                        bill_from: {
+                            name: "Anthony Conti",
+                            company: "Astra AI, Inc.",
+                            email: "anthony@theastraway.com",
+                        },
+                        bill_to: {
+                            name: bill_to_name,
+                            company: bill_to_company ?? null,
+                            email: bill_to_email ?? null,
+                        },
+                        line_items: line_item_description
+                            ? [
+                                {
+                                    description: line_item_description,
+                                    quantity: quantity ?? 1,
+                                    unit_price: unit_price ?? 0,
+                                },
+                            ]
+                            : [],
+                        currency: currency ?? "USD",
+                    };
+                    if (invoice_notes)
+                        invoicePayload.notes = invoice_notes;
+                    const res = await client.createAgentInvoice(slug, invoicePayload);
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `🧾 Created invoice ${res.invoice.invoice_number} (${res.invoice.currency} ${res.invoice.total.toFixed(2)}) and linked it to ${slug}.`,
+                            },
+                        ],
+                    };
+                }
+            }
+        }
+        catch (err) {
+            return {
+                content: [{ type: "text", text: `mind_agents error: ${err}` }],
+                isError: true,
+            };
+        }
+    });
+    // ─── mind_accounts ──────────────────────────────────────
+    // Multi-MIND accounts: discover the MINDs this key's owner can access,
+    // create new ones, and manage owners / viewers. Requires the server to
+    // have MULTI_MIND_ACCOUNTS_ENABLED set.
+    server.tool("mind_accounts", "Manage multi-MIND accounts. A 'MIND' is a knowledge-graph account; one person can own or be granted access to many. Use to discover every MIND you can access (list), spin up a new one (create), permanently delete one (delete), see who can access a MIND (members), grant an existing user access (grant), or email an invitation (invite).", {
+        action: zod_1.z
+            .enum(["list", "create", "delete", "members", "grant", "invite"])
+            .describe("list (every MIND you can access), create (a new MIND you own), delete (permanently delete a MIND you own), members (owners/viewers of a MIND), grant (give an existing user access), invite (email an invitation)"),
+        label: zod_1.z
+            .string()
+            .optional()
+            .describe("Display name for the new MIND (required for create)"),
+        mind_username: zod_1.z
+            .string()
+            .optional()
+            .describe("Username of the MIND to manage (required for delete/members/grant/invite)"),
+        grantee_username: zod_1.z
+            .string()
+            .optional()
+            .describe("Existing MINDapp username to grant access to (required for grant)"),
+        email: zod_1.z
+            .string()
+            .optional()
+            .describe("Email address to send an invitation to (required for invite)"),
+        role: zod_1.z
+            .enum(["owner", "viewer"])
+            .optional()
+            .default("owner")
+            .describe("Access level: owner (full access) or viewer (read-only)"),
+    }, async ({ action, label, mind_username, grantee_username, email, role }) => {
+        try {
+            switch (action) {
+                case "list": {
+                    const res = await client.listMinds();
+                    if (!res.enabled) {
+                        return {
+                            content: [
+                                {
+                                    type: "text",
+                                    text: "Multi-MIND accounts are not enabled for this MIND.",
+                                },
+                            ],
+                        };
+                    }
+                    const lines = res.accounts.map((a) => `${a.is_active ? "▸" : " "} ${a.label} (@${a.username}) — ${a.role}${a.is_self ? " · you" : ""}`);
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `MINDs you can access (${res.accounts.length}):\n${lines.join("\n")}`,
+                            },
+                        ],
+                    };
+                }
+                case "create": {
+                    if (!label) {
+                        return {
+                            content: [{ type: "text", text: "Error: label is required for create" }],
+                            isError: true,
+                        };
+                    }
+                    const res = await client.createMind(label);
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `✅ Created MIND "${res.label}" (@${res.username}).`,
+                            },
+                        ],
+                    };
+                }
+                case "delete": {
+                    if (!mind_username) {
+                        return {
+                            content: [{ type: "text", text: "Error: mind_username is required for delete" }],
+                            isError: true,
+                        };
+                    }
+                    await client.deleteMind(mind_username);
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `✅ Permanently deleted MIND @${mind_username}.`,
+                            },
+                        ],
+                    };
+                }
+                case "members": {
+                    if (!mind_username) {
+                        return {
+                            content: [{ type: "text", text: "Error: mind_username is required for members" }],
+                            isError: true,
+                        };
+                    }
+                    const res = await client.listMindMembers(mind_username);
+                    const members = res.members
+                        .map((m) => `• @${m.username} — ${m.role}${m.is_primary ? " (primary)" : ""}`)
+                        .join("\n");
+                    const invites = res.pending_invites.length
+                        ? "\nPending invites:\n" +
+                            res.pending_invites.map((i) => `• ${i.email} — ${i.role}`).join("\n")
+                        : "";
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `Members of @${res.mind_username}:\n${members}${invites}`,
+                            },
+                        ],
+                    };
+                }
+                case "grant": {
+                    if (!mind_username || !grantee_username) {
+                        return {
+                            content: [
+                                {
+                                    type: "text",
+                                    text: "Error: mind_username and grantee_username are required for grant",
+                                },
+                            ],
+                            isError: true,
+                        };
+                    }
+                    await client.grantMindMember(mind_username, grantee_username, role);
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `✅ Granted @${grantee_username} ${role} access to @${mind_username}.`,
+                            },
+                        ],
+                    };
+                }
+                case "invite": {
+                    if (!mind_username || !email) {
+                        return {
+                            content: [
+                                {
+                                    type: "text",
+                                    text: "Error: mind_username and email are required for invite",
+                                },
+                            ],
+                            isError: true,
+                        };
+                    }
+                    const res = await client.createMindInvite(mind_username, email, role);
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `✅ Invitation sent to ${res.email} (${res.role}) for @${mind_username}.`,
+                            },
+                        ],
+                    };
+                }
+            }
+        }
+        catch (err) {
+            return {
+                content: [{ type: "text", text: `mind_accounts error: ${err}` }],
+                isError: true,
+            };
+        }
+    });
     return server;
 }
 //# sourceMappingURL=server.js.map