@astramindapp/mcp-server 0.17.0 → 0.19.0

package/dist/server.js

@@ -293,15 +293,15 @@ function createMindMcpServer(client) {
     // ─── mind_folders ───────────────────────────────────────
     // Organize documents into folders. Folders are a presentation layer — the
     // knowledge graph still indexes every document regardless of folder.
-    server.tool("mind_folders", "Organize your MIND documents into folders. Folders are a presentation layer — the knowledge graph still indexes and retrieves across every document regardless of folder. Use mind_remember to create a document, then mind_folders move_documents to file it. Actions: list, create, rename, move, delete, move_documents.", {
+    server.tool("mind_folders", "Organize your MIND documents into folders. Folders are a presentation layer — the knowledge graph still indexes and retrieves across every document regardless of folder. Use mind_remember to create a document, then mind_folders move_documents to file it. Actions: list, create, rename, move, delete, move_documents, set_hint (set the agent-routing hint read by mind_folder_suggest).", {
         action: zod_1.z
-            .enum(["list", "create", "rename", "move", "delete", "move_documents"])
-            .describe("list (all folders + counts), create (new folder), rename (change a folder's name), move (re-nest a folder), delete (remove a folder — its documents and subfolders move up a level, nothing is deleted), move_documents (file documents into a folder)"),
+            .enum(["list", "create", "rename", "move", "delete", "move_documents", "set_hint"])
+            .describe("list (all folders + counts + routing hints), create (new folder; pass routing_hint to enable agent-routing), rename (change a folder's name), move (re-nest a folder), delete (remove a folder — its documents and subfolders move up a level, nothing is deleted), move_documents (file documents into a folder), set_hint (write/clear the routing_hint that mind_folder_suggest reads)"),
         name: zod_1.z.string().optional().describe("Folder name — required for create and rename"),
         folder_id: zod_1.z
             .string()
             .optional()
-            .describe("Folder id — the folder to rename/move/delete, or the destination for move_documents (omit or pass 'root' to file documents at the top level)"),
+            .describe("Folder id — the folder to rename/move/delete/set_hint, or the destination for move_documents (omit or pass 'root' to file documents at the top level)"),
         parent_id: zod_1.z
             .string()
             .optional()
@@ -310,7 +310,11 @@ function createMindMcpServer(client) {
             .array(zod_1.z.string())
             .optional()
             .describe("Document ids to file — required for move_documents"),
-    }, async ({ action, name, folder_id, parent_id, doc_ids }) => {
+        routing_hint: zod_1.z
+            .string()
+            .optional()
+            .describe("Free-text instruction answering \"when should MIND save things to this folder?\". Read by mind_folder_suggest to LLM-route new content. Pass on create to set up-front; pass on set_hint to update. Pass empty string to clear (disables the folder from auto-routing)."),
+    }, async ({ action, name, folder_id, parent_id, doc_ids, routing_hint }) => {
         try {
             switch (action) {
                 case "list": {
@@ -328,7 +332,9 @@ function createMindMcpServer(client) {
                     const byId = new Map(res.folders.map((f) => [f.id, f]));
                     const lines = res.folders.map((f) => {
                         const parent = f.parent_id ? byId.get(f.parent_id)?.name ?? "?" : "(top level)";
-                        return `• ${f.name} — ${f.document_count ?? 0} doc(s) · id: ${f.id} · parent: ${parent}`;
+                        const hint = (f.routing_hint || "").trim();
+                        const hintTail = hint ? ` · hint: ${hint.length > 80 ? hint.slice(0, 80) + "…" : hint}` : "";
+                        return `• ${f.name} — ${f.document_count ?? 0} doc(s) · id: ${f.id} · parent: ${parent}${hintTail}`;
                     });
                     return {
                         content: [
@@ -346,10 +352,10 @@ function createMindMcpServer(client) {
                 case "create": {
                     if (!name)
                         throw new Error("'name' is required to create a folder");
-                    const res = await client.createFolder(name, parent_id ?? null);
+                    const res = await client.createFolder(name, parent_id ?? null, routing_hint);
                     return {
                         content: [
-                            { type: "text", text: `Created folder "${res.folder.name}" (id: ${res.folder.id})` },
+                            { type: "text", text: `Created folder "${res.folder.name}" (id: ${res.folder.id})${routing_hint ? " · routing hint set" : ""}` },
                         ],
                     };
                 }
@@ -404,6 +410,24 @@ function createMindMcpServer(client) {
                         ],
                     };
                 }
+                case "set_hint": {
+                    if (!folder_id)
+                        throw new Error("'folder_id' is required to set a routing hint");
+                    if (routing_hint === undefined)
+                        throw new Error("'routing_hint' is required for set_hint (pass empty string to clear)");
+                    const res = await client.updateFolder(folder_id, { routing_hint });
+                    const cleared = !routing_hint.trim();
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: cleared
+                                    ? `Cleared routing hint on "${res.folder.name}" — folder is no longer auto-routed.`
+                                    : `Routing hint set on "${res.folder.name}". mind_folder_suggest will now consider this folder.`,
+                            },
+                        ],
+                    };
+                }
                 default:
                     throw new Error(`Unknown action: ${action}`);
             }
@@ -415,6 +439,154 @@ function createMindMcpServer(client) {
             };
         }
     });
+    // ─── mind_folder_routes ─────────────────────────────────
+    // Deterministic per-source_type system-folder routing. Configure once
+    // and every life_item / crm / chat-save / etc. lands in its designated
+    // folder automatically. ``apply_recommended`` is the one-tap setup.
+    server.tool("mind_folder_routes", "Configure deterministic system-folder routing — which folder each kind of system-generated doc (life items, CRM, chat saves, tasks, training, reasoning trajectories, playbooks, trader signals, cloud imports) is filed into automatically. Actions: list, set, clear, apply_recommended (idempotent one-tap setup that creates Life/CRM/Chats/Reasoning/Trader folders and wires every source_type to its destination). User uploads are unaffected — this is system writes only.", {
+        action: zod_1.z
+            .enum(["list", "set", "clear", "apply_recommended"])
+            .describe("list (current routing table + every supported source_type with label/description), set (route one source_type to a folder), clear (remove a route — that source_type goes to the top level again), apply_recommended (create Life/CRM/Chats/Reasoning/Trader folders if missing and wire all routes; idempotent and safe to re-run)"),
+        source_type: zod_1.z
+            .string()
+            .optional()
+            .describe("Required for set and clear. Canonical values: life_item, task, crm, chat, training, trajectory, playbook, trader, document. Custom values accepted (the route will fire whenever save_document_record is called with that source_type)."),
+        folder_id: zod_1.z
+            .string()
+            .optional()
+            .describe("Required for set — the folder id to route this source_type into."),
+    }, async ({ action, source_type, folder_id }) => {
+        try {
+            switch (action) {
+                case "list": {
+                    const res = await client.listFolderRoutes();
+                    const folders = await client.listFolders();
+                    const folderById = new Map(folders.folders.map((f) => [f.id, f]));
+                    const lines = res.categories.map((cat) => {
+                        const fid = res.routes[cat.source_type];
+                        const folder = fid ? folderById.get(fid) : null;
+                        const dest = folder
+                            ? `→ ${folder.name} (id: ${fid})`
+                            : "→ (unrouted — files at top level)";
+                        return `• ${cat.label} [${cat.source_type}] ${dest}\n  ${cat.description}`;
+                    });
+                    const configured = Object.keys(res.routes).length;
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: [
+                                    `${configured}/${res.categories.length} routes configured.`,
+                                    "",
+                                    ...lines,
+                                ].join("\n"),
+                            },
+                        ],
+                    };
+                }
+                case "set": {
+                    if (!source_type)
+                        throw new Error("'source_type' is required");
+                    if (!folder_id)
+                        throw new Error("'folder_id' is required for set");
+                    await client.setFolderRoute(source_type, folder_id);
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `Routed source_type "${source_type}" → folder ${folder_id}. Future writes of that type will file there automatically.`,
+                            },
+                        ],
+                    };
+                }
+                case "clear": {
+                    if (!source_type)
+                        throw new Error("'source_type' is required");
+                    await client.clearFolderRoute(source_type);
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `Cleared route for "${source_type}". Future writes of that type land at the top level.`,
+                            },
+                        ],
+                    };
+                }
+                case "apply_recommended": {
+                    const res = await client.applyRecommendedFolders();
+                    const lines = [];
+                    if (res.created.length)
+                        lines.push(`Created: ${res.created.join(", ")}`);
+                    if (res.reused.length)
+                        lines.push(`Reused: ${res.reused.join(", ")}`);
+                    if (res.hint_updated.length)
+                        lines.push(`Hints filled: ${res.hint_updated.join(", ")}`);
+                    lines.push("");
+                    lines.push(`${res.routes_set.length} routes set:`);
+                    for (const r of res.routes_set) {
+                        lines.push(`  • ${r.source_type} → ${r.folder_name}`);
+                    }
+                    return { content: [{ type: "text", text: lines.join("\n") }] };
+                }
+                default:
+                    throw new Error(`Unknown action: ${action}`);
+            }
+        }
+        catch (err) {
+            return {
+                content: [
+                    { type: "text", text: `Error managing folder routes: ${err}` },
+                ],
+                isError: true,
+            };
+        }
+    });
+    // ─── mind_folder_suggest ─────────────────────────────────
+    // LLM-driven content-aware folder picker. Reads every folder's
+    // routing_hint and chooses the best match (or null when nothing fits).
+    server.tool("mind_folder_suggest", "Ask MIND which folder a piece of content belongs in. Reads every folder's routing_hint (set via mind_folders set_hint) and uses a cheap LLM to pick the best match. Returns folder_id=null when no folder's hint clearly applies — in that case leave the doc unfiled rather than guess. Typical agent flow: suggest → mind_remember (create the doc) → mind_folders move_documents (file it to the suggested folder).", {
+        content: zod_1.z
+            .string()
+            .describe("The text of the new document you're about to file. The picker reads it against every folder's routing_hint."),
+        title: zod_1.z
+            .string()
+            .optional()
+            .describe("Optional title — helps the picker disambiguate short content."),
+    }, async ({ content, title }) => {
+        try {
+            const res = await client.suggestFolder(content, title);
+            if (!res.folder_id) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `No folder match — ${res.reason}\n\nLeave the doc unfiled or call mind_folder_routes apply_recommended to set up the default folder layout.`,
+                        },
+                    ],
+                };
+            }
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: [
+                            `Suggested folder: ${res.folder_name} (id: ${res.folder_id})`,
+                            `Confidence: ${Math.round(res.confidence * 100)}%`,
+                            `Reason: ${res.reason}`,
+                        ].join("\n"),
+                    },
+                ],
+            };
+        }
+        catch (err) {
+            return {
+                content: [
+                    { type: "text", text: `Error suggesting folder: ${err}` },
+                ],
+                isError: true,
+            };
+        }
+    });
     // ─── mind_context ───────────────────────────────────────
     // Get structured always-loaded context.
     // Equivalent to OpenClaw's SOUL.md + USER.md + AGENTS.md bootstrap injection,
@@ -453,7 +625,7 @@ function createMindMcpServer(client) {
     // ─── mind_life ──────────────────────────────────────────
     // 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.", {
+    server.tool("mind_life", "Manage Focus → Project → Outcome hierarchy + calendar in MIND Life. Items are either projects (top-level domain/client buckets that live inside a Focus) or outcomes (deliverables that live under a parent project). Use `item_type` + `parent_id` + `focus_id` on create/update to wire the hierarchy. Use list filters (item_type, parent_id, focus_id, top_level_only) to slice the board.", {
         action: zod_1.z
             .enum([
             "list", "create", "update", "complete", "delete", "bulk_delete", "move", "get",
@@ -484,17 +656,61 @@ function createMindMcpServer(client) {
             .optional()
             .describe("Left-border color stripe on the board card. Use to group items (e.g. Astra=red, Atlas=blue)."),
         target_date: zod_1.z.string().optional().describe("Target completion date in YYYY-MM-DD format — when the project should be done. Powers the countdown badge on the card."),
-    }, async ({ action, title, description, status, priority, due_date, item_id, item_ids, start_time, end_time, event_id, all_day, tags, color, target_date }) => {
+        item_type: zod_1.z
+            .enum(["project", "outcome"])
+            .optional()
+            .describe("'project' (top-level domain/client bucket; lives inside a Focus) or 'outcome' (deliverable under a parent project). Defaults to 'outcome' on create. Pass on list to filter."),
+        parent_id: zod_1.z
+            .string()
+            .optional()
+            .describe("For outcomes — the item_id of the parent project. Pass empty string on update to detach (make top-level). On list, pass an item_id to fetch its outcomes, or 'none' for items with no parent."),
+        focus_id: zod_1.z
+            .string()
+            .optional()
+            .describe("For projects — the focus_id this project belongs to. Pass empty string on update to detach (No Focus). On list, pass a focus_id to filter to that focus, or 'none' for unfiled projects."),
+        agent_ids: zod_1.z.array(zod_1.z.string()).optional().describe("Agents bound to this project (project only). On update, REPLACES the existing list."),
+        workflow_ids: zod_1.z.array(zod_1.z.string()).optional().describe("Workflows bound to this project (project only). On update, REPLACES the existing list."),
+        top_level_only: zod_1.z.boolean().optional().describe("On list — true returns only items with no parent (board roots: projects + unassigned outcomes)."),
+        include_completed: zod_1.z.boolean().optional().describe("On list — false hides completed items. Defaults true."),
+        limit: zod_1.z.number().int().min(1).max(500).optional().describe("On list — max items to return (1–500, default 30)."),
+    }, async ({ action, title, description, status, priority, due_date, item_id, item_ids, start_time, end_time, event_id, all_day, tags, color, target_date, item_type, parent_id, focus_id, agent_ids, workflow_ids, top_level_only, include_completed, limit }) => {
         try {
             switch (action) {
                 case "list": {
-                    const result = await client.listLifeItems(status);
+                    const result = await client.listLifeItems({
+                        status,
+                        item_type,
+                        parent_id,
+                        focus_id,
+                        top_level_only,
+                        include_completed,
+                        limit,
+                    });
                     const items = result.items ?? [];
                     if (items.length === 0) {
                         return { content: [{ type: "text", text: "No life items found." }] };
                     }
-                    const lines = items.map((i) => `• [${i.priority ?? "—"}] ${i.title} (status: ${i.status ?? "—"}${i.due_date ? `, due: ${i.due_date}` : ""}) — id: ${i.item_id}`);
-                    return { content: [{ type: "text", text: lines.join("\n") }] };
+                    const lines = items.map((i) => {
+                        const tag = i.item_type === "project" ? "📁 project" : "🎯 outcome";
+                        const parts = [`[${i.priority ?? "—"}] ${tag} ${i.title}`];
+                        parts.push(`status: ${i.status ?? "—"}`);
+                        if (i.due_date)
+                            parts.push(`due: ${i.due_date}`);
+                        if (i.item_type === "project") {
+                            if (i.focus_id)
+                                parts.push(`focus: ${i.focus_id}`);
+                            if (typeof i.subtask_count === "number")
+                                parts.push(`outcomes: ${i.subtasks_completed ?? 0}/${i.subtask_count}`);
+                        }
+                        else if (i.parent_id) {
+                            parts.push(`parent: ${i.parent_id}`);
+                        }
+                        return `• ${parts.join(" · ")} — id: ${i.item_id}`;
+                    });
+                    const header = typeof result.total === "number" ? `Showing ${items.length} of ${result.total} items.` : null;
+                    return {
+                        content: [{ type: "text", text: [header, ...lines].filter(Boolean).join("\n") }],
+                    };
                 }
                 case "create": {
                     if (!title) {
@@ -512,8 +728,19 @@ function createMindMcpServer(client) {
                         tags,
                         color,
                         target_date,
+                        item_type,
+                        parent_id,
+                        focus_id,
+                        agent_ids,
+                        workflow_ids,
                     });
                     const extras = [];
+                    if (result.item_type)
+                        extras.push(`type: ${result.item_type}`);
+                    if (result.parent_id)
+                        extras.push(`parent: ${result.parent_id}`);
+                    if (result.focus_id)
+                        extras.push(`focus: ${result.focus_id}`);
                     if (result.tags && result.tags.length > 0)
                         extras.push(`tags: ${result.tags.join(", ")}`);
                     if (result.color && result.color !== "default")
@@ -539,22 +766,39 @@ function createMindMcpServer(client) {
                     const patch = {};
                     if (title)
                         patch.title = title;
-                    if (description)
+                    if (description !== undefined)
                         patch.description = description;
                     if (status)
                         patch.status = status;
                     if (priority)
                         patch.priority = priority;
-                    if (due_date)
+                    if (due_date !== undefined)
                         patch.due_date = due_date;
                     if (tags)
                         patch.tags = tags;
                     if (color)
                         patch.color = color;
-                    if (target_date)
+                    if (target_date !== undefined)
                         patch.target_date = target_date;
+                    if (item_type !== undefined)
+                        patch.item_type = item_type;
+                    // parent_id / focus_id: pass empty string explicitly to clear; pass undefined to leave unchanged
+                    if (parent_id !== undefined)
+                        patch.parent_id = parent_id;
+                    if (focus_id !== undefined)
+                        patch.focus_id = focus_id;
+                    if (agent_ids !== undefined)
+                        patch.agent_ids = agent_ids;
+                    if (workflow_ids !== undefined)
+                        patch.workflow_ids = workflow_ids;
                     const result = await client.updateLifeItem(item_id, patch);
                     const extras = [];
+                    if (result.item_type)
+                        extras.push(`type: ${result.item_type}`);
+                    if (result.parent_id)
+                        extras.push(`parent: ${result.parent_id}`);
+                    if (result.focus_id)
+                        extras.push(`focus: ${result.focus_id}`);
                     if (result.tags && result.tags.length > 0)
                         extras.push(`tags: ${result.tags.join(", ")}`);
                     if (result.color && result.color !== "default")
@@ -625,16 +869,25 @@ function createMindMcpServer(client) {
                         };
                     }
                     const result = await client.getLifeItem(item_id);
+                    const r = result;
                     const lines = [
-                        `**${result.title}**`,
+                        `**${result.title}** (id: ${result.item_id})`,
                         `Status: ${result.status ?? "—"} | Priority: ${result.priority ?? "—"} | Due: ${result.due_date ?? "none"}`,
+                        `Type: ${r.item_type ?? "outcome"}${r.parent_id ? ` | Parent: ${r.parent_id}` : ""}${r.focus_id ? ` | Focus: ${r.focus_id}` : ""}`,
                     ];
-                    if (result.color && result.color !== "default")
-                        lines.push(`Color: ${result.color}`);
-                    if (result.target_date)
-                        lines.push(`Target: ${result.target_date}`);
-                    if (result.tags && result.tags.length > 0)
-                        lines.push(`Tags: ${result.tags.join(", ")}`);
+                    if (r.item_type === "project" && typeof r.subtask_count === "number") {
+                        lines.push(`Outcomes: ${r.subtasks_completed ?? 0}/${r.subtask_count} complete`);
+                    }
+                    if (r.agent_ids && r.agent_ids.length > 0)
+                        lines.push(`Agents: ${r.agent_ids.join(", ")}`);
+                    if (r.workflow_ids && r.workflow_ids.length > 0)
+                        lines.push(`Workflows: ${r.workflow_ids.join(", ")}`);
+                    if (r.color && r.color !== "default")
+                        lines.push(`Color: ${r.color}`);
+                    if (r.target_date)
+                        lines.push(`Target: ${r.target_date}`);
+                    if (r.tags && r.tags.length > 0)
+                        lines.push(`Tags: ${r.tags.join(", ")}`);
                     if (result.description)
                         lines.push(`\n${result.description}`);
                     return { content: [{ type: "text", text: lines.join("\n") }] };
@@ -729,6 +982,129 @@ function createMindMcpServer(client) {
             };
         }
     });
+    // ─── mind_focuses ──────────────────────────────────────
+    // Top of the Focus → Project → Outcome → Task hierarchy.
+    // A Focus is a per-user bucket that groups multiple Life Projects, and
+    // can carry shared agents/workflows that apply to every project inside.
+    server.tool("mind_focuses", "Manage Focuses — the top-level buckets that group Life Projects. Every project lives inside one focus (or 'No Focus'). Use list to see all focuses + their project counts, create to add a new bucket (e.g. 'Astra', 'Atlas', 'Fundraising'), update/delete to maintain them. Pass the returned focus_id to mind_life when creating projects.", {
+        action: zod_1.z
+            .enum(["list", "get", "create", "update", "delete"])
+            .describe("list/get/create/update/delete focuses. 'delete' soft-archives by default; pass hard=true to remove permanently."),
+        focus_id: zod_1.z.string().optional().describe("Focus id — required for get/update/delete"),
+        name: zod_1.z.string().optional().describe("Display name — required for create"),
+        description: zod_1.z.string().optional().describe("Long-form description"),
+        color: zod_1.z
+            .enum(["default", "red", "orange", "yellow", "green", "blue", "purple", "pink"])
+            .optional()
+            .describe("Color stripe used in the UI"),
+        icon: zod_1.z.string().optional().describe("Lucide icon name (e.g. 'briefcase', 'rocket'). Defaults to 'folder'."),
+        position: zod_1.z.number().int().optional().describe("Sort position (lower = earlier)"),
+        agent_ids: zod_1.z.array(zod_1.z.string()).optional().describe("Agents bound to every project inside this focus. On update, REPLACES the existing list."),
+        workflow_ids: zod_1.z.array(zod_1.z.string()).optional().describe("Workflows bound to every project inside this focus. On update, REPLACES the existing list."),
+        include_archived: zod_1.z.boolean().optional().describe("On list — true to include archived focuses (default false)"),
+        hard: zod_1.z.boolean().optional().describe("On delete — true to remove permanently (default false = soft archive)"),
+    }, async ({ action, focus_id, name, description, color, icon, position, agent_ids, workflow_ids, include_archived, hard }) => {
+        try {
+            switch (action) {
+                case "list": {
+                    const result = await client.listFocuses(include_archived ?? false);
+                    const focuses = result.focuses ?? [];
+                    if (focuses.length === 0 && (result.unfiled_project_count ?? 0) === 0) {
+                        return { content: [{ type: "text", text: "No focuses yet. Create one with action='create'." }] };
+                    }
+                    const lines = focuses.map((f) => {
+                        const c = f.color && f.color !== "default" ? ` (${f.color})` : "";
+                        const counts = `${f.project_count_active ?? 0} active / ${f.project_count ?? 0} total`;
+                        return `• 📁 ${f.name}${c} — ${counts} projects — id: ${f.focus_id}`;
+                    });
+                    if (typeof result.unfiled_project_count === "number" && result.unfiled_project_count > 0) {
+                        lines.push(`• 🗂  No Focus — ${result.unfiled_project_count} unfiled project(s)`);
+                    }
+                    return { content: [{ type: "text", text: lines.join("\n") }] };
+                }
+                case "get": {
+                    if (!focus_id) {
+                        return { content: [{ type: "text", text: "Error: focus_id is required for get" }], isError: true };
+                    }
+                    const f = await client.getFocus(focus_id);
+                    const lines = [
+                        `**${f.name}** (id: ${f.focus_id})`,
+                        `Color: ${f.color ?? "default"} | Icon: ${f.icon ?? "folder"} | Position: ${f.position ?? 0}`,
+                        `Projects: ${f.project_count_active ?? 0} active / ${f.project_count_completed ?? 0} completed / ${f.project_count ?? 0} total`,
+                    ];
+                    if (f.agent_ids && f.agent_ids.length > 0)
+                        lines.push(`Agents: ${f.agent_ids.join(", ")}`);
+                    if (f.workflow_ids && f.workflow_ids.length > 0)
+                        lines.push(`Workflows: ${f.workflow_ids.join(", ")}`);
+                    if (f.archived_at)
+                        lines.push(`Archived at: ${f.archived_at}`);
+                    if (f.description)
+                        lines.push(`\n${f.description}`);
+                    return { content: [{ type: "text", text: lines.join("\n") }] };
+                }
+                case "create": {
+                    if (!name) {
+                        return { content: [{ type: "text", text: "Error: name is required to create a focus" }], isError: true };
+                    }
+                    const f = await client.createFocus({
+                        name,
+                        description,
+                        color,
+                        icon,
+                        position,
+                        agent_ids,
+                        workflow_ids,
+                    });
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `✅ Created focus: "${f.name}" (id: ${f.focus_id}, color: ${f.color ?? "default"}, icon: ${f.icon ?? "folder"})`,
+                            },
+                        ],
+                    };
+                }
+                case "update": {
+                    if (!focus_id) {
+                        return { content: [{ type: "text", text: "Error: focus_id is required for update" }], isError: true };
+                    }
+                    const patch = {};
+                    if (name !== undefined)
+                        patch.name = name;
+                    if (description !== undefined)
+                        patch.description = description;
+                    if (color !== undefined)
+                        patch.color = color;
+                    if (icon !== undefined)
+                        patch.icon = icon;
+                    if (position !== undefined)
+                        patch.position = position;
+                    if (agent_ids !== undefined)
+                        patch.agent_ids = agent_ids;
+                    if (workflow_ids !== undefined)
+                        patch.workflow_ids = workflow_ids;
+                    const f = await client.updateFocus(focus_id, patch);
+                    return {
+                        content: [{ type: "text", text: `✅ Updated focus: "${f.name}" (id: ${f.focus_id})` }],
+                    };
+                }
+                case "delete": {
+                    if (!focus_id) {
+                        return { content: [{ type: "text", text: "Error: focus_id is required for delete" }], isError: true };
+                    }
+                    const r = await client.deleteFocus(focus_id, hard ?? false);
+                    const verb = r.deleted ? "Deleted" : "Archived";
+                    return { content: [{ type: "text", text: `✅ ${verb} focus ${r.focus_id} (projects inside detached to 'No Focus').` }] };
+                }
+            }
+        }
+        catch (err) {
+            return {
+                content: [{ type: "text", text: `Error in mind_focuses: ${err}` }],
+                isError: true,
+            };
+        }
+    });
     // ─── mind_tasks ─────────────────────────────────────────
     // Site-wide tasks: assignable, completable work items that attach to a
     // Life project, a CRM contact, an agent, or stand alone.