@noelclaw/mcp 3.2.0 → 3.3.0

package/README.md

@@ -2,7 +2,7 @@
 
 [![npm version](https://img.shields.io/npm/v/@noelclaw/mcp.svg)](https://www.npmjs.com/package/@noelclaw/mcp)
 
-74 MCP tools for your AI — persistent memory, DeFi execution on Base, multi-agent research, automations, and on-chain actions.
+81 MCP tools for your AI — persistent memory, autonomous research monitors, live web search, DeFi execution on Base, multi-agent swarms, and on-chain actions.
 
 No API key required to start. Ask your AI in plain English.
 
@@ -21,37 +21,7 @@ npx -y @noelclaw/mcp
 
 ### Claude Code
 ```bash
-claude mcp add noelclaw -- npx -y @noelclaw/mcp
-```
-
-### Aeon
-
-Open **Settings → MCP Servers** and add:
-
-```json
-{
-  "mcpServers": {
-    "noelclaw": {
-      "command": "npx",
-      "args": ["-y", "@noelclaw/mcp"]
-    }
-  }
-}
-```
-
-### Hermes
-
-Open **Settings → MCP Servers** and add:
-
-```json
-{
-  "mcpServers": {
-    "noelclaw": {
-      "command": "npx",
-      "args": ["-y", "@noelclaw/mcp"]
-    }
-  }
-}
+claude mcp add noelclaw -s user -- npx -y @noelclaw/mcp
 ```
 
 ### Claude Desktop
@@ -69,7 +39,7 @@ Add to `%APPDATA%\Claude\claude_desktop_config.json` (Windows) or `~/Library/App
 }
 ```
 
-### Any Other MCP Client
+### Aeon / Hermes / Cursor / Windsurf
 
 ```json
 {
@@ -91,27 +61,24 @@ Restart your client. Tools load automatically.
 Ask your AI anything — it routes to the right tool automatically.
 
 ```
-what's the ETH gas price and latest block on Base?
+search for AI agent news today
+→ Returns top results from across the web, summarized
+
+set up a daily monitor for AI agents news
+→ ✓ monitor created · runs daily at 8am · findings saved to vault + Telegram
+
+what's the ETH gas price on Base right now?
 → Gas: 0.006 gwei · Block: 46,773,463 · ETH: $1,991
 
 show me the best yield vaults on Base right now
 → Clearstar USDC Reactor: 7.57% APY ($2.6M TVL)
 → Moonwell Flagship USDC: 4.63% APY ($9.1M TVL)
 
-remember my Aerodrome thesis for next time
-→ ✓ saved to Vault · auto-loaded every session
-
-set up weekly $100 ETH DCA every Monday
-→ ✓ automation created · runs weekly 09:00 UTC
+give me a bull vs bear thesis on ETH
+→ Full analysis · auto-saved to vault
 
 swap 0.5 ETH to USDC on Base
 → ✓ swapped → 1,842 USDC · tx confirmed in 2s
-
-swarm research topic: "ETH vs SOL which wins 2025"
-→ Triggers multi-agent research, saves findings to your vault
-
-generate a Solidity ERC-20 with burn and pause features
-→ Returns production-ready OpenZeppelin contract
 ```
 
 ---
@@ -126,7 +93,7 @@ Three pillars: **Remember** · **Act** · **Know**
 
 Your AI loads your context before you type a single word.
 
-#### Vault — Structured Notes (15 tools)
+#### Vault — Structured Notes (12 tools)
 
 > Save research, decisions, and notes. Every entry is versioned and auto-tagged.
 
@@ -141,14 +108,11 @@ Your AI loads your context before you type a single word.
 | **Vault Export** `vault_export` | Export vault as JSON or markdown |
 | **Store Credential** `vault_store_credential` | Securely store an API key or secret |
 | **Get Credential** `vault_get_credential` | Retrieve a stored credential |
-| **Vault Publish** `vault_publish` | Publish an entry as a public note |
-| **Vault Explore** `vault_explore` | Browse by tag or category |
 | **Vault Pin** `vault_pin` | Pin an important entry to the top |
 | **Vault Delete** `vault_delete` | Delete an entry |
-| **Vault Link** `vault_link` | Link two entries together |
 | **Vault Tag** `vault_tag` | Add or update tags on an entry |
 
-#### Memory — Semantic Search (7 tools)
+#### Memory — Semantic Search (9 tools)
 
 > Find anything by meaning, not keywords. "What did I say about ETH yield?" just works.
 
@@ -161,6 +125,8 @@ Your AI loads your context before you type a single word.
 | **Memory List** `memory_list` | List recent memory entries |
 | **Memory Delete** `memory_delete` | Remove a memory entry |
 | **Memory Insight** `memory_insight` | AI-generated insights from your memory patterns |
+| **Memory Extract** `memory_extract` | Auto-extract discrete facts from any text and save each individually |
+| **Memory Consolidate** `memory_consolidate` | Merge overlapping memories on a topic into one clean summary |
 
 #### OS — Session Lifecycle (3 tools)
 
@@ -176,6 +142,16 @@ Your AI loads your context before you type a single word.
 
 Tell it what to do. It runs — on schedule, on-chain, or right now.
 
+#### Autonomous Monitor (3 tools)
+
+> Runs research on a schedule with no prompting needed.
+
+| Name | Description |
+|------|-------------|
+| **Create Monitor** `create_monitor` | Schedule a recurring research agent for any topic |
+| **List Monitors** `list_monitors` | View all active monitors with schedule and next run |
+| **Cancel Monitor** `cancel_monitor` | Stop a monitor by ID |
+
 #### Automations (6 tools)
 
 | Name | Description |
@@ -187,7 +163,7 @@ Tell it what to do. It runs — on schedule, on-chain, or right now.
 | **Automation Runs** `get_automation_runs` | Execution history |
 | **Run Now** `run_automation` | Trigger an automation manually |
 
-#### DeFi Execution (7 tools)
+#### DeFi Execution (6 tools)
 
 > Transactions are signed client-side — your private key never leaves your machine.
 
@@ -197,7 +173,6 @@ Tell it what to do. It runs — on schedule, on-chain, or right now.
 | **Estimate Swap** `estimate_swap` | Get a swap quote via 0x before executing |
 | **Swap Tokens** `swap_tokens` | Execute a token swap on Base |
 | **Send Token** `send_token` | Send ETH or ERC-20 to any address |
-| **Scan Wallet** `scan_wallet` | Analyze a wallet — holdings, activity, risk signals |
 | **Analyze Wallet** `analyze_wallet` | Deep wallet analysis with on-chain patterns |
 | **DeFi Yields** `get_defi_yields` | Find the best yield opportunities on Base |
 
@@ -215,20 +190,17 @@ Tell it what to do. It runs — on schedule, on-chain, or right now.
 | Name | Description |
 |------|-------------|
 | **Wallet Address** `get_wallet_address` | Get or generate your MCP wallet address |
-| **Set Telegram** `set_telegram` | Connect Telegram for automation notifications |
+| **Set Telegram** `set_telegram` | Connect Telegram for monitor and automation notifications |
 
-#### Playbooks (6 tools)
+#### Playbooks (3 tools)
 
 > Reusable sequences with safety rules applied before any action runs.
 
 | Name | Description |
 |------|-------------|
-| **Create Task** `create_task_packet` | Convert intent into a structured task with constraints |
-| **List Tasks** `list_task_packets` | List all task packets |
 | **List Playbooks** `list_playbooks` | Browse available playbooks |
 | **Run Playbook** `run_playbook` | Execute a playbook by ID |
-| **Noel Ledger** `get_noel_ledger` | Credits and full audit trail |
-| **Sentinel Rules** `get_sentinel_rules` | View safety rules applied before actions |
+| **Noel Ledger** `get_noel_ledger` | Audit trail of all agent actions |
 
 ---
 
@@ -236,6 +208,13 @@ Tell it what to do. It runs — on schedule, on-chain, or right now.
 
 Always informed before you act.
 
+#### Web Research (2 tools)
+
+| Name | Description |
+|------|-------------|
+| **Web Search** `web_search` | Search the web in real time for any topic |
+| **Web Scrape** `web_scrape` | Read the full content of any URL |
+
 #### Market & Prices (5 tools)
 
 | Name | Description |
@@ -260,10 +239,10 @@ Always informed before you act.
 | Name | Description |
 |------|-------------|
 | **Ask Noel** `ask_noel` | AI crypto analyst — opinions, trade ideas, market outlook |
-| **Market Thesis** `market_thesis` | Investment thesis for any token or sector |
-| **Trade Plan** `trade_plan` | Structured trade plan with entry, exit, and risk levels |
+| **Market Thesis** `market_thesis` | Investment thesis for any token or sector — auto-saved to vault |
+| **Trade Plan** `trade_plan` | Structured trade plan with entry, exit, and risk levels — auto-saved to vault |
 
-#### Agent Network (15 tools)
+#### Agent Network (8 tools)
 
 > Spin up multiple AI agents that research and monitor in parallel.
 
@@ -272,16 +251,9 @@ Always informed before you act.
 | **Start Swarm** `start_swarm` | Start the agent network |
 | **Stop Swarm** `stop_swarm` | Stop the active swarm |
 | **Swarm Status** `get_swarm_status` | Status and shared memory snapshot |
-| **Trigger Agent** `trigger_agent` | Run a specific agent now |
-| **Write Memory** `write_swarm_memory` | Write to shared agent memory |
-| **Read Memory** `get_swarm_memory` | Read from shared agent memory |
-| **Execution Scores** `get_execution_scores` | Performance scores across all agents |
 | **Swarm Research** `swarm_research` | Multi-agent research on any topic — saves to vault |
+| **Trigger Agent** `trigger_agent` | Run a specific agent now |
 | **Swarm Brief** `swarm_brief` | Summary of everything the swarm has found |
-| **Broadcast** `swarm_broadcast` | Send a message to all active agents |
-| **Swarm Pulse** `swarm_pulse` | Heartbeat — active agents and last activity |
-| **Swarm Reflect** `swarm_reflect` | Agents self-evaluate what went well |
-| **Swarm Watch** `swarm_watch` | Watch a token or topic for changes |
 | **List Agents** `list_agents` | Browse available specialist agents |
 | **Hire Agent** `hire_agent` | Hire an agent for a specific task |
 
@@ -289,17 +261,15 @@ Always informed before you act.
 
 ### 🛠 BUILD — Developer & Content Tools
 
-#### Coder (7 tools)
+#### Coder (5 tools)
 
 | Name | Description |
 |------|-------------|
-| **Scaffold Project** `scaffold_project` | Scaffold a DeFi or Web3 project |
-| **Generate Component** `generate_component` | React component with wagmi/viem |
 | **Generate Contract** `generate_contract` | Solidity smart contract |
 | **Audit Contract** `audit_contract` | Contract vulnerability audit |
 | **Explain Code** `explain_code` | Explain any code in plain English |
-| **Generate MCP Skill** `generate_mcp_skill` | Generate a new MCP tool from plain English |
 | **Review Code** `review_code` | Code review with actionable feedback |
+| **Generate MCP Skill** `generate_mcp_skill` | Generate a new MCP tool from plain English |
 
 #### Content & Humanizer (3 tools)
 
@@ -321,9 +291,7 @@ Always informed before you act.
 
 ## Configuration
 
-No config required to start — all tools work out of the box via the Noelclaw backend.
-
-For additional capabilities, add to the `env` block in your MCP config:
+All tools work out of the box. Add optional keys for extra features:
 
 ```json
 {
@@ -332,8 +300,8 @@ For additional capabilities, add to the `env` block in your MCP config:
       "command": "npx",
       "args": ["-y", "@noelclaw/mcp"],
       "env": {
-        "NOELCLAW_API_KEY": "noel_sk_...",
-        "ANTHROPIC_API_KEY": "sk-ant-..."
+        "FIRECRAWL_API_KEY": "fc-...",
+        "TRIGGER_SECRET_KEY": "tr_prod_..."
       }
     }
   }
@@ -342,10 +310,14 @@ For additional capabilities, add to the `env` block in your MCP config:
 
 | Variable | Purpose |
 |----------|---------|
-| `NOELCLAW_API_KEY` | Unlocks swarm, automation, framework, and agent tools. Get one at [app.noelclaw.com](https://app.noelclaw.com) |
-| `ANTHROPIC_API_KEY` | AI tools use your Claude quota — you pay, not the server |
-| `NOELCLAW_SESSION_TOKEN` | Session token from app.noelclaw.com (alternative to API key) |
-| `NOELCLAW_CONVEX_URL` | Override the backend URL (for self-hosted deployments) |
+| `NOELCLAW_SESSION_TOKEN` | Session token from noelclaw.com — recommended for full access |
+| `ANTHROPIC_API_KEY` | Use your own Claude quota |
+| `BANKR_API_KEY` | Use Bankr/Grok instead of Anthropic |
+| `FIRECRAWL_API_KEY` | Required for `web_search` and `web_scrape` |
+| `TRIGGER_SECRET_KEY` | Required for `create_monitor` |
+| `TELEGRAM_BOT_TOKEN` | Your Telegram bot token — for monitor notifications |
+| `TELEGRAM_CHAT_ID` | Your Telegram chat ID |
+| `ALCHEMY_API_KEY` | Faster swap quotes and Base balance lookups |
 
 ---
 
@@ -354,9 +326,12 @@ For additional capabilities, add to the `env` block in your MCP config:
 | Problem | Fix |
 |---------|-----|
 | Tools not appearing | Restart your MCP client after adding the config |
-| Swarm returns auth error | Add `NOELCLAW_API_KEY` — get one at app.noelclaw.com |
-| Server starts but no output | Expected — server waits for MCP stdin, not HTTP |
-| Old version loading | Run `npx clear-npx-cache` then restart your client |
+| Old version loading | Run `npx clear-npx-cache` then restart |
+| `web_search` fails | Add `FIRECRAWL_API_KEY` to env |
+| `create_monitor` fails | Add `TRIGGER_SECRET_KEY` to env |
+| No Telegram notifications | Add `TELEGRAM_BOT_TOKEN` and `TELEGRAM_CHAT_ID` to env |
+| Swap fails | Check balance with `get_portfolio`, confirm Base mainnet connectivity |
+| Rate limit (429) | Auto-retries up to 3× with backoff — no action needed |
 
 ---
 
@@ -365,4 +340,4 @@ For additional capabilities, add to the `env` block in your MCP config:
 - npm: [npmjs.com/package/@noelclaw/mcp](https://www.npmjs.com/package/@noelclaw/mcp)
 - GitHub: [github.com/noelclaw/mcp](https://github.com/noelclaw/mcp)
 - App: [app.noelclaw.com](https://app.noelclaw.com)
-- Docs: [docs.noelclaw.fun](https://docs.noelclaw.fun)
+- Docs: [docs.noelclaw.com](https://docs.noelclaw.com)

package/dist/agent-loop.js

@@ -3,7 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.runAgent = runAgent;
 const server_js_1 = require("./server.js");
 const llm_js_1 = require("./llm.js");
-const SYSTEM_PROMPT = "You are Noelclaw, a persistent AI with 74 tools covering memory, automations, DeFi execution, research, and code. " +
+const convex_js_1 = require("./convex.js");
+const SYSTEM_PROMPT = "You are Noelclaw, a persistent AI with 76 tools covering memory, automations, DeFi execution, research, and code. " +
     "Be concise and direct. Use tools when needed. Summarize tool results in plain English.";
 async function runAgent(userMessage, history, onToolCall) {
     const anthropicKey = process.env.ANTHROPIC_API_KEY;
@@ -12,9 +13,16 @@ async function runAgent(userMessage, history, onToolCall) {
         return runAnthropicLoop(anthropicKey, userMessage, history, onToolCall);
     if (bankrKey)
         return runBankrLoop(bankrKey, userMessage, history, onToolCall);
-    // Fallback — no direct tool execution, just LLM chat via Convex
-    const text = await (0, llm_js_1.callLLM)(SYSTEM_PROMPT, userMessage, 1024, history);
-    return { text, toolCalls: [] };
+    // No direct key — proxy through Noelclaw backend. Wallet auto-creates at ~/.noelclaw/wallet.json
+    // on first use and signs requests transparently. No account or config needed.
+    try {
+        return await runConvexProxiedLoop(userMessage, history, onToolCall);
+    }
+    catch {
+        // Network down or backend unavailable — plain chat fallback
+        const text = await (0, llm_js_1.callLLM)(SYSTEM_PROMPT, userMessage, 1024, history);
+        return { text, toolCalls: [] };
+    }
 }
 // ── Anthropic agent loop ─────────────────────────────────────────────────────
 function toAnthropicTool(tool) {
@@ -80,6 +88,55 @@ async function runAnthropicLoop(apiKey, userMessage, history, onToolCall) {
     }
     return { text: "Reached max tool iterations.", toolCalls };
 }
+// ── Convex-proxied Anthropic loop (session token only — platform covers LLM) ──
+async function runConvexProxiedLoop(userMessage, history, onToolCall) {
+    const model = process.env.ANTHROPIC_MODEL ?? "claude-haiku-4-5-20251001";
+    const tools = server_js_1.ALL_TOOLS.map(toAnthropicTool);
+    const toolCalls = [];
+    const messages = [
+        ...history.map(h => ({ role: h.role, content: h.content })),
+        { role: "user", content: userMessage },
+    ];
+    for (let turn = 0; turn < 10; turn++) {
+        // callConvex handles wallet/session auth automatically; 90s timeout matches the proxy endpoint
+        const data = await (0, convex_js_1.callConvex)("/llm/complete", "POST", {
+            model,
+            max_tokens: 2048,
+            system: SYSTEM_PROMPT,
+            tools,
+            messages,
+        }, "llm_complete", 90000);
+        messages.push({ role: "assistant", content: data.content });
+        if (data.stop_reason !== "tool_use") {
+            const text = data.content
+                .filter(b => b.type === "text")
+                .map(b => b.text)
+                .join("");
+            return { text, toolCalls };
+        }
+        const toolResults = [];
+        for (const block of data.content) {
+            if (block.type !== "tool_use")
+                continue;
+            onToolCall(block.name);
+            toolCalls.push({ name: block.name });
+            let resultText;
+            try {
+                const handler = server_js_1.HANDLER_MAP.get(block.name);
+                if (!handler)
+                    throw new Error(`Unknown tool: ${block.name}`);
+                const result = await handler(block.name, block.input ?? {});
+                resultText = result?.content?.[0]?.text ?? "Done.";
+            }
+            catch (err) {
+                resultText = `Error: ${err.message}`;
+            }
+            toolResults.push({ type: "tool_result", tool_use_id: block.id, content: resultText });
+        }
+        messages.push({ role: "user", content: toolResults });
+    }
+    return { text: "Reached max tool iterations.", toolCalls };
+}
 // ── Bankr (OpenAI-compatible) agent loop ─────────────────────────────────────
 function toBankrTool(tool) {
     return {

package/dist/cli.js

@@ -90,7 +90,7 @@ async function main() {
         ? `${C.green}Anthropic${C.reset} ${C.dim}(full tool use)${C.reset}`
         : process.env.BANKR_API_KEY
             ? `${C.green}Bankr${C.reset} ${C.dim}(full tool use)${C.reset}`
-            : `${C.yellow}Convex chat${C.reset} ${C.dim}(no tool execution — set ANTHROPIC_API_KEY for full mode)${C.reset}`;
+            : `${C.green}Noelclaw${C.reset} ${C.dim}(full tool use · auto-wallet)${C.reset}`;
     console.log(`  ${C.dim}Mode:${C.reset} ${mode}\n`);
     const history = [];
     const rl = readline.createInterface({

package/dist/convex.js

@@ -19,15 +19,15 @@ exports.PaymentRequiredError = PaymentRequiredError;
 function buildPaymentHeader(txHash, requestId) {
     return Buffer.from(`${txHash}:${requestId}`).toString("base64");
 }
-async function attemptConvex(url, method, headers, body) {
+async function attemptConvex(url, method, headers, body, timeoutMs = 30000) {
     return fetch(url, {
         method,
         headers,
         body: body ? JSON.stringify(body) : undefined,
-        signal: AbortSignal.timeout(30000),
+        signal: AbortSignal.timeout(timeoutMs),
     });
 }
-async function callConvex(path, method, body, toolName = "unknown") {
+async function callConvex(path, method, body, toolName = "unknown", timeoutMs = 30000) {
     const url = `${CONVEX_SITE}${path}`;
     const headers = { "Content-Type": "application/json" };
     const apiKey = process.env.NOELCLAW_API_KEY;
@@ -72,7 +72,7 @@ async function callConvex(path, method, body, toolName = "unknown") {
         }
         let res;
         try {
-            res = await attemptConvex(url, method, headers, body);
+            res = await attemptConvex(url, method, headers, body, timeoutMs);
         }
         catch (err) {
             lastError = err;
@@ -85,8 +85,8 @@ async function callConvex(path, method, body, toolName = "unknown") {
         if (res.status === 401) {
             const b = await res.json().catch(() => ({}));
             throw new Error(`🔑 ${b.message || "Authentication required"}\n\n` +
-                `→ Get your API key: ${b.url || "https://noelclaw.com"}\n\n` +
-                `Hint: ${b.hint || "Set NOELCLAW_API_KEY=noel_sk_xxx in your MCP config"}\n\n` +
+                `→ Sign in at: ${b.url || "https://noelclaw.com"}\n\n` +
+                `Hint: ${b.hint || 'Add NOELCLAW_SESSION_TOKEN=noel_... to the env block in your MCP config'}\n\n` +
                 `${b.alternative ? `Alternative: ${b.alternative}` : ""}`);
         }
         if (RETRY_STATUSES.has(res.status) && attempt < RETRY_DELAYS.length) {

package/dist/index.js

@@ -35,26 +35,33 @@ async function main() {
     const categories = [
         { label: "Market", count: 5, tools: "get_market_data · get_token_data · compare_tokens · market_overview · token_history" },
         { label: "Insight", count: 3, tools: "ask_noel · market_thesis · trade_plan" },
-        { label: "DeFi", count: 6, tools: "portfolio · swap · send · scan_wallet · estimate · get_defi_yields" },
-        { label: "Automation", count: 5, tools: "create · list · pause · delete · runs" },
+        { label: "DeFi", count: 6, tools: "get_portfolio · estimate_swap · swap_tokens · send_token · analyze_wallet · get_defi_yields" },
+        { label: "Automation", count: 6, tools: "create · list · pause · delete · runs · run_now" },
+        { label: "Swarm", count: 6, tools: "start_swarm · stop_swarm · get_swarm_status · swarm_research · trigger_agent · swarm_brief" },
+        { label: "Framework", count: 3, tools: "list_playbooks · run_playbook · get_noel_ledger" },
+        { label: "Vault", count: 12, tools: "save · read · list · search · history · diff · export · credential · pin · delete · link · tag" },
+        { label: "Wallet", count: 2, tools: "get_wallet_address · set_telegram" },
+        { label: "MiroShark", count: 3, tools: "simulate · status · stop" },
         { label: "Scanner", count: 4, tools: "scan_dips · scan_momentum · score_token · check_token" },
         { label: "Agents", count: 2, tools: "list_agents · hire_agent" },
-        { label: "Swarm", count: 11, tools: "start · stop · status · memory · scores · research · trigger · brief · broadcast · pulse" },
-        { label: "Framework", count: 6, tools: "create_task · list_tasks · list_playbooks · run_playbook · ledger · sentinel" },
-        { label: "Vault", count: 18, tools: "save · read · list · search · history · diff · export · remember · context · credential · publish · explore · connect · pin · delete · link · tag" },
-        { label: "Memory", count: 8, tools: "add · search · context · profile · connect · list · delete · update" },
-        { label: "MiroShark", count: 3, tools: "simulate · status · stop" },
-        { label: "Wallet", count: 2, tools: "get_wallet_address · set_telegram" },
         { label: "Social", count: 3, tools: "humanize_text · write_thread · write_post" },
-        { label: "Coder", count: 7, tools: "scaffold_project · generate_component · generate_contract · audit_contract · explain_code · review_code · generate_mcp_skill" },
+        { label: "Coder", count: 5, tools: "generate_contract · audit_contract · explain_code · review_code · generate_mcp_skill" },
         { label: "Base", count: 4, tools: "query_vaults · list_markets · prepare_deposit · chain_stats" },
+        { label: "Memory", count: 9, tools: "add · search · context · profile · list · delete · insight · extract · consolidate" },
+        { label: "OS", count: 3, tools: "noel_boot · noel_status · noel_shutdown" },
+        { label: "Research", count: 2, tools: "web_scrape · web_search" },
+        { label: "Monitor", count: 3, tools: "create_monitor · list_monitors · cancel_monitor" },
     ];
     const total = server_js_1.ALL_TOOLS.length;
     divider();
     process.stderr.write(`\n`);
-    line("version", `v2.4.0  ${C.dim}MCP protocol 2.1.0${C.reset}`);
-    line("network", `Base mainnet  ${C.dim}via 0x Protocol · ethers v6${C.reset}`);
-    line("ai", `Bankr LLM  ${C.dim}grok-3 · llm.bankr.bot${C.reset}`);
+    const aiMode = process.env.ANTHROPIC_API_KEY
+        ? `Anthropic  ${C.dim}claude-haiku-4.5${C.reset}`
+        : process.env.BANKR_API_KEY
+            ? `Bankr  ${C.dim}claude-haiku-4.5${C.reset}`
+            : `Noelclaw  ${C.dim}proxy · auto-auth${C.reset}`;
+    line("version", `v3.3.0  ${C.dim}MCP protocol 2.1.0${C.reset}`);
+    line("ai", aiMode);
     line("tools", `${C.white}${C.bold}${total} tools loaded${C.reset}  ${C.dim}across ${categories.length} categories${C.reset}`);
     process.stderr.write(`\n`);
     divider();

package/dist/llm.js

@@ -75,7 +75,7 @@ async function callAnthropic(apiKey, systemPrompt, userPrompt, maxTokens, histor
     return data.content?.find(b => b.type === "text")?.text ?? "";
 }
 async function callBankr(apiKey, systemPrompt, userPrompt, maxTokens, history, timeoutMs) {
-    const model = process.env.BANKR_MODEL ?? "grok-3";
+    const model = process.env.BANKR_MODEL ?? "claude-haiku-4.5";
     const res = await fetch(BANKR_URL, {
         method: "POST",
         headers: { "Content-Type": "application/json", "X-API-Key": apiKey },

package/dist/server.js

@@ -22,6 +22,8 @@ const coder_js_1 = require("./tools/coder.js");
 const base_js_1 = require("./tools/base.js");
 const memory_js_1 = require("./tools/memory.js");
 const os_js_1 = require("./tools/os.js");
+const research_js_1 = require("./tools/research.js");
+const monitor_js_1 = require("./tools/monitor.js");
 const PRIVATE_KEY_RESPONSE = {
     content: [{
             type: "text",
@@ -52,7 +54,9 @@ exports.ALL_TOOLS = [
     ...base_js_1.BASE_TOOLS, // 4 — query_vaults, list_markets, prepare_deposit, chain_stats
     ...memory_js_1.MEMORY_TOOLS, // 9 — memory_add, memory_search, memory_context, memory_profile, memory_list, memory_delete, memory_insight, memory_extract, memory_consolidate
     ...os_js_1.OS_TOOLS, // 3 — noel_status, noel_boot, noel_shutdown
-    // total: 76
+    ...research_js_1.RESEARCH_TOOLS, // 2 — web_scrape, web_search
+    ...monitor_js_1.MONITOR_TOOLS, // 3 — create_monitor, list_monitors, cancel_monitor
+    // total: 81
 ];
 exports.HANDLER_MAP = new Map([
     ...market_js_1.MARKET_TOOLS.map(t => [t.name, market_js_1.handleMarketTool]),
@@ -71,8 +75,10 @@ exports.HANDLER_MAP = new Map([
     ...base_js_1.BASE_TOOLS.map(t => [t.name, base_js_1.handleBaseTool]),
     ...memory_js_1.MEMORY_TOOLS.map(t => [t.name, memory_js_1.handleMemoryTool]),
     ...os_js_1.OS_TOOLS.map(t => [t.name, os_js_1.handleOsTool]),
+    ...research_js_1.RESEARCH_TOOLS.map(t => [t.name, research_js_1.handleResearchTool]),
+    ...monitor_js_1.MONITOR_TOOLS.map(t => [t.name, monitor_js_1.handleMonitorTool]),
 ]);
-exports.server = new index_js_1.Server({ name: "noelclaw", version: "3.2.0" }, { capabilities: { tools: {} } });
+exports.server = new index_js_1.Server({ name: "noelclaw", version: "3.3.0" }, { capabilities: { tools: {} } });
 exports.server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => ({ tools: exports.ALL_TOOLS }));
 exports.server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
     const { name, arguments: args } = request.params;

package/dist/tools/defi.js

@@ -168,12 +168,6 @@ async function handleDefiTool(name, args) {
             if (!result.success)
                 return { content: [{ type: "text", text: `Send failed: ${result.error}` }], isError: true };
             const txHash = await (0, wallet_js_1.signAndBroadcast)(wallet, result.txData);
-            if (result.feeTxData) {
-                try {
-                    await (0, wallet_js_1.signAndBroadcast)(wallet, result.feeTxData);
-                }
-                catch { /* non-fatal */ }
-            }
             return {
                 content: [{
                         type: "text",

package/dist/tools/insight.js

@@ -167,7 +167,20 @@ async function handleInsightTool(name, args) {
         try {
             const systemPrompt = await buildSystemPrompt(`${token} ${context ?? ""}`);
             const answer = await (0, llm_js_1.callLLM)(systemPrompt, prompt, 1200);
-            return { content: [{ type: "text", text: answer }] };
+            const date = new Date().toISOString().slice(0, 10);
+            (0, convex_js_1.callConvex)("/vault/save", "POST", {
+                type: "research",
+                title: `${token.toUpperCase()} Thesis — ${date}`,
+                content: answer,
+                key: `thesis/${token.toLowerCase()}-${date}`,
+                agentId: "noel",
+                tags: ["thesis", token.toLowerCase()],
+                commitMsg: "market_thesis auto-save",
+            }, "vault_save").catch(() => { });
+            const suggest = process.env.TRIGGER_SECRET_KEY
+                ? `\n\n---\n💡 Want to stay on top of this? Use \`create_monitor\` to get automatic research briefings on ${token.toUpperCase()} delivered on a schedule — no prompting needed.`
+                : "";
+            return { content: [{ type: "text", text: answer + suggest }] };
         }
         catch (err) {
             return { content: [{ type: "text", text: `market_thesis error: ${err.message}` }], isError: true };
@@ -228,7 +241,20 @@ async function handleInsightTool(name, args) {
         try {
             const systemPrompt = await buildSystemPrompt(`${token} trade ${riskTolerance} ${timeframe ?? ""}`);
             const answer = await (0, llm_js_1.callLLM)(systemPrompt, prompt, 1200);
-            return { content: [{ type: "text", text: answer }] };
+            const date = new Date().toISOString().slice(0, 10);
+            (0, convex_js_1.callConvex)("/vault/save", "POST", {
+                type: "execution",
+                title: `Trade Plan: ${token.toUpperCase()} ${side.toUpperCase()} — ${date}`,
+                content: answer,
+                key: `trade-plan/${token.toLowerCase()}-${side}-${date}`,
+                agentId: "noel",
+                tags: ["trade-plan", token.toLowerCase(), side],
+                commitMsg: "trade_plan auto-save",
+            }, "vault_save").catch(() => { });
+            const suggest = process.env.TRIGGER_SECRET_KEY
+                ? `\n\n---\n💡 Want to stay on top of this? Use \`create_monitor\` to get automatic research briefings on ${token.toUpperCase()} delivered on a schedule — no prompting needed.`
+                : "";
+            return { content: [{ type: "text", text: answer + suggest }] };
         }
         catch (err) {
             return { content: [{ type: "text", text: `trade_plan error: ${err.message}` }], isError: true };

package/dist/tools/monitor.js

@@ -0,0 +1,226 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MONITOR_TOOLS = void 0;
+exports.handleMonitorTool = handleMonitorTool;
+const zod_1 = require("zod");
+const convex_js_1 = require("../convex.js");
+const TRIGGER_BASE = "https://api.trigger.dev/api/v1";
+const MONITOR_TASK_ID = "noelclaw-monitor";
+exports.MONITOR_TOOLS = [
+    {
+        name: "create_monitor",
+        description: "Set up a recurring autonomous monitor — runs on a schedule, researches a topic, saves findings to vault, " +
+            "and sends a Telegram notification. No chat needed: the agent runs completely on its own. " +
+            "Requires TRIGGER_SECRET_KEY env var (trigger.dev). " +
+            "Examples: monitor news on a topic daily, track competitors weekly, get morning briefings.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                topic: { type: "string", description: "What to monitor — topic, keyword, or research question" },
+                schedule: {
+                    type: "string",
+                    description: "Cron expression or preset. Presets: 'daily-8am', 'daily-6pm', 'weekly-monday', 'hourly'. Or raw cron: '0 8 * * *'",
+                },
+                label: { type: "string", description: "Optional: short label to identify this monitor (e.g. 'morning brief', 'competitor watch')" },
+            },
+            required: ["topic", "schedule"],
+        },
+    },
+    {
+        name: "list_monitors",
+        description: "List all active autonomous monitors — shows topic, schedule, next run, and monitor ID.",
+        inputSchema: { type: "object", properties: {}, required: [] },
+    },
+    {
+        name: "cancel_monitor",
+        description: "Cancel and delete an autonomous monitor by its ID. Use list_monitors to get the ID.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                id: { type: "string", description: "Monitor ID (from list_monitors)" },
+            },
+            required: ["id"],
+        },
+    },
+];
+const CRON_PRESETS = {
+    "daily-8am": "0 8 * * *",
+    "daily-6pm": "0 18 * * *",
+    "weekly-monday": "0 8 * * 1",
+    "hourly": "0 * * * *",
+};
+const CreateSchema = zod_1.z.object({
+    topic: zod_1.z.string().min(1).max(200),
+    schedule: zod_1.z.string().min(1),
+    label: zod_1.z.string().max(80).optional(),
+});
+const CancelSchema = zod_1.z.object({ id: zod_1.z.string().min(1) });
+function getKey() {
+    return process.env.TRIGGER_SECRET_KEY ?? null;
+}
+function noKeyMsg() {
+    return {
+        content: [{
+                type: "text",
+                text: [
+                    `⚠️ **TRIGGER_SECRET_KEY not set.**`,
+                    ``,
+                    `To enable autonomous monitors:`,
+                    `1. Sign up at trigger.dev (free tier available)`,
+                    `2. Create a project, go to API Keys → copy your Secret Key`,
+                    `3. Add to your MCP config env block: \`"TRIGGER_SECRET_KEY": "tr_prod_..."\``,
+                    `4. In the noelclaw worker directory, run: \`npx trigger.dev@latest deploy\``,
+                    ``,
+                    `Then monitors will run autonomously — no chat needed.`,
+                ].join("\n"),
+            }],
+        isError: true,
+    };
+}
+function resolveCron(input) {
+    return CRON_PRESETS[input] ?? input;
+}
+async function handleMonitorTool(name, args) {
+    if (name === "create_monitor") {
+        const parsed = CreateSchema.safeParse(args);
+        if (!parsed.success)
+            return { content: [{ type: "text", text: `Invalid input: ${parsed.error.issues[0].message}` }], isError: true };
+        const key = getKey();
+        if (!key)
+            return noKeyMsg();
+        const { topic, schedule, label } = parsed.data;
+        const cron = resolveCron(schedule);
+        // Unique stable ID — worker reads config from vault using this as key
+        const externalId = `monitor-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 7)}`;
+        try {
+            const res = await fetch(`${TRIGGER_BASE}/schedules`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json", "Authorization": `Bearer ${key}` },
+                body: JSON.stringify({ task: MONITOR_TASK_ID, cron, externalId, deduplicationKey: externalId }),
+                signal: AbortSignal.timeout(10000),
+            });
+            if (!res.ok) {
+                const err = await res.text();
+                return { content: [{ type: "text", text: `Failed to create monitor: ${err}` }], isError: true };
+            }
+            const data = await res.json();
+            const scheduleId = data.id ?? externalId;
+            // Save config to vault so the worker can retrieve topic + metadata
+            let configSaved = true;
+            try {
+                await (0, convex_js_1.callConvex)("/vault/save", "POST", {
+                    type: "workflow",
+                    title: `Monitor: ${label ?? topic}`,
+                    content: JSON.stringify({ topic, label: label ?? topic, cron, scheduleId, externalId }),
+                    key: `monitor-config/${externalId}`,
+                    agentId: "os",
+                    tags: ["monitor-config"],
+                    commitMsg: "create_monitor config",
+                }, "vault_save");
+            }
+            catch {
+                configSaved = false;
+            }
+            return {
+                content: [{
+                        type: "text",
+                        text: [
+                            `✅ **Monitor created**`,
+                            ``,
+                            `📌 Topic:    ${topic}`,
+                            `🕐 Schedule: ${cron}${CRON_PRESETS[schedule] ? ` (${schedule})` : ""}`,
+                            `🆔 ID:       ${scheduleId}`,
+                            data.nextRun ? `⏭️ Next run: ${new Date(data.nextRun).toUTCString()}` : "",
+                            ``,
+                            configSaved
+                                ? `The agent will research "${topic}" on schedule, save findings to vault, and send a Telegram notification if configured.`
+                                : `⚠️ Monitor schedule created but config save failed — the agent may use a default topic on first run. Try \`cancel_monitor\` and recreate.`,
+                            `Use \`list_monitors\` to see all active monitors.`,
+                        ].filter(Boolean).join("\n"),
+                    }],
+            };
+        }
+        catch (err) {
+            return { content: [{ type: "text", text: `Monitor error: ${err.message}` }], isError: true };
+        }
+    }
+    if (name === "list_monitors") {
+        const key = getKey();
+        if (!key)
+            return noKeyMsg();
+        try {
+            const res = await fetch(`${TRIGGER_BASE}/schedules`, {
+                headers: { "Authorization": `Bearer ${key}` },
+                signal: AbortSignal.timeout(10000),
+            });
+            if (!res.ok) {
+                const err = await res.text();
+                return { content: [{ type: "text", text: `Failed to list monitors: ${err}` }], isError: true };
+            }
+            const data = await res.json();
+            const schedules = (data.data ?? []).filter((s) => (s.task ?? s.taskIdentifier) === MONITOR_TASK_ID);
+            if (!schedules.length) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `No active monitors.\n\nUse \`create_monitor\` to set up an autonomous agent that runs on a schedule.`,
+                        }],
+                };
+            }
+            // Load topic labels from vault for each schedule
+            const configMap = new Map();
+            await Promise.allSettled(schedules
+                .filter(s => s.externalId)
+                .map(async (s) => {
+                try {
+                    const cfg = await (0, convex_js_1.callConvex)(`/vault/read?key=monitor-config/${s.externalId}`, "GET", undefined, "vault_read");
+                    if (cfg?.content) {
+                        const parsed = JSON.parse(cfg.content);
+                        configMap.set(s.externalId, { topic: parsed.topic, label: parsed.label ?? parsed.topic });
+                    }
+                }
+                catch { /* skip — show raw externalId */ }
+            }));
+            const lines = [`📋 **Active Monitors** — ${schedules.length} running\n`];
+            for (const s of schedules) {
+                const cfg = s.externalId ? configMap.get(s.externalId) : undefined;
+                const label = cfg?.label ?? s.externalId ?? s.id;
+                const topic = cfg?.topic ? ` — ${cfg.topic}` : "";
+                const next = s.nextRun ? new Date(s.nextRun).toUTCString() : "unknown";
+                lines.push(`**${label}**${topic}`);
+                lines.push(`  ID: \`${s.id}\` · Cron: \`${s.cron}\` · Next: ${next}`);
+                lines.push("");
+            }
+            lines.push(`Use \`cancel_monitor id: "<id>"\` to stop a monitor.`);
+            return { content: [{ type: "text", text: lines.join("\n") }] };
+        }
+        catch (err) {
+            return { content: [{ type: "text", text: `List error: ${err.message}` }], isError: true };
+        }
+    }
+    if (name === "cancel_monitor") {
+        const parsed = CancelSchema.safeParse(args);
+        if (!parsed.success)
+            return { content: [{ type: "text", text: `Invalid input: ${parsed.error.issues[0].message}` }], isError: true };
+        const key = getKey();
+        if (!key)
+            return noKeyMsg();
+        const { id } = parsed.data;
+        try {
+            const res = await fetch(`${TRIGGER_BASE}/schedules/${id}`, {
+                method: "DELETE",
+                headers: { "Authorization": `Bearer ${key}` },
+                signal: AbortSignal.timeout(10000),
+            });
+            if (!res.ok) {
+                const err = await res.text();
+                return { content: [{ type: "text", text: `Failed to cancel monitor: ${err}` }], isError: true };
+            }
+            return { content: [{ type: "text", text: `✅ Monitor \`${id}\` cancelled.` }] };
+        }
+        catch (err) {
+            return { content: [{ type: "text", text: `Cancel error: ${err.message}` }], isError: true };
+        }
+    }
+    return null;
+}

package/dist/tools/os.js

@@ -99,7 +99,7 @@ async function handleOsTool(name, args) {
                 lines.push("");
             }
             lines.push(swarmActive
-                ? `💡 Run \`swarm_pulse\` for a live snapshot from all agents.`
+                ? `💡 Run \`get_swarm_status\` for a live snapshot from all agents.`
                 : `💡 Run \`noel_boot\` to wake up the full system.`);
             return { content: [{ type: "text", text: lines.join("\n") }] };
         }
@@ -169,7 +169,7 @@ async function handleOsTool(name, args) {
                 lines.push("");
             }
             lines.push(`**Quick actions:**`);
-            lines.push(`  • \`swarm_pulse\` — live readings from all agents`);
+            lines.push(`  • \`get_swarm_status\` — live readings from all agents`);
             if (focus) {
                 lines.push(`  • \`swarm_research topic: "${focus}"\` — deep research session`);
                 lines.push(`  • \`memory_insight topic: "${focus}"\` — full intelligence report`);

package/dist/tools/research.js

@@ -0,0 +1,154 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RESEARCH_TOOLS = void 0;
+exports.handleResearchTool = handleResearchTool;
+const zod_1 = require("zod");
+const FC_BASE = "https://api.firecrawl.dev/v1";
+exports.RESEARCH_TOOLS = [
+    {
+        name: "web_scrape",
+        description: "Fetch and extract clean readable content from any URL — returns markdown. " +
+            "Use when an agent needs to read an article, docs page, GitHub repo, or any web page. " +
+            "Set FIRECRAWL_API_KEY for best quality (firecrawl.dev). Falls back to basic fetch if not set.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                url: { type: "string", description: "URL to fetch" },
+                focus: { type: "string", description: "Optional: specific topic or section to extract from the page" },
+            },
+            required: ["url"],
+        },
+    },
+    {
+        name: "web_search",
+        description: "Search the web and get clean results: titles, URLs, and content snippets. " +
+            "Use for research on any topic, finding recent news, or gathering live information. " +
+            "Requires FIRECRAWL_API_KEY (firecrawl.dev).",
+        inputSchema: {
+            type: "object",
+            properties: {
+                query: { type: "string", description: "Search query" },
+                limit: { type: "number", description: "Max results (default 5, max 10)" },
+            },
+            required: ["query"],
+        },
+    },
+];
+const ScrapeSchema = zod_1.z.object({
+    url: zod_1.z.string().url(),
+    focus: zod_1.z.string().optional(),
+});
+const SearchSchema = zod_1.z.object({
+    query: zod_1.z.string().min(1),
+    limit: zod_1.z.number().int().min(1).max(10).optional(),
+});
+async function firecrawlScrape(url) {
+    const key = process.env.FIRECRAWL_API_KEY;
+    if (!key)
+        return null;
+    try {
+        const res = await fetch(`${FC_BASE}/scrape`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json", "Authorization": `Bearer ${key}` },
+            body: JSON.stringify({ url, formats: ["markdown"], onlyMainContent: true }),
+            signal: AbortSignal.timeout(20000),
+        });
+        if (!res.ok)
+            return null;
+        const data = await res.json();
+        return data.data?.markdown ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+async function basicFetch(url) {
+    try {
+        const res = await fetch(url, {
+            headers: { "User-Agent": "Mozilla/5.0 (compatible; NoelclawBot/1.0)" },
+            signal: AbortSignal.timeout(10000),
+        });
+        if (!res.ok)
+            return null;
+        const html = await res.text();
+        return html
+            .replace(/<script[\s\S]*?<\/script>/gi, "")
+            .replace(/<style[\s\S]*?<\/style>/gi, "")
+            .replace(/<[^>]+>/g, " ")
+            .replace(/\s+/g, " ")
+            .trim()
+            .slice(0, 4000);
+    }
+    catch {
+        return null;
+    }
+}
+async function handleResearchTool(name, args) {
+    if (name === "web_scrape") {
+        const parsed = ScrapeSchema.safeParse(args);
+        if (!parsed.success)
+            return { content: [{ type: "text", text: `Invalid input: ${parsed.error.issues[0].message}` }], isError: true };
+        const { url, focus } = parsed.data;
+        let content = await firecrawlScrape(url);
+        const source = content ? "Firecrawl" : "basic fetch";
+        if (!content)
+            content = await basicFetch(url);
+        if (!content) {
+            return { content: [{ type: "text", text: `Could not fetch ${url} — page may require JavaScript or block crawlers.` }], isError: true };
+        }
+        const focusNote = focus ? `\n\n_Focus: ${focus}_\n\n` : "\n\n";
+        const body = content.length > 6000 ? content.slice(0, 6000) + "\n\n…(truncated)" : content;
+        return { content: [{ type: "text", text: `**${url}**${focusNote}${body}\n\n_Source: ${source}_` }] };
+    }
+    if (name === "web_search") {
+        const parsed = SearchSchema.safeParse(args);
+        if (!parsed.success)
+            return { content: [{ type: "text", text: `Invalid input: ${parsed.error.issues[0].message}` }], isError: true };
+        const { query, limit = 5 } = parsed.data;
+        const key = process.env.FIRECRAWL_API_KEY;
+        if (!key) {
+            return {
+                content: [{
+                        type: "text",
+                        text: [
+                            `web_search requires FIRECRAWL_API_KEY.`,
+                            ``,
+                            `Get a free key at firecrawl.dev, then add to your MCP config:`,
+                            `\`"env": { "FIRECRAWL_API_KEY": "fc-..." }\``,
+                        ].join("\n"),
+                    }],
+                isError: true,
+            };
+        }
+        try {
+            const res = await fetch(`${FC_BASE}/search`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json", "Authorization": `Bearer ${key}` },
+                body: JSON.stringify({ query, limit }),
+                signal: AbortSignal.timeout(15000),
+            });
+            if (!res.ok) {
+                const err = await res.text();
+                return { content: [{ type: "text", text: `Search failed: ${err}` }], isError: true };
+            }
+            const data = await res.json();
+            const results = data.data ?? [];
+            if (!results.length) {
+                return { content: [{ type: "text", text: `No results found for: "${query}"` }] };
+            }
+            const lines = [`🔍 **Web Search: "${query}"** — ${results.length} results\n`];
+            for (const r of results) {
+                lines.push(`**${r.title ?? r.url}**`);
+                lines.push(r.url);
+                if (r.description)
+                    lines.push(r.description.slice(0, 200));
+                lines.push("");
+            }
+            return { content: [{ type: "text", text: lines.join("\n") }] };
+        }
+        catch (err) {
+            return { content: [{ type: "text", text: `Search error: ${err.message}` }], isError: true };
+        }
+    }
+    return null;
+}

package/dist/tools/swarm.js

@@ -102,10 +102,9 @@ 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 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` +
-    `  "env": { "NOELCLAW_API_KEY": "noel_sk_..." }`;
+const NO_KEY_MSG = `⚠️ Swarm auth failed.\n\n` +
+    `Your local wallet auto-generates on first use at ~/.noelclaw/wallet.json — no API key needed.\n\n` +
+    `Try restarting your MCP client. If the error persists, run \`get_wallet_address\` to confirm the wallet is initialised.`;
 function swarmAuthError(err) {
     const msg = err instanceof Error ? err.message : String(err);
     const isAuth = msg.includes("🔑") || msg.includes("Authentication") || msg.includes("401");
@@ -240,7 +239,7 @@ async function handleSwarmTool(name, args) {
                             ``,
                             data.message ?? "Research triggered. Findings will appear in vault automatically.",
                             ``,
-                            `**Next:** \`swarm_reflect focus: "${topic}"\` to consolidate findings`,
+                            `**Next:** \`memory_consolidate topic: "${topic}"\` to merge findings into one summary`,
                             `Or: \`memory_insight topic: "${topic}"\` to see full intelligence report`,
                         ].join("\n"),
                     }],
@@ -279,7 +278,7 @@ async function handleSwarmTool(name, args) {
                             resultText,
                             ``,
                             `Findings saved to vault automatically.`,
-                            `Use \`swarm_reflect\` to consolidate or \`memory_insight topic: "${contextQuery.split(" ")[1] ?? agentId}"\` for full report.`,
+                            `Use \`memory_consolidate topic: "${contextQuery.split(" ")[1] ?? agentId}"\` to merge findings, or \`memory_insight\` for full report.`,
                         ].filter(Boolean).join("\n"),
                     }],
             };
@@ -299,7 +298,8 @@ async function handleSwarmTool(name, args) {
             }
             if (data.error)
                 return { content: [{ type: "text", text: `Error: ${data.error}` }], isError: true };
-            const entries = (data.entries ?? []).filter((e) => e.agentId === "market-monitor" || e.agentId === "sentiment-tracker");
+            const SWARM_AGENTS = new Set(["market-monitor", "sentiment-tracker", "onchain-analyst", "news-aggregator", "risk-verifier", "memory-manager", "workflow-executor"]);
+            const entries = (data.entries ?? []).filter((e) => e.agentId && SWARM_AGENTS.has(e.agentId));
             if (!entries.length) {
                 return { content: [{ type: "text", text: `No swarm research in vault yet.\nStart the swarm with \`start_swarm\` or run \`swarm_research topic: "BTC"\` to build your knowledge base.` }] };
             }

package/dist/tools/vault.js

@@ -18,7 +18,7 @@ exports.VAULT_TOOLS = [
             type: "object",
             properties: {
                 type: { type: "string", enum: [...VAULT_TYPES], description: "Entry type" },
-                title: { type: "string", description: "Human-readable title" },
+                title: { type: "string", description: "Human-readable title (auto-generated from content if omitted)" },
                 content: { type: "string", description: "Main content — markdown, JSON, code, or plain text" },
                 key: { type: "string", description: "Optional slug key e.g. 'research/btc-dominance-analysis'. Auto-generated if omitted." },
                 contentType: { type: "string", enum: ["markdown", "json", "text", "code"], description: "Content format hint" },
@@ -27,7 +27,7 @@ exports.VAULT_TOOLS = [
                 commitMsg: { type: "string", description: "Commit message for this version, e.g. 'initial research', 'refined with on-chain data'" },
                 metadata: { type: "string", description: "Optional JSON string for extra structured fields" },
             },
-            required: ["type", "title", "content"],
+            required: ["type", "content"],
         },
     },
     {
@@ -179,7 +179,7 @@ exports.VAULT_TOOLS = [
 // ─── Zod schemas ─────────────────────────────────────────────────────────────
 const SaveSchema = zod_1.z.object({
     type: zod_1.z.enum(VAULT_TYPES),
-    title: zod_1.z.string().min(1),
+    title: zod_1.z.string().optional(),
     content: zod_1.z.string().min(1),
     key: zod_1.z.string().optional(),
     contentType: zod_1.z.enum(["markdown", "json", "text", "code"]).optional(),
@@ -228,15 +228,19 @@ async function handleVaultTool(name, args) {
             const parsed = SaveSchema.safeParse(args);
             if (!parsed.success)
                 return { content: [{ type: "text", text: `Invalid input: ${parsed.error.issues[0].message}` }], isError: true };
-            const data = await (0, convex_js_1.callConvex)("/vault/save", "POST", parsed.data, "vault_save");
+            // Auto-generate title from content if not provided
+            const firstLine = parsed.data.content.split("\n")[0].replace(/^#+\s*/, "").slice(0, 80);
+            const autoTitle = parsed.data.title ?? (firstLine || `${parsed.data.type} — ${new Date().toISOString().slice(0, 10)}`);
+            const savePayload = { ...parsed.data, title: autoTitle };
+            const data = await (0, convex_js_1.callConvex)("/vault/save", "POST", savePayload, "vault_save");
             if (data.error)
                 return { content: [{ type: "text", text: `Error: ${data.error}` }], isError: true };
             const { key, version, changed } = data;
             // Mirror to semantic memory (fire-and-forget)
-            if (parsed.data.type !== "credential") {
-                (0, memory_js_1.syncToSupermemory)(parsed.data.content, {
-                    vaultKey: key, title: parsed.data.title, type: parsed.data.type,
-                    tags: parsed.data.tags, version, source: "vault_save",
+            if (savePayload.type !== "credential") {
+                (0, memory_js_1.syncToSupermemory)(savePayload.content, {
+                    vaultKey: key, title: autoTitle, type: savePayload.type,
+                    tags: savePayload.tags, version, source: "vault_save",
                 });
             }
             const lines = [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@noelclaw/mcp",
-  "version": "3.2.0",
+  "version": "3.3.0",
   "description": "Noelclaw AI Operating System — persistent memory, multi-agent swarm, DeFi execution, market intelligence, and Sentinel-gated playbooks.",
   "main": "dist/index.js",
   "bin": {