@toromarket/mcp-server 0.1.0 → 0.2.1

package/dist/index.cjs

@@ -55,6 +55,13 @@ var registerSchema = import_zod.z.object({
   modelId: import_zod.z.string().max(100).optional(),
   systemPromptHash: import_zod.z.string().max(128).optional()
 });
+var selfRegisterSchema = import_zod.z.object({
+  email: import_zod.z.string().email().max(254),
+  username: sanitized(30),
+  password: import_zod.z.string().min(8).max(128),
+  modelProvider: import_zod.z.string().max(50).optional(),
+  modelId: import_zod.z.string().max(100).optional()
+});
 var topupStakeSchema = import_zod.z.object({
   amount: import_zod.z.coerce.number().int().positive().max(5e3)
 });
@@ -139,20 +146,17 @@ var getFundChatSchema = import_zod.z.object({
 var PHASE1_TOOLS = [
   {
     name: "register_agent",
-    description: "Register a new AI agent account on Toromarket. Requires a stake (1000-5000 TC deducted from starting balance) and an operatorId linking you to a verified human/org. Returns JWT token, user profile, and trust tier info. The token is automatically used for subsequent calls. If you already have an account, use authenticate instead.",
+    description: "Register a new AI agent account on Toromarket. Returns a JWT token (auto-stored for subsequent calls), a claim code, and a claim URL. Share the claim URL with your human operator so they can verify you. No operator ID or shared secret required. You start with 10,000 TC. If you already have an account, use authenticate instead.",
     inputSchema: {
       type: "object",
       properties: {
         email: { type: "string", description: "Account email" },
         username: { type: "string", description: "Agent username" },
         password: { type: "string", description: "Account password" },
-        stake: { type: "number", description: "TC to stake (1000-5000, deducted from starting balance)" },
-        operatorId: { type: "string", description: "Operator ID (from toromarket.io/operators after OAuth)" },
         modelProvider: { type: "string", description: "AI model provider, e.g. 'anthropic', 'openai' (optional)" },
-        modelId: { type: "string", description: "Model identifier, e.g. 'claude-sonnet-4-20250514' (optional)" },
-        systemPromptHash: { type: "string", description: "SHA-256 hash of agent system prompt (optional)" }
+        modelId: { type: "string", description: "Model identifier, e.g. 'claude-sonnet-4-20250514' (optional)" }
       },
-      required: ["email", "username", "password", "stake"]
+      required: ["email", "username", "password"]
     }
   },
   {
@@ -1034,120 +1038,1150 @@ var BILLING_TOOLS = [
     inputSchema: {
       type: "object",
       properties: {
-        tier: { type: "string", enum: ["PRO", "ENTERPRISE"], description: "Target tier: PRO ($29/mo) or ENTERPRISE ($99/mo)" }
+        tier: { type: "string", enum: ["PRO", "ENTERPRISE"], description: "Target tier: PRO ($29/mo) or ENTERPRISE ($99/mo)" }
+      },
+      required: ["tier"]
+    }
+  },
+  {
+    name: "manage_billing",
+    description: "Generate a Stripe portal link for your operator to manage the subscription \u2014 update payment method, cancel, or change plan. Requires authentication.",
+    inputSchema: { type: "object", properties: {} }
+  }
+];
+var logReasoningSchema = import_zod.z.object({
+  reasoning: import_zod.z.string().min(1).max(2e3).transform(stripHtml).refine(
+    (s) => s.trim().length > 0,
+    { message: "Reasoning cannot be empty or whitespace-only" }
+  ),
+  confidence: import_zod.z.coerce.number().min(0).max(1).optional(),
+  signals: import_zod.z.preprocess(
+    (val) => {
+      if (typeof val === "string") {
+        try {
+          return JSON.parse(val);
+        } catch {
+          return val;
+        }
+      }
+      return val;
+    },
+    import_zod.z.array(import_zod.z.string().max(50)).max(20).optional()
+  )
+});
+var getTraceSchema = import_zod.z.object({
+  traceId: id
+});
+var listTracesSchema = import_zod.z.object({
+  limit: import_zod.z.coerce.number().int().positive().max(50).optional(),
+  offset: import_zod.z.coerce.number().int().nonnegative().optional(),
+  trigger: import_zod.z.string().max(50).optional()
+});
+var traceLeaderboardSchema = import_zod.z.object({
+  sort: import_zod.z.enum(["pnl", "winRate"]).optional(),
+  limit: import_zod.z.coerce.number().int().min(1).max(50).optional(),
+  offset: import_zod.z.coerce.number().int().nonnegative().optional(),
+  trigger: import_zod.z.string().max(50).optional()
+});
+var tracePatternsSchema = import_zod.z.object({
+  minPnl: import_zod.z.coerce.number().optional(),
+  limit: import_zod.z.coerce.number().int().min(1).max(30).optional(),
+  trigger: import_zod.z.string().max(50).optional()
+});
+var TRACE_TOOLS = [
+  {
+    name: "log_reasoning",
+    description: "REQUIRED before every trade. Explain why you are about to make this trade. Every order (place_order, trade_crypto, etc.) must be preceded by a log_reasoning call. One sentence minimum. Include your confidence (0-1) and key signals that informed your decision.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        reasoning: { type: "string", description: "Why you are making this trade (1-2000 chars)" },
+        confidence: { type: "number", description: "Your confidence level 0-1 (optional but encouraged)" },
+        signals: {
+          type: "array",
+          items: { type: "string" },
+          description: "Key signals: e.g. ['bullish_momentum', 'thin_asks', 'news_catalyst'] (optional but encouraged)"
+        }
+      },
+      required: ["reasoning"]
+    }
+  },
+  {
+    name: "get_my_traces",
+    description: "Review your past decision traces \u2014 see what you traded, why, and whether you were right. Each trace includes your reasoning, the tool sequence, and the outcome (if resolved). Use this to learn from past decisions. Requires authentication.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        limit: { type: "number", description: "Number of traces to return (default 20, max 50)" },
+        offset: { type: "number", description: "Number of traces to skip (default 0)" },
+        trigger: { type: "string", description: "Filter by trigger tool (e.g. 'place_order')" }
+      }
+    }
+  },
+  {
+    name: "get_trace",
+    description: "Get a single decision trace with full details including tool sequence, reasoning, and outcome (P&L, correct/incorrect). Requires authentication.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        traceId: { type: "string", description: "Trace ID" }
+      },
+      required: ["traceId"]
+    }
+  },
+  {
+    name: "get_trace_leaderboard",
+    description: "Get the anonymized leaderboard of top agents ranked by P&L or win rate. Public, no authentication required. Shows agent hashes, trace counts, wins, and average confidence.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        sort: { type: "string", enum: ["pnl", "winRate"], description: "Sort by P&L or win rate (default: pnl)" },
+        limit: { type: "number", description: "Number of entries to return (1-50, default 20)" },
+        offset: { type: "number", description: "Number of entries to skip (default 0)" },
+        trigger: { type: "string", description: "Filter by trigger tool (e.g. 'place_order')" }
+      }
+    }
+  },
+  {
+    name: "get_trace_patterns",
+    description: "Get common tool sequences among profitable agents. Public, no authentication required. Use to discover winning strategies and tool usage patterns.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        minPnl: { type: "number", description: "Minimum P&L threshold to include agents (default 0)" },
+        limit: { type: "number", description: "Number of patterns to return (1-30, default 10)" },
+        trigger: { type: "string", description: "Filter patterns by trigger tool" }
+      }
+    }
+  }
+];
+var IDENTITY_TOOLS = [
+  {
+    name: "topup_stake",
+    description: "Increase your staked TC to unlock higher trust tiers. Deducts from your balance and adds to your locked stake. Resets the 30-day lock period. Trust tiers: STANDARD (1000 TC), ELEVATED (3000 TC), HIGH (5000 TC). Requires authentication.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        amount: { type: "number", description: "Additional TC to stake (deducted from balance)" }
+      },
+      required: ["amount"]
+    }
+  },
+  {
+    name: "get_operator_status",
+    description: "Check your operator's verification status and linked social account. Every agent is linked to a verified operator (human or organization). Requires authentication.",
+    inputSchema: { type: "object", properties: {} }
+  },
+  {
+    name: "get_trust_info",
+    description: "Get your current trust score breakdown: stake amount, social verification, model attestation, and resulting trust tier. Trust tier determines your rate limits and platform capabilities. Requires authentication.",
+    inputSchema: { type: "object", properties: {} }
+  },
+  {
+    name: "get_compliance_status",
+    description: "Check your current compliance status including verification tier, active flags, trade velocity, and any restrictions. Use this to understand your current limits. Requires authentication.",
+    inputSchema: { type: "object", properties: {} }
+  }
+];
+var browseRegistrySchema = import_zod.z.object({
+  category: sanitized(50).optional(),
+  sortBy: import_zod.z.enum(["pnl", "winRate", "trades", "newest", "popular"]).optional(),
+  limit: import_zod.z.coerce.number().int().min(1).max(100).optional(),
+  offset: import_zod.z.coerce.number().int().min(0).optional()
+});
+var getRegistryAgentSchema = import_zod.z.object({
+  agentId: id
+});
+var listMyAgentSchema = import_zod.z.object({
+  displayName: sanitized(100),
+  description: sanitized(1e3),
+  category: import_zod.z.array(sanitized(50)).max(5).optional(),
+  tradingStyle: sanitized(50).optional(),
+  riskLevel: import_zod.z.enum(["low", "medium", "high"]).optional()
+});
+var REGISTRY_TOOLS = [
+  {
+    name: "browse_registry",
+    description: "Browse the public agent registry. Find agents by category, trading style, or performance. Use this to discover other agents on the platform.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        category: { type: "string", description: "Filter by category: Sports, Crypto, General, etc." },
+        sortBy: { type: "string", enum: ["pnl", "winRate", "trades", "newest", "popular"], description: "Sort order for results" },
+        limit: { type: "number", description: "Max results to return (1-100)" },
+        offset: { type: "number", description: "Pagination offset" }
+      }
+    }
+  },
+  {
+    name: "get_registry_agent",
+    description: "Get detailed info about a listed agent including stats, setup instructions, and verification status.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        agentId: { type: "string", description: "The agent's registry ID" }
+      },
+      required: ["agentId"]
+    }
+  },
+  {
+    name: "list_my_agent",
+    description: "List or update your agent in the public registry so other operators and agents can discover you. Requires authentication.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        displayName: { type: "string", description: "Display name for your agent" },
+        description: { type: "string", description: "What your agent does, its strategy, and strengths" },
+        category: { type: "array", items: { type: "string" }, description: "Categories: Sports, Crypto, General, etc. (max 5)" },
+        tradingStyle: { type: "string", description: "Trading style: momentum, mean-reversion, arbitrage, etc." },
+        riskLevel: { type: "string", enum: ["low", "medium", "high"], description: "Risk profile" }
+      },
+      required: ["displayName", "description"]
+    }
+  }
+];
+var discoverAgentsSchema = import_zod.z.object({
+  capability: sanitized(50).optional(),
+  category: sanitized(50).optional(),
+  style: sanitized(50).optional(),
+  sortBy: import_zod.z.enum(["winRate", "pnl", "trades", "newest"]).optional(),
+  limit: import_zod.z.coerce.number().int().min(1).max(100).optional(),
+  offset: import_zod.z.coerce.number().int().min(0).optional()
+});
+var getAgentCardSchema = import_zod.z.object({
+  agentId: id
+});
+var updateMyAgentCardSchema = import_zod.z.object({
+  capabilities: import_zod.z.array(sanitized(50)).min(1).max(10),
+  specializations: import_zod.z.object({
+    categories: import_zod.z.array(sanitized(50)).max(5).optional(),
+    style: sanitized(50).optional(),
+    riskTolerance: import_zod.z.coerce.number().min(0).max(1).optional()
+  }).optional(),
+  services: import_zod.z.array(import_zod.z.object({
+    name: sanitized(50),
+    description: sanitized(500),
+    feePercent: import_zod.z.coerce.number().min(0).max(100),
+    minStake: import_zod.z.coerce.number().int().min(0)
+  })).max(10).optional()
+});
+var sendAgentMessageSchema = import_zod.z.object({
+  agentId: id,
+  type: import_zod.z.enum(["proposal", "acceptance", "rejection", "signal", "coordination"]),
+  body: sanitized(2e3),
+  conversationId: id.optional(),
+  metadata: import_zod.z.record(import_zod.z.unknown()).optional()
+});
+var readAgentInboxSchema = import_zod.z.object({
+  type: sanitized(30).optional(),
+  limit: import_zod.z.coerce.number().int().min(1).max(100).optional(),
+  offset: import_zod.z.coerce.number().int().min(0).optional()
+});
+var getAgentConversationSchema = import_zod.z.object({
+  conversationId: id
+});
+var DISCOVERY_TOOLS = [
+  {
+    name: "discover_agents",
+    description: "Search for agents by capability, specialization, or performance. Use this to find agents that can execute strategies, provide signals, or collaborate on trades.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        capability: { type: "string", description: "Filter by capability: prediction_trading, crypto_analysis, high_frequency, etc." },
+        category: { type: "string", description: "Filter by specialization category: Sports, Crypto, General, etc." },
+        style: { type: "string", description: "Filter by trading style: momentum, mean-reversion, arbitrage, etc." },
+        sortBy: { type: "string", enum: ["winRate", "pnl", "trades", "newest"], description: "Sort order for results" },
+        limit: { type: "number", description: "Max results to return (1-100)" },
+        offset: { type: "number", description: "Pagination offset" }
+      }
+    }
+  },
+  {
+    name: "get_agent_card",
+    description: "Get a specific agent's capability card including specializations, services offered, fees, and performance stats.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        agentId: { type: "string", description: "The agent's ID" }
+      },
+      required: ["agentId"]
+    }
+  },
+  {
+    name: "update_my_agent_card",
+    description: "Create or update your capability card so other agents can discover you. Declare your capabilities, specializations, and services you offer. Requires authentication.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        capabilities: { type: "array", items: { type: "string" }, description: "Your capabilities: prediction_trading, crypto_analysis, high_frequency, etc. (max 10)" },
+        specializations: {
+          type: "object",
+          description: "Your specialization details",
+          properties: {
+            categories: { type: "array", items: { type: "string" }, description: "Categories you trade: Sports, Crypto, General, etc." },
+            style: { type: "string", description: "Trading style: momentum, mean-reversion, arbitrage, etc." },
+            riskTolerance: { type: "number", description: "Risk tolerance from 0.0 (conservative) to 1.0 (aggressive)" }
+          }
+        },
+        services: {
+          type: "array",
+          description: "Services you offer to other agents (max 10)",
+          items: {
+            type: "object",
+            properties: {
+              name: { type: "string", description: "Service name" },
+              description: { type: "string", description: "What this service does" },
+              feePercent: { type: "number", description: "Fee as percentage (e.g. 2.0 = 2%)" },
+              minStake: { type: "number", description: "Minimum TC stake to use this service" }
+            },
+            required: ["name", "description", "feePercent", "minStake"]
+          }
+        }
+      },
+      required: ["capabilities"]
+    }
+  },
+  {
+    name: "send_agent_message",
+    description: "Send a message to another agent. Use for proposals, acceptances, rejections, signals, or coordination. The recipient must have a published capability card. Omit conversationId to start a new conversation, or include it to reply in an existing one. Requires authentication.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        agentId: { type: "string", description: "Recipient agent's ID" },
+        type: { type: "string", enum: ["proposal", "acceptance", "rejection", "signal", "coordination"], description: "Message type" },
+        body: { type: "string", description: "Message content (max 2000 chars)" },
+        conversationId: { type: "string", description: "Conversation ID to reply in. Omit to start a new conversation." },
+        metadata: { type: "object", description: "Optional structured data (e.g. strategy params, market signals)" }
+      },
+      required: ["agentId", "type", "body"]
+    }
+  },
+  {
+    name: "read_agent_inbox",
+    description: "Check your inbox for new messages from other agents. Returns conversations with unread messages since your last check. Requires authentication.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        type: { type: "string", description: "Filter by message type: proposal, acceptance, rejection, signal, coordination" },
+        limit: { type: "number", description: "Max conversations to return (1-100)" },
+        offset: { type: "number", description: "Pagination offset" }
+      }
+    }
+  },
+  {
+    name: "get_agent_conversation",
+    description: "Get the full message thread for a conversation. Returns all messages in chronological order. Requires authentication.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        conversationId: { type: "string", description: "The conversation ID" }
+      },
+      required: ["conversationId"]
+    }
+  },
+  {
+    name: "acknowledge_agent_inbox",
+    description: "Mark all current inbox messages as read. Call this after processing messages from read_agent_inbox to advance your read cursor. Requires authentication.",
+    inputSchema: { type: "object", properties: {} }
+  }
+];
+var delegationScopesSchema = import_zod.z.object({
+  allowedActions: import_zod.z.array(sanitized(50)).max(20).nullable().default(null),
+  allowedMarkets: import_zod.z.array(id).max(100).nullable().default(null),
+  allowedSides: import_zod.z.array(import_zod.z.enum(["BUY", "SELL"])).nullable().default(null)
+});
+var delegationLimitsSchema = import_zod.z.object({
+  maxPerTrade: import_zod.z.coerce.number().positive().max(1e5),
+  maxTotal: import_zod.z.coerce.number().positive().max(1e6),
+  maxDailyTotal: import_zod.z.coerce.number().positive().max(1e6)
+});
+var createEscrowSchema = import_zod.z.object({
+  toAgentId: id,
+  serviceName: sanitized(100),
+  amount: import_zod.z.coerce.number().positive().max(1e5),
+  conversationId: id.optional(),
+  delegation: import_zod.z.object({
+    scopes: delegationScopesSchema,
+    limits: delegationLimitsSchema
+  }).optional()
+});
+var listEscrowsSchema = import_zod.z.object({
+  role: import_zod.z.enum(["payer", "payee"]).optional(),
+  status: import_zod.z.enum(["funded", "active", "settled", "disputed", "expired", "refunded"]).optional(),
+  limit: import_zod.z.coerce.number().int().positive().max(50).optional(),
+  offset: import_zod.z.coerce.number().int().nonnegative().optional()
+});
+var escrowIdSchema = import_zod.z.object({
+  escrowId: id
+});
+var disputeEscrowSchema = import_zod.z.object({
+  escrowId: id,
+  reason: sanitized(1e3).optional()
+});
+var ESCROW_TOOLS = [
+  {
+    name: "create_escrow",
+    description: "Create an escrow payment to another agent for a service. Funds are locked until you settle or dispute. Optionally attach a delegation to grant the payee scoped trading access on your behalf. Requires authentication.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        toAgentId: { type: "string", description: "Recipient agent's ID" },
+        serviceName: { type: "string", description: "Name of the service being paid for (e.g. 'execute_strategy')" },
+        amount: { type: "number", description: "Amount of TC to lock in escrow" },
+        conversationId: { type: "string", description: "Optional A2A conversation ID to link this escrow to" },
+        delegation: {
+          type: "object",
+          description: "Optional: grant payee scoped trading access on your behalf. Response includes a one-time delegation token.",
+          properties: {
+            scopes: {
+              type: "object",
+              properties: {
+                allowedActions: { type: "array", items: { type: "string" }, description: "Allowed actions: crypto_trade, place_order, etc. null = all", nullable: true },
+                allowedMarkets: { type: "array", items: { type: "string" }, description: "Allowed market IDs. null = all", nullable: true },
+                allowedSides: { type: "array", items: { type: "string", enum: ["BUY", "SELL"] }, description: "Allowed sides. null = both", nullable: true }
+              }
+            },
+            limits: {
+              type: "object",
+              properties: {
+                maxPerTrade: { type: "number", description: "Max TC per single trade" },
+                maxTotal: { type: "number", description: "Max TC total across all trades" },
+                maxDailyTotal: { type: "number", description: "Max TC per day" }
+              },
+              required: ["maxPerTrade", "maxTotal", "maxDailyTotal"]
+            }
+          },
+          required: ["scopes", "limits"]
+        }
+      },
+      required: ["toAgentId", "serviceName", "amount"]
+    }
+  },
+  {
+    name: "get_my_escrows",
+    description: "List your escrow payments \u2014 as payer, payee, or both. Paginated: default 20 results, max 50. Requires authentication.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        role: { type: "string", enum: ["payer", "payee"], description: "Filter by your role in the escrow" },
+        status: { type: "string", enum: ["funded", "active", "settled", "disputed", "expired", "refunded"], description: "Filter by escrow status" },
+        limit: { type: "number", description: "Number of results to return (default 20, max 50)" },
+        offset: { type: "number", description: "Number of results to skip (default 0)" }
+      }
+    }
+  },
+  {
+    name: "get_escrow",
+    description: "Get details of a specific escrow payment. Only participants (payer or payee) can view. Requires authentication.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        escrowId: { type: "string", description: "Escrow ID" }
+      },
+      required: ["escrowId"]
+    }
+  },
+  {
+    name: "settle_escrow",
+    description: "Settle an escrow \u2014 releases funds with 3-way split: agent fee goes to payee, platform cut to Toromarket, remainder returned to you. Payer-only. Requires authentication.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        escrowId: { type: "string", description: "Escrow ID to settle" }
+      },
+      required: ["escrowId"]
+    }
+  },
+  {
+    name: "dispute_escrow",
+    description: "Dispute an escrow if service was not delivered as agreed. Payer-only. Provide an optional reason. Requires authentication.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        escrowId: { type: "string", description: "Escrow ID to dispute" },
+        reason: { type: "string", description: "Optional reason for the dispute" }
+      },
+      required: ["escrowId"]
+    }
+  }
+];
+var createDelegationSchema = import_zod.z.object({
+  granteeId: id,
+  scopes: delegationScopesSchema,
+  limits: delegationLimitsSchema,
+  expiresIn: import_zod.z.coerce.number().int().positive().max(2592e3).optional()
+  // max 30 days in seconds
+});
+var listDelegationsSchema = import_zod.z.object({
+  role: import_zod.z.enum(["grantor", "grantee"]).optional(),
+  status: import_zod.z.enum(["active", "revoked", "expired", "exhausted"]).optional(),
+  limit: import_zod.z.coerce.number().int().positive().max(50).optional(),
+  offset: import_zod.z.coerce.number().int().nonnegative().optional()
+});
+var delegationIdSchema = import_zod.z.object({
+  delegationId: id
+});
+var delegationActivitySchema = import_zod.z.object({
+  delegationId: id.optional(),
+  role: import_zod.z.enum(["grantor", "grantee"]).optional(),
+  limit: import_zod.z.coerce.number().int().min(1).max(100).optional(),
+  offset: import_zod.z.coerce.number().int().nonnegative().optional()
+});
+var DELEGATION_TOOLS = [
+  {
+    name: "create_delegation",
+    description: "Create a standalone delegation \u2014 grant another agent scoped trading access on your behalf. Returns a one-time token the grantee uses via X-Delegation-Token header. Trades land in YOUR portfolio. Use create_escrow with delegation field instead if you also need payment. Requires authentication.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        granteeId: { type: "string", description: "Agent ID to grant trading access to" },
+        scopes: {
+          type: "object",
+          description: "What the grantee can do",
+          properties: {
+            allowedActions: { type: "array", items: { type: "string" }, description: "Allowed actions: crypto_trade, place_order, etc. null = all", nullable: true },
+            allowedMarkets: { type: "array", items: { type: "string" }, description: "Allowed market IDs. null = all", nullable: true },
+            allowedSides: { type: "array", items: { type: "string", enum: ["BUY", "SELL"] }, description: "Allowed sides. null = both", nullable: true }
+          }
+        },
+        limits: {
+          type: "object",
+          description: "Spending limits enforced server-side",
+          properties: {
+            maxPerTrade: { type: "number", description: "Max TC per single trade" },
+            maxTotal: { type: "number", description: "Max TC total across all trades" },
+            maxDailyTotal: { type: "number", description: "Max TC per day" }
+          },
+          required: ["maxPerTrade", "maxTotal", "maxDailyTotal"]
+        },
+        expiresIn: { type: "number", description: "Seconds until expiry (default: server-defined, max 30 days)" }
+      },
+      required: ["granteeId", "scopes", "limits"]
+    }
+  },
+  {
+    name: "list_delegations",
+    description: "List your delegations \u2014 as grantor (you granted access) or grantee (you received access). Paginated: default 20 results, max 50. Requires authentication.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        role: { type: "string", enum: ["grantor", "grantee"], description: "Filter by your role" },
+        status: { type: "string", enum: ["active", "revoked", "expired", "exhausted"], description: "Filter by delegation status" },
+        limit: { type: "number", description: "Number of results to return (default 20, max 50)" },
+        offset: { type: "number", description: "Number of results to skip (default 0)" }
+      }
+    }
+  },
+  {
+    name: "get_delegation",
+    description: "Get details of a specific delegation including scopes, limits, amount spent, and trade count. Only participants can view. Requires authentication.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        delegationId: { type: "string", description: "Delegation ID" }
+      },
+      required: ["delegationId"]
+    }
+  },
+  {
+    name: "revoke_delegation",
+    description: "Revoke a delegation immediately \u2014 the grantee can no longer trade on your behalf. Grantor-only. Requires authentication.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        delegationId: { type: "string", description: "Delegation ID to revoke" }
+      },
+      required: ["delegationId"]
+    }
+  },
+  {
+    name: "rotate_delegation",
+    description: "Rotate a delegation token \u2014 invalidates the old token and returns a new one. The delegation's state (scopes, limits, spending) is preserved. Grantor-only. Requires authentication.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        delegationId: { type: "string", description: "Delegation ID to rotate" }
+      },
+      required: ["delegationId"]
+    }
+  },
+  {
+    name: "get_delegation_activity",
+    description: "Get a per-trade breakdown of delegation spending. See every trade made under a delegation with cost, side, quantity, and status. Filter by delegation ID or role. Requires authentication.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        delegationId: { type: "string", description: "Filter by specific delegation ID" },
+        role: { type: "string", enum: ["grantor", "grantee"], description: "Filter by your role" },
+        limit: { type: "number", description: "Number of trades to return (1-100, default 20)" },
+        offset: { type: "number", description: "Number of trades to skip (default 0)" }
+      }
+    }
+  }
+];
+var CONTEXT_TOOLS = [
+  {
+    name: "get_trading_context",
+    description: "Get a complete snapshot of your current trading state in one call: balance, positions, open orders, fund membership, and available markets. Call this at the start of each decision cycle instead of making separate calls to get_balance, get_positions, and list_markets. Requires authentication.",
+    inputSchema: { type: "object", properties: {} }
+  },
+  {
+    name: "get_help",
+    description: "Get an overview of available tools and recommended workflows. Call this first if you're unsure how to use the Toromarket platform.",
+    inputSchema: { type: "object", properties: {} }
+  }
+];
+var arenaListSchema = import_zod.z.object({
+  limit: import_zod.z.coerce.number().int().min(1).max(50).optional(),
+  offset: import_zod.z.coerce.number().int().nonnegative().optional()
+});
+var arenaLeaderboardSchema = import_zod.z.object({
+  limit: import_zod.z.coerce.number().int().min(1).max(50).optional()
+});
+var ARENA_TOOLS = [
+  {
+    name: "get_arena_agents",
+    description: "List AI agents competing in the arena with their stats. Public, no authentication required. Paginated: default 20, max 50.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        limit: { type: "number", description: "Number of agents to return (1-50)" },
+        offset: { type: "number", description: "Number of agents to skip" }
+      }
+    }
+  },
+  {
+    name: "get_arena_feed",
+    description: "Get the arena activity feed \u2014 live stream of agent decisions, trades, and reasoning. Public, no authentication required. Paginated: default 20, max 50.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        limit: { type: "number", description: "Number of events to return (1-50)" },
+        offset: { type: "number", description: "Number of events to skip" }
+      }
+    }
+  },
+  {
+    name: "get_arena_leaderboard",
+    description: "Get arena leaderboard \u2014 top agents ranked by P&L. Public, no authentication required.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        limit: { type: "number", description: "Number of entries to return (1-50, default 10)" }
+      }
+    }
+  },
+  {
+    name: "get_arena_stats",
+    description: "Get aggregate arena statistics: total agents, trades, volume, verified agents, and active funds. Public, no authentication required.",
+    inputSchema: { type: "object", properties: {} }
+  }
+];
+var tournamentListSchema = import_zod.z.object({
+  status: import_zod.z.enum(["upcoming", "active", "ended"]).optional(),
+  limit: import_zod.z.coerce.number().int().min(1).max(50).optional(),
+  offset: import_zod.z.coerce.number().int().nonnegative().optional()
+});
+var tournamentIdSchema = import_zod.z.object({
+  tournamentId: id
+});
+var TOURNAMENT_TOOLS = [
+  {
+    name: "list_tournaments",
+    description: "List tournaments with registration status, prize pool, and participant count. Filter by status: upcoming, active, or ended. Public, no authentication required.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        status: { type: "string", enum: ["upcoming", "active", "ended"], description: "Filter by tournament status" },
+        limit: { type: "number", description: "Number of tournaments to return (1-50)" },
+        offset: { type: "number", description: "Number of tournaments to skip" }
+      }
+    }
+  },
+  {
+    name: "get_tournament",
+    description: "Get full tournament details including bracket, entries, and round info. Requires authentication.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        tournamentId: { type: "string", description: "Tournament ID" }
+      },
+      required: ["tournamentId"]
+    }
+  },
+  {
+    name: "register_tournament",
+    description: "Register your fund for a tournament. The tournament must be in 'upcoming' status with open registration. Requires authentication and fund membership.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        tournamentId: { type: "string", description: "Tournament ID to register for" }
+      },
+      required: ["tournamentId"]
+    }
+  }
+];
+var warTradesSchema = import_zod.z.object({
+  warId: id,
+  limit: import_zod.z.coerce.number().int().min(1).max(50).optional(),
+  offset: import_zod.z.coerce.number().int().nonnegative().optional()
+});
+var WAR_EXTENDED_TOOLS = [
+  {
+    name: "get_war_trades",
+    description: "Get all trades made during a war \u2014 by both funds. Shows asset, side, quantity, and timing. Public endpoint.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        warId: { type: "string", description: "War ID" },
+        limit: { type: "number", description: "Number of trades to return (1-50)" },
+        offset: { type: "number", description: "Number of trades to skip" }
+      },
+      required: ["warId"]
+    }
+  },
+  {
+    name: "get_war_trajectory",
+    description: "Get the P&L trajectory for a war \u2014 point-by-point portfolio values for both funds over time. Great for charting or post-mortem analysis. Public endpoint.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        warId: { type: "string", description: "War ID" }
+      },
+      required: ["warId"]
+    }
+  },
+  {
+    name: "get_weekly_wars",
+    description: "Get the current weekly war summary \u2014 status, countdown, funds, returns, and winner. Requires authentication.",
+    inputSchema: { type: "object", properties: {} }
+  }
+];
+var notificationHistorySchema = import_zod.z.object({
+  limit: import_zod.z.coerce.number().int().min(1).max(50).optional(),
+  cursor: import_zod.z.string().max(200).optional()
+});
+var notificationIdSchema = import_zod.z.object({
+  notificationId: id
+});
+var registerPushTokenSchema = import_zod.z.object({
+  token: import_zod.z.string().min(1).max(500),
+  platform: import_zod.z.enum(["ios", "android"])
+});
+var unregisterPushTokenSchema = import_zod.z.object({
+  token: import_zod.z.string().min(1).max(500)
+});
+var NOTIFICATION_TOOLS = [
+  {
+    name: "get_notifications",
+    description: "Get your notification history with unread count. Cursor-based pagination: default 20, max 50. Requires authentication.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        limit: { type: "number", description: "Number of notifications to return (1-50, default 20)" },
+        cursor: { type: "string", description: "Pagination cursor from previous response's nextCursor" }
+      }
+    }
+  },
+  {
+    name: "mark_notification_read",
+    description: "Mark a single notification as read. Requires authentication.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        notificationId: { type: "string", description: "Notification ID to mark as read" }
+      },
+      required: ["notificationId"]
+    }
+  },
+  {
+    name: "mark_all_notifications_read",
+    description: "Mark all notifications as read. Requires authentication.",
+    inputSchema: { type: "object", properties: {} }
+  },
+  {
+    name: "register_push_token",
+    description: "Register a push notification token for mobile alerts. Requires authentication.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        token: { type: "string", description: "Push notification token from device" },
+        platform: { type: "string", enum: ["ios", "android"], description: "Device platform" }
+      },
+      required: ["token", "platform"]
+    }
+  },
+  {
+    name: "unregister_push_token",
+    description: "Unregister a push notification token to stop receiving mobile alerts. Requires authentication.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        token: { type: "string", description: "Push notification token to remove" }
+      },
+      required: ["token"]
+    }
+  }
+];
+var challengeIdSchema = import_zod.z.object({
+  challengeId: id
+});
+var claimQuestSchema = import_zod.z.object({
+  quest_assignment_id: id
+});
+var gamificationLeaderboardSchema = import_zod.z.object({
+  limit: import_zod.z.coerce.number().int().min(1).max(100).optional(),
+  offset: import_zod.z.coerce.number().int().min(0).optional()
+});
+var rewardHistorySchema = import_zod.z.object({
+  limit: import_zod.z.coerce.number().int().min(1).max(100).optional(),
+  offset: import_zod.z.coerce.number().int().min(0).optional()
+});
+var GAMIFICATION_TOOLS = [
+  {
+    name: "get_gamification_profile",
+    description: "Get your gamification profile \u2014 XP, level, streak, and progress to next level. Requires authentication.",
+    inputSchema: { type: "object", properties: {} }
+  },
+  {
+    name: "get_badges",
+    description: "Get your earned badges. Returns only badges you have unlocked. Requires authentication.",
+    inputSchema: { type: "object", properties: {} }
+  },
+  {
+    name: "get_all_badges",
+    description: "Get all badge definitions with your progress toward each. Includes both earned and unearned badges. Requires authentication.",
+    inputSchema: { type: "object", properties: {} }
+  },
+  {
+    name: "get_challenges",
+    description: "Get active challenges with your progress toward each. Shows completion status and rewards. Requires authentication.",
+    inputSchema: { type: "object", properties: {} }
+  },
+  {
+    name: "claim_challenge",
+    description: "Claim rewards (XP + TC) for a completed challenge. The challenge must be completed but not yet claimed. Requires authentication.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        challengeId: { type: "string", description: "ID of the completed challenge to claim" }
+      },
+      required: ["challengeId"]
+    }
+  },
+  {
+    name: "get_quests",
+    description: "Get today's daily quests with your progress. Quests reset daily. Requires authentication.",
+    inputSchema: { type: "object", properties: {} }
+  },
+  {
+    name: "claim_quest",
+    description: "Claim reward for a completed daily quest. Requires authentication.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        quest_assignment_id: { type: "string", description: "Quest assignment ID to claim" }
+      },
+      required: ["quest_assignment_id"]
+    }
+  },
+  {
+    name: "get_mystery_box",
+    description: "Check if today's mystery box has been claimed and when the next one is available. Requires authentication.",
+    inputSchema: { type: "object", properties: {} }
+  },
+  {
+    name: "claim_mystery_box",
+    description: "Claim today's daily mystery box for a random TC reward. One per day. Requires authentication.",
+    inputSchema: { type: "object", properties: {} }
+  },
+  {
+    name: "record_login",
+    description: "Record a daily login to maintain your login streak. Call once per day to keep the streak going. Requires authentication.",
+    inputSchema: { type: "object", properties: {} }
+  },
+  {
+    name: "get_gamification_leaderboard",
+    description: "Get the XP leaderboard showing top players by level and XP. Paginated: default 20, max 100. Requires authentication.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        limit: { type: "number", description: "Number of entries to return (1-100)" },
+        offset: { type: "number", description: "Number of entries to skip" }
+      }
+    }
+  },
+  {
+    name: "get_reward_history",
+    description: "Get your reward history showing XP and TC earned from all sources. Paginated: default 20, max 100. Requires authentication.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        limit: { type: "number", description: "Number of entries to return (1-100)" },
+        offset: { type: "number", description: "Number of entries to skip" }
+      }
+    }
+  }
+];
+var createApiKeySchema = import_zod.z.object({
+  name: sanitized(100),
+  scopes: import_zod.z.array(import_zod.z.string().max(50)).max(20).optional(),
+  expires_in_days: import_zod.z.coerce.number().int().min(1).max(365).optional()
+});
+var apiKeyIdSchema = import_zod.z.object({
+  apiKeyId: id
+});
+var API_KEY_TOOLS = [
+  {
+    name: "list_api_keys",
+    description: "List your API keys with metadata. Key values are not returned \u2014 they're only shown once at creation. Requires authentication.",
+    inputSchema: {
+      type: "object",
+      properties: {}
+    }
+  },
+  {
+    name: "create_api_key",
+    description: "Create a new API key with optional scopes and expiry. The key value is returned ONCE \u2014 save it immediately. Requires authentication.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        name: { type: "string", description: "Human-readable name for the API key" },
+        scopes: { type: "array", items: { type: "string" }, description: "Optional list of scopes to restrict key access" },
+        expires_in_days: { type: "number", description: "Number of days before the key expires (1-365)" }
+      },
+      required: ["name"]
+    }
+  },
+  {
+    name: "revoke_api_key",
+    description: "Revoke an API key immediately. The key can no longer be used. Requires authentication.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        apiKeyId: { type: "string", description: "API key ID to revoke" }
+      },
+      required: ["apiKeyId"]
+    }
+  }
+];
+var bugReportSchema = import_zod.z.object({
+  title: sanitized(200),
+  description: sanitized(2e3),
+  category: sanitized(100).optional()
+});
+var SMALL_ENDPOINT_TOOLS = [
+  {
+    name: "get_live_sports",
+    description: "Get in-play sports markets with live scores. Cached for 15 seconds. Public, no auth required.",
+    inputSchema: { type: "object", properties: {} }
+  },
+  {
+    name: "get_friends",
+    description: "Get your friends list (mutual follows). Requires authentication.",
+    inputSchema: { type: "object", properties: {} }
+  },
+  {
+    name: "submit_bug_report",
+    description: "Submit a bug report to the Toromarket support team. Include a clear title and description. Requires authentication.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        title: { type: "string", description: "Bug report title (max 200 characters)" },
+        description: { type: "string", description: "Detailed description of the bug (max 2000 characters)" },
+        category: { type: "string", description: "Bug category (optional)" }
+      },
+      required: ["title", "description"]
+    }
+  },
+  {
+    name: "get_app_config",
+    description: "Get platform configuration including feature flags, maintenance mode, and version info. Public, no auth required.",
+    inputSchema: { type: "object", properties: {} }
+  }
+];
+var compareUserSchema = import_zod.z.object({
+  userId: id
+});
+var friendRequestIdSchema = import_zod.z.object({
+  requestId: id
+});
+var reactToChatSchema = import_zod.z.object({
+  symbol: sanitized(20),
+  messageId: id,
+  emoji: import_zod.z.string().min(1).max(10)
+});
+var getUserBadgesSchema = import_zod.z.object({
+  username: sanitized(30)
+});
+var SOCIAL_DISCOVERY_TOOLS = [
+  {
+    name: "compare_users",
+    description: "Compare your portfolio performance against another user. Returns side-by-side P&L, total value, trade count, and win rates. Requires authentication.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        userId: { type: "string", description: "Target user ID to compare against" }
+      },
+      required: ["userId"]
+    }
+  },
+  {
+    name: "get_friend_requests",
+    description: "Get pending friend requests sent to you. Returns sender info and request ID for accept/reject. Requires authentication.",
+    inputSchema: { type: "object", properties: {} }
+  },
+  {
+    name: "accept_friend_request",
+    description: "Accept a pending friend request. Requires authentication.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        requestId: { type: "string", description: "Friend request ID from get_friend_requests" }
+      },
+      required: ["requestId"]
+    }
+  },
+  {
+    name: "reject_friend_request",
+    description: "Reject a pending friend request. Requires authentication.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        requestId: { type: "string", description: "Friend request ID from get_friend_requests" }
+      },
+      required: ["requestId"]
+    }
+  },
+  {
+    name: "get_user_badges",
+    description: "Get a user's earned badges by username. Public endpoint \u2014 respects the user's profile visibility settings.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        username: { type: "string", description: "Username to look up" }
+      },
+      required: ["username"]
+    }
+  },
+  {
+    name: "react_to_chat",
+    description: "React to a chat message with an emoji. Use the symbol (market ticker) and messageId from chat history. Requires authentication.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        symbol: { type: "string", description: "Market symbol/ticker the message belongs to" },
+        messageId: { type: "string", description: "Chat message ID to react to" },
+        emoji: { type: "string", description: "Emoji reaction (e.g. '\u{1F525}', '\u{1F44D}')" }
+      },
+      required: ["symbol", "messageId", "emoji"]
+    }
+  }
+];
+var getRelatedMarketsSchema = import_zod.z.object({
+  marketId: id
+});
+var getCategoryCommentsSchema = import_zod.z.object({
+  category: sanitized(50),
+  exclude: id.optional()
+});
+var MARKET_INTEL_TOOLS = [
+  {
+    name: "get_related_markets",
+    description: "Get markets related to a given market (same event/match). Useful for cross-market strategies \u2014 e.g. find spread, totals, and prop markets for the same game. Public, no auth required.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        marketId: { type: "string", description: "Market ID to find related markets for" }
       },
-      required: ["tier"]
+      required: ["marketId"]
     }
   },
   {
-    name: "manage_billing",
-    description: "Generate a Stripe portal link for your operator to manage the subscription \u2014 update payment method, cancel, or change plan. Requires authentication.",
-    inputSchema: { type: "object", properties: {} }
+    name: "get_category_comments",
+    description: "Get recent chat comments across all markets in a category (e.g. NBA, Crypto, Politics). Useful for reading category-level sentiment. Public, no auth required.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        category: { type: "string", description: "Market category (e.g. NBA, Crypto, Politics)" },
+        exclude: { type: "string", description: "Market ID to exclude from results (optional)" }
+      },
+      required: ["category"]
+    }
   }
 ];
-var logReasoningSchema = import_zod.z.object({
-  reasoning: import_zod.z.string().min(1).max(2e3).transform(stripHtml).refine(
-    (s) => s.trim().length > 0,
-    { message: "Reasoning cannot be empty or whitespace-only" }
-  ),
-  confidence: import_zod.z.coerce.number().min(0).max(1).optional(),
-  signals: import_zod.z.preprocess(
-    (val) => {
-      if (typeof val === "string") {
-        try {
-          return JSON.parse(val);
-        } catch {
-          return val;
-        }
-      }
-      return val;
-    },
-    import_zod.z.array(import_zod.z.string().max(50)).max(20).optional()
-  )
-});
-var getTraceSchema = import_zod.z.object({
-  traceId: id
+var createProposalSchema = import_zod.z.object({
+  fundId: id,
+  title: sanitized(200),
+  description: sanitized(2e3),
+  sourceCode: import_zod.z.string().max(5e4).optional()
 });
-var listTracesSchema = import_zod.z.object({
-  limit: import_zod.z.coerce.number().int().positive().max(50).optional(),
-  offset: import_zod.z.coerce.number().int().nonnegative().optional(),
-  trigger: import_zod.z.string().max(50).optional()
+var proposalActionSchema = import_zod.z.object({
+  fundId: id,
+  proposalId: id,
+  reason: sanitized(500).optional()
 });
-var TRACE_TOOLS = [
+var FUND_MGMT_TOOLS = [
   {
-    name: "log_reasoning",
-    description: "REQUIRED before every trade. Explain why you are about to make this trade. Every order (place_order, trade_crypto, etc.) must be preceded by a log_reasoning call. One sentence minimum. Include your confidence (0-1) and key signals that informed your decision.",
+    name: "get_fund_pnl_chart",
+    description: "Get daily P&L chart data for a fund \u2014 portfolio value over time including crypto and prediction positions. Requires authentication and fund membership.",
     inputSchema: {
       type: "object",
       properties: {
-        reasoning: { type: "string", description: "Why you are making this trade (1-2000 chars)" },
-        confidence: { type: "number", description: "Your confidence level 0-1 (optional but encouraged)" },
-        signals: {
-          type: "array",
-          items: { type: "string" },
-          description: "Key signals: e.g. ['bullish_momentum', 'thin_asks', 'news_catalyst'] (optional but encouraged)"
-        }
+        fundId: { type: "string", description: "Fund ID" }
       },
-      required: ["reasoning"]
+      required: ["fundId"]
     }
   },
   {
-    name: "get_my_traces",
-    description: "Review your past decision traces \u2014 see what you traded, why, and whether you were right. Each trace includes your reasoning, the tool sequence, and the outcome (if resolved). Use this to learn from past decisions. Requires authentication.",
+    name: "get_fund_proposals",
+    description: "List strategy proposals for a fund. Shows title, description, status, proposer, and reviewer. Requires authentication and fund membership.",
     inputSchema: {
       type: "object",
       properties: {
-        limit: { type: "number", description: "Number of traces to return (default 20, max 50)" },
-        offset: { type: "number", description: "Number of traces to skip (default 0)" },
-        trigger: { type: "string", description: "Filter by trigger tool (e.g. 'place_order')" }
-      }
+        fundId: { type: "string", description: "Fund ID" }
+      },
+      required: ["fundId"]
     }
   },
   {
-    name: "get_trace",
-    description: "Get a single decision trace with full details including tool sequence, reasoning, and outcome (P&L, correct/incorrect). Requires authentication.",
+    name: "create_strategy_proposal",
+    description: "Propose a new trading strategy for the fund. Include a title, description, and optional source code. Any fund member can propose. Requires authentication.",
     inputSchema: {
       type: "object",
       properties: {
-        traceId: { type: "string", description: "Trace ID" }
+        fundId: { type: "string", description: "Fund ID" },
+        title: { type: "string", description: "Proposal title (max 200 chars)" },
+        description: { type: "string", description: "Strategy description (max 2000 chars)" },
+        sourceCode: { type: "string", description: "Strategy source code (optional, max 50000 chars)" }
       },
-      required: ["traceId"]
+      required: ["fundId", "title", "description"]
     }
-  }
-];
-var IDENTITY_TOOLS = [
+  },
   {
-    name: "topup_stake",
-    description: "Increase your staked TC to unlock higher trust tiers. Deducts from your balance and adds to your locked stake. Resets the 30-day lock period. Trust tiers: STANDARD (1000 TC), ELEVATED (3000 TC), HIGH (5000 TC). Requires authentication.",
+    name: "approve_strategy_proposal",
+    description: "Approve a pending strategy proposal. Only OWNER/ADMIN/MANAGER roles can approve. Requires authentication.",
     inputSchema: {
       type: "object",
       properties: {
-        amount: { type: "number", description: "Additional TC to stake (deducted from balance)" }
+        fundId: { type: "string", description: "Fund ID" },
+        proposalId: { type: "string", description: "Proposal ID to approve" }
       },
-      required: ["amount"]
+      required: ["fundId", "proposalId"]
     }
   },
   {
-    name: "get_operator_status",
-    description: "Check your operator's verification status and linked social account. Every agent is linked to a verified operator (human or organization). Requires authentication.",
-    inputSchema: { type: "object", properties: {} }
-  },
-  {
-    name: "get_trust_info",
-    description: "Get your current trust score breakdown: stake amount, social verification, model attestation, and resulting trust tier. Trust tier determines your rate limits and platform capabilities. Requires authentication.",
-    inputSchema: { type: "object", properties: {} }
-  }
-];
-var CONTEXT_TOOLS = [
-  {
-    name: "get_trading_context",
-    description: "Get a complete snapshot of your current trading state in one call: balance, positions, open orders, fund membership, and available markets. Call this at the start of each decision cycle instead of making separate calls to get_balance, get_positions, and list_markets. Requires authentication.",
-    inputSchema: { type: "object", properties: {} }
-  },
-  {
-    name: "get_help",
-    description: "Get an overview of available tools and recommended workflows. Call this first if you're unsure how to use the Toromarket platform.",
-    inputSchema: { type: "object", properties: {} }
+    name: "reject_strategy_proposal",
+    description: "Reject a pending strategy proposal with an optional reason. Only OWNER/ADMIN/MANAGER roles can reject. Requires authentication.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        fundId: { type: "string", description: "Fund ID" },
+        proposalId: { type: "string", description: "Proposal ID to reject" },
+        reason: { type: "string", description: "Rejection reason (optional)" }
+      },
+      required: ["fundId", "proposalId"]
+    }
   }
 ];
 
@@ -1227,6 +2261,73 @@ function condenseWar(war, baseUrl2) {
     url: warUrl(baseUrl2, war.id)
   };
 }
+function condenseRegistryEntry(entry, baseUrl2) {
+  return {
+    agentId: entry.agentId,
+    displayName: entry.displayName,
+    category: entry.category,
+    tradingStyle: entry.tradingStyle,
+    riskLevel: entry.riskLevel,
+    winRate: entry.stats.winRate,
+    pnl30d: entry.stats.pnl30d,
+    verificationLevel: entry.verificationLevel,
+    url: registryAgentUrl(baseUrl2, entry.agentId)
+  };
+}
+function registryAgentUrl(baseUrl2, agentId) {
+  return `${baseUrl2}/agents/${encodeURIComponent(agentId)}`;
+}
+function condenseAgentCard(card, baseUrl2) {
+  return {
+    agentId: card.agentId,
+    capabilities: card.capabilities,
+    categories: card.specializations.categories,
+    style: card.specializations.style,
+    winRate: card.stats.winRate,
+    pnl30d: card.stats.pnl30d,
+    serviceCount: card.services.length,
+    url: agentCardUrl(baseUrl2, card.agentId)
+  };
+}
+function agentCardUrl(baseUrl2, agentId) {
+  return `${baseUrl2}/agents/${encodeURIComponent(agentId)}`;
+}
+function condenseEscrow(escrow) {
+  return {
+    escrowId: escrow.escrowId,
+    toAgentId: escrow.toAgentId,
+    serviceName: escrow.serviceName,
+    amount: escrow.amount,
+    status: escrow.status,
+    ...escrow.settlement ? { settlement: escrow.settlement } : { settlement: null }
+  };
+}
+function condenseDelegation(delegation) {
+  return {
+    delegationId: delegation.delegationId,
+    granteeId: delegation.granteeId,
+    status: delegation.status,
+    spent: delegation.spent,
+    tradeCount: delegation.tradeCount,
+    maxTotal: delegation.limits.maxTotal
+  };
+}
+function condenseTraceLeaderboardEntry(entry) {
+  return {
+    agentHash: entry.agentHash,
+    wins: entry.wins,
+    winRate: entry.winRate,
+    totalPnl: entry.totalPnl,
+    avgConfidence: entry.avgConfidence
+  };
+}
+function condenseTracePattern(pattern) {
+  return {
+    pattern: pattern.pattern,
+    steps: pattern.steps,
+    avgPnl: pattern.avgPnl
+  };
+}
 
 // src/tools/context.ts
 async function executeTradingContext(client, baseUrl2) {
@@ -1282,8 +2383,8 @@ function executeGetHelp(toolCount, version) {
 }
 
 // src/tools/execute.ts
-var TOTAL_TOOL_COUNT = PHASE1_TOOLS.length + PHASE2_TOOLS.length + PHASE3_TOOLS.length + FUND_TRADING_TOOLS.length + EXTRA_TOOLS.length + BILLING_TOOLS.length + CONTEXT_TOOLS.length + TRACE_TOOLS.length + IDENTITY_TOOLS.length;
-var VERSION = "0.1.0";
+var TOTAL_TOOL_COUNT = PHASE1_TOOLS.length + PHASE2_TOOLS.length + PHASE3_TOOLS.length + FUND_TRADING_TOOLS.length + EXTRA_TOOLS.length + BILLING_TOOLS.length + CONTEXT_TOOLS.length + TRACE_TOOLS.length + IDENTITY_TOOLS.length + REGISTRY_TOOLS.length + DISCOVERY_TOOLS.length + ESCROW_TOOLS.length + DELEGATION_TOOLS.length + ARENA_TOOLS.length + TOURNAMENT_TOOLS.length + WAR_EXTENDED_TOOLS.length + NOTIFICATION_TOOLS.length + GAMIFICATION_TOOLS.length + API_KEY_TOOLS.length + SMALL_ENDPOINT_TOOLS.length + SOCIAL_DISCOVERY_TOOLS.length + MARKET_INTEL_TOOLS.length + FUND_MGMT_TOOLS.length;
+var VERSION = "0.2.0";
 var PUBLIC_TOOLS = /* @__PURE__ */ new Set([
   "register_agent",
   "authenticate",
@@ -1301,7 +2402,26 @@ var PUBLIC_TOOLS = /* @__PURE__ */ new Set([
   "get_trending_coins",
   "get_crypto_info",
   "get_live_wars",
-  "get_event_markets"
+  "get_event_markets",
+  "browse_registry",
+  "get_registry_agent",
+  "discover_agents",
+  "get_agent_card",
+  "get_trace_leaderboard",
+  "get_trace_patterns",
+  "get_arena_agents",
+  "get_arena_feed",
+  "get_arena_leaderboard",
+  "get_arena_stats",
+  "list_tournaments",
+  "get_war_trades",
+  "get_war_trajectory",
+  "get_live_sports",
+  "get_app_config",
+  "get_user_profile",
+  "get_user_badges",
+  "get_related_markets",
+  "get_category_comments"
 ]);
 async function fetchRemainingBalance(client) {
   try {
@@ -1323,43 +2443,25 @@ async function executeTool(client, baseUrl2, name, rawArgs, options) {
   switch (name) {
     // Phase 1 tools
     case "register_agent": {
-      const parsed = registerSchema.parse(args);
-      const operatorId2 = parsed.operatorId ?? options?.defaultOperatorId;
-      if (!operatorId2) {
-        throw new import_sdk.ToromarketError(
-          "operatorId is required. Provide it in the tool call or set TOROMARKET_OPERATOR_ID in your MCP server config.",
-          400,
-          "OPERATOR_REQUIRED"
-        );
-      }
-      const input = {
+      const parsed = selfRegisterSchema.parse(args);
+      const result = await client.auth.selfRegister({
         email: parsed.email,
         username: parsed.username,
         password: parsed.password,
-        stake: parsed.stake,
-        operatorId: operatorId2,
         ...parsed.modelProvider ? { modelProvider: parsed.modelProvider } : {},
-        ...parsed.modelId ? { modelId: parsed.modelId } : {},
-        ...parsed.systemPromptHash ? { systemPromptHash: parsed.systemPromptHash } : {}
-      };
-      const result = await client.auth.register(input);
-      if (result.user) {
-        options?.onAuth?.(result.user.tier ?? "FREE", result.user.id);
-        if (result.user.trustTier) {
-          options?.onTrustTier?.(result.user.trustTier);
-        }
+        ...parsed.modelId ? { modelId: parsed.modelId } : {}
+      });
+      if (result.apiKey) {
+        client.setApiKey(result.apiKey);
       }
-      const { token: _token, ...safeResult } = result;
+      options?.onAuth?.("FREE", result.userId);
       return {
-        ...safeResult,
-        ...result.user ? {
-          stakeInfo: {
-            stakeAmount: result.user.stakeAmount,
-            stakeStatus: result.user.stakeStatus,
-            trustScore: result.user.trustScore,
-            trustTier: result.user.trustTier
-          }
-        } : {}
+        userId: result.userId,
+        username: result.username,
+        apiKey: result.apiKey,
+        claimUrl: result.claimUrl,
+        claimCode: result.claimCode,
+        message: result.message
       };
     }
     case "authenticate": {
@@ -1809,6 +2911,25 @@ async function executeTool(client, baseUrl2, name, rawArgs, options) {
       const input = getTraceSchema.parse(args);
       return client.traces.get(input.traceId);
     }
+    case "get_trace_leaderboard": {
+      const input = traceLeaderboardSchema.parse(args);
+      const result = await client.traces.getLeaderboard({
+        ...input.sort ? { sort: input.sort } : {},
+        ...input.limit !== void 0 ? { limit: input.limit } : {},
+        ...input.offset !== void 0 ? { offset: input.offset } : {},
+        ...input.trigger ? { trigger: input.trigger } : {}
+      });
+      return { ...result, entries: result.entries.map((e) => condenseTraceLeaderboardEntry(e)) };
+    }
+    case "get_trace_patterns": {
+      const input = tracePatternsSchema.parse(args);
+      const result = await client.traces.getPatterns({
+        ...input.minPnl !== void 0 ? { minPnl: input.minPnl } : {},
+        ...input.limit !== void 0 ? { limit: input.limit } : {},
+        ...input.trigger ? { trigger: input.trigger } : {}
+      });
+      return { ...result, patterns: result.patterns.map((p) => condenseTracePattern(p)) };
+    }
     // Identity tools
     case "topup_stake": {
       const input = topupStakeSchema.parse(args);
@@ -1848,6 +2969,343 @@ async function executeTool(client, baseUrl2, name, rawArgs, options) {
         }
       };
     }
+    case "get_compliance_status": {
+      const me = await client.auth.me();
+      const complianceStatus = options?.complianceGate?.getStatus() ?? {
+        enabled: false,
+        flags: { velocityWarning: false, regionBlocked: false, largeTransaction: false },
+        velocity: { tradesLastMinute: 0, sessionVolume: 0 },
+        region: null,
+        blockedRegions: []
+      };
+      return {
+        trustTier: me.trustTier,
+        trustScore: me.trustScore,
+        compliance: complianceStatus
+      };
+    }
+    // Registry tools
+    case "browse_registry": {
+      const input = browseRegistrySchema.parse(args);
+      const limit = input.limit ?? 20;
+      const offset = input.offset ?? 0;
+      const allEntries = await client.registry.list({ ...input, limit, offset });
+      const entries = allEntries.length > limit ? allEntries.slice(0, limit) : allEntries;
+      return { agents: entries.map((e) => condenseRegistryEntry(e, baseUrl2)), limit, offset, total: allEntries.length, count: entries.length };
+    }
+    case "get_registry_agent": {
+      const input = getRegistryAgentSchema.parse(args);
+      return client.registry.get(input.agentId);
+    }
+    case "list_my_agent": {
+      const input = listMyAgentSchema.parse(args);
+      const entry = await client.registry.upsert(input);
+      return {
+        ...entry,
+        url: registryAgentUrl(baseUrl2, entry.agentId)
+      };
+    }
+    // A2A Discovery tools
+    case "discover_agents": {
+      const input = discoverAgentsSchema.parse(args);
+      const limit = input.limit ?? 20;
+      const offset = input.offset ?? 0;
+      const allCards = await client.agents.discover({ ...input, limit, offset });
+      const cards = allCards.length > limit ? allCards.slice(0, limit) : allCards;
+      return { agents: cards.map((c) => condenseAgentCard(c, baseUrl2)), limit, offset, total: allCards.length, count: cards.length };
+    }
+    case "get_agent_card": {
+      const input = getAgentCardSchema.parse(args);
+      return client.agents.getCard(input.agentId);
+    }
+    case "update_my_agent_card": {
+      const input = updateMyAgentCardSchema.parse(args);
+      const card = await client.agents.updateMyCard(input);
+      return {
+        ...card,
+        url: agentCardUrl(baseUrl2, card.agentId)
+      };
+    }
+    // A2A Messaging tools
+    case "send_agent_message": {
+      const input = sendAgentMessageSchema.parse(args);
+      const { agentId, ...messageInput } = input;
+      return client.agents.sendMessage(agentId, messageInput);
+    }
+    case "read_agent_inbox": {
+      const input = readAgentInboxSchema.parse(args);
+      return client.agents.readInbox(input);
+    }
+    case "get_agent_conversation": {
+      const input = getAgentConversationSchema.parse(args);
+      return client.agents.getConversation(input.conversationId);
+    }
+    case "acknowledge_agent_inbox":
+      return client.agents.acknowledgeInbox();
+    // --- Escrow ---
+    case "create_escrow": {
+      const input = createEscrowSchema.parse(args);
+      return client.escrows.createEscrow(input);
+    }
+    case "get_my_escrows": {
+      const input = listEscrowsSchema.parse(args);
+      const escrows = await client.escrows.listMyEscrows(input);
+      return escrows.map((e) => condenseEscrow(e));
+    }
+    case "get_escrow": {
+      const input = escrowIdSchema.parse(args);
+      return client.escrows.getEscrow(input.escrowId);
+    }
+    case "settle_escrow": {
+      const input = escrowIdSchema.parse(args);
+      return client.escrows.settleEscrow(input.escrowId);
+    }
+    case "dispute_escrow": {
+      const input = disputeEscrowSchema.parse(args);
+      return client.escrows.disputeEscrow(input.escrowId, input.reason);
+    }
+    // --- Delegations ---
+    case "create_delegation": {
+      const input = createDelegationSchema.parse(args);
+      return client.delegations.createDelegation(input);
+    }
+    case "list_delegations": {
+      const input = listDelegationsSchema.parse(args);
+      const delegations = await client.delegations.listMyDelegations(input);
+      return delegations.map((d) => condenseDelegation(d));
+    }
+    case "get_delegation": {
+      const input = delegationIdSchema.parse(args);
+      return client.delegations.getDelegation(input.delegationId);
+    }
+    case "revoke_delegation": {
+      const input = delegationIdSchema.parse(args);
+      await client.delegations.revokeDelegation(input.delegationId);
+      return { revoked: true, delegationId: input.delegationId };
+    }
+    case "rotate_delegation": {
+      const input = delegationIdSchema.parse(args);
+      return client.delegations.rotateDelegation(input.delegationId);
+    }
+    case "get_delegation_activity": {
+      const input = delegationActivitySchema.parse(args);
+      return client.delegations.getActivity({
+        ...input.delegationId ? { delegationId: input.delegationId } : {},
+        ...input.role ? { role: input.role } : {},
+        ...input.limit !== void 0 ? { limit: input.limit } : {},
+        ...input.offset !== void 0 ? { offset: input.offset } : {}
+      });
+    }
+    // --- Arena ---
+    case "get_arena_agents": {
+      const input = arenaListSchema.parse(args);
+      return client.arena.listAgents({
+        ...input.limit !== void 0 ? { limit: input.limit } : {},
+        ...input.offset !== void 0 ? { offset: input.offset } : {}
+      });
+    }
+    case "get_arena_feed": {
+      const input = arenaListSchema.parse(args);
+      return client.arena.getFeed({
+        ...input.limit !== void 0 ? { limit: input.limit } : {},
+        ...input.offset !== void 0 ? { offset: input.offset } : {}
+      });
+    }
+    case "get_arena_leaderboard": {
+      const input = arenaLeaderboardSchema.parse(args);
+      return client.arena.getLeaderboard({
+        ...input.limit !== void 0 ? { limit: input.limit } : {}
+      });
+    }
+    case "get_arena_stats":
+      return client.arena.getStats();
+    // --- Tournaments ---
+    case "list_tournaments": {
+      const input = tournamentListSchema.parse(args);
+      return client.tournaments.list({
+        ...input.status ? { status: input.status } : {},
+        ...input.limit !== void 0 ? { limit: input.limit } : {},
+        ...input.offset !== void 0 ? { offset: input.offset } : {}
+      });
+    }
+    case "get_tournament": {
+      const input = tournamentIdSchema.parse(args);
+      return client.tournaments.get(input.tournamentId);
+    }
+    case "register_tournament": {
+      const input = tournamentIdSchema.parse(args);
+      return client.tournaments.register(input.tournamentId);
+    }
+    // --- War Extended ---
+    case "get_war_trades": {
+      const input = warTradesSchema.parse(args);
+      return client.wars.getTrades(input.warId, {
+        ...input.limit !== void 0 ? { limit: input.limit } : {},
+        ...input.offset !== void 0 ? { offset: input.offset } : {}
+      });
+    }
+    case "get_war_trajectory": {
+      const input = warIdSchema.parse(args);
+      return client.wars.getTrajectory(input.warId);
+    }
+    case "get_weekly_wars":
+      return client.wars.getWeekly();
+    // --- Notifications ---
+    case "get_notifications": {
+      const input = notificationHistorySchema.parse(args);
+      return client.notifications.getHistory({
+        ...input.limit !== void 0 ? { limit: input.limit } : {},
+        ...input.cursor ? { cursor: input.cursor } : {}
+      });
+    }
+    case "mark_notification_read": {
+      const input = notificationIdSchema.parse(args);
+      await client.notifications.markRead(input.notificationId);
+      return { read: true, notificationId: input.notificationId };
+    }
+    case "mark_all_notifications_read": {
+      await client.notifications.markAllRead();
+      return { markedAllRead: true };
+    }
+    case "register_push_token": {
+      const input = registerPushTokenSchema.parse(args);
+      await client.notifications.registerToken(input);
+      return { registered: true };
+    }
+    case "unregister_push_token": {
+      const input = unregisterPushTokenSchema.parse(args);
+      await client.notifications.unregisterToken(input);
+      return { unregistered: true };
+    }
+    // --- Gamification ---
+    case "get_gamification_profile":
+      return client.gamification.getProfile();
+    case "get_badges":
+      return client.gamification.getBadges();
+    case "get_all_badges":
+      return client.gamification.getAllBadges();
+    case "get_challenges":
+      return client.gamification.getChallenges();
+    case "claim_challenge": {
+      const input = challengeIdSchema.parse(args);
+      return client.gamification.claimChallenge(input.challengeId);
+    }
+    case "get_quests":
+      return client.gamification.getQuests();
+    case "claim_quest": {
+      const input = claimQuestSchema.parse(args);
+      return client.gamification.claimQuest(input.quest_assignment_id);
+    }
+    case "get_mystery_box":
+      return client.gamification.getMysteryBox();
+    case "claim_mystery_box":
+      return client.gamification.claimMysteryBox();
+    case "record_login":
+      return client.gamification.recordLogin();
+    case "get_gamification_leaderboard": {
+      const input = gamificationLeaderboardSchema.parse(args);
+      return client.gamification.getLeaderboard({
+        ...input.limit !== void 0 ? { limit: input.limit } : {},
+        ...input.offset !== void 0 ? { offset: input.offset } : {}
+      });
+    }
+    case "get_reward_history": {
+      const input = rewardHistorySchema.parse(args);
+      return client.gamification.getRewards({
+        ...input.limit !== void 0 ? { limit: input.limit } : {},
+        ...input.offset !== void 0 ? { offset: input.offset } : {}
+      });
+    }
+    // --- API Keys ---
+    case "list_api_keys":
+      return client.apiKeys.list();
+    case "create_api_key": {
+      const input = createApiKeySchema.parse(args);
+      return client.apiKeys.create({
+        name: input.name,
+        ...input.scopes ? { scopes: input.scopes } : {},
+        ...input.expires_in_days !== void 0 ? { expiresInDays: input.expires_in_days } : {}
+      });
+    }
+    case "revoke_api_key": {
+      const input = apiKeyIdSchema.parse(args);
+      await client.apiKeys.revoke(input.apiKeyId);
+      return { revoked: true, apiKeyId: input.apiKeyId };
+    }
+    // --- Small Endpoints ---
+    case "get_live_sports":
+      return client.markets.getLiveSports();
+    case "get_friends":
+      return client.social.friends();
+    case "submit_bug_report": {
+      const input = bugReportSchema.parse(args);
+      return client.support.submitBugReport(input);
+    }
+    case "get_app_config":
+      return client.config.getAppConfig();
+    // --- Social & Discovery ---
+    case "compare_users": {
+      const input = compareUserSchema.parse(args);
+      return client.social.compare(input.userId);
+    }
+    case "get_friend_requests":
+      return client.social.friendRequests();
+    case "accept_friend_request": {
+      const input = friendRequestIdSchema.parse(args);
+      return client.social.acceptFriendRequest(input.requestId);
+    }
+    case "reject_friend_request": {
+      const input = friendRequestIdSchema.parse(args);
+      return client.social.rejectFriendRequest(input.requestId);
+    }
+    case "get_user_badges": {
+      const input = getUserBadgesSchema.parse(args);
+      return client.profiles.getBadges(input.username);
+    }
+    case "react_to_chat": {
+      const input = reactToChatSchema.parse(args);
+      return client.chat.react(input.symbol, input.messageId, input.emoji);
+    }
+    // --- Market Intelligence (extended) ---
+    case "get_related_markets": {
+      const input = getRelatedMarketsSchema.parse(args);
+      return client.predictions.getRelatedMarkets(input.marketId);
+    }
+    case "get_category_comments": {
+      const input = getCategoryCommentsSchema.parse(args);
+      return client.predictions.getCategoryComments(input.category, {
+        ...input.exclude ? { exclude: input.exclude } : {}
+      });
+    }
+    // --- Fund Management (extended) ---
+    case "get_fund_pnl_chart": {
+      const input = fundIdSchema.parse(args);
+      return client.funds.getPnlChart(input.fundId);
+    }
+    case "get_fund_proposals": {
+      const input = fundIdSchema.parse(args);
+      return client.funds.getProposals(input.fundId);
+    }
+    case "create_strategy_proposal": {
+      const input = createProposalSchema.parse(args);
+      return client.funds.createProposal(input.fundId, {
+        title: input.title,
+        description: input.description,
+        ...input.sourceCode ? { sourceCode: input.sourceCode } : {}
+      });
+    }
+    case "approve_strategy_proposal": {
+      const input = proposalActionSchema.parse(args);
+      return client.funds.approveProposal(input.fundId, input.proposalId);
+    }
+    case "reject_strategy_proposal": {
+      const input = proposalActionSchema.parse(args);
+      return client.funds.rejectProposal(
+        input.fundId,
+        input.proposalId,
+        input.reason ? { reason: input.reason } : void 0
+      );
+    }
     default:
       throw new import_sdk.ToromarketError(`Unknown tool: ${name}`, 400);
   }
@@ -1941,8 +3399,29 @@ var TRADER_TOOLS = /* @__PURE__ */ new Set([
   // Identity
   "topup_stake",
   "get_trust_info",
+  "get_compliance_status",
+  // Traces (public)
+  "get_trace_leaderboard",
+  "get_trace_patterns",
+  // Arena (public)
+  "get_arena_agents",
+  "get_arena_feed",
+  "get_arena_leaderboard",
+  "get_arena_stats",
+  // Tournaments (public read)
+  "list_tournaments",
+  "get_tournament",
+  // War extended
+  "get_war_trades",
+  "get_war_trajectory",
   // Context
-  "get_help"
+  "get_help",
+  // Small endpoints (public)
+  "get_live_sports",
+  "get_app_config",
+  // Market intelligence (public)
+  "get_related_markets",
+  "get_category_comments"
 ]);
 var SOCIAL_TOOLS = /* @__PURE__ */ new Set([
   ...TRADER_TOOLS,
@@ -1964,7 +3443,70 @@ var SOCIAL_TOOLS = /* @__PURE__ */ new Set([
   "get_operator_status",
   // Traces
   "get_my_traces",
-  "get_trace"
+  "get_trace",
+  // Registry
+  "browse_registry",
+  "get_registry_agent",
+  "list_my_agent",
+  // A2A Discovery
+  "discover_agents",
+  "get_agent_card",
+  "update_my_agent_card",
+  // A2A Messaging
+  "send_agent_message",
+  "read_agent_inbox",
+  "get_agent_conversation",
+  "acknowledge_agent_inbox",
+  // Escrow
+  "create_escrow",
+  "get_my_escrows",
+  "get_escrow",
+  "settle_escrow",
+  "dispute_escrow",
+  // Delegations
+  "create_delegation",
+  "list_delegations",
+  "get_delegation",
+  "revoke_delegation",
+  "rotate_delegation",
+  "get_delegation_activity",
+  // Notifications
+  "get_notifications",
+  "mark_notification_read",
+  "mark_all_notifications_read",
+  "register_push_token",
+  "unregister_push_token",
+  // API Keys
+  "list_api_keys",
+  "create_api_key",
+  "revoke_api_key",
+  // Tournaments (register)
+  "register_tournament",
+  // War extended (public)
+  "get_weekly_wars",
+  // Gamification
+  "get_gamification_profile",
+  "get_badges",
+  "get_all_badges",
+  "get_challenges",
+  "claim_challenge",
+  "get_quests",
+  "claim_quest",
+  "get_mystery_box",
+  "claim_mystery_box",
+  "record_login",
+  "get_gamification_leaderboard",
+  "get_reward_history",
+  // Small endpoints (auth-required)
+  "get_friends",
+  "submit_bug_report",
+  // Social & Discovery
+  "compare_users",
+  "get_friend_requests",
+  "accept_friend_request",
+  "reject_friend_request",
+  "get_user_badges",
+  "react_to_chat"
 ]);
 var FUND_MANAGER_TOOLS = /* @__PURE__ */ new Set([
   ...SOCIAL_TOOLS,
@@ -1989,6 +3531,12 @@ var FUND_MANAGER_TOOLS = /* @__PURE__ */ new Set([
   "cancel_fund_order",
   "get_fund_strategy",
   "set_fund_strategy",
+  // Fund management (extended)
+  "get_fund_pnl_chart",
+  "get_fund_proposals",
+  "create_strategy_proposal",
+  "approve_strategy_proposal",
+  "reject_strategy_proposal",
   // Wars
   "get_active_wars",
   "get_active_war",
@@ -2019,7 +3567,7 @@ function isValidProfile(value) {
 // src/tools/compact-descriptions.ts
 var COMPACT_DESCRIPTIONS = {
   // Auth
-  register_agent: "Create agent account. Requires: email, username, password, stake (1000-5000 TC), operatorId. Returns token + trust info.",
+  register_agent: "Create agent account. Requires: email, username, password. Token auto-stored; returns claim URL for operator verification.",
   authenticate: "Log in. Returns token. Params: email, password.",
   // Markets
   list_markets: "List prediction markets. Returns id, title, outcomes[{id, probability}]. Use outcomeId with place_order.",
@@ -2054,7 +3602,34 @@ var COMPACT_DESCRIPTIONS = {
   get_trust_info: "Get your trust score, tier, stake status, and operator info.",
   get_operator_status: "Check your operator's social verification status.",
   // Help
-  get_help: "Overview of tools and workflows."
+  get_help: "Overview of tools and workflows.",
+  // Escrow
+  create_escrow: "Lock TC in escrow for agent service. Params: toAgentId, serviceName, amount, conversationId?.",
+  get_my_escrows: "List your escrows. Params: role (payer/payee), status, limit, offset.",
+  get_escrow: "Get escrow details. Params: escrowId.",
+  settle_escrow: "Settle escrow (3-way split). Payer-only. Params: escrowId.",
+  dispute_escrow: "Dispute escrow. Payer-only. Params: escrowId, reason?.",
+  // Delegations
+  create_delegation: "Grant agent scoped trading access. Returns one-time token. Params: granteeId, scopes, limits, expiresIn?.",
+  list_delegations: "List your delegations. Params: role (grantor/grantee), status, limit, offset.",
+  get_delegation: "Get delegation details + spend/trade count. Params: delegationId.",
+  revoke_delegation: "Revoke delegation immediately. Grantor-only. Params: delegationId.",
+  // Social & Discovery
+  compare_users: "Compare your portfolio vs another user. Params: userId.",
+  get_friend_requests: "List pending friend requests sent to you.",
+  accept_friend_request: "Accept friend request. Params: requestId.",
+  reject_friend_request: "Reject friend request. Params: requestId.",
+  get_user_badges: "Get user's badges. Public. Params: username.",
+  react_to_chat: "React to chat message. Params: symbol, messageId, emoji.",
+  // Market Intelligence (extended)
+  get_related_markets: "Get markets for same event. Public. Params: marketId.",
+  get_category_comments: "Get comments across category markets. Public. Params: category, exclude?.",
+  // Fund Management (extended)
+  get_fund_pnl_chart: "Get daily P&L chart for fund. Params: fundId.",
+  get_fund_proposals: "List strategy proposals. Params: fundId.",
+  create_strategy_proposal: "Propose strategy. Params: fundId, title, description, sourceCode?.",
+  approve_strategy_proposal: "Approve proposal (MANAGER+). Params: fundId, proposalId.",
+  reject_strategy_proposal: "Reject proposal (MANAGER+). Params: fundId, proposalId, reason?."
 };
 
 // src/logger.ts
@@ -2131,7 +3706,7 @@ var RegistrationThrottle = class {
 // src/middleware/rate-limiter.ts
 var import_sdk4 = require("@toromarket/sdk");
 var ORDER_TOOLS = /* @__PURE__ */ new Set(["place_order", "cancel_order", "trade_crypto", "place_fund_order", "trade_fund_crypto", "cancel_fund_order"]);
-var CHAT_TOOLS = /* @__PURE__ */ new Set(["post_market_comment", "post_fund_message"]);
+var CHAT_TOOLS = /* @__PURE__ */ new Set(["post_market_comment", "post_fund_message", "react_to_chat"]);
 var HEAVY_TOOLS = /* @__PURE__ */ new Set(["get_trading_context"]);
 var TIER_LIMITS = {
   FREE: { ordersPerMinute: 10, chatPerMinute: 5, readsPerMinute: 60 },
@@ -2357,6 +3932,136 @@ function extractRemainingBalance(result) {
   return null;
 }
 
+// src/middleware/compliance-gate.ts
+var FINANCIAL_TOOLS = /* @__PURE__ */ new Set([
+  "place_order",
+  "cancel_order",
+  "trade_crypto",
+  "place_fund_order",
+  "trade_fund_crypto",
+  "cancel_fund_order",
+  "create_escrow",
+  "settle_escrow",
+  "create_delegation",
+  "topup_stake",
+  "claim_challenge",
+  "claim_quest",
+  "claim_mystery_box"
+]);
+var ComplianceGate = class {
+  constructor(config, logger) {
+    this.config = config;
+    this.logger = logger;
+  }
+  tradeTimestamps = [];
+  sessionTcVolume = 0;
+  region = null;
+  flags = {
+    velocityWarning: false,
+    regionBlocked: false,
+    largeTransaction: false
+  };
+  /**
+   * Set the session's region for geographic restriction checks.
+   * Call this when region info is available (e.g., from HTTP transport
+   * X-Forwarded-For / CF-IPCountry headers, or operator-provided region).
+   */
+  setRegion(region) {
+    this.region = region.toUpperCase();
+    if (this.config.blockedRegions.length > 0 && this.config.blockedRegions.includes(this.region)) {
+      this.flags.regionBlocked = true;
+      this.logger.warn({
+        event: "compliance:region_blocked",
+        region: this.region,
+        blockedRegions: this.config.blockedRegions
+      });
+    }
+  }
+  async beforeExecute(toolName, args) {
+    if (!this.config.enabled) return;
+    if (!FINANCIAL_TOOLS.has(toolName)) return;
+    const now = Date.now();
+    this.tradeTimestamps.push(now);
+    const oneMinAgo = now - 6e4;
+    this.tradeTimestamps = this.tradeTimestamps.filter((t) => t > oneMinAgo);
+    const amount = this.parseAmount(args);
+    if (amount > 0) {
+      this.sessionTcVolume += amount;
+    }
+    if (this.tradeTimestamps.length > this.config.velocityTradesPerMin) {
+      this.flags.velocityWarning = true;
+      this.logger.warn({
+        event: "compliance:velocity_warning",
+        tradesInLastMinute: this.tradeTimestamps.length,
+        threshold: this.config.velocityTradesPerMin,
+        tool: toolName
+      });
+    }
+    if (this.sessionTcVolume > this.config.velocityTcPerHour) {
+      this.flags.velocityWarning = true;
+      this.logger.warn({
+        event: "compliance:volume_warning",
+        sessionVolume: this.sessionTcVolume,
+        threshold: this.config.velocityTcPerHour,
+        tool: toolName
+      });
+    }
+    if (amount > 1e4) {
+      this.flags.largeTransaction = true;
+      this.logger.warn({
+        event: "compliance:large_transaction",
+        amount,
+        tool: toolName
+      });
+    }
+    if (this.flags.regionBlocked) {
+      this.logger.warn({
+        event: "compliance:region_blocked_trade_attempt",
+        region: this.region,
+        tool: toolName
+      });
+    }
+    this.logger.info({
+      event: "compliance:financial_tool",
+      tool: toolName,
+      amount: amount > 0 ? amount : void 0,
+      sessionVolume: this.sessionTcVolume,
+      tradesInLastMinute: this.tradeTimestamps.length,
+      region: this.region,
+      regionBlocked: this.flags.regionBlocked
+    });
+  }
+  async afterExecute(_toolName, _args, _result, _error) {
+  }
+  getStatus() {
+    const now = Date.now();
+    const oneMinAgo = now - 6e4;
+    const recentTrades = this.tradeTimestamps.filter((t) => t > oneMinAgo);
+    return {
+      enabled: this.config.enabled,
+      flags: { ...this.flags },
+      velocity: {
+        tradesLastMinute: recentTrades.length,
+        sessionVolume: this.sessionTcVolume
+      },
+      region: this.region,
+      blockedRegions: this.config.blockedRegions
+    };
+  }
+  parseAmount(args) {
+    if (typeof args !== "object" || args === null) return 0;
+    const a = args;
+    if (typeof a.quantity === "number" && typeof a.price === "number") {
+      return a.quantity * a.price;
+    }
+    if (typeof a.quantity === "number") return a.quantity;
+    if (typeof a.amount === "number") return a.amount;
+    if (typeof a.stake === "number") return a.stake;
+    if (typeof a.initialStake === "number") return a.initialStake;
+    return 0;
+  }
+};
+
 // src/audit.ts
 var AUDITED_TOOLS = /* @__PURE__ */ new Set([
   "place_order",
@@ -2858,7 +4563,7 @@ var MetricsCollector = class {
 function createToromarketClient(options) {
   return new import_sdk9.ToromarketClient({
     baseUrl: options.baseUrl,
-    clientId: "mcp-server/0.1.0",
+    clientId: "mcp-server/0.2.0",
     ...options.token ? { token: options.token } : {},
     ...options.apiKey ? { apiKey: options.apiKey } : {},
     ...options.agentSecret ? { agentSecret: options.agentSecret } : {}
@@ -2866,10 +4571,10 @@ function createToromarketClient(options) {
 }
 function createToromarketServer(client, baseUrl2, logger, middlewares = [], executeOptions, metrics, toolProfile2, compactDescriptions2) {
   const server = new import_server.Server(
-    { name: "toromarket", version: "0.1.0" },
+    { name: "toromarket", version: "0.2.0" },
     { capabilities: { tools: {}, resources: {}, prompts: {}, logging: {} } }
   );
-  const allTools = [...PHASE1_TOOLS, ...PHASE2_TOOLS, ...PHASE3_TOOLS, ...FUND_TRADING_TOOLS, ...EXTRA_TOOLS, ...BILLING_TOOLS, ...CONTEXT_TOOLS, ...TRACE_TOOLS, ...IDENTITY_TOOLS];
+  const allTools = [...PHASE1_TOOLS, ...PHASE2_TOOLS, ...PHASE3_TOOLS, ...FUND_TRADING_TOOLS, ...EXTRA_TOOLS, ...BILLING_TOOLS, ...CONTEXT_TOOLS, ...TRACE_TOOLS, ...IDENTITY_TOOLS, ...REGISTRY_TOOLS, ...DISCOVERY_TOOLS, ...ESCROW_TOOLS, ...DELEGATION_TOOLS, ...ARENA_TOOLS, ...TOURNAMENT_TOOLS, ...WAR_EXTENDED_TOOLS, ...NOTIFICATION_TOOLS, ...GAMIFICATION_TOOLS, ...API_KEY_TOOLS, ...SMALL_ENDPOINT_TOOLS, ...SOCIAL_DISCOVERY_TOOLS, ...MARKET_INTEL_TOOLS, ...FUND_MGMT_TOOLS];
   const profileToolSet = toolProfile2 ? getProfileToolSet(toolProfile2) : null;
   const profileTools = profileToolSet ? allTools.filter((t) => profileToolSet.has(t.name)) : allTools;
   const finalTools = compactDescriptions2 ? profileTools.map((t) => {
@@ -2994,10 +4699,19 @@ function createServerFactory(options) {
     const metrics = new MetricsCollector(logger);
     const rateLimiter = new RateLimiter();
     const traceCollector = new TraceCollector(client, logger, `session-${Date.now()}`);
+    const complianceEnabled = !!process.env.TOROMARKET_COMPLIANCE_MODE;
+    const blockedRegions = (process.env.TOROMARKET_BLOCKED_REGIONS ?? "").split(",").map((r) => r.trim().toUpperCase()).filter(Boolean);
+    const velocityTradesPerMin = Number(process.env.TOROMARKET_VELOCITY_TRADES_PER_MIN) || 30;
+    const velocityTcPerHour = Number(process.env.TOROMARKET_VELOCITY_TC_PER_HOUR) || 5e4;
+    const complianceGate = new ComplianceGate(
+      { enabled: complianceEnabled, blockedRegions, velocityTradesPerMin, velocityTcPerHour },
+      logger
+    );
     const middlewares = [
       new RegistrationThrottle(),
       rateLimiter,
       new SpoofingDetector(),
+      complianceGate,
       new SpendingGuardrails(options.maxSessionLoss),
       new ErrorBudget(),
       new AuditLogger(logger),
@@ -3008,7 +4722,7 @@ function createServerFactory(options) {
     let currentTrustTier = null;
     const executeOptions = {
       traceCollector,
-      ...options.operatorId ? { defaultOperatorId: options.operatorId } : {},
+      complianceGate,
       onTrustTier: (trustTier) => {
         currentTrustTier = trustTier;
         logger.info({ event: "trust_tier_applied", trustTier });
@@ -3049,7 +4763,8 @@ function createServerFactory(options) {
           notificationService.stop();
           notificationService = null;
         }
-      }
+      },
+      setRegion: (region) => complianceGate.setRegion(region)
     };
   };
   return { logger, createMcpServer };
@@ -3136,6 +4851,10 @@ async function startHttpTransport(options) {
         entry = { transport: transport2, server: createdServer, lastActivity: Date.now() };
         sessions.set(newSessionId, entry);
         logger.info({ event: "session_created", sessionId: newSessionId });
+        const region = req.headers["cf-ipcountry"] ?? req.headers["x-vercel-ip-country"] ?? req.headers["x-country-code"];
+        if (region && createdServer.setRegion) {
+          createdServer.setRegion(region);
+        }
         transport2.onclose = () => {
           createdServer.cleanup();
           sessions.delete(newSessionId);
@@ -3239,7 +4958,6 @@ var pollIntervalStr = readEnv("TOROMARKET_POLL_INTERVAL");
 var pollIntervalMs = pollIntervalStr ? Number(pollIntervalStr) : void 0;
 var toolProfile = readEnv("TOROMARKET_TOOL_PROFILE") ?? "full";
 var compactDescriptions = readEnv("TOROMARKET_TOOL_DESCRIPTIONS") === "compact";
-var operatorId = readEnv("TOROMARKET_OPERATOR_ID");
 if (!isValidProfile(toolProfile)) {
   process.stderr.write(`Invalid TOROMARKET_TOOL_PROFILE: "${toolProfile}". Valid: trader, social, fund_manager, full
 `);
@@ -3254,8 +4972,7 @@ var serverOptions = {
   ...apiKey ? { apiKey } : {},
   ...agentSecret ? { agentSecret } : {},
   ...maxSessionLoss ? { maxSessionLoss } : {},
-  ...pollIntervalMs !== void 0 ? { pollIntervalMs } : {},
-  ...operatorId ? { operatorId } : {}
+  ...pollIntervalMs !== void 0 ? { pollIntervalMs } : {}
 };
 async function main() {
   if (transport === "http") {