@noelclaw/mcp 2.4.0 → 3.1.0

package/dist/tools/swarm.js

@@ -38,34 +38,6 @@ exports.SWARM_TOOLS = [
         description: "Get the current status of the swarm: active agents, shared memory snapshot, execution scores, and recent runs.",
         inputSchema: { type: "object", properties: {}, required: [] },
     },
-    {
-        name: "write_swarm_memory",
-        description: "Write a key-value pair to the swarm's shared memory.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                agentId: { type: "string", description: "ID of the agent writing this memory entry" },
-                key: { type: "string", description: "Memory key" },
-                value: { type: "string", description: "Value to store" },
-                ttlSeconds: { type: "number", description: "Optional TTL in seconds" },
-            },
-            required: ["agentId", "key", "value"],
-        },
-    },
-    {
-        name: "get_swarm_memory",
-        description: "Read a value from the swarm's shared memory by key.",
-        inputSchema: {
-            type: "object",
-            properties: { key: { type: "string", description: "Memory key to read" } },
-            required: ["key"],
-        },
-    },
-    {
-        name: "get_execution_scores",
-        description: "Get the self-improvement scores for all skills.",
-        inputSchema: { type: "object", properties: {}, required: [] },
-    },
     {
         name: "swarm_research",
         description: "Research any topic using the multi-agent swarm — automatically starts the swarm if needed, " +
@@ -117,71 +89,6 @@ exports.SWARM_TOOLS = [
             required: [],
         },
     },
-    {
-        name: "swarm_broadcast",
-        description: "Broadcast a message or signal to all active swarm agents simultaneously. " +
-            "All agents will receive and act on the message in their next cycle. " +
-            "Use to coordinate the swarm: change focus, alert about market conditions, or inject a directive.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                message: { type: "string", description: "Message to broadcast to all agents (max 500 chars)" },
-                priority: { type: "string", enum: ["low", "normal", "high", "urgent"], description: "Message priority (default: normal)" },
-                targetAgents: { type: "array", items: { type: "string" }, description: "Optional: target specific agent IDs. Omit to broadcast to all." },
-            },
-            required: ["message"],
-        },
-    },
-    {
-        name: "swarm_pulse",
-        description: "Get an instant snapshot from all swarm agents — market prices, sentiment, on-chain activity, and agent health. " +
-            "Unlike get_swarm_status, swarm_pulse triggers all agents to report their latest readings right now. " +
-            "Best for a quick market briefing or sanity check before making decisions.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                token: { type: "string", description: "Optional: focus the pulse on a specific token (e.g. 'BTC', 'ETH')" },
-            },
-            required: [],
-        },
-    },
-    {
-        name: "swarm_reflect",
-        description: "Consolidate everything the swarm has learned into a single coherent intelligence summary. " +
-            "Reads all recent research vault entries from swarm agents, groups by agent, extracts key signals, " +
-            "and saves a unified reflection to vault. " +
-            "Run this after swarm_research or swarm_pulse to crystallize findings into long-term memory. " +
-            "Best used once per research session or daily for ongoing monitoring.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                hoursBack: { type: "number", description: "How many hours of swarm activity to include (default: 24)" },
-                focus: { type: "string", description: "Optional: focus reflection on a specific topic or token" },
-            },
-            required: [],
-        },
-    },
-    {
-        name: "swarm_watch",
-        description: "Register a topic or token for continuous swarm monitoring. " +
-            "Swarm agents will prioritize this topic in every cycle — price changes, sentiment shifts, news, on-chain flows. " +
-            "Findings are saved to vault and semantic memory automatically. " +
-            "Use memory_insight or swarm_brief to check accumulated findings. " +
-            "Alert conditions: price_spike | sentiment_shift | news | whale_move | all.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                topic: { type: "string", description: "What to watch — token symbol, protocol name, or any topic (e.g. 'ETH', 'Lido', 'Base ecosystem')" },
-                priority: { type: "string", enum: ["low", "normal", "high"], description: "Monitoring priority (default: normal)" },
-                alertOn: {
-                    type: "array",
-                    items: { type: "string", enum: ["price_spike", "sentiment_shift", "news", "whale_move", "all"] },
-                    description: "Which signals to watch for (default: price_spike, sentiment_shift, news)",
-                },
-            },
-            required: ["topic"],
-        },
-    },
 ];
 const StartSwarmSchema = zod_1.z.object({
     config: zod_1.z.object({
@@ -189,26 +96,12 @@ const StartSwarmSchema = zod_1.z.object({
         byok: zod_1.z.boolean().optional(),
     }).optional(),
 });
-const WriteMemorySchema = zod_1.z.object({ agentId: zod_1.z.string().min(1), key: zod_1.z.string().min(1), value: zod_1.z.string(), ttlSeconds: zod_1.z.number().optional() });
-const GetMemorySchema = zod_1.z.object({ key: zod_1.z.string().min(1) });
 const ResearchSchema = zod_1.z.object({ topic: zod_1.z.string().min(1), depth: zod_1.z.enum(["quick", "standard", "deep"]).optional() });
 const BriefSchema = zod_1.z.object({ limit: zod_1.z.number().optional() });
 const TriggerAgentSchema = zod_1.z.object({
     agentId: zod_1.z.enum(["market-monitor", "sentiment-tracker", "memory-manager", "risk-verifier", "workflow-executor", "onchain-analyst", "news-aggregator"]),
     params: zod_1.z.record(zod_1.z.string(), zod_1.z.any()).optional(),
 });
-const BroadcastSchema = zod_1.z.object({
-    message: zod_1.z.string().min(1).max(500),
-    priority: zod_1.z.enum(["low", "normal", "high", "urgent"]).optional(),
-    targetAgents: zod_1.z.array(zod_1.z.string()).optional(),
-});
-const PulseSchema = zod_1.z.object({ token: zod_1.z.string().optional() });
-const ReflectSchema = zod_1.z.object({ hoursBack: zod_1.z.number().positive().optional(), focus: zod_1.z.string().optional() });
-const WatchSchema = zod_1.z.object({
-    topic: zod_1.z.string().min(1),
-    priority: zod_1.z.enum(["low", "normal", "high"]).optional(),
-    alertOn: zod_1.z.array(zod_1.z.enum(["price_spike", "sentiment_shift", "news", "whale_move", "all"])).optional(),
-});
 const NO_KEY_MSG = `🔑 Swarm tools require a NoelClaw API key.\n\n` +
     `→ Get yours free at: https://noelclaw.com\n\n` +
     `Then add it to your MCP config:\n` +
@@ -311,41 +204,6 @@ async function handleSwarmTool(name, args) {
             }
             return { content: [{ type: "text", text: lines.join("\n") }] };
         }
-        case "write_swarm_memory": {
-            const parsed = WriteMemorySchema.safeParse(args);
-            if (!parsed.success)
-                return { content: [{ type: "text", text: `Invalid input: ${String(parsed.error.issues[0].path[0])} ${parsed.error.issues[0].message}` }], isError: true };
-            const { agentId, key, value, ttlSeconds } = parsed.data;
-            await (0, convex_js_1.callConvex)("/swarm/memory/write", "POST", { agentId, key, value, ttlSeconds }, "write_swarm_memory");
-            return { content: [{ type: "text", text: `✅ Memory written: [${agentId}] ${key}${ttlSeconds ? ` (expires in ${ttlSeconds}s)` : ""}` }] };
-        }
-        case "get_swarm_memory": {
-            const parsed = GetMemorySchema.safeParse(args);
-            if (!parsed.success)
-                return { content: [{ type: "text", text: `Invalid input: key ${parsed.error.issues[0].message}` }], isError: true };
-            const data = await (0, convex_js_1.callConvex)(`/swarm/memory/read?key=${encodeURIComponent(parsed.data.key)}`, "GET", undefined, "get_swarm_memory");
-            if (data.error)
-                return { content: [{ type: "text", text: `Error: ${data.error}` }], isError: true };
-            if (data.value === null || data.value === undefined)
-                return { content: [{ type: "text", text: `No value found for key: ${parsed.data.key}` }] };
-            return { content: [{ type: "text", text: `**${parsed.data.key}**: ${data.value}` }] };
-        }
-        case "get_execution_scores": {
-            const data = await (0, convex_js_1.callConvex)("/swarm/scores", "GET", undefined, "get_execution_scores");
-            if (data.error)
-                return { content: [{ type: "text", text: `Error: ${data.error}` }], isError: true };
-            const scores = data.scores ?? [];
-            if (!scores.length)
-                return { content: [{ type: "text", text: "No execution scores yet. Run some swarm agents to build a history." }] };
-            const sorted = scores.sort((a, b) => b.lastScore - a.lastScore);
-            const lines = [
-                `**Execution Scores**`, ``,
-                `| Skill | Score | W | L | Avg Duration | Last Adapted |`,
-                `|-------|-------|---|---|--------------|--------------|`,
-                ...sorted.map((s) => `| ${s.skillName} | ${(s.lastScore * 100).toFixed(0)}% | ${s.successCount} | ${s.failCount} | ${Math.round(s.avgDurationMs / 1000)}s | ${new Date(s.lastAdaptedAt).toUTCString()} |`),
-            ];
-            return { content: [{ type: "text", text: lines.join("\n") }] };
-        }
         case "swarm_research": {
             const parsed = ResearchSchema.safeParse(args);
             if (!parsed.success)
@@ -453,219 +311,6 @@ async function handleSwarmTool(name, args) {
             lines.push(`\nUse \`memory_context topic: "<topic>"\` to load full content for any research area.`);
             return { content: [{ type: "text", text: lines.join("\n") }] };
         }
-        case "swarm_broadcast": {
-            const parsed = BroadcastSchema.safeParse(args);
-            if (!parsed.success)
-                return { content: [{ type: "text", text: `Invalid input: ${parsed.error.issues[0].message}` }], isError: true };
-            const { message, priority = "normal", targetAgents } = parsed.data;
-            let data;
-            try {
-                data = await (0, convex_js_1.callConvex)("/swarm/broadcast", "POST", { message, priority, targetAgents }, "swarm_broadcast");
-            }
-            catch (err) {
-                return swarmAuthError(err);
-            }
-            if (data.error)
-                return { content: [{ type: "text", text: `Error: ${data.error}` }], isError: true };
-            const targets = targetAgents?.join(", ") ?? "all agents";
-            return {
-                content: [{
-                        type: "text",
-                        text: [
-                            `📡 **Broadcast sent** [${priority}]`,
-                            `To: ${targets}`,
-                            `Message: "${message}"`,
-                            data.deliveredTo ? `Delivered to ${data.deliveredTo} agent(s)` : "",
-                        ].filter(Boolean).join("\n"),
-                    }],
-            };
-        }
-        case "swarm_pulse": {
-            const parsed = PulseSchema.safeParse(args ?? {});
-            if (!parsed.success)
-                return { content: [{ type: "text", text: `Invalid input: ${parsed.error.issues[0].message}` }], isError: true };
-            const { token } = parsed.data;
-            await (0, convex_js_1.callConvex)("/swarm/start", "POST", {}, "start_swarm").catch(() => { });
-            let data;
-            try {
-                data = await (0, convex_js_1.callConvex)("/swarm/pulse", "POST", { token }, "swarm_pulse");
-            }
-            catch (err) {
-                return swarmAuthError(err);
-            }
-            if (data.error)
-                return { content: [{ type: "text", text: `Error: ${data.error}` }], isError: true };
-            const readings = data.readings ?? [];
-            const lines = [
-                `💓 **Swarm Pulse**${token ? ` — ${token}` : ""}`,
-                `Agents reporting: ${readings.length}`,
-                ``,
-            ];
-            for (const r of readings) {
-                lines.push(`**[${r.agentId}]** ${r.summary ?? "No data"}`);
-                if (r.data) {
-                    const preview = JSON.stringify(r.data).slice(0, 120);
-                    lines.push(`  ${preview}${preview.length === 120 ? "…" : ""}`);
-                }
-                lines.push("");
-            }
-            if (!readings.length)
-                lines.push("No agents responding. Use `start_swarm` first.");
-            return { content: [{ type: "text", text: lines.join("\n") }] };
-        }
-        case "swarm_reflect": {
-            const parsed = ReflectSchema.safeParse(args ?? {});
-            if (!parsed.success)
-                return { content: [{ type: "text", text: `Invalid input: ${parsed.error.issues[0].message}` }], isError: true };
-            const { hoursBack = 24, focus } = parsed.data;
-            const params = new URLSearchParams({ type: "research", limit: "30" });
-            let data;
-            try {
-                data = await (0, convex_js_1.callConvex)(`/vault/list?${params}`, "GET", undefined, "swarm_reflect");
-            }
-            catch (err) {
-                return swarmAuthError(err);
-            }
-            if (data.error)
-                return { content: [{ type: "text", text: `Error: ${data.error}` }], isError: true };
-            const SWARM_AGENTS = new Set(["market-monitor", "sentiment-tracker", "onchain-analyst", "news-aggregator", "risk-verifier", "memory-manager"]);
-            const cutoff = Date.now() - hoursBack * 3600000;
-            const entries = (data.entries ?? []).filter((e) => {
-                const isSwarm = SWARM_AGENTS.has(e.agentId);
-                const isRecent = e.updatedAt >= cutoff;
-                const matchesFocus = !focus || e.title.toLowerCase().includes(focus.toLowerCase());
-                return isSwarm && isRecent && matchesFocus;
-            });
-            if (!entries.length) {
-                return {
-                    content: [{
-                            type: "text",
-                            text: [
-                                `📋 **Swarm Reflection** — Nothing to consolidate`,
-                                ``,
-                                `No swarm research found in the last ${hoursBack}h${focus ? ` about "${focus}"` : ""}.`,
-                                ``,
-                                `Start one: \`swarm_research topic: "${focus ?? "market overview"}"\``,
-                            ].join("\n"),
-                        }],
-                };
-            }
-            // Group by agent
-            const byAgent = {};
-            for (const e of entries) {
-                const a = e.agentId ?? "unknown";
-                (byAgent[a] ?? (byAgent[a] = [])).push(e);
-            }
-            const agentSummaries = Object.entries(byAgent).map(([agent, es]) => {
-                const items = es.map((e) => `  • ${e.title}`).join("\n");
-                return `**[${agent}]** — ${es.length} finding(s)\n${items}`;
-            });
-            const signals = entries
-                .sort((a, b) => b.updatedAt - a.updatedAt)
-                .slice(0, 6)
-                .map((e) => `• [${e.agentId}] ${e.title}`);
-            // Write synthesis to vault for long-term memory
-            const now = new Date();
-            const reflectionKey = `swarm/reflection-${now.toISOString().slice(0, 10)}-${now.getHours()}h`;
-            const reflectionContent = [
-                `# Swarm Reflection — ${now.toUTCString()}`,
-                `Period: last ${hoursBack}h${focus ? ` · Focus: ${focus}` : ""} · ${entries.length} entries from ${Object.keys(byAgent).length} agent(s)`,
-                ``,
-                `## Agent Findings`,
-                agentSummaries.join("\n\n"),
-                ``,
-                `## Key Signals`,
-                signals.join("\n"),
-            ].join("\n");
-            const saved = await (0, convex_js_1.callConvex)("/vault/save", "POST", {
-                type: "research",
-                title: `Swarm Reflection — ${now.toLocaleDateString("en-US")}${focus ? ` — ${focus}` : ""}`,
-                content: reflectionContent,
-                key: reflectionKey,
-                agentId: "swarm-coordinator",
-                tags: ["reflection", "swarm", ...(focus ? [focus] : [])],
-                commitMsg: "swarm_reflect auto-consolidation",
-            }, "swarm_reflect").catch(() => null);
-            // Also sync to semantic memory so it's retrievable by topic
-            if (saved) {
-                (0, memory_js_1.syncToSupermemory)(reflectionContent, {
-                    vaultKey: reflectionKey, title: `Swarm Reflection ${now.toLocaleDateString("en-US")}`,
-                    type: "research", tags: ["reflection"], source: "swarm_reflect",
-                });
-            }
-            return {
-                content: [{
-                        type: "text",
-                        text: [
-                            `📋 **Swarm Reflection** — ${entries.length} findings from ${Object.keys(byAgent).length} agent(s)`,
-                            `Period: last ${hoursBack}h${focus ? ` · Focus: ${focus}` : ""}`,
-                            ``,
-                            agentSummaries.join("\n\n"),
-                            ``,
-                            `**Key signals:**`,
-                            ...signals,
-                            ``,
-                            saved ? `✅ Synthesis saved to vault: \`${reflectionKey}\`` : "⚠️ Could not save synthesis",
-                            ``,
-                            `Use \`memory_insight topic: "${focus ?? "swarm research"}"\` for the full intelligence picture.`,
-                        ].filter(Boolean).join("\n"),
-                    }],
-            };
-        }
-        case "swarm_watch": {
-            const parsed = WatchSchema.safeParse(args);
-            if (!parsed.success)
-                return { content: [{ type: "text", text: `Invalid input: ${parsed.error.issues[0].message}` }], isError: true };
-            const { topic, priority = "normal", alertOn = ["price_spike", "sentiment_shift", "news"] } = parsed.data;
-            const watchKey = `watch:${topic.toLowerCase().replace(/\s+/g, "-")}`;
-            const watchConfig = JSON.stringify({
-                topic, priority,
-                alertOn: alertOn.includes("all") ? ["price_spike", "sentiment_shift", "news", "whale_move"] : alertOn,
-                registeredAt: Date.now(),
-            });
-            // Write to swarm shared memory (picked up by agents in next cycle)
-            await (0, convex_js_1.callConvex)("/swarm/memory/write", "POST", {
-                agentId: "swarm-coordinator",
-                key: watchKey,
-                value: watchConfig,
-            }, "swarm_watch").catch(() => { });
-            // Persist to vault so it survives swarm restarts
-            await (0, convex_js_1.callConvex)("/vault/save", "POST", {
-                type: "memory",
-                title: `Watch: ${topic}`,
-                content: watchConfig,
-                key: `watch/${topic.toLowerCase().replace(/\s+/g, "-")}`,
-                agentId: "swarm-coordinator",
-                tags: ["watch", "monitor", topic.toLowerCase()],
-                commitMsg: "swarm_watch registered",
-            }, "swarm_watch").catch(() => { });
-            const alertList = (alertOn.includes("all")
-                ? ["price_spike", "sentiment_shift", "news", "whale_move"]
-                : alertOn).join(", ");
-            return {
-                content: [{
-                        type: "text",
-                        text: [
-                            `👁️ **Watch Registered: ${topic}**`,
-                            `Priority: ${priority} · Alerts: ${alertList}`,
-                            ``,
-                            `Swarm agents will now prioritize "${topic}" in every monitoring cycle.`,
-                            `Watch key: \`${watchKey}\``,
-                            ``,
-                            `**What happens next:**`,
-                            `• market-monitor will track price & volume anomalies`,
-                            `• sentiment-tracker will watch social signal shifts`,
-                            `• news-aggregator will flag relevant news & narratives`,
-                            alertOn.includes("whale_move") || alertOn.includes("all") ? `• onchain-analyst will detect large wallet movements` : "",
-                            ``,
-                            `**Check findings:**`,
-                            `• \`swarm_brief\` — latest research entries`,
-                            `• \`memory_insight topic: "${topic}"\` — full intelligence report`,
-                            `• \`swarm_reflect focus: "${topic}"\` — consolidated summary`,
-                        ].filter(Boolean).join("\n"),
-                    }],
-            };
-        }
         default:
             return null;
     }

package/dist/tools/vault.js

@@ -6,7 +6,6 @@ const zod_1 = require("zod");
 const convex_js_1 = require("../convex.js");
 const memory_js_1 = require("./memory.js");
 const VAULT_TYPES = ["research", "execution", "workflow", "prompt", "file", "memory", "credential"];
-const LINK_RELATIONS = ["references", "derived_from", "supersedes", "related", "continues"];
 exports.VAULT_TOOLS = [
     {
         name: "vault_save",
@@ -137,36 +136,6 @@ exports.VAULT_TOOLS = [
             required: ["name"],
         },
     },
-    {
-        name: "vault_publish",
-        description: "Publish a vault entry to the community vault so other Noelclaw users can discover and fork it. " +
-            "Credentials are never published — only research, prompts, workflows, memory, and execution entries. " +
-            "You can also unpublish by setting isPublic to false.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                key: { type: "string", description: "Entry key to publish or unpublish" },
-                isPublic: { type: "boolean", description: "true to publish, false to unpublish (default true)" },
-                authorName: { type: "string", description: "Display name shown to the community (default: Anonymous)" },
-            },
-            required: ["key"],
-        },
-    },
-    {
-        name: "vault_explore",
-        description: "Browse the community vault — public entries shared by all Noelclaw users. " +
-            "Discover research, prompts, and workflows published by the community. " +
-            "Use vault_save to fork any entry into your own vault.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                type: { type: "string", enum: ["research", "execution", "workflow", "prompt", "file", "memory"], description: "Filter by entry type" },
-                search: { type: "string", description: "Search query to filter community entries" },
-                limit: { type: "number", description: "Max entries to return (default 20)" },
-            },
-            required: [],
-        },
-    },
     {
         name: "vault_pin",
         description: "Pin or unpin a Noel-Vault entry. Pinned entries always appear first in vault_list and are " +
@@ -192,20 +161,6 @@ exports.VAULT_TOOLS = [
             required: ["key"],
         },
     },
-    {
-        name: "vault_link",
-        description: "Create a semantic link between two Noel-Vault entries. Links appear in vault_read output and " +
-            "help agents navigate related knowledge. Relations: references | derived_from | supersedes | related | continues.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                fromKey: { type: "string", description: "Source entry key" },
-                toKey: { type: "string", description: "Target entry key" },
-                relation: { type: "string", enum: [...LINK_RELATIONS], description: "Relationship type (default: related)" },
-            },
-            required: ["fromKey", "toKey"],
-        },
-    },
     {
         name: "vault_tag",
         description: "Add or replace tags on an existing Noel-Vault entry without modifying its content. " +
@@ -250,11 +205,8 @@ const DiffSchema = zod_1.z.object({ key: zod_1.z.string().min(1), fromVersion: z
 const ExportSchema = zod_1.z.object({ type: zod_1.z.enum(VAULT_TYPES).optional() });
 const StoreCredentialSchema = zod_1.z.object({ name: zod_1.z.string().min(1), value: zod_1.z.string().min(1), description: zod_1.z.string().optional() });
 const GetCredentialSchema = zod_1.z.object({ name: zod_1.z.string().min(1) });
-const PublishSchema = zod_1.z.object({ key: zod_1.z.string().min(1), isPublic: zod_1.z.boolean().optional(), authorName: zod_1.z.string().optional() });
-const ExploreSchema = zod_1.z.object({ type: zod_1.z.enum(["research", "execution", "workflow", "prompt", "file", "memory"]).optional(), search: zod_1.z.string().optional(), limit: zod_1.z.number().optional() });
 const PinSchema = zod_1.z.object({ key: zod_1.z.string().min(1), pinned: zod_1.z.boolean().optional() });
 const DeleteSchema = zod_1.z.object({ key: zod_1.z.string().min(1) });
-const LinkSchema = zod_1.z.object({ fromKey: zod_1.z.string().min(1), toKey: zod_1.z.string().min(1), relation: zod_1.z.enum(LINK_RELATIONS).optional() });
 const TagSchema = zod_1.z.object({ key: zod_1.z.string().min(1), tags: zod_1.z.array(zod_1.z.string()).min(1), replace: zod_1.z.boolean().optional() });
 // ─── Helpers ─────────────────────────────────────────────────────────────────
 function formatBytes(n) {
@@ -467,54 +419,6 @@ async function handleVaultTool(name, args) {
                 lines.push(`Stored: ${data.storedAt}`);
             return { content: [{ type: "text", text: lines.join("\n") }] };
         }
-        case "vault_publish": {
-            const parsed = PublishSchema.safeParse(args);
-            if (!parsed.success)
-                return { content: [{ type: "text", text: `Invalid input: ${parsed.error.issues[0].message}` }], isError: true };
-            const { key, isPublic = true, authorName } = parsed.data;
-            const endpoint = isPublic ? "/vault/publish" : "/vault/unpublish";
-            const data = await (0, convex_js_1.callConvex)(endpoint, "POST", { key, authorName }, "vault_publish");
-            if (data.error)
-                return { content: [{ type: "text", text: `Error: ${data.error}` }], isError: true };
-            return {
-                content: [{
-                        type: "text",
-                        text: isPublic
-                            ? `🌐 **Published to community vault**\nKey: \`${key}\`\nOther Noelclaw users can now discover this entry.\nUse \`vault_publish key: "${key}" isPublic: false\` to unpublish.`
-                            : `🔒 **Unpublished**\nKey: \`${key}\` is now private.`,
-                    }],
-            };
-        }
-        case "vault_explore": {
-            const parsed = ExploreSchema.safeParse(args ?? {});
-            if (!parsed.success)
-                return { content: [{ type: "text", text: `Invalid input: ${parsed.error.issues[0].message}` }], isError: true };
-            const params = new URLSearchParams();
-            if (parsed.data.type)
-                params.set("type", parsed.data.type);
-            if (parsed.data.search)
-                params.set("search", parsed.data.search);
-            if (parsed.data.limit)
-                params.set("limit", String(parsed.data.limit));
-            const data = await (0, convex_js_1.callConvex)(`/vault/community?${params}`, "GET", undefined, "vault_explore");
-            if (data.error)
-                return { content: [{ type: "text", text: `Error: ${data.error}` }], isError: true };
-            const entries = data.entries ?? [];
-            if (!entries.length)
-                return { content: [{ type: "text", text: `No community vault entries found${parsed.data.type ? ` of type '${parsed.data.type}'` : ""}.${parsed.data.search ? ` Try a different search term.` : "\nBe the first to publish with vault_publish!"}` }] };
-            const header = `🌐 **Community Vault** — ${entries.length} public entries`;
-            const rows = entries.map((e) => [
-                `**[${e.type}]** ${e.title}  ·  by ${e.authorName ?? "Anonymous"}`,
-                `  \`${e.key}\`  ·  v${e.version}  ·  ${formatDate(e.updatedAt)}`,
-                e.content ? `  ${e.content.slice(0, 100)}${e.content.length > 100 ? "…" : ""}` : "",
-            ].filter(Boolean).join("\n"));
-            return {
-                content: [{
-                        type: "text",
-                        text: [header, "", ...rows, "", "To fork an entry: `vault_save type: <type> title: <title> content: <content>`"].join("\n"),
-                    }],
-            };
-        }
         case "vault_pin": {
             const parsed = PinSchema.safeParse(args);
             if (!parsed.success)
@@ -534,16 +438,6 @@ async function handleVaultTool(name, args) {
                 return { content: [{ type: "text", text: `Error: ${data.error}` }], isError: true };
             return { content: [{ type: "text", text: `🗑️ Deleted: \`${parsed.data.key}\` (${data.versionsRemoved ?? 0} versions removed)` }] };
         }
-        case "vault_link": {
-            const parsed = LinkSchema.safeParse(args);
-            if (!parsed.success)
-                return { content: [{ type: "text", text: `Invalid input: ${parsed.error.issues[0].message}` }], isError: true };
-            const { fromKey, toKey, relation = "related" } = parsed.data;
-            const data = await (0, convex_js_1.callConvex)("/vault/link", "POST", { fromKey, toKey, relation }, "vault_link");
-            if (data.error)
-                return { content: [{ type: "text", text: `Error: ${data.error}` }], isError: true };
-            return { content: [{ type: "text", text: `🔗 Linked: \`${fromKey}\` → [${relation}] → \`${toKey}\`` }] };
-        }
         case "vault_tag": {
             const parsed = TagSchema.safeParse(args);
             if (!parsed.success)

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "@noelclaw/mcp",
-  "version": "2.4.0",
+  "version": "3.1.0",
   "description": "Noelclaw AI Operating System — persistent memory, multi-agent swarm, DeFi execution, market intelligence, and Sentinel-gated playbooks.",
   "main": "dist/index.js",
   "bin": {
-    "noelclaw-mcp": "dist/index.js"
+    "noelclaw-mcp": "dist/index.js",
+    "noelclaw": "dist/cli.js"
   },
   "scripts": {
     "build": "tsc",