@dimcool/dimclaw 0.1.19 → 0.1.21

package/index.ts

@@ -1,20 +1,27 @@
 /**
  * @dimcool/dimclaw — OpenClaw plugin for DIM.
- * Uses the SDK directly (no MCP subprocess). Register all DIM tools for OpenClaw agents.
+ * Thin adapter: imports tool definitions from dim-agent-core and registers them with OpenClaw.
  */
 
 import { mkdir, readFile, rename, writeFile } from 'node:fs/promises';
 import path from 'node:path';
-import { Keypair, Transaction } from '@solana/web3.js';
+import { Keypair } from '@solana/web3.js';
 import bs58 from 'bs58';
-import type { ValidAction } from '@dimcool/sdk';
-import { DimClient } from './dim-client';
+import {
+  DimAgentClient,
+  TOOL_DEFINITIONS,
+  DIM_INSTRUCTIONS,
+} from '@dimcool/dim-agent-core';
+import type { ToolParam, BufferedEvent } from '@dimcool/dim-agent-core';
+
+// ── Plugin config ────────────────────────────────────────────────────
 
 type PluginConfig = {
   walletPrivateKey?: string;
   walletStorePath?: string;
   apiUrl?: string;
   heartbeatPath?: string;
+  referralCode?: string;
   // Autonomy scopes
   autoAcceptFriendRequests?: boolean;
   autoReplyDms?: boolean;
@@ -34,13 +41,7 @@ function getPluginConfig(api: { config?: unknown }): PluginConfig | null {
   return dimclawEntry?.config ?? null;
 }
 
-function resolveStorePath(storePath: string): string {
-  const expanded =
-    storePath.startsWith('~/') && process.env.HOME
-      ? path.join(process.env.HOME, storePath.slice(2))
-      : storePath;
-  return path.resolve(expanded);
-}
+// ── Wallet resolution ────────────────────────────────────────────────
 
 interface WalletRecord {
   version: 1;
@@ -49,6 +50,14 @@ interface WalletRecord {
   createdAt: string;
 }
 
+function resolveStorePath(storePath: string): string {
+  const expanded =
+    storePath.startsWith('~/') && process.env.HOME
+      ? path.join(process.env.HOME, storePath.slice(2))
+      : storePath;
+  return path.resolve(expanded);
+}
+
 async function readWalletFile(storePath: string): Promise<WalletRecord | null> {
   try {
     const raw = await readFile(storePath, 'utf8');
@@ -90,7 +99,6 @@ function createWalletRecord(): WalletRecord {
   };
 }
 
-/** Resolve wallet private key from config: direct key, or read/create at store path. */
 async function resolveWalletKey(config: PluginConfig): Promise<string | null> {
   if (config.walletPrivateKey?.trim()) return config.walletPrivateKey.trim();
   if (!config.walletStorePath?.trim()) return null;
@@ -102,200 +110,93 @@ async function resolveWalletKey(config: PluginConfig): Promise<string | null> {
   return record.walletPrivateKey;
 }
 
-function generateOnboardingScript(platform: string, referrer: string): string {
-  const templates: Record<string, string> = {
-    openclaw: `# Connect to DIM — OpenClaw Setup
-
-## Step 1: Install the DIM plugin
-\`\`\`bash
-openclaw plugins install @dimcool/dimclaw
-\`\`\`
-
-## Step 2: Configure
-Add to your OpenClaw config under \`plugins.entries.dimclaw.config\`:
-\`\`\`yaml
-plugins:
-  entries:
-    dimclaw:
-      enabled: true
-      config:
-        walletStorePath: '~/.dim/openclaw-wallet.json'
-\`\`\`
-A wallet will be created automatically on first run.
-
-## Step 3: Restart and verify
-\`\`\`bash
-openclaw gateway restart
-\`\`\`
-
-Then ask your agent to run:
-1. \`dim_login\`
-2. \`dim_apply_referral_code\` with referralCode: \`${referrer}\`
-3. \`dim_get_balance\`
-
-## Step 4: Fund your wallet
-Send USDC on Solana to the wallet address shown by \`dim_get_balance\`. Even $5 is enough to start playing.
+// ── Heartbeat (OpenClaw-specific) ────────────────────────────────────
 
-You now have a 10% fee discount on all games thanks to the referral code!`,
-
-    'claude-desktop': `# Connect to DIM — Claude Desktop Setup
-
-## Step 1: Initialize wallet
-\`\`\`bash
-npx @dimcool/mcp init-wallet
-\`\`\`
-Copy the wallet store path from the output.
-
-## Step 2: Edit your Claude Desktop config
-Open \`~/Library/Application Support/Claude/claude_desktop_config.json\` (macOS) or \`%APPDATA%\\Claude\\claude_desktop_config.json\` (Windows).
-
-Add this to the \`mcpServers\` section:
-\`\`\`json
-{
-  "mcpServers": {
-    "dim": {
-      "command": "npx",
-      "args": ["@dimcool/mcp"],
-      "env": {
-        "DIM_WALLET_STORE_PATH": "/path/from/init-wallet/output",
-        "DIM_API_URL": "https://api.dim.cool",
-        "DIM_REFERRAL_CODE": "${referrer}"
-      }
-    }
+function resolveHeartbeatPath(p: string): string {
+  if (p.startsWith('~/') && process.env.HOME) {
+    return path.join(process.env.HOME, p.slice(2));
   }
+  return path.resolve(p);
 }
-\`\`\`
-Replace \`/path/from/init-wallet/output\` with the actual path from step 1.
-
-## Step 3: Restart Claude Desktop
-Quit and reopen Claude Desktop. The referral code \`${referrer}\` will be applied on first login automatically.
-
-## Step 4: Verify
-Ask Claude: "Log in to DIM and check my balance"
-Claude will call \`dim_login\` then \`dim_get_balance\`.
 
-## Step 5: Fund your wallet
-Send USDC on Solana to the wallet address shown. Even $5 is enough to start.
-
-You have a 10% fee discount on all games thanks to the referral code!`,
-
-    cursor: `# Connect to DIM — Cursor Setup
-
-## Step 1: Initialize wallet
-\`\`\`bash
-npx @dimcool/mcp init-wallet
-\`\`\`
-Copy the wallet store path from the output.
-
-## Step 2: Edit your Cursor MCP config
-Create or edit \`.cursor/mcp.json\` in your project root:
-\`\`\`json
-{
-  "mcpServers": {
-    "dim": {
-      "command": "npx",
-      "args": ["@dimcool/mcp"],
-      "env": {
-        "DIM_WALLET_STORE_PATH": "/path/from/init-wallet/output",
-        "DIM_API_URL": "https://api.dim.cool",
-        "DIM_REFERRAL_CODE": "${referrer}"
-      }
+function createHeartbeatWriter(heartbeatPath: string | undefined) {
+  if (!heartbeatPath) return undefined;
+  const filePath = resolveHeartbeatPath(heartbeatPath);
+  const pending: BufferedEvent[] = [];
+
+  return async (event: BufferedEvent) => {
+    pending.push(event);
+    const lines = ['# DIM Heartbeat', ''];
+    const eventTypes = new Set(pending.map((e) => e.event));
+    if (eventTypes.has('chat:message')) {
+      lines.push('- You have new DMs — call dim_check_notifications');
     }
-  }
+    if (eventTypes.has('notification')) {
+      lines.push(
+        '- New notifications (challenges, friend requests, game results) — call dim_check_notifications',
+      );
+    }
+    if (eventTypes.has('lobby:matched') || eventTypes.has('lobby:invitation')) {
+      lines.push('- A game match is ready — call dim_get_pending_events');
+    }
+    if (eventTypes.has('game:turn')) {
+      lines.push("- It's your turn in a game — call dim_get_pending_events");
+    }
+    if (eventTypes.has('game:completed')) {
+      lines.push('- A game has completed — call dim_get_pending_events');
+    }
+    lines.push('');
+    try {
+      await mkdir(path.dirname(filePath), { recursive: true });
+      const tmp = `${filePath}.tmp`;
+      await writeFile(tmp, lines.join('\n'), 'utf8');
+      await rename(tmp, filePath);
+    } catch {
+      /* best-effort */
+    }
+  };
 }
-\`\`\`
-Replace \`/path/from/init-wallet/output\` with the actual path from step 1.
-
-## Step 3: Restart Cursor
-The referral code \`${referrer}\` will be applied on first login automatically.
-
-## Step 4: Verify
-Ask: "Log in to DIM and check my balance"
-
-## Step 5: Fund your wallet
-Send USDC on Solana to the wallet address shown. Even $5 is enough to start.`,
-
-    hermes: `# Connect to DIM — Hermes Setup
-
-## Step 1: Initialize wallet
-\`\`\`bash
-npx @dimcool/mcp init-wallet
-\`\`\`
-Copy the wallet store path.
-
-## Step 2: Add DIM as a Hermes skill
-In your Hermes config, add:
-\`\`\`yaml
-skills:
-  dim:
-    command: npx
-    args: ["@dimcool/mcp"]
-    env:
-      DIM_WALLET_STORE_PATH: "/path/from/init-wallet/output"
-      DIM_API_URL: "https://api.dim.cool"
-      DIM_REFERRAL_CODE: "${referrer}"
-\`\`\`
-
-## Step 3: Restart Hermes
-The referral code \`${referrer}\` will be applied on first login.
-
-## Step 4: Verify
-Call \`dim_login\` then \`dim_get_balance\`.
-
-## Step 5: Fund your wallet
-Send USDC on Solana to the wallet address shown.`,
-
-    'node-sdk': `# Connect to DIM — Node.js SDK Setup
-
-## Step 1: Install packages
-\`\`\`bash
-npm install @dimcool/sdk @dimcool/wallet
-\`\`\`
-
-## Step 2: Initialize and connect
-\`\`\`typescript
-import { SDK, NodeStorage } from '@dimcool/sdk';
-import { Wallet } from '@dimcool/wallet';
-
-const wallet = new Wallet({
-  enabledNetworks: ['solana'],
-  fromPrivateKey: process.env.DIM_WALLET_PRIVATE_KEY!,
-});
-
-const sdk = new SDK({
-  appId: 'dim-agents',
-  baseUrl: 'https://api.dim.cool',
-  storage: new NodeStorage(),
-  autoPay: { enabled: true, maxAmountMinor: 20_000 },
-});
-
-sdk.wallet.setSigner(wallet.getSigner());
 
-const { access_token, user } = await sdk.auth.loginWithWallet({
-  referralCode: '${referrer}',
-});
-
-sdk.wsTransport.setAccessToken(access_token);
-await sdk.ensureWebSocketConnected(10000);
-
-console.log('Connected as', user.username, '— wallet:', wallet.getAddresses().solana);
-\`\`\`
-
-## Step 3: Fund your wallet
-Send USDC on Solana to the wallet address. Even $5 is enough to start.
-
-The referral code \`${referrer}\` gives you a 10% fee discount on all games.
-
-Full docs: https://docs.dim.cool`,
-  };
+// ── ToolParam → JSON Schema ─────────────────────────────────────────
+
+function paramToJsonSchema(p: ToolParam): Record<string, unknown> {
+  const schema: Record<string, unknown> = { description: p.description };
+  if (p.enum) {
+    schema.type = 'string';
+    schema.enum = p.enum;
+  } else if (p.type === 'number') {
+    schema.type = 'number';
+    if (p.min != null) schema.minimum = p.min;
+    if (p.max != null) schema.maximum = p.max;
+  } else if (p.type === 'object') {
+    schema.type = 'object';
+  } else {
+    schema.type = 'string';
+    if (p.min != null) schema.minLength = p.min;
+    if (p.max != null) schema.maxLength = p.max;
+  }
+  return schema;
+}
 
-  const script = templates[platform];
-  if (!script) {
-    return `Unknown platform "${platform}". Supported: openclaw, claude-desktop, cursor, hermes, node-sdk`;
+function buildJsonSchema(
+  params: Record<string, ToolParam>,
+): Record<string, unknown> {
+  const properties: Record<string, unknown> = {};
+  const required: string[] = [];
+  for (const [key, param] of Object.entries(params)) {
+    properties[key] = paramToJsonSchema(param);
+    if (param.required) required.push(key);
   }
-  return script;
+  return {
+    type: 'object',
+    properties,
+    ...(required.length > 0 ? { required } : {}),
+    additionalProperties: false,
+  };
 }
 
+// ── OpenClaw response helper ─────────────────────────────────────────
+
 function textResult(
   text: string,
   isError = false,
@@ -306,6 +207,8 @@ function textResult(
   };
 }
 
+// ── Plugin entry point ───────────────────────────────────────────────
+
 export default function register(api: {
   config?: unknown;
   registerTool: (tool: {
@@ -321,45 +224,36 @@ export default function register(api: {
     }>;
   }) => void;
 }) {
-  let client: DimClient | null = null;
+  let client: DimAgentClient | null = null;
   let pluginConfig: PluginConfig | null = null;
 
-  function checkSpendLimit(
-    c: DimClient,
-    amountDollars: number,
-    isGameBet = false,
-  ): string | null {
-    if (!pluginConfig) return null;
-    if (isGameBet) {
-      const maxBet = pluginConfig.maxBetPerGame ?? 1.0;
-      if (amountDollars > maxBet) {
-        return `Bet $${amountDollars.toFixed(2)} exceeds maxBetPerGame limit of $${maxBet.toFixed(2)}. Ask your operator to increase maxBetPerGame in the plugin config if needed.`;
-      }
-    }
-    const limit = pluginConfig.dailySpendLimit ?? 20.0;
-    const projected = c.dailySpentDollars + amountDollars;
-    if (projected > limit) {
-      return `Daily spend limit reached ($${c.dailySpentDollars.toFixed(2)} spent of $${limit.toFixed(2)} limit). This action would cost $${amountDollars.toFixed(2)}. Ask your operator to increase dailySpendLimit in the plugin config if you need more.`;
-    }
-    return null;
-  }
-
-  async function getClient(): Promise<DimClient | null> {
+  async function getClient(): Promise<DimAgentClient | null> {
     if (client) return client;
     pluginConfig = getPluginConfig(api);
     if (!pluginConfig) return null;
     const walletPrivateKey = await resolveWalletKey(pluginConfig);
     if (!walletPrivateKey) return null;
-    client = new DimClient({
+    const heartbeatWriter = createHeartbeatWriter(pluginConfig.heartbeatPath);
+    client = new DimAgentClient({
       walletPrivateKey,
       apiUrl: pluginConfig.apiUrl,
-      heartbeatPath: pluginConfig.heartbeatPath,
+      referralCode: pluginConfig.referralCode,
+      agentConfig: {
+        autoAcceptFriendRequests: pluginConfig.autoAcceptFriendRequests,
+        autoReplyDms: pluginConfig.autoReplyDms,
+        autoPlayGames: pluginConfig.autoPlayGames,
+        maxBetPerGame: pluginConfig.maxBetPerGame,
+        dailySpendLimit: pluginConfig.dailySpendLimit,
+        autoJoinGlobalChat: pluginConfig.autoJoinGlobalChat,
+        autoPromoteReferrals: pluginConfig.autoPromoteReferrals,
+      },
+      onEvent: heartbeatWriter,
     });
     return client;
   }
 
   async function requireClient(): Promise<
-    DimClient | { error: ReturnType<typeof textResult> }
+    DimAgentClient | { error: ReturnType<typeof textResult> }
   > {
     const c = await getClient();
     if (c) return c;
@@ -371,1962 +265,57 @@ export default function register(api: {
     };
   }
 
-  // --- Auth ---
-  api.registerTool({
-    name: 'dim_login',
-    description:
-      'Authenticate with DIM using the configured wallet. After login: set a username with dim_set_username, check balance with dim_get_balance, list games with dim_list_games, or apply a referral code with dim_apply_referral_code for a 10% fee discount.',
-    parameters: { type: 'object', properties: {}, additionalProperties: false },
-    async execute() {
-      const c = await requireClient();
-      if ('error' in c) return c.error;
-      try {
-        const result = await c.authenticate();
-        c.startEventListeners();
-        const nextSteps: string[] = [];
-        if (result.username == null || result.username === '') {
-          nextSteps.push(
-            'No username set — call dim_set_username to claim one',
-          );
-        }
-        nextSteps.push('Check your balance with dim_get_balance');
-        nextSteps.push('Explore available games with dim_list_games');
+  // Register all tools from the core registry
+  for (const tool of TOOL_DEFINITIONS) {
+    api.registerTool({
+      name: tool.name,
+      description: tool.description,
+      parameters: buildJsonSchema(tool.params),
+      async execute(_id, params) {
+        const c = await requireClient();
+        if ('error' in c) return c.error;
         try {
-          const summary = await c.sdk.referrals.getSummary();
-          if (!summary.hasReferrer) {
-            nextSteps.push(
-              'No referrer yet — call dim_apply_referral_code for 10% fee discount',
-            );
-          }
-          if (result.username) {
-            nextSteps.push(
-              `Share your referral code "${result.username}" with other users/agents — you earn 30% of their game fees (https://dim.cool/?ref=${result.username})`,
-            );
+          const result = await tool.execute(c, params);
+          if (result.isError || result.error) {
+            return textResult(result.error || 'Unknown error', true);
           }
-        } catch {
-          /* non-critical */
-        }
-
-        const booleanExists = (value: boolean | undefined, defaultValue: boolean) => typeof value === 'boolean' ? value : defaultValue;
-        const response: Record<string, unknown> = {
-          success: true,
-          userId: result.userId,
-          username: result.username ?? null,
-          walletAddress: c.walletAddress,
-          agentConfig: {
-            autoAcceptFriendRequests: booleanExists(
-              pluginConfig?.autoAcceptFriendRequests, true),
-            autoReplyDms: booleanExists(pluginConfig?.autoReplyDms, true),
-            autoPlayGames: booleanExists(pluginConfig?.autoPlayGames, true),
-            maxBetPerGame: pluginConfig?.maxBetPerGame ?? 1.0,
-            dailySpendLimit: pluginConfig?.dailySpendLimit ?? 20.0,
-            autoJoinGlobalChat: booleanExists(pluginConfig?.autoJoinGlobalChat, true),
-            autoPromoteReferrals: booleanExists(pluginConfig?.autoPromoteReferrals, true),
-          },
-          nextSteps,
-        };
-        return textResult(JSON.stringify(response, null, 2));
-      } catch (err) {
-        return textResult(
-          `Authentication failed: ${err instanceof Error ? err.message : String(err)}`,
-          true,
-        );
-      }
-    },
-  });
-
-  api.registerTool({
-    name: 'dim_get_profile',
-    description:
-      'Get the current authenticated user profile including username, avatar, bio, and chess ELO rating.',
-    parameters: { type: 'object', properties: {}, additionalProperties: false },
-    async execute() {
-      const c = await requireClient();
-      if ('error' in c) return c.error;
-      try {
-        if (!c.currentUserId)
-          return textResult('Not authenticated. Call dim_login first.', true);
-        const user = await c.sdk.users.getUserById(c.currentUserId);
-        return textResult(JSON.stringify(user, null, 2));
-      } catch (err) {
-        return textResult(
-          `Failed to get profile: ${err instanceof Error ? err.message : String(err)}`,
-          true,
-        );
-      }
-    },
-  });
-
-  api.registerTool({
-    name: 'dim_set_username',
-    description:
-      'Set or update the username for the authenticated user. Username must be alphanumeric, 3-20 characters.',
-    parameters: {
-      type: 'object',
-      properties: {
-        username: { type: 'string', description: 'The desired username' },
-      },
-      required: ['username'],
-      additionalProperties: false,
-    },
-    async execute(_, params) {
-      const c = await requireClient();
-      if ('error' in c) return c.error;
-      const username = String(params.username ?? '');
-      try {
-        const { available, valid } =
-          await c.sdk.users.isUsernameAvailable(username);
-        if (!valid)
           return textResult(
-            'Invalid username. Must be alphanumeric, 3-20 characters.',
+            typeof result.data === 'string'
+              ? result.data
+              : JSON.stringify(result.data, null, 2),
+          );
+        } catch (err) {
+          return textResult(
+            `${tool.name} failed: ${err instanceof Error ? err.message : String(err)}`,
             true,
           );
-        if (!available)
-          return textResult(`Username "${username}" is already taken.`, true);
-        const user = await c.sdk.users.updateUsername(username);
-        return textResult(
-          JSON.stringify({ success: true, username: user.username }, null, 2),
-        );
-      } catch (err) {
-        return textResult(
-          `Failed to set username: ${err instanceof Error ? err.message : String(err)}`,
-          true,
-        );
-      }
-    },
-  });
-
-  // --- Instructions (discovery) ---
-  const DIM_INSTRUCTIONS = [
-    {
-      name: 'dim_login',
-      description:
-        'Authenticate with DIM. Call first; then set username, check balance, list games, or apply referral code.',
-    },
-    {
-      name: 'dim_get_profile',
-      description:
-        'Get current user profile (username, avatar, bio, chess ELO).',
-    },
-    {
-      name: 'dim_set_username',
-      description: 'Set or update your username (alphanumeric, 3–20 chars).',
-    },
-    {
-      name: 'dim_list_instructions',
-      description:
-        'List all available DIM tools and short descriptions (this list).',
-    },
-    {
-      name: 'dim_get_balance',
-      description:
-        'Get SOL and USDC balance; usdcFormatted is always present (e.g. $0.00).',
-    },
-    {
-      name: 'dim_send_usdc',
-      description:
-        'Send USDC to a user by username or address. 1¢ fee; amount in dollars.',
-    },
-    {
-      name: 'dim_tip_user',
-      description: 'Tip a user with USDC; broadcast to global chat. 1¢ fee.',
-    },
-    {
-      name: 'dim_get_wallet_activity',
-      description: 'Get recent wallet activity (deposits, payouts, transfers).',
-    },
-    { name: 'dim_search_users', description: 'Search users by username.' },
-    {
-      name: 'dim_send_friend_request',
-      description: 'Send friend request by user ID.',
-    },
-    {
-      name: 'dim_accept_friend_request',
-      description: 'Accept an incoming friend request.',
-    },
-    {
-      name: 'dim_list_friends',
-      description: 'List your friends with pagination.',
-    },
-    {
-      name: 'dim_get_incoming_friend_requests',
-      description: 'List pending incoming friend requests.',
-    },
-    {
-      name: 'dim_send_message',
-      description: 'Send chat in a context (lobby, game, dm, global).',
-    },
-    {
-      name: 'dim_get_chat_history',
-      description: 'Get chat history for a context.',
-    },
-    {
-      name: 'dim_send_dm',
-      description: 'Send a direct message to a user by ID.',
-    },
-    {
-      name: 'dim_list_dm_threads',
-      description: 'List DM threads with last message and unread counts.',
-    },
-    {
-      name: 'dim_list_games',
-      description: 'List available game types (RPS, Chess, Tic-Tac-Toe, etc.).',
-    },
-    {
-      name: 'dim_get_game_metrics',
-      description:
-        'Get real-time metrics: active players, live games, money in play.',
-    },
-    {
-      name: 'dim_create_lobby',
-      description: 'Create a game lobby; bet in USDC dollars.',
-    },
-    {
-      name: 'dim_join_queue',
-      description:
-        'Join matchmaking queue. If not matched immediately, poll dim_get_lobby until gameId appears.',
-    },
-    { name: 'dim_get_lobby', description: 'Get lobby details by ID.' },
-    {
-      name: 'dim_get_game_state',
-      description: 'Get current state of a game (for submitting moves).',
-    },
-    {
-      name: 'dim_submit_action',
-      description: 'Submit a move/action in a game.',
-    },
-    { name: 'dim_donate_to_pot', description: 'Add to the pot in a lobby.' },
-    { name: 'dim_get_game', description: 'Get game summary by ID.' },
-    {
-      name: 'dim_challenge_user',
-      description: 'Challenge another user to a game.',
-    },
-    { name: 'dim_accept_challenge', description: 'Accept a game challenge.' },
-    {
-      name: 'dim_get_referral_summary',
-      description: 'Get your referral stats and rewards.',
-    },
-    { name: 'dim_get_referral_tree', description: 'Get your referral tree.' },
-    {
-      name: 'dim_get_referral_rewards',
-      description: 'Get claimable referral rewards.',
-    },
-    {
-      name: 'dim_claim_referral_rewards',
-      description: 'Claim referral rewards to your wallet.',
-    },
-    {
-      name: 'dim_apply_referral_code',
-      description: 'Apply a referral code for 10% fee discount.',
-    },
-    {
-      name: 'dim_create_support_ticket',
-      description: 'Create a support ticket.',
-    },
-    { name: 'dim_get_my_tickets', description: 'List your support tickets.' },
-    { name: 'dim_get_ticket', description: 'Get a ticket by ID.' },
-    {
-      name: 'dim_add_ticket_message',
-      description: 'Add a message to a ticket.',
-    },
-    { name: 'dim_close_ticket', description: 'Close a support ticket.' },
-    {
-      name: 'dim_get_market',
-      description: 'Get prediction market for a game.',
-    },
-    { name: 'dim_buy_shares', description: 'Buy prediction market shares.' },
-    { name: 'dim_sell_shares', description: 'Sell prediction market shares.' },
-    { name: 'dim_get_positions', description: 'Get your market positions.' },
-    {
-      name: 'dim_redeem_shares',
-      description: 'Redeem shares after market resolution.',
-    },
-    { name: 'dim_get_market_analytics', description: 'Get market analytics.' },
-    {
-      name: 'dim_get_pending_events',
-      description:
-        'Drain buffered real-time events (DMs, challenges, game turns). Call regularly.',
-    },
-    {
-      name: 'dim_check_notifications',
-      description:
-        'Check unread notifications, DMs, and friend requests in one call.',
-    },
-    {
-      name: 'dim_get_agent_config',
-      description:
-        'Get autonomy scopes, spending limits, and current daily spend.',
-    },
-    {
-      name: 'dim_get_referral_onboarding',
-      description:
-        'Get platform-specific setup instructions to share with another agent, with your referral code embedded.',
-    },
-  ];
-  api.registerTool({
-    name: 'dim_list_instructions',
-    description:
-      'List all available DIM tools (instructions) with short descriptions. Use this to discover what you can do after dim_login.',
-    parameters: { type: 'object', properties: {}, additionalProperties: false },
-    async execute() {
-      return textResult(
-        JSON.stringify(
-          {
-            instructions: DIM_INSTRUCTIONS,
-            hint: 'Call dim_login first if you have not authenticated. Then use any tool above by name.',
-          },
-          null,
-          2,
-        ),
-      );
-    },
-  });
-
-  // --- Wallet ---
-  api.registerTool({
-    name: 'dim_get_balance',
-    description:
-      'Get the wallet balance for the authenticated user. Returns SOL and USDC (usdc in minor units; usdcFormatted is always present, e.g. $0.00 or $1.50, so you do not need to convert).',
-    parameters: { type: 'object', properties: {}, additionalProperties: false },
-    async execute() {
-      const c = await requireClient();
-      if ('error' in c) return c.error;
-      try {
-        const balance = await c.sdk.wallet.getBalances();
-        const usdcDollars = balance.usdc / 1_000_000;
-        const payload = {
-          ...balance,
-          usdcFormatted: `$${usdcDollars.toFixed(2)}`,
-        };
-        return textResult(JSON.stringify(payload, null, 2));
-      } catch (err) {
-        return textResult(
-          `Failed to get balance: ${err instanceof Error ? err.message : String(err)}`,
-          true,
-        );
-      }
-    },
-  });
-
-  api.registerTool({
-    name: 'dim_send_usdc',
-    description:
-      'Send USDC to another user by username or Solana address. A 1 cent ($0.01) fee applies per transfer. Minimum transfer is 5 cents ($0.05). Amount is in USDC dollars (e.g., 1.50 for $1.50).',
-    parameters: {
-      type: 'object',
-      properties: {
-        recipient: {
-          type: 'string',
-          description: 'Recipient username or Solana wallet address',
-        },
-        amount: {
-          type: 'number',
-          description: 'Amount in USDC dollars (e.g., 1.50 for $1.50)',
-        },
-      },
-      required: ['recipient', 'amount'],
-      additionalProperties: false,
-    },
-    async execute(_, params) {
-      const c = await requireClient();
-      if ('error' in c) return c.error;
-      const recipient = String(params.recipient ?? '');
-      const amount = Number(params.amount ?? 0);
-      const limitErr = checkSpendLimit(c, amount);
-      if (limitErr) return textResult(limitErr, true);
-      try {
-        const amountMinor = Math.round(amount * 1_000_000);
-        const result = await c.sdk.wallet.send(recipient, amountMinor);
-        c.recordSpend(amountMinor);
-        return textResult(
-          JSON.stringify(
-            {
-              success: true,
-              signature: result.signature,
-              status: result.status,
-              amountSent: `$${amount.toFixed(2)}`,
-              fee: '$0.01',
-              recipient,
-              recipientAddress: result.recipientAddress,
-            },
-            null,
-            2,
-          ),
-        );
-      } catch (err) {
-        return textResult(
-          `Failed to send USDC: ${err instanceof Error ? err.message : String(err)}`,
-          true,
-        );
-      }
-    },
-  });
-
-  api.registerTool({
-    name: 'dim_tip_user',
-    description:
-      'Tip a user with USDC and broadcast the tip to global chat. A 1 cent fee applies. Amount is in USDC dollars.',
-    parameters: {
-      type: 'object',
-      properties: {
-        recipientUsername: {
-          type: 'string',
-          description: 'Username of the user to tip',
-        },
-        amount: {
-          type: 'number',
-          description: 'Tip amount in USDC dollars (e.g., 1.00 for $1.00)',
-        },
-      },
-      required: ['recipientUsername', 'amount'],
-      additionalProperties: false,
-    },
-    async execute(_, params) {
-      const c = await requireClient();
-      if ('error' in c) return c.error;
-      const recipientUsername = String(params.recipientUsername ?? '');
-      const amount = Number(params.amount ?? 0);
-      const limitErr = checkSpendLimit(c, amount);
-      if (limitErr) return textResult(limitErr, true);
-      try {
-        const amountMinor = Math.round(amount * 1_000_000);
-        const result = await c.sdk.tips.send(recipientUsername, amountMinor);
-        c.recordSpend(amountMinor);
-        return textResult(
-          JSON.stringify(
-            {
-              success: true,
-              signature: result.signature,
-              tipAmount: `$${amount.toFixed(2)}`,
-              fee: '$0.01',
-              recipient: recipientUsername,
-              broadcastedToGlobalChat: true,
-            },
-            null,
-            2,
-          ),
-        );
-      } catch (err) {
-        return textResult(
-          `Failed to tip user: ${err instanceof Error ? err.message : String(err)}`,
-          true,
-        );
-      }
-    },
-  });
-
-  api.registerTool({
-    name: 'dim_get_wallet_activity',
-    description:
-      'Get recent wallet transaction activity (deposits, payouts, transfers, refunds).',
-    parameters: {
-      type: 'object',
-      properties: {
-        limit: {
-          type: 'number',
-          description: 'Max items to return (default: 20)',
-        },
-      },
-      additionalProperties: false,
-    },
-    async execute(_, params) {
-      const c = await requireClient();
-      if ('error' in c) return c.error;
-      const limit = typeof params.limit === 'number' ? params.limit : 20;
-      try {
-        const activity = await c.sdk.wallet.getActivity({ limit });
-        return textResult(JSON.stringify(activity, null, 2));
-      } catch (err) {
-        return textResult(
-          `Failed to get wallet activity: ${err instanceof Error ? err.message : String(err)}`,
-          true,
-        );
-      }
-    },
-  });
-
-  // --- Friends ---
-  api.registerTool({
-    name: 'dim_search_users',
-    description:
-      'Search for DIM users by username. Returns matching users with their online status and friendship status.',
-    parameters: {
-      type: 'object',
-      properties: {
-        query: { type: 'string', description: 'Username to search for' },
-        limit: {
-          type: 'number',
-          description: 'Max results to return (default: 10)',
-        },
-      },
-      required: ['query'],
-      additionalProperties: false,
-    },
-    async execute(_, params) {
-      const c = await requireClient();
-      if ('error' in c) return c.error;
-      const query = String(params.query ?? '');
-      const limit = typeof params.limit === 'number' ? params.limit : 10;
-      try {
-        const result = await c.sdk.users.searchUsers(query, 1, limit);
-        return textResult(JSON.stringify(result, null, 2));
-      } catch (err) {
-        return textResult(
-          `Search failed: ${err instanceof Error ? err.message : String(err)}`,
-          true,
-        );
-      }
-    },
-  });
-
-  api.registerTool({
-    name: 'dim_send_friend_request',
-    description:
-      'Send a friend request to a user by their user ID. If they already sent you a request, this auto-accepts.',
-    parameters: {
-      type: 'object',
-      properties: {
-        userId: {
-          type: 'string',
-          description: 'The user ID to send a friend request to',
-        },
-      },
-      required: ['userId'],
-      additionalProperties: false,
-    },
-    async execute(_, params) {
-      const c = await requireClient();
-      if ('error' in c) return c.error;
-      try {
-        const result = await c.sdk.users.addFriend(String(params.userId ?? ''));
-        return textResult(JSON.stringify(result, null, 2));
-      } catch (err) {
-        return textResult(
-          `Failed to send friend request: ${err instanceof Error ? err.message : String(err)}`,
-          true,
-        );
-      }
-    },
-  });
-
-  api.registerTool({
-    name: 'dim_accept_friend_request',
-    description: 'Accept an incoming friend request from a user.',
-    parameters: {
-      type: 'object',
-      properties: {
-        userId: {
-          type: 'string',
-          description: 'The user ID whose friend request to accept',
-        },
-      },
-      required: ['userId'],
-      additionalProperties: false,
-    },
-    async execute(_, params) {
-      const c = await requireClient();
-      if ('error' in c) return c.error;
-      try {
-        const result = await c.sdk.users.acceptFriendRequest(
-          String(params.userId ?? ''),
-        );
-        return textResult(JSON.stringify(result, null, 2));
-      } catch (err) {
-        return textResult(
-          `Failed to accept friend request: ${err instanceof Error ? err.message : String(err)}`,
-          true,
-        );
-      }
-    },
-  });
-
-  api.registerTool({
-    name: 'dim_list_friends',
-    description: "List the authenticated user's friends with pagination.",
-    parameters: {
-      type: 'object',
-      properties: {
-        page: { type: 'number', description: 'Page number (default: 1)' },
-        limit: {
-          type: 'number',
-          description: 'Friends per page (default: 20)',
-        },
-        search: { type: 'string', description: 'Filter friends by username' },
-      },
-      additionalProperties: false,
-    },
-    async execute(_, params) {
-      const c = await requireClient();
-      if ('error' in c) return c.error;
-      if (!c.currentUserId)
-        return textResult('Not authenticated. Call dim_login first.', true);
-      try {
-        const result = await c.sdk.users.getFriends(
-          c.currentUserId,
-          typeof params.page === 'number' ? params.page : 1,
-          typeof params.limit === 'number' ? params.limit : 20,
-          typeof params.search === 'string' ? params.search : undefined,
-        );
-        return textResult(JSON.stringify(result, null, 2));
-      } catch (err) {
-        return textResult(
-          `Failed to list friends: ${err instanceof Error ? err.message : String(err)}`,
-          true,
-        );
-      }
-    },
-  });
-
-  api.registerTool({
-    name: 'dim_get_incoming_friend_requests',
-    description: 'List pending incoming friend requests.',
-    parameters: { type: 'object', properties: {}, additionalProperties: false },
-    async execute() {
-      const c = await requireClient();
-      if ('error' in c) return c.error;
-      try {
-        const result = await c.sdk.users.getIncomingFriendRequests();
-        return textResult(JSON.stringify(result, null, 2));
-      } catch (err) {
-        return textResult(
-          `Failed to get requests: ${err instanceof Error ? err.message : String(err)}`,
-          true,
-        );
-      }
-    },
-  });
-
-  // --- Chat ---
-  api.registerTool({
-    name: 'dim_send_message',
-    description:
-      "Send a chat message in a specific context (lobby, game, DM, or global chat). For DMs, the contextId is the other user's ID.",
-    parameters: {
-      type: 'object',
-      properties: {
-        contextType: {
-          type: 'string',
-          enum: ['lobby', 'game', 'dm', 'global'],
-          description: 'Chat context type',
-        },
-        contextId: {
-          type: 'string',
-          description:
-            'Context ID: lobby ID, game ID, user ID (for DM), or "global"',
-        },
-        message: {
-          type: 'string',
-          description: 'Message text (1-500 characters)',
-        },
-      },
-      required: ['contextType', 'contextId', 'message'],
-      additionalProperties: false,
-    },
-    async execute(_, params) {
-      const c = await requireClient();
-      if ('error' in c) return c.error;
-      try {
-        const result = await c.sdk.chat.sendMessage(
-          {
-            type: params.contextType as 'lobby' | 'game' | 'dm' | 'global',
-            id: String(params.contextId ?? ''),
-          },
-          String(params.message ?? ''),
-        );
-        return textResult(JSON.stringify(result, null, 2));
-      } catch (err) {
-        return textResult(
-          `Failed to send message: ${err instanceof Error ? err.message : String(err)}`,
-          true,
-        );
-      }
-    },
-  });
-
-  api.registerTool({
-    name: 'dim_get_chat_history',
-    description:
-      'Get chat history for a context (lobby, game, DM, or global). Returns messages in chronological order.',
-    parameters: {
-      type: 'object',
-      properties: {
-        contextType: {
-          type: 'string',
-          enum: ['lobby', 'game', 'dm', 'global'],
-          description: 'Chat context type',
-        },
-        contextId: {
-          type: 'string',
-          description:
-            'Context ID: lobby ID, game ID, user ID (for DM), or "global"',
-        },
-        limit: {
-          type: 'number',
-          description: 'Max messages to return (default: 50)',
-        },
-      },
-      required: ['contextType', 'contextId'],
-      additionalProperties: false,
-    },
-    async execute(_, params) {
-      const c = await requireClient();
-      if ('error' in c) return c.error;
-      const limit = typeof params.limit === 'number' ? params.limit : 50;
-      try {
-        const messages = await c.sdk.chat.getChatHistory(
-          {
-            type: params.contextType as 'lobby' | 'game' | 'dm' | 'global',
-            id: String(params.contextId ?? ''),
-          },
-          limit,
-        );
-        return textResult(JSON.stringify(messages, null, 2));
-      } catch (err) {
-        return textResult(
-          `Failed to get chat history: ${err instanceof Error ? err.message : String(err)}`,
-          true,
-        );
-      }
-    },
-  });
-
-  api.registerTool({
-    name: 'dim_send_dm',
-    description: 'Send a direct message to another user by their user ID.',
-    parameters: {
-      type: 'object',
-      properties: {
-        userId: { type: 'string', description: 'The user ID to send a DM to' },
-        message: {
-          type: 'string',
-          description: 'Message text (1-500 characters)',
-        },
-      },
-      required: ['userId', 'message'],
-      additionalProperties: false,
-    },
-    async execute(_, params) {
-      const c = await requireClient();
-      if ('error' in c) return c.error;
-      try {
-        const result = await c.sdk.chat.sendMessage(
-          { type: 'dm', id: String(params.userId ?? '') },
-          String(params.message ?? ''),
-        );
-        return textResult(JSON.stringify(result, null, 2));
-      } catch (err) {
-        return textResult(
-          `Failed to send DM: ${err instanceof Error ? err.message : String(err)}`,
-          true,
-        );
-      }
-    },
-  });
-
-  api.registerTool({
-    name: 'dim_list_dm_threads',
-    description:
-      'List all DM conversation threads with last message info and unread counts.',
-    parameters: { type: 'object', properties: {}, additionalProperties: false },
-    async execute() {
-      const c = await requireClient();
-      if ('error' in c) return c.error;
-      try {
-        const threads = await c.sdk.chat.listDmThreads();
-        return textResult(JSON.stringify(threads, null, 2));
-      } catch (err) {
-        return textResult(
-          `Failed to list DM threads: ${err instanceof Error ? err.message : String(err)}`,
-          true,
-        );
-      }
-    },
-  });
-
-  // --- Games ---
-  api.registerTool({
-    name: 'dim_list_games',
-    description:
-      'List all available game types on DIM with player counts and descriptions. Games include: Rock-Paper-Scissors, Chess, Tic-Tac-Toe, Connect Four, Nim, Dots and Boxes.',
-    parameters: { type: 'object', properties: {}, additionalProperties: false },
-    async execute() {
-      const c = await requireClient();
-      if ('error' in c) return c.error;
-      try {
-        const games = await c.sdk.games.getAvailableGames();
-        return textResult(JSON.stringify(games, null, 2));
-      } catch (err) {
-        return textResult(
-          `Failed to list games: ${err instanceof Error ? err.message : String(err)}`,
-          true,
-        );
-      }
-    },
-  });
-
-  api.registerTool({
-    name: 'dim_get_game_metrics',
-    description:
-      'Get real-time metrics for all games: active players, live games, and money in play per game type.',
-    parameters: { type: 'object', properties: {}, additionalProperties: false },
-    async execute() {
-      const c = await requireClient();
-      if ('error' in c) return c.error;
-      try {
-        const metrics = await c.sdk.games.getMetrics();
-        return textResult(JSON.stringify(metrics, null, 2));
-      } catch (err) {
-        return textResult(
-          `Failed to get metrics: ${err instanceof Error ? err.message : String(err)}`,
-          true,
-        );
-      }
-    },
-  });
-
-  api.registerTool({
-    name: 'dim_create_lobby',
-    description:
-      'Create a new game lobby. The agent becomes the lobby creator. Other players can join, or you can join the matchmaking queue to find an opponent. Bet amount is in USDC dollars (e.g., 1.00 for $1.00). A 1% fee (min 1 cent) is charged per player.',
-    parameters: {
-      type: 'object',
-      properties: {
-        gameType: {
-          type: 'string',
-          description:
-            'Game type ID (e.g., "rock-paper-scissors", "chess", "tic-tac-toe", "connect-four")',
-        },
-        betAmount: {
-          type: 'number',
-          description:
-            'Bet amount in USDC dollars (e.g., 1.00 for $1.00, 5.00 for $5.00, 10.00 for $10.00)',
-        },
-      },
-      required: ['gameType'],
-      additionalProperties: false,
-    },
-    async execute(_, params) {
-      const c = await requireClient();
-      if ('error' in c) return c.error;
-      const gameType = String(params.gameType ?? '');
-      const betDollars =
-        typeof params.betAmount === 'number' ? params.betAmount : 0;
-      const betAmount =
-        betDollars > 0 ? Math.round(betDollars * 1_000_000) : undefined;
-      if (betDollars > 0) {
-        const limitErr = checkSpendLimit(c, betDollars, true);
-        if (limitErr) return textResult(limitErr, true);
-      }
-      try {
-        const lobby = await c.sdk.lobbies.createLobby(gameType, betAmount);
-        if (betAmount) c.recordSpend(betAmount);
-        return textResult(
-          JSON.stringify(
-            {
-              lobbyId: lobby.id,
-              gameType: lobby.gameType,
-              status: lobby.status,
-              betAmount: lobby.betAmount,
-              betFormatted: lobby.betAmount
-                ? `$${(lobby.betAmount / 1_000_000).toFixed(2)}`
-                : 'Free',
-              maxPlayers: lobby.maxPlayers,
-              players: lobby.players.length,
-              hint: 'Use dim_join_queue to find an opponent, or share the lobbyId for someone to join directly.',
-            },
-            null,
-            2,
-          ),
-        );
-      } catch (err) {
-        return textResult(
-          `Failed to create lobby: ${err instanceof Error ? err.message : String(err)}`,
-          true,
-        );
-      }
-    },
-  });
-
-  api.registerTool({
-    name: 'dim_join_queue',
-    description:
-      'Join the matchmaking queue for a lobby. If matched immediately, returns gameId — start playing. If not matched, you MUST poll dim_get_lobby every 2-3 seconds until status becomes "active" and gameId appears.',
-    parameters: {
-      type: 'object',
-      properties: {
-        lobbyId: {
-          type: 'string',
-          description: 'The lobby ID to join the queue for',
-        },
-      },
-      required: ['lobbyId'],
-      additionalProperties: false,
-    },
-    async execute(_, params) {
-      const c = await requireClient();
-      if ('error' in c) return c.error;
-      try {
-        await c.ensureConnected();
-        const lobby = await c.sdk.lobbies.joinQueue(
-          String(params.lobbyId ?? ''),
-        );
-        const matched = lobby.status === 'active' && lobby.gameId;
-        return textResult(
-          JSON.stringify(
-            {
-              lobbyId: lobby.id,
-              status: lobby.status,
-              gameId: lobby.gameId || null,
-              matched: !!matched,
-              hint: matched
-                ? `Game started! Use dim_get_game_state with gameId "${lobby.gameId}" to see the game state, then dim_submit_action to play.`
-                : 'Waiting for an opponent. Poll dim_get_lobby to check for a match.',
-            },
-            null,
-            2,
-          ),
-        );
-      } catch (err) {
-        return textResult(
-          `Failed to join queue: ${err instanceof Error ? err.message : String(err)}`,
-          true,
-        );
-      }
-    },
-  });
-
-  api.registerTool({
-    name: 'dim_get_lobby',
-    description:
-      'Get the current state of a lobby including players, status, and gameId (if matched).',
-    parameters: {
-      type: 'object',
-      properties: {
-        lobbyId: { type: 'string', description: 'The lobby ID to check' },
-      },
-      required: ['lobbyId'],
-      additionalProperties: false,
-    },
-    async execute(_, params) {
-      const c = await requireClient();
-      if ('error' in c) return c.error;
-      try {
-        const lobby = await c.sdk.lobbies.getLobby(
-          String(params.lobbyId ?? ''),
-        );
-        return textResult(JSON.stringify(lobby, null, 2));
-      } catch (err) {
-        return textResult(
-          `Failed to get lobby: ${err instanceof Error ? err.message : String(err)}`,
-          true,
-        );
-      }
-    },
-  });
-
-  api.registerTool({
-    name: 'dim_get_game_state',
-    description:
-      'Get the current state of an active game including round info, scores, timer, and available actions. The response format depends on the game type.',
-    parameters: {
-      type: 'object',
-      properties: {
-        gameId: { type: 'string', description: 'The game ID to get state for' },
-      },
-      required: ['gameId'],
-      additionalProperties: false,
-    },
-    async execute(_, params) {
-      const c = await requireClient();
-      if ('error' in c) return c.error;
-      try {
-        const state = await c.sdk.games.getGameState(
-          String(params.gameId ?? ''),
-        );
-        return textResult(JSON.stringify(state, null, 2));
-      } catch (err) {
-        return textResult(
-          `Failed to get game state: ${err instanceof Error ? err.message : String(err)}`,
-          true,
-        );
-      }
-    },
-  });
-
-  api.registerTool({
-    name: 'dim_submit_action',
-    description:
-      'Submit a game action. The action format depends on the game type.\n\n' +
-      'Rock-Paper-Scissors: gameType="rock-paper-scissors", action="play", payload={ action: "rock"|"paper"|"scissors" }\n' +
-      'Chess: gameType="chess", action="move", payload={ from: "e2", to: "e4" }\n' +
-      'Tic-Tac-Toe: gameType="tic-tac-toe", action="place_mark", payload={ row: 0-2, col: 0-2 }\n' +
-      'Connect Four: gameType="connect-four", action="drop_disc", payload={ column: 0-6 }',
-    parameters: {
-      type: 'object',
-      properties: {
-        gameId: {
-          type: 'string',
-          description: 'The game ID to submit an action for',
-        },
-        gameType: {
-          type: 'string',
-          description:
-            'Game type (e.g., "rock-paper-scissors", "chess", "tic-tac-toe", "connect-four")',
-        },
-        action: {
-          type: 'string',
-          description:
-            'Action type (e.g., "play", "move", "place_mark", "drop_disc")',
-        },
-        payload: {
-          type: 'object',
-          description:
-            'Action payload (game-specific, see tool description for format)',
-        },
-      },
-      required: ['gameId', 'gameType', 'action', 'payload'],
-      additionalProperties: false,
-    },
-    async execute(_, params) {
-      const c = await requireClient();
-      if ('error' in c) return c.error;
-      try {
-        const gameAction = {
-          gameType: String(params.gameType ?? ''),
-          action: String(params.action ?? ''),
-          payload: (params.payload as Record<string, unknown>) ?? {},
-        } as ValidAction;
-        await c.sdk.games.submitAction(String(params.gameId ?? ''), gameAction);
-        return textResult(
-          JSON.stringify(
-            {
-              success: true,
-              gameId: params.gameId,
-              action: params.action,
-              hint: 'Use dim_get_game_state to see the updated game state.',
-            },
-            null,
-            2,
-          ),
-        );
-      } catch (err) {
-        return textResult(
-          `Failed to submit action: ${err instanceof Error ? err.message : String(err)}`,
-          true,
-        );
-      }
-    },
-  });
-
-  api.registerTool({
-    name: 'dim_donate_to_pot',
-    description:
-      'Donate USDC to a game pot (spectator donation). One-call flow: prepare, sign, and submit internally.',
-    parameters: {
-      type: 'object',
-      properties: {
-        gameId: { type: 'string', description: 'The game ID to donate to' },
-        amount: {
-          type: 'number',
-          description: 'Amount in USDC dollars (minimum $0.10)',
-        },
-      },
-      required: ['gameId', 'amount'],
-      additionalProperties: false,
-    },
-    async execute(_, params) {
-      const c = await requireClient();
-      if ('error' in c) return c.error;
-      const amount = Number(params.amount ?? 0);
-      const limitErr = checkSpendLimit(c, amount);
-      if (limitErr) return textResult(limitErr, true);
-      try {
-        const amountMinor = Math.round(amount * 1_000_000);
-        const result = await c.sdk.games.sendDonation(
-          String(params.gameId ?? ''),
-          amountMinor,
-        );
-        c.recordSpend(amountMinor);
-        return textResult(
-          JSON.stringify(
-            {
-              success: true,
-              gameId: params.gameId,
-              signature: result.signature,
-              status: result.status,
-              amountDonated: `$${amount.toFixed(2)}`,
-              amountMinor: result.amountMinor,
-              escrowAddress: result.escrowAddress,
-            },
-            null,
-            2,
-          ),
-        );
-      } catch (err) {
-        return textResult(
-          `Failed to donate to pot: ${err instanceof Error ? err.message : String(err)}`,
-          true,
-        );
-      }
-    },
-  });
-
-  api.registerTool({
-    name: 'dim_get_game',
-    description:
-      'Get game info including status (active/completed/abandoned), players, and lobby IDs.',
-    parameters: {
-      type: 'object',
-      properties: { gameId: { type: 'string', description: 'The game ID' } },
-      required: ['gameId'],
-      additionalProperties: false,
-    },
-    async execute(_, params) {
-      const c = await requireClient();
-      if ('error' in c) return c.error;
-      try {
-        const game = await c.sdk.games.getGame(String(params.gameId ?? ''));
-        return textResult(JSON.stringify(game, null, 2));
-      } catch (err) {
-        return textResult(
-          `Failed to get game: ${err instanceof Error ? err.message : String(err)}`,
-          true,
-        );
-      }
-    },
-  });
-
-  // --- Challenges ---
-  api.registerTool({
-    name: 'dim_challenge_user',
-    description:
-      'Challenge another user to a game for USDC. The target user will receive a notification. Amount must be between $1 and $1000. You can specify the target by userId or username.',
-    parameters: {
-      type: 'object',
-      properties: {
-        gameType: {
-          type: 'string',
-          description:
-            'Game type (e.g., "rock-paper-scissors", "chess", "tic-tac-toe")',
-        },
-        amount: {
-          type: 'number',
-          description: 'Challenge amount in USDC dollars (e.g., 5.00 for $5)',
-        },
-        targetUsername: {
-          type: 'string',
-          description: 'Username of the user to challenge',
-        },
-        targetUserId: {
-          type: 'string',
-          description: 'User ID of the user to challenge',
-        },
-      },
-      required: ['gameType', 'amount'],
-      additionalProperties: false,
-    },
-    async execute(_, params) {
-      const c = await requireClient();
-      if ('error' in c) return c.error;
-      const targetUsername =
-        typeof params.targetUsername === 'string'
-          ? params.targetUsername
-          : undefined;
-      const targetUserId =
-        typeof params.targetUserId === 'string'
-          ? params.targetUserId
-          : undefined;
-      if (!targetUsername && !targetUserId) {
-        return textResult(
-          'Must provide either targetUsername or targetUserId.',
-          true,
-        );
-      }
-      try {
-        const amountMinor = Math.round(Number(params.amount ?? 0) * 1_000_000);
-        const result = await c.sdk.challenges.create({
-          gameType: String(params.gameType ?? ''),
-          amount: amountMinor,
-          targetUsername,
-          targetUserId,
-        });
-        return textResult(
-          JSON.stringify(
-            {
-              ...result,
-              amountFormatted: `$${Number(params.amount).toFixed(2)}`,
-              hint: 'The challenged user will receive a notification. When they accept, a lobby is created automatically.',
-            },
-            null,
-            2,
-          ),
-        );
-      } catch (err) {
-        return textResult(
-          `Failed to create challenge: ${err instanceof Error ? err.message : String(err)}`,
-          true,
-        );
-      }
-    },
-  });
-
-  api.registerTool({
-    name: 'dim_accept_challenge',
-    description:
-      'Accept a challenge that was sent to you. Creates a lobby with the challenge amount and returns the lobby/game info.',
-    parameters: {
-      type: 'object',
-      properties: {
-        challengeId: {
-          type: 'string',
-          description: 'The challenge ID to accept',
-        },
-      },
-      required: ['challengeId'],
-      additionalProperties: false,
-    },
-    async execute(_, params) {
-      const c = await requireClient();
-      if ('error' in c) return c.error;
-      try {
-        const result = await c.sdk.challenges.accept(
-          String(params.challengeId ?? ''),
-        );
-        return textResult(
-          JSON.stringify(
-            {
-              ...result,
-              hint: result.gameId
-                ? `Game started! Use dim_get_game_state with gameId "${result.gameId}".`
-                : `Lobby created: ${result.lobbyId}. Use dim_join_queue to start matchmaking.`,
-            },
-            null,
-            2,
-          ),
-        );
-      } catch (err) {
-        return textResult(
-          `Failed to accept challenge: ${err instanceof Error ? err.message : String(err)}`,
-          true,
-        );
-      }
-    },
-  });
-
-  // --- Referrals ---
-  api.registerTool({
-    name: 'dim_get_referral_summary',
-    description:
-      'Get your referral summary including your referral code (your username), referral link, total referrals per level, and earnings (pending + claimed). DIM has a 3-level referral system: Level 1 = 30% of game fees, Level 2 = 3%, Level 3 = 2%.',
-    parameters: { type: 'object', properties: {}, additionalProperties: false },
-    async execute() {
-      const c = await requireClient();
-      if ('error' in c) return c.error;
-      try {
-        const summary = await c.sdk.referrals.getSummary();
-        const pendingDollars = summary.earnings.pending / 1_000_000;
-        const claimedDollars = summary.earnings.claimed / 1_000_000;
-        const result: Record<string, unknown> = {
-          ...summary,
-          pendingFormatted: `$${pendingDollars.toFixed(2)}`,
-          claimedFormatted: `$${claimedDollars.toFixed(2)}`,
-          referralRates: {
-            level1: '30% of referred user game fees',
-            level2: '3% of level-2 referral game fees',
-            level3: '2% of level-3 referral game fees',
-          },
-          referredUserBenefit: '10% fee discount (0.9% instead of 1%)',
-        };
-        if (!summary.hasReferrer) {
-          result.applyReferralHint =
-            'You have no referrer yet. Use dim_apply_referral_code to apply one and get a 10% fee discount.';
         }
-        return textResult(JSON.stringify(result, null, 2));
-      } catch (err) {
-        return textResult(
-          `Failed to get referral summary: ${err instanceof Error ? err.message : String(err)}`,
-          true,
-        );
-      }
-    },
-  });
-
-  api.registerTool({
-    name: 'dim_get_referral_tree',
-    description:
-      'Get your referral tree at a specific level. Level 1 = direct referrals, Level 2 = referrals of your referrals, Level 3 = one more level deep.',
-    parameters: {
-      type: 'object',
-      properties: {
-        level: {
-          type: 'string',
-          enum: ['1', '2', '3'],
-          description: 'Referral level to view (1, 2, or 3)',
-        },
-        limit: {
-          type: 'number',
-          description: 'Max results (default: 50, max: 200)',
-        },
-        cursor: { type: 'string', description: 'Pagination cursor' },
       },
-      required: ['level'],
-      additionalProperties: false,
-    },
-    async execute(_, params) {
-      const c = await requireClient();
-      if ('error' in c) return c.error;
-      try {
-        const tree = await c.sdk.referrals.getTree({
-          level: parseInt(String(params.level ?? '1'), 10) as 1 | 2 | 3,
-          limit: typeof params.limit === 'number' ? params.limit : 50,
-          cursor: typeof params.cursor === 'string' ? params.cursor : undefined,
-        });
-        return textResult(JSON.stringify(tree, null, 2));
-      } catch (err) {
-        return textResult(
-          `Failed to get referral tree: ${err instanceof Error ? err.message : String(err)}`,
-          true,
-        );
-      }
-    },
-  });
-
-  api.registerTool({
-    name: 'dim_get_referral_rewards',
-    description:
-      'Get your referral reward history. Filter by status: PENDING (unclaimed), CLAIMED (already claimed), CANCELLED.',
-    parameters: {
-      type: 'object',
-      properties: {
-        status: {
-          type: 'string',
-          enum: ['PENDING', 'CLAIMED', 'CANCELLED'],
-          description: 'Filter by reward status',
-        },
-        limit: {
-          type: 'number',
-          description: 'Max results (default: 50, max: 200)',
-        },
-        cursor: { type: 'string', description: 'Pagination cursor' },
-      },
-      additionalProperties: false,
-    },
-    async execute(_, params) {
-      const c = await requireClient();
-      if ('error' in c) return c.error;
-      try {
-        const rewards = await c.sdk.referrals.getRewards({
-          status: params.status as
-            | 'PENDING'
-            | 'CLAIMED'
-            | 'CANCELLED'
-            | undefined,
-          limit: typeof params.limit === 'number' ? params.limit : 50,
-          cursor: typeof params.cursor === 'string' ? params.cursor : undefined,
-        });
-        return textResult(JSON.stringify(rewards, null, 2));
-      } catch (err) {
-        return textResult(
-          `Failed to get referral rewards: ${err instanceof Error ? err.message : String(err)}`,
-          true,
-        );
-      }
-    },
-  });
-
-  api.registerTool({
-    name: 'dim_claim_referral_rewards',
-    description:
-      'Claim all pending referral rewards. USDC is transferred from escrow to your wallet. Returns the claimed amount and transaction signature.',
-    parameters: { type: 'object', properties: {}, additionalProperties: false },
-    async execute() {
-      const c = await requireClient();
-      if ('error' in c) return c.error;
-      try {
-        const result = await c.sdk.referrals.claimRewards();
-        const claimedDollars = result.claimedAmount / 1_000_000;
-        return textResult(
-          JSON.stringify(
-            { ...result, claimedFormatted: `$${claimedDollars.toFixed(2)}` },
-            null,
-            2,
-          ),
-        );
-      } catch (err) {
-        return textResult(
-          `Failed to claim rewards: ${err instanceof Error ? err.message : String(err)}`,
-          true,
-        );
-      }
-    },
-  });
-
-  api.registerTool({
-    name: 'dim_apply_referral_code',
-    description:
-      "Apply a referral code to your account (another user's username). Can only be applied once — if you already have a referrer, this will fail. Gives you a 10% fee discount.",
-    parameters: {
-      type: 'object',
-      properties: {
-        referralCode: {
-          type: 'string',
-          description: "The referral code to apply (another user's username)",
-        },
-      },
-      required: ['referralCode'],
-      additionalProperties: false,
-    },
-    async execute(_, params) {
-      const c = await requireClient();
-      if ('error' in c) return c.error;
-      try {
-        const result = await c.sdk.referrals.applyCode(
-          String(params.referralCode ?? ''),
-        );
-        return textResult(
-          JSON.stringify(
-            {
-              ...result,
-              message: `Referral code applied! ${result.referrerUsername} is now your referrer. You get a 10% fee discount on all games.`,
-            },
-            null,
-            2,
-          ),
-        );
-      } catch (err) {
-        return textResult(
-          `Failed to apply referral code: ${err instanceof Error ? err.message : String(err)}`,
-          true,
-        );
-      }
-    },
-  });
-
-  // --- Support ---
-  api.registerTool({
-    name: 'dim_create_support_ticket',
-    description:
-      'Create a support ticket to contact the DIM team. Use this when you need help with your account, payments, games, bugs, or any other issue. Categories: BUG, FEATURE_REQUEST, QUESTION, ACCOUNT, PAYMENT, GAME, TECHNICAL, OTHER.',
-    parameters: {
-      type: 'object',
-      properties: {
-        message: {
-          type: 'string',
-          description: 'Describe the issue or question (max 2000 chars)',
-        },
-        category: {
-          type: 'string',
-          enum: [
-            'BUG',
-            'FEATURE_REQUEST',
-            'QUESTION',
-            'ACCOUNT',
-            'PAYMENT',
-            'GAME',
-            'TECHNICAL',
-            'OTHER',
-          ],
-          description: 'Ticket category (default: OTHER)',
-        },
-        subject: {
-          type: 'string',
-          description:
-            'Short subject line (auto-generated from category if omitted)',
-        },
-      },
-      required: ['message'],
-      additionalProperties: false,
-    },
-    async execute(_, params) {
-      const c = await requireClient();
-      if ('error' in c) return c.error;
-      try {
-        const ticket = await c.sdk.support.create({
-          message: String(params.message ?? ''),
-          category: params.category as
-            | 'BUG'
-            | 'FEATURE_REQUEST'
-            | 'QUESTION'
-            | 'ACCOUNT'
-            | 'PAYMENT'
-            | 'GAME'
-            | 'TECHNICAL'
-            | 'OTHER'
-            | undefined,
-          subject:
-            typeof params.subject === 'string' ? params.subject : undefined,
-        });
-        return textResult(
-          JSON.stringify(
-            {
-              ...ticket,
-              hint: 'Ticket created successfully. You can check its status with dim_get_my_tickets or add follow-up messages with dim_add_ticket_message.',
-            },
-            null,
-            2,
-          ),
-        );
-      } catch (err) {
-        return textResult(
-          `Failed to create support ticket: ${err instanceof Error ? err.message : String(err)}`,
-          true,
-        );
-      }
-    },
-  });
-
-  api.registerTool({
-    name: 'dim_get_my_tickets',
-    description:
-      'Get your support tickets. Filter by status (OPEN, IN_PROGRESS, WAITING_REPLY, RESOLVED, CLOSED) or category.',
-    parameters: {
-      type: 'object',
-      properties: {
-        status: {
-          type: 'string',
-          enum: ['OPEN', 'IN_PROGRESS', 'WAITING_REPLY', 'RESOLVED', 'CLOSED'],
-          description: 'Filter by ticket status',
-        },
-        category: {
-          type: 'string',
-          enum: [
-            'BUG',
-            'FEATURE_REQUEST',
-            'QUESTION',
-            'ACCOUNT',
-            'PAYMENT',
-            'GAME',
-            'TECHNICAL',
-            'OTHER',
-          ],
-          description: 'Filter by category',
-        },
-        page: { type: 'number', description: 'Page number (default: 1)' },
-        limit: {
-          type: 'number',
-          description: 'Results per page (default: 10)',
-        },
-      },
-      additionalProperties: false,
-    },
-    async execute(_, params) {
-      const c = await requireClient();
-      if ('error' in c) return c.error;
-      try {
-        const tickets = await c.sdk.support.getMyTickets({
-          status: params.status as any,
-          category: params.category as any,
-          page: typeof params.page === 'number' ? params.page : undefined,
-          limit: typeof params.limit === 'number' ? params.limit : undefined,
-        });
-        return textResult(JSON.stringify(tickets, null, 2));
-      } catch (err) {
-        return textResult(
-          `Failed to get tickets: ${err instanceof Error ? err.message : String(err)}`,
-          true,
-        );
-      }
-    },
-  });
-
-  api.registerTool({
-    name: 'dim_get_ticket',
-    description:
-      'Get a specific support ticket with all messages. You can only view your own tickets.',
-    parameters: {
-      type: 'object',
-      properties: {
-        ticketId: { type: 'string', description: 'The ticket ID' },
-      },
-      required: ['ticketId'],
-      additionalProperties: false,
-    },
-    async execute(_, params) {
-      const c = await requireClient();
-      if ('error' in c) return c.error;
-      try {
-        const ticket = await c.sdk.support.getMyTicketById(
-          String(params.ticketId ?? ''),
-        );
-        return textResult(JSON.stringify(ticket, null, 2));
-      } catch (err) {
-        return textResult(
-          `Failed to get ticket: ${err instanceof Error ? err.message : String(err)}`,
-          true,
-        );
-      }
-    },
-  });
-
-  api.registerTool({
-    name: 'dim_add_ticket_message',
-    description:
-      'Add a follow-up message to an existing support ticket. You can only message your own tickets.',
-    parameters: {
-      type: 'object',
-      properties: {
-        ticketId: { type: 'string', description: 'The ticket ID' },
-        message: {
-          type: 'string',
-          description: 'Your follow-up message (max 2000 chars)',
-        },
-      },
-      required: ['ticketId', 'message'],
-      additionalProperties: false,
-    },
-    async execute(_, params) {
-      const c = await requireClient();
-      if ('error' in c) return c.error;
-      try {
-        const msg = await c.sdk.support.addMessage(
-          String(params.ticketId ?? ''),
-          String(params.message ?? ''),
-        );
-        return textResult(
-          JSON.stringify(
-            { ...msg, hint: 'Message added. The DIM team will be notified.' },
-            null,
-            2,
-          ),
-        );
-      } catch (err) {
-        return textResult(
-          `Failed to add message: ${err instanceof Error ? err.message : String(err)}`,
-          true,
-        );
-      }
-    },
-  });
-
-  api.registerTool({
-    name: 'dim_close_ticket',
-    description:
-      'Close a support ticket. Only close if your issue has been resolved.',
-    parameters: {
-      type: 'object',
-      properties: {
-        ticketId: { type: 'string', description: 'The ticket ID to close' },
-      },
-      required: ['ticketId'],
-      additionalProperties: false,
-    },
-    async execute(_, params) {
-      const c = await requireClient();
-      if ('error' in c) return c.error;
-      try {
-        const ticket = await c.sdk.support.closeTicket(
-          String(params.ticketId ?? ''),
-        );
-        return textResult(JSON.stringify(ticket, null, 2));
-      } catch (err) {
-        return textResult(
-          `Failed to close ticket: ${err instanceof Error ? err.message : String(err)}`,
-          true,
-        );
-      }
-    },
-  });
-
-  // --- Markets ---
-  api.registerTool({
-    name: 'dim_get_market',
-    description:
-      'Get the prediction market state for an active game. Returns share prices (implied probabilities), total collateral locked, total volume, and resolution status.',
-    parameters: {
-      type: 'object',
-      properties: {
-        gameId: {
-          type: 'string',
-          description: 'The game ID to get market state for',
-        },
-      },
-      required: ['gameId'],
-      additionalProperties: false,
-    },
-    async execute(_, params) {
-      const c = await requireClient();
-      if ('error' in c) return c.error;
-      try {
-        const market = await c.sdk.markets.getMarket(
-          String(params.gameId ?? ''),
-        );
-        return textResult(JSON.stringify(market, null, 2));
-      } catch (err) {
-        return textResult(
-          `Failed to get market: ${err instanceof Error ? err.message : String(err)}`,
-          true,
-        );
-      }
-    },
-  });
-
-  api.registerTool({
-    name: 'dim_buy_shares',
-    description:
-      'Buy shares in a prediction market outcome. Pick which player you think will win and how much to bet. Amount is in USDC dollars (e.g., 1.00 for $1.00).',
-    parameters: {
-      type: 'object',
-      properties: {
-        gameId: { type: 'string', description: 'The game ID' },
-        outcomeId: {
-          type: 'string',
-          description: 'The outcome (player user ID) to buy shares of',
-        },
-        amount: {
-          type: 'number',
-          description: 'Amount in USDC dollars (e.g., 1.00 for $1.00)',
-        },
-      },
-      required: ['gameId', 'outcomeId', 'amount'],
-      additionalProperties: false,
-    },
-    async execute(_, params) {
-      const c = await requireClient();
-      if ('error' in c) return c.error;
-      const amount = Number(params.amount ?? 0);
-      const gameId = String(params.gameId ?? '');
-      const outcomeId = String(params.outcomeId ?? '');
-      const limitErr = checkSpendLimit(c, amount);
-      if (limitErr) return textResult(limitErr, true);
-      try {
-        const amountMinor = Math.round(amount * 1_000_000);
-        const { transaction: txBase64 } = await c.sdk.markets.prepareBuyOrder(
-          gameId,
-          outcomeId,
-          amountMinor,
-        );
-        const tx = Transaction.from(Buffer.from(txBase64, 'base64'));
-        tx.partialSign(c.getKeypair());
-        const signedTxBase64 = Buffer.from(tx.serialize()).toString('base64');
-        const result = await c.sdk.markets.submitBuyOrder(
-          gameId,
-          signedTxBase64,
-          outcomeId,
-          amountMinor,
-        );
-        c.recordSpend(amountMinor);
-        return textResult(
-          JSON.stringify(
-            {
-              success: true,
-              tradeId: result.tradeId,
-              sharesReceived: result.sharesReceived,
-              costPerShare: result.costPerShare,
-              amountSpent: `$${amount.toFixed(2)}`,
-            },
-            null,
-            2,
-          ),
-        );
-      } catch (err) {
-        return textResult(
-          `Failed to buy shares: ${err instanceof Error ? err.message : String(err)}`,
-          true,
-        );
-      }
-    },
-  });
-
-  api.registerTool({
-    name: 'dim_sell_shares',
-    description:
-      'Sell shares to exit a prediction market position. Shares are in minor units (1 share = 1,000,000 minor units).',
-    parameters: {
-      type: 'object',
-      properties: {
-        gameId: { type: 'string', description: 'The game ID' },
-        outcomeId: {
-          type: 'string',
-          description: 'The outcome to sell shares of',
-        },
-        shares: {
-          type: 'number',
-          description:
-            'Number of shares to sell in minor units (1 share = 1,000,000)',
-        },
-      },
-      required: ['gameId', 'outcomeId', 'shares'],
-      additionalProperties: false,
-    },
-    async execute(_, params) {
-      const c = await requireClient();
-      if ('error' in c) return c.error;
-      try {
-        const result = await c.sdk.markets.sellShares(
-          String(params.gameId ?? ''),
-          String(params.outcomeId ?? ''),
-          Number(params.shares ?? 0),
-        );
-        return textResult(
-          JSON.stringify(
-            {
-              success: true,
-              tradeId: result.tradeId,
-              amountReceived: result.amountReceived,
-              pricePerShare: result.pricePerShare,
-              newPrices: result.newPrices,
-            },
-            null,
-            2,
-          ),
-        );
-      } catch (err) {
-        return textResult(
-          `Failed to sell shares: ${err instanceof Error ? err.message : String(err)}`,
-          true,
-        );
-      }
-    },
-  });
-
-  api.registerTool({
-    name: 'dim_get_positions',
-    description:
-      'Get your current prediction market positions for a game. Shows shares held, average cost, current value, and unrealized profit/loss.',
-    parameters: {
-      type: 'object',
-      properties: { gameId: { type: 'string', description: 'The game ID' } },
-      required: ['gameId'],
-      additionalProperties: false,
-    },
-    async execute(_, params) {
-      const c = await requireClient();
-      if ('error' in c) return c.error;
-      try {
-        const positions = await c.sdk.markets.getMyPositions(
-          String(params.gameId ?? ''),
-        );
-        return textResult(JSON.stringify(positions, null, 2));
-      } catch (err) {
-        return textResult(
-          `Failed to get positions: ${err instanceof Error ? err.message : String(err)}`,
-          true,
-        );
-      }
-    },
-  });
-
-  api.registerTool({
-    name: 'dim_redeem_shares',
-    description:
-      'Redeem winning shares after a prediction market has been resolved. Winners split the pool pro-rata by shares held, minus a 3% fee.',
-    parameters: {
-      type: 'object',
-      properties: {
-        gameId: {
-          type: 'string',
-          description: 'The game ID to redeem shares for',
-        },
-      },
-      required: ['gameId'],
-      additionalProperties: false,
-    },
-    async execute(_, params) {
-      const c = await requireClient();
-      if ('error' in c) return c.error;
-      try {
-        const result = await c.sdk.markets.redeemShares(
-          String(params.gameId ?? ''),
-        );
-        return textResult(JSON.stringify(result, null, 2));
-      } catch (err) {
-        return textResult(
-          `Failed to redeem shares: ${err instanceof Error ? err.message : String(err)}`,
-          true,
-        );
-      }
-    },
-  });
-
-  api.registerTool({
-    name: 'dim_get_market_analytics',
-    description:
-      'Get platform analytics for prediction markets. Shows total markets, orders, volume, fees, unique traders, and daily trends. Requires admin privileges.',
-    parameters: {
-      type: 'object',
-      properties: {
-        type: {
-          type: 'string',
-          enum: ['overview', 'daily', 'markets'],
-          description:
-            'overview = aggregate totals, daily = per-day breakdown, markets = paginated list of all markets',
-        },
-        days: {
-          type: 'number',
-          description: 'Number of days for daily stats (default 30)',
-        },
-        page: {
-          type: 'number',
-          description: 'Page number for markets list (default 1)',
-        },
-        limit: {
-          type: 'number',
-          description: 'Items per page for markets list (default 20)',
-        },
-      },
-      required: ['type'],
-      additionalProperties: false,
-    },
-    async execute(_, params) {
-      const c = await requireClient();
-      if ('error' in c) return c.error;
-      try {
-        let data: unknown;
-        switch (String(params.type)) {
-          case 'overview':
-            data = await c.sdk.markets.getAdminStats();
-            break;
-          case 'daily':
-            data = await c.sdk.markets.getAdminDailyStats(
-              typeof params.days === 'number' ? params.days : 30,
-            );
-            break;
-          case 'markets':
-            data = await c.sdk.markets.getAdminMarkets(
-              typeof params.page === 'number' ? params.page : undefined,
-              typeof params.limit === 'number' ? params.limit : undefined,
-            );
-            break;
-          default:
-            return textResult(
-              'Invalid type. Use overview, daily, or markets.',
-              true,
-            );
-        }
-        return textResult(JSON.stringify(data, null, 2));
-      } catch (err) {
-        return textResult(
-          `Failed to get market analytics: ${err instanceof Error ? err.message : String(err)}`,
-          true,
-        );
-      }
-    },
-  });
-
-  // ── Agent config ─────────────────────────────────────────────────────
+    });
+  }
 
+  // dim_list_instructions — special meta-tool
   api.registerTool({
-    name: 'dim_get_agent_config',
-    description:
-      'Get the agent autonomy configuration: what actions are allowed (friends, DMs, games, chat, referral promotion), spending limits, and current daily spend.',
+    name: 'dim_list_instructions',
+    description: 'List all available DIM tools with short descriptions.',
     parameters: { type: 'object', properties: {}, additionalProperties: false },
     async execute() {
-      const c = await requireClient();
-      if ('error' in c) return c.error;
       return textResult(
         JSON.stringify(
           {
-            autoAcceptFriendRequests:
-              pluginConfig?.autoAcceptFriendRequests ?? false,
-            autoReplyDms: pluginConfig?.autoReplyDms ?? false,
-            autoPlayGames: pluginConfig?.autoPlayGames ?? false,
-            maxBetPerGame: pluginConfig?.maxBetPerGame ?? 1.0,
-            dailySpendLimit: pluginConfig?.dailySpendLimit ?? 20.0,
-            dailySpentSoFar: `$${c.dailySpentDollars.toFixed(2)}`,
-            dailyRemaining: `$${Math.max(0, (pluginConfig?.dailySpendLimit ?? 20.0) - c.dailySpentDollars).toFixed(2)}`,
-            autoJoinGlobalChat: pluginConfig?.autoJoinGlobalChat ?? false,
-            autoPromoteReferrals: pluginConfig?.autoPromoteReferrals ?? false,
-            hint: 'These scopes are set by your operator in the plugin config. If you need higher limits, ask your operator to update dailySpendLimit or maxBetPerGame.',
+            hint: 'Game flow: dim_create_lobby → dim_join_queue → dim_game_loop (blocks until your turn) → dim_submit_action → dim_game_loop → repeat until completed',
+            move_formats: {
+              'rock-paper-scissors':
+                'action: "play", payload: { action: "rock"|"paper"|"scissors" }',
+              chess: 'action: "move", payload: { from: "e2", to: "e4" }',
+              'tic-tac-toe':
+                'action: "place_mark", payload: { row: 0-2, col: 0-2 }',
+              'connect-four': 'action: "drop_disc", payload: { column: 0-6 }',
+            },
+            market_flow:
+              'dim_get_market → dim_buy_shares (dollars) → dim_get_positions → dim_sell_shares or dim_redeem_shares after resolution',
+            fees: '1% game fee (min 1¢), 1¢ transfer fee, 3% market payout fee',
+            instructions: DIM_INSTRUCTIONS,
           },
           null,
           2,
@@ -2334,123 +323,4 @@ export default function register(api: {
       );
     },
   });
-
-  // ── Referral onboarding ──────────────────────────────────────────────
-
-  api.registerTool({
-    name: 'dim_get_referral_onboarding',
-    description:
-      'Get platform-specific setup instructions to share with another agent or user to onboard them to DIM with your referral code. The instructions include your referral code so the new user is attributed to you.',
-    parameters: {
-      type: 'object',
-      properties: {
-        platform: {
-          type: 'string',
-          enum: ['openclaw', 'claude-desktop', 'cursor', 'hermes', 'node-sdk'],
-          description:
-            'Target platform: openclaw, claude-desktop, cursor, hermes, or node-sdk',
-        },
-      },
-      required: ['platform'],
-      additionalProperties: false,
-    },
-    async execute(_, params) {
-      const c = await requireClient();
-      if ('error' in c) return c.error;
-      try {
-        let username = 'YOUR_USERNAME';
-        try {
-          if (c.currentUserId) {
-            const profile = await c.sdk.users.getUserById(c.currentUserId);
-            if (profile.username) username = profile.username;
-          }
-        } catch {
-          /* use fallback */
-        }
-        const platform = String(params.platform ?? 'openclaw');
-        const script = generateOnboardingScript(platform, username);
-        return textResult(script);
-      } catch (err) {
-        return textResult(
-          `Failed to generate onboarding script: ${err instanceof Error ? err.message : String(err)}`,
-          true,
-        );
-      }
-    },
-  });
-
-  // ── Real-time event awareness ─────────────────────────────────────────
-
-  api.registerTool({
-    name: 'dim_get_pending_events',
-    description:
-      'Drain buffered real-time events (DMs, challenges, game turns, match notifications). Call this regularly during game loops or idle time to stay aware of incoming activity.',
-    parameters: { type: 'object', properties: {}, additionalProperties: false },
-    async execute() {
-      const c = await requireClient();
-      if ('error' in c) return c.error;
-      try {
-        const events = c.drainEvents();
-        return textResult(
-          JSON.stringify(
-            {
-              count: events.length,
-              events,
-              hint:
-                events.length === 0
-                  ? 'No new events since last check.'
-                  : 'Process these events and take action as needed.',
-            },
-            null,
-            2,
-          ),
-        );
-      } catch (err) {
-        return textResult(
-          `Failed to get pending events: ${err instanceof Error ? err.message : String(err)}`,
-          true,
-        );
-      }
-    },
-  });
-
-  api.registerTool({
-    name: 'dim_check_notifications',
-    description:
-      'Check all pending items in one call: unread notifications (challenges, game results), unread DM threads, and incoming friend requests. Use this to catch up after being idle.',
-    parameters: { type: 'object', properties: {}, additionalProperties: false },
-    async execute() {
-      const c = await requireClient();
-      if ('error' in c) return c.error;
-      try {
-        const [notifications, dmThreads, friendRequests] = await Promise.all([
-          c.sdk.notifications.list({ page: 1, limit: 20 }),
-          c.sdk.chat.listDmThreads(),
-          c.sdk.users.getIncomingFriendRequests(),
-        ]);
-        const unreadDms = (dmThreads as Array<{ unreadCount?: number }>).filter(
-          (t) => (t.unreadCount ?? 0) > 0,
-        );
-        return textResult(
-          JSON.stringify(
-            {
-              unreadNotificationCount: notifications.unreadCount,
-              notifications: notifications.notifications.filter((n) => !n.read),
-              unreadDmThreads: unreadDms,
-              incomingFriendRequests: friendRequests,
-              pendingWsEvents: c.pendingEventCount,
-              hint: 'Use dim_get_pending_events to drain buffered real-time events.',
-            },
-            null,
-            2,
-          ),
-        );
-      } catch (err) {
-        return textResult(
-          `Failed to check notifications: ${err instanceof Error ? err.message : String(err)}`,
-          true,
-        );
-      }
-    },
-  });
 }