@noelclaw/mcp 2.3.1 → 3.0.0

package/dist/tools/scanner.js

@@ -85,13 +85,116 @@ function scoreDipReversal(c, minLiquidity = DEFAULT_MIN_LIQ) {
         buyPressure5m: bp,
     };
 }
-// ── Fetch helper ──────────────────────────────────────────────────────────────
+// ── Fetch helpers ─────────────────────────────────────────────────────────────
 async function fetchJson(url) {
     const res = await fetch(url, { signal: AbortSignal.timeout(15000) });
     if (!res.ok)
         throw new Error(`HTTP ${res.status} from ${new URL(url).hostname}`);
     return res.json();
 }
+async function fetchBasePools(minLiquidity, limit) {
+    const [trendingRes, newPoolsRes] = await Promise.allSettled([
+        fetchJson("https://api.geckoterminal.com/api/v2/networks/base/trending_pools?page=1"),
+        fetchJson("https://api.geckoterminal.com/api/v2/networks/base/new_pools?page=1"),
+    ]);
+    const rawPools = [
+        ...(trendingRes.status === "fulfilled" ? trendingRes.value.data ?? [] : []),
+        ...(newPoolsRes.status === "fulfilled" ? newPoolsRes.value.data ?? [] : []),
+    ];
+    if (!rawPools.length)
+        throw new Error("GeckoTerminal returned no pools. Try again in a moment.");
+    const seen = new Set();
+    const deduped = rawPools.filter(p => {
+        if (!p?.attributes || !p.id)
+            return false;
+        if (seen.has(p.id))
+            return false;
+        seen.add(p.id);
+        return true;
+    });
+    return deduped
+        .map((p) => {
+        const a = p.attributes ?? {};
+        const txns = a.transactions ?? {};
+        const pc = a.price_change_percentage ?? {};
+        const vol = a.volume_usd ?? {};
+        const liq = parseFloat(a.reserve_in_usd ?? "0");
+        const tokenRel = p.relationships?.base_token?.data?.id ?? "";
+        const mint = tokenRel.includes("_") ? tokenRel.split("_")[1] : tokenRel;
+        if (!mint?.startsWith("0x"))
+            return null;
+        return {
+            mint,
+            symbol: (a.name ?? "").split(" / ")[0] || mint.slice(0, 8),
+            priceUsd: parseFloat(a.base_token_price_usd ?? "0"),
+            priceChange5m: parseFloat(pc.m5 ?? "0"),
+            priceChange1h: parseFloat(pc.h1 ?? "0"),
+            priceChange6h: parseFloat(pc.h6 ?? "0"),
+            priceChange24h: parseFloat(pc.h24 ?? "0"),
+            volume1h: parseFloat(vol.h1 ?? "0"),
+            liquidity: liq,
+            buys5m: txns.m5?.buys ?? 0,
+            sells5m: txns.m5?.sells ?? 0,
+            buys1h: txns.h1?.buys ?? 0,
+            sells1h: txns.h1?.sells ?? 0,
+        };
+    })
+        .filter((c) => c !== null && c.liquidity >= minLiquidity)
+        .slice(0, limit);
+}
+function scoreMomentum(c, minLiquidity = DEFAULT_MIN_LIQ) {
+    const pc5m = c.priceChange5m;
+    const pc1h = c.priceChange1h;
+    const pc6h = c.priceChange6h;
+    const pc24h = c.priceChange24h;
+    const liq = c.liquidity;
+    const vol1h = c.volume1h;
+    const totalTxns5m = c.buys5m + c.sells5m;
+    const buyRatio5m = totalTxns5m > 0 ? c.buys5m / totalTxns5m : 0;
+    const totalTxns1h = c.buys1h + c.sells1h;
+    const buyRatio1h = totalTxns1h > 0 ? c.buys1h / totalTxns1h : 0;
+    const bp = buyRatio5m * 100;
+    // Hard gates — all must pass
+    const gateFailures = [];
+    if (pc1h < 3)
+        gateFailures.push(`1h momentum weak (${pc1h.toFixed(1)}% < 3%)`);
+    if (pc5m < 0.5)
+        gateFailures.push(`5m not accelerating (${pc5m.toFixed(1)}% < 0.5%)`);
+    if (totalTxns5m > 5 && buyRatio5m < 0.55)
+        gateFailures.push(`buy pressure low (${bp.toFixed(0)}% < 55%)`);
+    if (liq < minLiquidity)
+        gateFailures.push(`liquidity $${(liq / 1000).toFixed(0)}k < $${(minLiquidity / 1000).toFixed(0)}k min`);
+    if (pc24h > 150)
+        gateFailures.push(`already parabolic (24h ${pc24h.toFixed(0)}%)`);
+    if (gateFailures.length > 0) {
+        return { score: 0, passed: false, pattern: null, gateFailures, buyPressure5m: bp };
+    }
+    // 1. Momentum strength (0–25 pts)
+    const momentumPts = pc1h >= 20 ? 25 : pc1h >= 10 ? 20 : pc1h >= 6 ? 15 : pc1h >= 3 ? 8 : 3;
+    // 2. 5m acceleration (0–20 pts)
+    const accelPts = pc5m >= 5 ? 20 : pc5m >= 3 ? 16 : pc5m >= 2 ? 12 : pc5m >= 1 ? 7 : 3;
+    // 3. Buy pressure (0–15 pts)
+    const bpPts = bp >= 70 ? 15 : bp >= 65 ? 12 : bp >= 60 ? 9 : bp >= 55 ? 5 : 2;
+    // 4. Volume & activity (0–15 pts)
+    const actPts = vol1h >= 100000 && totalTxns1h >= 200 ? 15
+        : vol1h >= 50000 && totalTxns1h >= 100 ? 12
+            : vol1h >= 20000 && totalTxns1h >= 40 ? 8
+                : vol1h >= 5000 && totalTxns1h >= 10 ? 4 : 1;
+    // 5. Trend continuation (0–15 pts)
+    let trendPts = 0;
+    if (pc6h > 5 && pc24h > 5)
+        trendPts = 15;
+    else if (pc6h > 0 && pc24h > 0)
+        trendPts = 10;
+    else if (pc6h > 0)
+        trendPts = 5;
+    // 6. Sentiment acceleration (0–10 pts)
+    const sentAccel = buyRatio5m - buyRatio1h;
+    const sentPts = sentAccel >= 0.10 ? 10 : sentAccel >= 0.05 ? 7 : sentAccel >= 0 ? 3 : 0;
+    const score = Math.max(0, Math.min(100, momentumPts + accelPts + bpPts + actPts + trendPts + sentPts));
+    const pattern = pc1h >= 15 ? "BREAKOUT" : pc1h >= 8 ? "MOMENTUM" : pc1h >= 3 ? "PUSH" : "WEAK-PUSH";
+    return { score, passed: true, pattern, gateFailures: [], buyPressure5m: bp };
+}
 // ── Schemas ───────────────────────────────────────────────────────────────────
 const AddressSchema = zod_1.z.string().regex(/^0x[0-9a-fA-F]{40}$/, "must be a valid 0x address");
 const ScoreTokenSchema = zod_1.z.object({ address: AddressSchema, minLiquidity: zod_1.z.number().positive().optional() });
@@ -101,6 +204,11 @@ const ScanDipsSchema = zod_1.z.object({
     minLiquidity: zod_1.z.number().positive().optional(),
     limit: zod_1.z.number().int().min(1).max(100).optional(),
 }).default({});
+const ScanMomentumSchema = zod_1.z.object({
+    minScore: zod_1.z.number().min(0).max(100).optional(),
+    minLiquidity: zod_1.z.number().positive().optional(),
+    limit: zod_1.z.number().int().min(1).max(100).optional(),
+}).default({});
 // ── Tool definitions ──────────────────────────────────────────────────────────
 exports.SCANNER_TOOLS = [
     {
@@ -139,6 +247,22 @@ exports.SCANNER_TOOLS = [
             required: [],
         },
     },
+    {
+        name: "scan_momentum",
+        description: "Scan Base pools for momentum breakout setups — tokens with strong 1h+ upward momentum that are still accelerating. " +
+            "The inverse of scan_dips: finds BREAKOUT / MOMENTUM / PUSH patterns instead of dip-reversals. " +
+            "Gates: 1h > +3%, 5m still rising, buy pressure > 55%, not already parabolic (24h < 150%). " +
+            "Returns scored and ranked candidates. No API keys required.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                minScore: { type: "number", description: "Min score to include (default 50)" },
+                minLiquidity: { type: "number", description: "Min pool liquidity in USD (default 50000)" },
+                limit: { type: "number", description: "Max pools to scan (default 40, max 100)" },
+            },
+            required: [],
+        },
+    },
 ];
 // ── Handlers ──────────────────────────────────────────────────────────────────
 async function handleScannerTool(name, args) {
@@ -279,58 +403,13 @@ async function handleScannerTool(name, args) {
         if (!parsed.success)
             return { content: [{ type: "text", text: `Invalid input: ${parsed.error.issues[0].message}` }], isError: true };
         const { minScore = DEFAULT_MIN_SCORE, minLiquidity = DEFAULT_MIN_LIQ, limit = 40 } = parsed.data;
-        // Fetch trending + new pools on Base from GeckoTerminal in parallel
-        const [trendingRes, newPoolsRes] = await Promise.allSettled([
-            fetchJson("https://api.geckoterminal.com/api/v2/networks/base/trending_pools?page=1"),
-            fetchJson("https://api.geckoterminal.com/api/v2/networks/base/new_pools?page=1"),
-        ]);
-        const rawPools = [
-            ...(trendingRes.status === "fulfilled" ? trendingRes.value.data ?? [] : []),
-            ...(newPoolsRes.status === "fulfilled" ? newPoolsRes.value.data ?? [] : []),
-        ];
-        if (!rawPools.length) {
-            return { content: [{ type: "text", text: "GeckoTerminal returned no pools. Try again in a moment." }], isError: true };
+        let candidates;
+        try {
+            candidates = await fetchBasePools(minLiquidity, limit);
+        }
+        catch (err) {
+            return { content: [{ type: "text", text: err.message }], isError: true };
         }
-        // Deduplicate by pool id
-        const seen = new Set();
-        const pools = rawPools.filter(p => {
-            if (!p?.attributes || !p.id)
-                return false;
-            if (seen.has(p.id))
-                return false;
-            seen.add(p.id);
-            return true;
-        });
-        // Map GeckoTerminal pool → Candidate
-        const candidates = pools
-            .map((p) => {
-            const a = p.attributes ?? {};
-            const txns = a.transactions ?? {};
-            const pc = a.price_change_percentage ?? {};
-            const vol = a.volume_usd ?? {};
-            const liq = parseFloat(a.reserve_in_usd ?? "0");
-            const tokenRel = p.relationships?.base_token?.data?.id ?? "";
-            const mint = tokenRel.includes("_") ? tokenRel.split("_")[1] : tokenRel;
-            if (!mint?.startsWith("0x"))
-                return null;
-            return {
-                mint,
-                symbol: (a.name ?? "").split(" / ")[0] || mint.slice(0, 8),
-                priceUsd: parseFloat(a.base_token_price_usd ?? "0"),
-                priceChange5m: parseFloat(pc.m5 ?? "0"),
-                priceChange1h: parseFloat(pc.h1 ?? "0"),
-                priceChange6h: parseFloat(pc.h6 ?? "0"),
-                priceChange24h: parseFloat(pc.h24 ?? "0"),
-                volume1h: parseFloat(vol.h1 ?? "0"),
-                liquidity: liq,
-                buys5m: txns.m5?.buys ?? 0,
-                sells5m: txns.m5?.sells ?? 0,
-                buys1h: txns.h1?.buys ?? 0,
-                sells1h: txns.h1?.sells ?? 0,
-            };
-        })
-            .filter((c) => c !== null && c.liquidity >= minLiquidity)
-            .slice(0, limit);
         const scored = candidates
             .map(c => ({ ...c, ...scoreDipReversal(c, minLiquidity) }))
             .filter(c => c.passed && c.score >= minScore)
@@ -371,5 +450,57 @@ async function handleScannerTool(name, args) {
         lines.push(`Next steps: \`score_token\` for full breakdown · \`check_token\` for rug check before buying`);
         return { content: [{ type: "text", text: lines.join("\n") }] };
     }
+    // ── scan_momentum ──────────────────────────────────────────────────────────
+    if (name === "scan_momentum") {
+        const parsed = ScanMomentumSchema.safeParse(args ?? {});
+        if (!parsed.success)
+            return { content: [{ type: "text", text: `Invalid input: ${parsed.error.issues[0].message}` }], isError: true };
+        const { minScore = DEFAULT_MIN_SCORE, minLiquidity = DEFAULT_MIN_LIQ, limit = 40 } = parsed.data;
+        let candidates;
+        try {
+            candidates = await fetchBasePools(minLiquidity, limit);
+        }
+        catch (err) {
+            return { content: [{ type: "text", text: err.message }], isError: true };
+        }
+        const scored = candidates
+            .map(c => ({ ...c, ...scoreMomentum(c, minLiquidity) }))
+            .filter(c => c.passed && c.score >= minScore)
+            .sort((a, b) => b.score - a.score);
+        if (!scored.length) {
+            return {
+                content: [{
+                        type: "text",
+                        text: [
+                            `## Momentum Scan — No Breakouts Found`,
+                            ``,
+                            `Scanned **${candidates.length} pools** on Base. None passed the momentum gates with score ≥ ${minScore}.`,
+                            ``,
+                            `When nothing breaks out, the market may be in consolidation or distribution.`,
+                            ``,
+                            `Try: \`scan_dips\` to look for reversal opportunities instead.`,
+                        ].join("\n"),
+                    }],
+            };
+        }
+        const sign = (n) => n >= 0 ? `+${n.toFixed(1)}` : n.toFixed(1);
+        const lines = [
+            `## Momentum Scan — ${scored.length} Breakout${scored.length !== 1 ? "s" : ""} Found`,
+            `Scanned **${candidates.length} pools** · Score ≥ ${minScore} · Liq ≥ $${(minLiquidity / 1000).toFixed(0)}k`,
+            ``,
+        ];
+        for (const c of scored.slice(0, 10)) {
+            const bar = "█".repeat(Math.round(c.score / 10)).padEnd(10, "░");
+            lines.push(`### ${c.symbol} · ${c.score}/100 \`${bar}\``);
+            lines.push(`**Pattern:** ${c.pattern} · **Liq:** $${(c.liquidity / 1000).toFixed(0)}k · **1h:** ${sign(c.priceChange1h)}% · **5m:** ${sign(c.priceChange5m)}%`);
+            lines.push(`**Buy pressure:** ${c.buyPressure5m.toFixed(0)}% · **Vol 1h:** $${(c.volume1h / 1000).toFixed(0)}k`);
+            lines.push(`**Trend:** 6h ${sign(c.priceChange6h)}% / 24h ${sign(c.priceChange24h)}%`);
+            lines.push(`\`${c.mint}\``);
+            lines.push(``);
+        }
+        lines.push(`---`);
+        lines.push(`Next steps: \`score_token\` for dip-reversal score · \`check_token\` for rug check before buying`);
+        return { content: [{ type: "text", text: lines.join("\n") }] };
+    }
     return null;
 }

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();
 }
@@ -37,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, " +
@@ -82,21 +55,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"],
@@ -122,12 +96,10 @@ 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"]),
+    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 NO_KEY_MSG = `🔑 Swarm tools require a NoelClaw API key.\n\n` +
@@ -232,46 +204,14 @@ 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)
                 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 +222,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 +252,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 +269,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,7 +308,7 @@ 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") }] };
         }
         default: