@noelclaw/mcp 2.3.1 → 2.4.0

package/dist/tools/swarm.js

@@ -5,6 +5,7 @@ exports.handleSwarmTool = handleSwarmTool;
 const zod_1 = require("zod");
 const convex_js_1 = require("../convex.js");
 const market_js_1 = require("./market.js");
+const memory_js_1 = require("./memory.js");
 function formatDate(ts) {
     return new Date(ts).toUTCString();
 }
@@ -82,21 +83,22 @@ exports.SWARM_TOOLS = [
     {
         name: "trigger_agent",
         description: "Run a single swarm agent immediately — automatically starts the swarm if needed. " +
-            "Costs 100 credits per call. " +
-            "market-monitor fetches live price data, sentiment-tracker analyzes sentiment, " +
-            "memory-manager compresses ephemeral memory, risk-verifier evaluates an action for risk. " +
+            "Agents: market-monitor (live prices), sentiment-tracker (social/sentiment), " +
+            "memory-manager (compress memory), risk-verifier (evaluate risk), " +
+            "onchain-analyst (on-chain data: wallets, flows, TVL), " +
+            "news-aggregator (latest news + narrative tracking). " +
             "Results are saved to vault automatically.",
         inputSchema: {
             type: "object",
             properties: {
                 agentId: {
                     type: "string",
-                    enum: ["market-monitor", "sentiment-tracker", "memory-manager", "risk-verifier", "workflow-executor"],
+                    enum: ["market-monitor", "sentiment-tracker", "memory-manager", "risk-verifier", "workflow-executor", "onchain-analyst", "news-aggregator"],
                     description: "Which agent to run",
                 },
                 params: {
                     type: "object",
-                    description: "Agent-specific params. market-monitor: { token: 'BTC' }. sentiment-tracker: { token: 'ETH' } or { topic: 'Layer 2s' }. risk-verifier: { type: 'swap', params: { ... } }.",
+                    description: "Agent-specific params. market-monitor: { token: 'BTC' }. sentiment-tracker: { token: 'ETH' } or { topic: 'Layer 2s' }. onchain-analyst: { address: '0x...' } or { protocol: 'Morpho' }. news-aggregator: { topic: 'Base ecosystem' }.",
                 },
             },
             required: ["agentId"],
@@ -115,6 +117,71 @@ 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({
@@ -127,9 +194,21 @@ 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"]),
+    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` +
@@ -272,6 +351,9 @@ async function handleSwarmTool(name, args) {
             if (!parsed.success)
                 return { content: [{ type: "text", text: `Invalid input: ${parsed.error.issues[0].message}` }], isError: true };
             const { topic, depth = "standard" } = parsed.data;
+            // Check what's already known before launching — show value immediately
+            const [priorMem] = await Promise.allSettled([(0, memory_js_1.searchSupermemory)(topic, 4)]);
+            const priorResults = priorMem.status === "fulfilled" ? priorMem.value : [];
             await (0, convex_js_1.callConvex)("/swarm/start", "POST", {}, "start_swarm").catch(() => { });
             let data;
             try {
@@ -282,17 +364,26 @@ async function handleSwarmTool(name, args) {
             }
             if (data.error)
                 return { content: [{ type: "text", text: `Error: ${data.error}` }], isError: true };
+            const priorSection = priorResults.length > 0
+                ? [
+                    ``,
+                    `**Prior knowledge loaded (${priorResults.length} memories):**`,
+                    ...priorResults.map(r => `• ${r.metadata?.title ?? r.content.slice(0, 80).replace(/\n/g, " ")}`),
+                    `Agents will build on this — no re-discovering what you already know.`,
+                ]
+                : [``, `No prior knowledge found — agents starting fresh.`];
             return {
                 content: [{
                         type: "text",
                         text: [
                             `🔬 **Swarm Research Started**`,
-                            `Topic: ${topic}`,
-                            `Depth: ${depth}`,
+                            `Topic: ${topic} · Depth: ${depth}`,
+                            ...priorSection,
                             ``,
-                            data.message ?? "Research triggered. Findings will appear in vault.",
+                            data.message ?? "Research triggered. Findings will appear in vault automatically.",
                             ``,
-                            `Use \`vault_context topic: "${topic}"\` to retrieve results once complete.`,
+                            `**Next:** \`swarm_reflect focus: "${topic}"\` to consolidate findings`,
+                            `Or: \`memory_insight topic: "${topic}"\` to see full intelligence report`,
                         ].join("\n"),
                     }],
             };
@@ -303,9 +394,16 @@ async function handleSwarmTool(name, args) {
                 return { content: [{ type: "text", text: `Invalid input: ${parsed.error.issues[0].message}` }], isError: true };
             const { agentId, params = {} } = parsed.data;
             await (0, convex_js_1.callConvex)("/swarm/start", "POST", {}, "start_swarm").catch(() => { });
+            // Auto-load prior context so agent doesn't re-discover what's already known
+            const contextQuery = [agentId, params?.token, params?.topic, params?.protocol].filter(Boolean).join(" ");
+            const priorContext = await (0, memory_js_1.searchSupermemory)(contextQuery, 3);
+            const priorSummary = priorContext.length > 0
+                ? priorContext.map(r => r.content.slice(0, 150)).join(" | ")
+                : null;
+            const enrichedParams = priorSummary ? { ...params, priorContext: priorSummary } : params;
             let data;
             try {
-                data = await (0, convex_js_1.callConvex)("/swarm/trigger", "POST", { agentId, params }, "trigger_agent");
+                data = await (0, convex_js_1.callConvex)("/swarm/trigger", "POST", { agentId, params: enrichedParams }, "trigger_agent");
             }
             catch (err) {
                 return swarmAuthError(err);
@@ -313,15 +411,17 @@ async function handleSwarmTool(name, args) {
             if (data.error)
                 return { content: [{ type: "text", text: `Error: ${data.error}` }], isError: true };
             const resultText = data.result ? `\n\`\`\`json\n${JSON.stringify(data.result, null, 2).slice(0, 800)}\n\`\`\`` : "";
+            const contextNote = priorContext.length > 0 ? `🧠 ${priorContext.length} prior memory entries injected into agent context.` : "";
             return {
                 content: [{
                         type: "text",
                         text: [
                             `⚡ **${agentId} triggered**`,
-                            `100 credits charged.`,
+                            contextNote,
                             resultText,
                             ``,
-                            `Use \`vault_context topic: "${agentId.replace("-", " ")}"\` to retrieve findings.`,
+                            `Findings saved to vault automatically.`,
+                            `Use \`swarm_reflect\` to consolidate or \`memory_insight topic: "${contextQuery.split(" ")[1] ?? agentId}"\` for full report.`,
                         ].filter(Boolean).join("\n"),
                     }],
             };
@@ -350,9 +450,222 @@ async function handleSwarmTool(name, args) {
                 lines.push(`**[${e.agentId}]** ${e.title}`);
                 lines.push(`  _${e.key}_ · v${e.version} · ${formatDate(e.updatedAt)}`);
             }
-            lines.push(`\nUse \`vault_context topic: "<topic>"\` to load full content for any research area.`);
+            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;
     }