finoptima 1.3.2 → 1.3.3

package/CLAUDE.md

@@ -0,0 +1,108 @@
+# FINOPTIMA — Agent IA Finance & Optimisation
+
+Tu es **FINOPTIMA**, un agent IA spécialisé en finance décentralisée sur la plateforme **EcoChain** (https://www.toutcreer.com/trading).
+
+---
+
+## Qui tu es
+
+- **Nom** : FINOPTIMA (Finance + Optimisation)
+- **Role** : Conseiller financier IA pour la plateforme EcoChain
+- **Ton** : Professionnel mais accessible, tu tutoies l'utilisateur, tu parles en français
+- **Specialite** : Gestion de portfolio, liquidité AMM, trading, swaps, analyse de marché
+
+---
+
+## Connexion — OBLIGATOIRE avant tout
+
+Tu ne peux rien faire sans te connecter d'abord. Voici le flow :
+
+1. **Demande le numéro de téléphone** à l'utilisateur (format international : +33...)
+2. **Appelle le tool `login`** avec ce numéro
+3. **Dis à l'utilisateur** : "Approuve la connexion sur ton app EcoAuth"
+4. Une fois connecté, tu as accès à tous les tools
+
+Si l'utilisateur dit "connecte-toi", "va sur le site", "login", ou similaire → démarre ce flow.
+
+**Exemple :**
+```
+Utilisateur: "Salut, va sur toutcreer.com"
+Toi: "Pour me connecter à EcoChain, j'ai besoin de ton numéro de téléphone (format +33...). Tu recevras une notification sur ton app EcoAuth pour approuver."
+Utilisateur: "+33768572653"
+Toi: → appelle login(phone_number: "+33768572653")
+     → "Notification envoyée ! Approuve sur ton app EcoAuth."
+     → une fois approuvé : "Connecté en tant que [nom]. Comment puis-je t'aider ?"
+```
+
+---
+
+## Ce que tu peux faire
+
+### Lecture (toujours disponible après login)
+- `get_balances` / `get_balance` — Soldes wallets (ECO, BTC, ETH)
+- `get_portfolio` — Vue complète : wallets + positions LP
+- `get_prices` — Prix BTC/ETH en EUR (CoinGecko)
+- `get_pools` / `get_pool_details` — Pools de liquidité AMM
+- `get_lp_positions` — Positions de liquidité de l'utilisateur
+- `get_orderbook` — Carnet d'ordres
+- `get_ticker` — Stats 24h d'une paire
+- `get_candles` — Données OHLCV pour analyse technique
+- `get_trading_pairs` — Paires de trading actives
+- `get_my_orders` — Ordres ouverts
+- `get_trade_history` — Historique des trades
+- `get_transaction_history` — Historique des transactions
+
+### Trading
+- `place_order` — Placer un ordre (limit/market, buy/sell)
+- `cancel_order` — Annuler un ordre
+
+### Swap AMM
+- `get_swap_quote` — Simuler un swap (sans exécuter)
+- `execute_swap` — Exécuter un swap (0.3% fee)
+
+### Liquidité
+- `add_liquidity` — Ajouter de la liquidité à un pool (mint LP tokens)
+- `remove_liquidity` — Retirer de la liquidité (burn LP tokens)
+
+### Transfert
+- `send_funds` — Envoyer des fonds à un autre utilisateur
+
+---
+
+## Stratégies que tu proposes
+
+### 1. Ajout de liquidité (prioritaire)
+- Analyse le portfolio de l'utilisateur
+- Calcule le ratio optimal pour le pool ECO/BTC
+- Propose quelle portion investir en LP
+- Explique les risques (impermanent loss) simplement
+
+### 2. Optimisation de portfolio
+- Bilan complet des actifs
+- Répartition recommandée
+- Opportunités de rendement via les pools
+
+### 3. Trading
+- Analyse du carnet d'ordres
+- Tendances via les candles
+- Suggestions d'ordres limit vs market
+
+---
+
+## Règles
+
+- **TOUJOURS** te connecter avant de tenter toute action
+- **TOUJOURS** expliquer ce que tu fais avant d'exécuter une action qui modifie les fonds (swap, trade, add/remove liquidity, send)
+- **TOUJOURS** demander confirmation avant d'exécuter une action financière
+- **JAMAIS** inventer des données — utilise les tools pour obtenir les vraies valeurs
+- **JAMAIS** envoyer des fonds sans confirmation explicite de l'utilisateur
+- Quand tu affiches des montants BTC, convertis aussi en EUR avec `get_prices`
+- Arrondis les montants pour la lisibilité (2 décimales EUR, 8 décimales BTC)
+
+---
+
+## Premier message
+
+Quand l'utilisateur démarre une conversation, présente-toi :
+
+"Salut ! Je suis **FINOPTIMA**, ton assistant finance sur EcoChain. Pour commencer, j'ai besoin de me connecter à ton compte. Quel est ton numéro de téléphone ? (format +33...)"

package/index.js

@@ -3,7 +3,7 @@
  * EcoChain MCP Server (DEC-2026-043)
  *
  * Model Context Protocol server for AI agent access to EcoChain.
- * Provides 30 tools: 1 login + 29 platform tools.
+ * Provides 35 tools: 1 login + 34 platform tools.
  *
  * Authentication: EcoAuth login flow (no hardcoded credentials)
  *   1. AI asks user for their phone number
@@ -13,7 +13,6 @@
  *
  * Environment variables:
  *   ECOCHAIN_API_URL — Optional. API base URL (default: https://api.toutcreer.com)
- *   ECOCHAIN_API_KEY — Optional. API key for agent auth (skips phone login)
  */
 
 const { Server } = require('@modelcontextprotocol/sdk/server/index.js');
@@ -31,14 +30,6 @@ const POLL_TIMEOUT_MS = 120000;
 
 let authenticated = false;
 
-// API key auth — skip phone login if ECOCHAIN_API_KEY is set (DEC-2026-050)
-const API_KEY = process.env.ECOCHAIN_API_KEY;
-if (API_KEY) {
-  apiClient.setApiKey(API_KEY);
-  authenticated = true;
-  console.error('[EcoChain MCP] Authenticated via API key (no phone login required)');
-}
-
 /**
  * EcoAuth login flow
  */
@@ -106,11 +97,7 @@ const loginTool = {
   },
   handler: async ({ phone_number }) => {
     if (authenticated) {
-      return JSON.stringify({
-        status: 'already_authenticated',
-        auth_method: API_KEY ? 'api_key' : 'ecoauth',
-        user_id: process.env.ECOCHAIN_USER_ID
-      });
+      return JSON.stringify({ status: 'already_authenticated', user_id: process.env.ECOCHAIN_USER_ID });
     }
 
     const result = await loginWithEcoAuth(phone_number);
@@ -130,79 +117,6 @@ const loginTool = {
 // All tools: login first, then platform tools
 const allToolsWithLogin = [loginTool, ...allTools];
 
-// Server instructions — shown to the AI to explain how to use FINOPTIMA
-const SERVER_INSTRUCTIONS = `FINOPTIMA — EcoChain AI Finance Agent (v1.3.0, ${allTools.length + 1} tools)
-
-## Setup
-If the user doesn't have FINOPTIMA installed, they can add it to their MCP config:
-\`\`\`json
-{
-  "mcpServers": {
-    "ecochain": {
-      "command": "npx",
-      "args": ["-y", "finoptima"],
-      "env": { "ECOCHAIN_API_URL": "https://api.toutcreer.com" }
-    }
-  }
-}
-\`\`\`
-
-## Authentication
-Two authentication methods are supported:
-
-### Method 1: EcoAuth (interactive — for users)
-1. Ask the user for their phone number (format: +33...)
-2. Call the \`login\` tool — a push notification is sent to their EcoAuth mobile app
-3. The user approves on their phone — JWT session is established
-4. All other tools are now active
-
-### Method 2: API Key (non-interactive — for agents)
-Set \`ECOCHAIN_API_KEY\` in the MCP config env:
-\`\`\`json
-{
-  "env": {
-    "ECOCHAIN_API_URL": "https://api.toutcreer.com",
-    "ECOCHAIN_API_KEY": "eco_ak_..."
-  }
-}
-\`\`\`
-No login call needed — all tools are immediately available.
-API keys are scoped (read/trade/swap/liquidity/send/strategy) and rate-limited.
-Requires a Pro or API subscription plan.
-
-## Available Capabilities
-- **Portfolio**: get_balances, get_portfolio, get_prices, get_lp_positions, get_transaction_history
-- **Market**: get_pools, get_pool_details, get_orderbook, get_ticker, get_candles, get_trading_pairs
-- **Trading**: place_order, cancel_order, get_my_orders, get_trade_history
-- **Swap (AMM)**: get_swap_quote, execute_swap (0.3% fee, multi-hop routing supported)
-- **Liquidity**: add_liquidity, remove_liquidity
-- **Transfer**: send_funds
-- **AI Strategies**: create_strategy, list_strategies, get_strategy, activate_strategy, pause_strategy
-- **Marketplace**: get_templates, subscribe_template, get_leaderboard, follow_strategy, unfollow_strategy
-- **Intents**: create_intent, list_intents
-- **Performance**: get_strategy_performance
-
-## Multi-Pool AMM
-Multiple liquidity pools supported (ECO/BTC, ECO/ETH). Swaps between non-direct pairs (e.g., BTC↔ETH) are automatically routed via ECO as a hub token (2-hop swap).
-
-## AI Trading Strategies
-4 strategy types: LP Yield, DCA, BTC Hedge, Eco Pilot.
-Pipeline: Create (draft) → Activate → Runner evaluates every 60s → Creates intents → Policy validation (8 rules) → Auto-approve if < 0.01 BTC, else manual approval → Execute.
-Modes: "auto" (auto-approve small trades) or "watch" (all manual approval).
-
-## Strategy Marketplace
-- Browse public strategy templates (\`get_templates\`)
-- Subscribe to a template to clone its config (\`subscribe_template\`)
-- Follow a provider's live trades with copy trading (\`follow_strategy\`)
-- View top-performing strategies (\`get_leaderboard\`)
-
-## Rules
-- Always call \`login\` first before any other tool (unless using API key auth)
-- Always confirm financial actions (trade, swap, send) with the user before executing
-- Use \`get_swap_quote\` before \`execute_swap\` to show expected outcome
-- Platform: https://www.toutcreer.com/trading
-`;
-
 // Create MCP server
 const server = new Server(
   {
@@ -213,7 +127,6 @@ const server = new Server(
     capabilities: {
       tools: {},
     },
-    instructions: SERVER_INSTRUCTIONS,
   }
 );
 
@@ -243,7 +156,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
   // Block all tools except login if not authenticated
   if (!authenticated && name !== 'login') {
     return {
-      content: [{ type: 'text', text: 'Not authenticated. Either set ECOCHAIN_API_KEY env var or ask the user for their phone number and call the `login` tool first.' }],
+      content: [{ type: 'text', text: 'Not authenticated. Please ask the user for their phone number and call the `login` tool first.' }],
       isError: true,
     };
   }

package/lib/api-client.js

@@ -12,7 +12,6 @@ class ApiClient {
   constructor() {
     this.apiUrl = process.env.ECOCHAIN_API_URL || 'https://api.toutcreer.com';
     this.jwtToken = null; // Set after EcoAuth login
-    this.apiKey = null;   // Set via ECOCHAIN_API_KEY env var (DEC-2026-050)
 
     const parsed = new URL(this.apiUrl);
     this.hostname = parsed.hostname;
@@ -28,13 +27,6 @@ class ApiClient {
     this.jwtToken = token;
   }
 
-  /**
-   * Set API key for agent authentication (DEC-2026-050)
-   */
-  setApiKey(key) {
-    this.apiKey = key;
-  }
-
   /**
    * Make an HTTP request to the backend API
    */
@@ -43,12 +35,9 @@ class ApiClient {
 
     const headers = {
       'Content-Type': 'application/json',
-      'X-Client-Type': 'mcp-agent',
     };
 
-    if (this.apiKey) {
-      headers['X-API-Key'] = this.apiKey;
-    } else if (this.jwtToken) {
+    if (this.jwtToken) {
       headers['Authorization'] = `Bearer ${this.jwtToken}`;
     }
 

package/package.json

@@ -1,8 +1,7 @@
 {
   "name": "finoptima",
-  "version": "1.3.2",
-  "mcpName": "com.toutcreer/finoptima",
-  "description": "FINOPTIMA — EcoChain AI Finance Agent via MCP. Multi-pool AMM (ECO/BTC, ECO/ETH), 4 AI strategies, strategy marketplace, copy trading, leaderboard. 35 tools. API key auth. Secured by EcoAuth 2FA.",
+  "version": "1.3.3",
+  "description": "FINOPTIMA — EcoChain AI Finance Agent via MCP. Portfolio optimization, AMM liquidity, trading, swaps. Secured by EcoAuth 2FA.",
   "main": "index.js",
   "bin": {
     "finoptima": "index.js"

package/tools/index.js

@@ -1,22 +1,21 @@
 /**
  * MCP Tools Registry (DEC-2026-043)
  *
- * 21 tools organized by scope:
+ * 34 tools organized by scope:
  * - READ (14): Portfolio, balances, prices, pools, orderbook, etc.
  * - TRADE (2): Place/cancel orders
  * - SWAP (2): Quote/execute AMM swaps
  * - LIQUIDITY (2): Add/remove liquidity
  * - SEND (1): Internal transfers
+ * - STRATEGY (5): Create/list/get/activate/pause strategies
+ * - MARKETPLACE (5): Templates, leaderboard, follow/unfollow
+ * - INTENTS (2): Create/list intents
+ * - PERFORMANCE (1): Strategy performance metrics
  */
 
 const apiClient = require('../lib/api-client');
 const { withLogging } = require('../lib/logger');
 
-// [DEC-2026-046] AI Trading Platform tools
-const { strategyTools } = require('./strategy-tools');
-const { intentTools } = require('./intent-tools');
-const { performanceTools } = require('./performance-tools');
-
 // Helper: get user ID from env (set at startup from API key lookup)
 function uid() {
   return process.env.ECOCHAIN_USER_ID || 'me';
@@ -354,7 +353,7 @@ const liquidityTools = [
       const data = await apiClient.post('/amm/liquidity/remove', {
         user_id: uid(),
         pool_id,
-        lp_amount
+        lp_tokens: lp_amount
       });
       return JSON.stringify(data, null, 2);
     })
@@ -380,12 +379,17 @@ const sendTools = [
       required: ['to', 'chain', 'amount']
     },
     handler: withLogging('send_funds', async ({ to, chain, amount, note }) => {
+      const isPhone = /^\+\d+$/.test(to);
       const body = {
         from_uid: uid(),
-        to_identifier: to,
         chain,
         amount
       };
+      if (isPhone) {
+        body.to_phone = to;
+      } else {
+        body.to_uid = to;
+      }
       if (note) body.note = note;
       const data = await apiClient.post('/transactions/send', body);
       return JSON.stringify(data, null, 2);
@@ -394,42 +398,104 @@ const sendTools = [
 ];
 
 // ============================================
-// MARKETPLACE TOOLS (DEC-2026-050)
+// STRATEGY TOOLS (scope: strategy)
 // ============================================
 
-const marketplaceTools = [
+const strategyTools = [
   {
-    name: 'get_leaderboard',
-    description: 'Get top performing public strategies. Returns strategy name, type, total return, max drawdown, follower count, and provider name.',
+    name: 'list_strategies',
+    description: 'List all AI trading strategies for the user. Returns name, type, status, intent counts.',
+    inputSchema: { type: 'object', properties: {}, required: [] },
+    handler: withLogging('list_strategies', async () => {
+      const data = await apiClient.get(`/strategies/${uid()}`);
+      return JSON.stringify(data, null, 2);
+    })
+  },
+  {
+    name: 'get_strategy',
+    description: 'Get detailed information about a specific strategy by ID.',
     inputSchema: {
       type: 'object',
       properties: {
-        limit: { type: 'number', description: 'Max results (default 50)' }
+        strategy_id: { type: 'string', description: 'The UUID of the strategy' }
       },
-      required: []
+      required: ['strategy_id']
     },
-    handler: withLogging('get_leaderboard', async ({ limit }) => {
-      const params = limit ? `?limit=${limit}` : '';
-      const data = await apiClient.get(`/performance/leaderboard${params}`);
-      return JSON.stringify(data);
+    handler: withLogging('get_strategy', async ({ strategy_id }) => {
+      const data = await apiClient.get(`/strategies/detail/${strategy_id}`);
+      return JSON.stringify(data, null, 2);
     })
   },
   {
-    name: 'get_templates',
-    description: 'List all active strategy templates in the marketplace. Returns template name, type, parameters, return, subscribers, and provider.',
+    name: 'create_strategy',
+    description: 'Create a new AI trading strategy. Types: lp_yield, dca, btc_hedge, eco_pilot. Created in draft status. Modes: "auto" (auto-approve small trades) or "watch" (manual approval).',
     inputSchema: {
       type: 'object',
-      properties: {},
-      required: []
+      properties: {
+        name: { type: 'string', description: 'Strategy name' },
+        type: { type: 'string', description: 'Strategy type', enum: ['lp_yield', 'dca', 'btc_hedge', 'eco_pilot'] },
+        mode: { type: 'string', description: 'Execution mode', enum: ['auto', 'watch'] },
+        params: { type: 'object', description: 'Strategy-specific parameters (e.g., drop_threshold, step, cooldown for btc_hedge)' }
+      },
+      required: ['name', 'type']
+    },
+    handler: withLogging('create_strategy', async ({ name, type, mode, params }) => {
+      const body = { user_id: uid(), name, type };
+      if (mode) body.mode = mode;
+      if (params) body.params = params;
+      const data = await apiClient.post('/strategies', body);
+      return JSON.stringify(data, null, 2);
+    })
+  },
+  {
+    name: 'activate_strategy',
+    description: 'Activate a strategy (draft or paused -> active). The runner will evaluate it every 60 seconds.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        strategy_id: { type: 'string', description: 'The UUID of the strategy to activate' }
+      },
+      required: ['strategy_id']
     },
+    handler: withLogging('activate_strategy', async ({ strategy_id }) => {
+      const data = await apiClient.post(`/strategies/${strategy_id}/activate`, { user_id: uid() });
+      return JSON.stringify(data, null, 2);
+    })
+  },
+  {
+    name: 'pause_strategy',
+    description: 'Pause an active strategy. Pending intents are cancelled automatically.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        strategy_id: { type: 'string', description: 'The UUID of the strategy to pause' }
+      },
+      required: ['strategy_id']
+    },
+    handler: withLogging('pause_strategy', async ({ strategy_id }) => {
+      const data = await apiClient.post(`/strategies/${strategy_id}/pause`, { user_id: uid() });
+      return JSON.stringify(data, null, 2);
+    })
+  }
+];
+
+// ============================================
+// MARKETPLACE TOOLS (scope: marketplace)
+// ============================================
+
+const marketplaceTools = [
+  {
+    name: 'get_templates',
+    description: 'Browse available strategy templates in the marketplace.',
+    inputSchema: { type: 'object', properties: {}, required: [] },
     handler: withLogging('get_templates', async () => {
       const data = await apiClient.get('/strategies/templates');
-      return JSON.stringify(data);
+      return JSON.stringify(data, null, 2);
     })
   },
   {
     name: 'subscribe_template',
-    description: 'Subscribe to a strategy template. Clones the template config into a new strategy for the user. Requires pilot+ plan.',
+    description: 'Subscribe to a strategy template to clone its configuration into a new personal strategy.',
     inputSchema: {
       type: 'object',
       properties: {
@@ -438,33 +504,37 @@ const marketplaceTools = [
       required: ['template_id']
     },
     handler: withLogging('subscribe_template', async ({ template_id }) => {
-      const data = await apiClient.post(`/strategies/templates/${template_id}/subscribe`);
-      return JSON.stringify(data);
+      const data = await apiClient.post('/strategies/templates/subscribe', { user_id: uid(), template_id });
+      return JSON.stringify(data, null, 2);
+    })
+  },
+  {
+    name: 'get_leaderboard',
+    description: 'View the strategy leaderboard — top-performing public strategies ranked by returns.',
+    inputSchema: { type: 'object', properties: {}, required: [] },
+    handler: withLogging('get_leaderboard', async () => {
+      const data = await apiClient.get('/strategies/leaderboard');
+      return JSON.stringify(data, null, 2);
     })
   },
   {
     name: 'follow_strategy',
-    description: 'Start copy trading a public strategy. Creates a shadow strategy that mirrors the provider\'s trades with optional scaling. Requires pilot+ plan.',
+    description: 'Follow a public strategy for copy trading. Automatically replicates the provider\'s trades.',
     inputSchema: {
       type: 'object',
       properties: {
-        strategy_id: { type: 'string', description: 'The UUID of the public strategy to follow' },
-        scale_factor: { type: 'number', description: 'Trade size multiplier (0.1-2.0, default 1.0)' },
-        max_trade_btc: { type: 'number', description: 'Maximum trade size in BTC (default 0.01)' }
+        strategy_id: { type: 'string', description: 'The UUID of the public strategy to follow' }
       },
       required: ['strategy_id']
     },
-    handler: withLogging('follow_strategy', async ({ strategy_id, scale_factor, max_trade_btc }) => {
-      const body = {};
-      if (scale_factor !== undefined) body.scale_factor = scale_factor;
-      if (max_trade_btc !== undefined) body.max_trade_btc = max_trade_btc;
-      const data = await apiClient.post(`/strategies/${strategy_id}/follow`, body);
-      return JSON.stringify(data);
+    handler: withLogging('follow_strategy', async ({ strategy_id }) => {
+      const data = await apiClient.post(`/strategies/${strategy_id}/follow`, { user_id: uid() });
+      return JSON.stringify(data, null, 2);
     })
   },
   {
     name: 'unfollow_strategy',
-    description: 'Stop copy trading a strategy. Pauses the shadow strategy and removes the copy trading link.',
+    description: 'Stop following a strategy and end copy trading.',
     inputSchema: {
       type: 'object',
       properties: {
@@ -473,10 +543,80 @@ const marketplaceTools = [
       required: ['strategy_id']
     },
     handler: withLogging('unfollow_strategy', async ({ strategy_id }) => {
-      const data = await apiClient.delete(`/strategies/${strategy_id}/follow`);
-      return JSON.stringify(data);
+      const data = await apiClient.post(`/strategies/${strategy_id}/unfollow`, { user_id: uid() });
+      return JSON.stringify(data, null, 2);
+    })
+  }
+];
+
+// ============================================
+// INTENT TOOLS (scope: strategy)
+// ============================================
+
+const intentTools = [
+  {
+    name: 'create_intent',
+    description: 'Create a trading intent for policy validation and execution. Goes through the policy engine (8 rules). Auto-approved if under threshold, otherwise requires manual approval. TTL: 10 minutes.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        strategy_id: { type: 'string', description: 'Strategy UUID (optional — omit for manual intents)' },
+        action: { type: 'string', description: 'Intent action type (e.g., execute_swap, vault_to_hot)' },
+        params: { type: 'object', description: 'Action parameters (e.g., token_in, token_out, amount)' },
+        reasoning: { type: 'string', description: 'Human-readable explanation of why this intent was created' }
+      },
+      required: ['action', 'params']
+    },
+    handler: withLogging('create_intent', async ({ strategy_id, action, params, reasoning }) => {
+      const body = { user_id: uid(), action, params };
+      if (strategy_id) body.strategy_id = strategy_id;
+      if (reasoning) body.reasoning = reasoning;
+      const data = await apiClient.post('/intents', body);
+      return JSON.stringify(data, null, 2);
     })
   },
+  {
+    name: 'list_intents',
+    description: 'List all intents for the user, showing the full pipeline: created -> policy_checked -> approved/rejected -> executed/expired.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        strategy_id: { type: 'string', description: 'Filter by strategy UUID (optional)' },
+        status: { type: 'string', description: 'Filter by status: pending, approved, rejected, executed, expired' }
+      },
+      required: []
+    },
+    handler: withLogging('list_intents', async ({ strategy_id, status }) => {
+      const params = new URLSearchParams();
+      if (strategy_id) params.set('strategy_id', strategy_id);
+      if (status) params.set('status', status);
+      const qs = params.toString();
+      const data = await apiClient.get(`/intents/${uid()}${qs ? '?' + qs : ''}`);
+      return JSON.stringify(data, null, 2);
+    })
+  }
+];
+
+// ============================================
+// PERFORMANCE TOOLS (scope: strategy)
+// ============================================
+
+const performanceTools = [
+  {
+    name: 'get_strategy_performance',
+    description: 'Get performance metrics for a strategy: total return, max drawdown, daily snapshots with balances and prices.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        strategy_id: { type: 'string', description: 'The UUID of the strategy' }
+      },
+      required: ['strategy_id']
+    },
+    handler: withLogging('get_strategy_performance', async ({ strategy_id }) => {
+      const data = await apiClient.get(`/strategies/${strategy_id}/performance`);
+      return JSON.stringify(data, null, 2);
+    })
+  }
 ];
 
 // Export all tools grouped by scope
@@ -487,18 +627,8 @@ module.exports = {
   liquidityTools,
   sendTools,
   strategyTools,
+  marketplaceTools,
   intentTools,
   performanceTools,
-  marketplaceTools,
-  allTools: [
-    ...readTools,
-    ...tradeTools,
-    ...swapTools,
-    ...liquidityTools,
-    ...sendTools,
-    ...strategyTools,
-    ...intentTools,
-    ...performanceTools,
-    ...marketplaceTools,
-  ]
+  allTools: [...readTools, ...tradeTools, ...swapTools, ...liquidityTools, ...sendTools, ...strategyTools, ...marketplaceTools, ...intentTools, ...performanceTools]
 };

package/tools/intent-tools.js

@@ -1,58 +0,0 @@
-/**
- * MCP Intent Tools (DEC-2026-046)
- * 2 tools for AI agent intent management (scope: trade)
- */
-
-const apiClient = require('../lib/api-client');
-const { withLogging } = require('../lib/logger');
-
-const intentTools = [
-  {
-    name: 'create_intent',
-    description: 'Create a trading intent with policy validation. Returns canonical_display (human-readable JSON) and intent_hash (SHA256) for approval verification. Auto-approved if amount < 0.01 BTC, otherwise awaits manual approval (30min TTL).',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        strategy_id: { type: 'string', description: 'Optional: link to a strategy' },
-        action: { type: 'string', description: 'Trading action', enum: ['execute_swap', 'add_liquidity', 'remove_liquidity', 'zap_liquidity', 'place_order', 'vault_to_hot'] },
-        params: {
-          type: 'object',
-          description: 'Action parameters. Swap: {token_in, token_out, amount_in, max_slippage_bps}. Liquidity: {pool_id, amount_a, amount_b}. Order: {pair_id, side, type, amount, price}.'
-        },
-        reasoning: { type: 'string', description: 'Why this trade (shown to user for approval)' }
-      },
-      required: ['action', 'params']
-    },
-    handler: withLogging('create_intent', async ({ strategy_id, action, params, reasoning }) => {
-      const body = { action, params };
-      if (strategy_id) body.strategy_id = strategy_id;
-      if (reasoning) body.reasoning = reasoning;
-      const data = await apiClient.post('/intents', body);
-      return JSON.stringify(data, null, 2);
-    })
-  },
-  {
-    name: 'list_intents',
-    description: 'List trading intents with optional filters. Shows status, canonical display, policy result, and execution result.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        status: { type: 'string', description: 'Filter by status', enum: ['pending', 'awaiting_approval', 'approved', 'rejected', 'executing', 'executed', 'failed', 'expired', 'canceled'] },
-        strategy_id: { type: 'string', description: 'Filter by strategy' },
-        limit: { type: 'number', description: 'Max results (default 50)' }
-      },
-      required: []
-    },
-    handler: withLogging('list_intents', async ({ status, strategy_id, limit }) => {
-      const params = new URLSearchParams();
-      if (status) params.set('status', status);
-      if (strategy_id) params.set('strategy_id', strategy_id);
-      if (limit) params.set('limit', limit.toString());
-      const qs = params.toString();
-      const data = await apiClient.get(`/intents${qs ? '?' + qs : ''}`);
-      return JSON.stringify(data, null, 2);
-    })
-  }
-];
-
-module.exports = { intentTools };

package/tools/performance-tools.js

@@ -1,30 +0,0 @@
-/**
- * MCP Performance Tools (DEC-2026-046)
- * 1 tool for AI agent performance monitoring (scope: read)
- */
-
-const apiClient = require('../lib/api-client');
-const { withLogging } = require('../lib/logger');
-
-const performanceTools = [
-  {
-    name: 'get_strategy_performance',
-    description: 'Get performance metrics for a trading strategy: total return, max drawdown, vs HODL benchmark, fees paid/earned, and PnL snapshots time-series.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        strategy_id: { type: 'string', description: 'Strategy UUID' }
-      },
-      required: ['strategy_id']
-    },
-    handler: withLogging('get_strategy_performance', async ({ strategy_id }) => {
-      const [metrics, snapshots] = await Promise.all([
-        apiClient.get(`/performance/strategy/${strategy_id}`),
-        apiClient.get(`/performance/strategy/${strategy_id}/snapshots?limit=50`)
-      ]);
-      return JSON.stringify({ metrics, snapshots }, null, 2);
-    })
-  }
-];
-
-module.exports = { performanceTools };

package/tools/strategy-tools.js

@@ -1,102 +0,0 @@
-/**
- * MCP Strategy Tools (DEC-2026-046)
- * 5 tools for AI agent strategy management (scope: strategy)
- */
-
-const apiClient = require('../lib/api-client');
-const { withLogging } = require('../lib/logger');
-
-function uid() {
-  return process.env.ECOCHAIN_USER_ID || 'me';
-}
-
-const strategyTools = [
-  {
-    name: 'list_strategies',
-    description: 'List all trading strategies for the user. Returns strategy name, type (lp_yield/dca/btc_hedge), status, mode, and PnL summary.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        status: { type: 'string', description: 'Filter by status', enum: ['draft', 'active', 'paused', 'stopped', 'error'] }
-      },
-      required: []
-    },
-    handler: withLogging('list_strategies', async ({ status }) => {
-      const params = status ? `?status=${status}` : '';
-      const data = await apiClient.get(`/strategies${params}`);
-      return JSON.stringify(data, null, 2);
-    })
-  },
-  {
-    name: 'get_strategy',
-    description: 'Get detailed info about a trading strategy: parameters, rules, latest PnL snapshot, and recent intents.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        strategy_id: { type: 'string', description: 'Strategy UUID' }
-      },
-      required: ['strategy_id']
-    },
-    handler: withLogging('get_strategy', async ({ strategy_id }) => {
-      const data = await apiClient.get(`/strategies/${strategy_id}`);
-      return JSON.stringify(data, null, 2);
-    })
-  },
-  {
-    name: 'create_strategy',
-    description: 'Create a new trading strategy (starts as draft). Types: lp_yield (LP optimization), dca (Dollar Cost Average), btc_hedge (BTC downside protection). Mode: auto (execute automatically) or watch (manual approval for all intents).',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        name: { type: 'string', description: 'Strategy name (e.g. "Daily BTC DCA")' },
-        type: { type: 'string', description: 'Strategy type', enum: ['lp_yield', 'dca', 'btc_hedge'] },
-        parameters: {
-          type: 'object',
-          description: 'Strategy parameters. DCA: {token_to_buy, spend_token, amount_per_interval, interval_hours, total_budget}. BTC Hedge: {btc_drop_threshold_percent, conversion_step_percent, cooldown_hours}. LP Yield: {pool_id, min_apr_threshold, rebalance_on_il_percent}.'
-        },
-        mode: { type: 'string', description: 'Execution mode', enum: ['auto', 'watch'] },
-        description: { type: 'string', description: 'Optional description' }
-      },
-      required: ['name', 'type', 'parameters']
-    },
-    handler: withLogging('create_strategy', async ({ name, type, parameters, mode, description }) => {
-      const body = { name, type, parameters };
-      if (mode) body.mode = mode;
-      if (description) body.description = description;
-      const data = await apiClient.post('/strategies', body);
-      return JSON.stringify(data, null, 2);
-    })
-  },
-  {
-    name: 'activate_strategy',
-    description: 'Activate a draft or paused strategy. Creates default policy rules if none exist and takes a start-of-day PnL snapshot.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        strategy_id: { type: 'string', description: 'Strategy UUID to activate' }
-      },
-      required: ['strategy_id']
-    },
-    handler: withLogging('activate_strategy', async ({ strategy_id }) => {
-      const data = await apiClient.post(`/strategies/${strategy_id}/activate`);
-      return JSON.stringify(data, null, 2);
-    })
-  },
-  {
-    name: 'pause_strategy',
-    description: 'Pause an active strategy. Cancels all pending/awaiting/approved intents. Can be resumed later with activate.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        strategy_id: { type: 'string', description: 'Strategy UUID to pause' }
-      },
-      required: ['strategy_id']
-    },
-    handler: withLogging('pause_strategy', async ({ strategy_id }) => {
-      const data = await apiClient.post(`/strategies/${strategy_id}/pause`);
-      return JSON.stringify(data, null, 2);
-    })
-  }
-];
-
-module.exports = { strategyTools };