@dimcool/mcp 0.1.26 → 0.1.28

package/dist/index.js

@@ -41,7 +41,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var require_XMLHttpRequest = __commonJS({
   "../../node_modules/xmlhttprequest-ssl/lib/XMLHttpRequest.js"(exports, module) {
     "use strict";
-    var fs = __require("fs");
+    var fs2 = __require("fs");
     var Url = __require("url");
     var spawn = __require("child_process").spawn;
     module.exports = XMLHttpRequest3;
@@ -199,7 +199,7 @@ var require_XMLHttpRequest = __commonJS({
             throw new Error("XMLHttpRequest: Only GET method is supported");
           }
           if (settings.async) {
-            fs.readFile(unescape(url2.pathname), function(error, data2) {
+            fs2.readFile(unescape(url2.pathname), function(error, data2) {
               if (error) {
                 self2.handleError(error, error.errno || -1);
               } else {
@@ -211,7 +211,7 @@ var require_XMLHttpRequest = __commonJS({
             });
           } else {
             try {
-              this.response = fs.readFileSync(unescape(url2.pathname));
+              this.response = fs2.readFileSync(unescape(url2.pathname));
               this.responseText = this.response.toString("utf8");
               this.status = 200;
               setState(self2.DONE);
@@ -337,15 +337,15 @@ var require_XMLHttpRequest = __commonJS({
         } else {
           var contentFile = ".node-xmlhttprequest-content-" + process.pid;
           var syncFile = ".node-xmlhttprequest-sync-" + process.pid;
-          fs.writeFileSync(syncFile, "", "utf8");
+          fs2.writeFileSync(syncFile, "", "utf8");
           var execString = "var http = require('http'), https = require('https'), fs = require('fs');var doRequest = http" + (ssl ? "s" : "") + ".request;var options = " + JSON.stringify(options) + ";var responseText = '';var responseData = Buffer.alloc(0);var req = doRequest(options, function(response) {response.on('data', function(chunk) {  var data = Buffer.from(chunk);  responseText += data.toString('utf8');  responseData = Buffer.concat([responseData, data]);});response.on('end', function() {fs.writeFileSync('" + contentFile + "', JSON.stringify({err: null, data: {statusCode: response.statusCode, headers: response.headers, text: responseText, data: responseData.toString('base64')}}), 'utf8');fs.unlinkSync('" + syncFile + "');});response.on('error', function(error) {fs.writeFileSync('" + contentFile + "', 'NODE-XMLHTTPREQUEST-ERROR:' + JSON.stringify(error), 'utf8');fs.unlinkSync('" + syncFile + "');});}).on('error', function(error) {fs.writeFileSync('" + contentFile + "', 'NODE-XMLHTTPREQUEST-ERROR:' + JSON.stringify(error), 'utf8');fs.unlinkSync('" + syncFile + "');});" + (data ? "req.write('" + JSON.stringify(data).slice(1, -1).replace(/'/g, "\\'") + "');" : "") + "req.end();";
           var syncProc = spawn(process.argv[0], ["-e", execString]);
           var statusText;
-          while (fs.existsSync(syncFile)) {
+          while (fs2.existsSync(syncFile)) {
           }
-          self2.responseText = fs.readFileSync(contentFile, "utf8");
+          self2.responseText = fs2.readFileSync(contentFile, "utf8");
           syncProc.stdin.end();
-          fs.unlinkSync(contentFile);
+          fs2.unlinkSync(contentFile);
           if (self2.responseText.match(/^NODE-XMLHTTPREQUEST-ERROR:/)) {
             var errorObj = JSON.parse(self2.responseText.replace(/^NODE-XMLHTTPREQUEST-ERROR:/, ""));
             self2.handleError(errorObj, 503);
@@ -1235,8 +1235,8 @@ var require_constants = __commonJS({
 var require_node_gyp_build = __commonJS({
   "../../node_modules/node-gyp-build/node-gyp-build.js"(exports, module) {
     "use strict";
-    var fs = __require("fs");
-    var path2 = __require("path");
+    var fs2 = __require("fs");
+    var path3 = __require("path");
     var os2 = __require("os");
     var runtimeRequire = typeof __webpack_require__ === "function" ? __non_webpack_require__ : __require;
     var vars = process.config && process.config.variables || {};
@@ -1253,21 +1253,21 @@ var require_node_gyp_build = __commonJS({
       return runtimeRequire(load.resolve(dir));
     }
     load.resolve = load.path = function(dir) {
-      dir = path2.resolve(dir || ".");
+      dir = path3.resolve(dir || ".");
       try {
-        var name = runtimeRequire(path2.join(dir, "package.json")).name.toUpperCase().replace(/-/g, "_");
+        var name = runtimeRequire(path3.join(dir, "package.json")).name.toUpperCase().replace(/-/g, "_");
         if (process.env[name + "_PREBUILD"]) dir = process.env[name + "_PREBUILD"];
       } catch (err) {
       }
       if (!prebuildsOnly) {
-        var release = getFirst(path2.join(dir, "build/Release"), matchBuild);
+        var release = getFirst(path3.join(dir, "build/Release"), matchBuild);
         if (release) return release;
-        var debug12 = getFirst(path2.join(dir, "build/Debug"), matchBuild);
+        var debug12 = getFirst(path3.join(dir, "build/Debug"), matchBuild);
         if (debug12) return debug12;
       }
-      var prebuild = resolve(dir);
+      var prebuild = resolve2(dir);
       if (prebuild) return prebuild;
-      var nearby = resolve(path2.dirname(process.execPath));
+      var nearby = resolve2(path3.dirname(process.execPath));
       if (nearby) return nearby;
       var target = [
         "platform=" + platform,
@@ -1283,27 +1283,27 @@ var require_node_gyp_build = __commonJS({
         // eslint-disable-line
       ].filter(Boolean).join(" ");
       throw new Error("No native build was found for " + target + "\n    loaded from: " + dir + "\n");
-      function resolve(dir2) {
-        var tuples = readdirSync(path2.join(dir2, "prebuilds")).map(parseTuple);
+      function resolve2(dir2) {
+        var tuples = readdirSync(path3.join(dir2, "prebuilds")).map(parseTuple);
         var tuple = tuples.filter(matchTuple(platform, arch)).sort(compareTuples)[0];
         if (!tuple) return;
-        var prebuilds = path2.join(dir2, "prebuilds", tuple.name);
+        var prebuilds = path3.join(dir2, "prebuilds", tuple.name);
         var parsed = readdirSync(prebuilds).map(parseTags);
         var candidates = parsed.filter(matchTags(runtime, abi));
         var winner = candidates.sort(compareTags(runtime))[0];
-        if (winner) return path2.join(prebuilds, winner.file);
+        if (winner) return path3.join(prebuilds, winner.file);
       }
     };
     function readdirSync(dir) {
       try {
-        return fs.readdirSync(dir);
+        return fs2.readdirSync(dir);
       } catch (err) {
         return [];
       }
     }
     function getFirst(dir, filter) {
       var files = readdirSync(dir).filter(filter);
-      return files[0] && path2.join(dir, files[0]);
+      return files[0] && path3.join(dir, files[0]);
     }
     function matchBuild(name) {
       return /\.node$/.test(name);
@@ -1390,7 +1390,7 @@ var require_node_gyp_build = __commonJS({
       return typeof window !== "undefined" && window.process && window.process.type === "renderer";
     }
     function isAlpine(platform2) {
-      return platform2 === "linux" && fs.existsSync("/etc/alpine-release");
+      return platform2 === "linux" && fs2.existsSync("/etc/alpine-release");
     }
     load.parseTags = parseTags;
     load.matchTags = matchTags;
@@ -3676,7 +3676,7 @@ var require_websocket = __commonJS({
     var tls = __require("tls");
     var { randomBytes, createHash } = __require("crypto");
     var { Duplex, Readable } = __require("stream");
-    var { URL } = __require("url");
+    var { URL: URL2 } = __require("url");
     var PerMessageDeflate = require_permessage_deflate();
     var Receiver2 = require_receiver();
     var Sender2 = require_sender();
@@ -4166,11 +4166,11 @@ var require_websocket = __commonJS({
         );
       }
       let parsedUrl;
-      if (address instanceof URL) {
+      if (address instanceof URL2) {
         parsedUrl = address;
       } else {
         try {
-          parsedUrl = new URL(address);
+          parsedUrl = new URL2(address);
         } catch (e) {
           throw new SyntaxError(`Invalid URL: ${address}`);
         }
@@ -4307,7 +4307,7 @@ var require_websocket = __commonJS({
           req.abort();
           let addr;
           try {
-            addr = new URL(location2, address);
+            addr = new URL2(location2, address);
           } catch (e) {
             const err = new SyntaxError(`Invalid URL: ${location2}`);
             emitErrorAndClose(websocket, err);
@@ -7309,13 +7309,13 @@ var require_nacl_fast = __commonJS({
 import {
   chmod,
   mkdir,
-  readFile,
+  readFile as readFile2,
   rename,
-  stat,
+  stat as stat2,
   writeFile
 } from "fs/promises";
 import os from "os";
-import path from "path";
+import path2 from "path";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { Keypair as Keypair2 } from "@solana/web3.js";
 import bs582 from "bs58";
@@ -8572,12 +8572,12 @@ function parse2(str) {
   uri.queryKey = queryKey(uri, uri["query"]);
   return uri;
 }
-function pathNames(obj, path2) {
-  const regx = /\/{2,9}/g, names = path2.replace(regx, "/").split("/");
-  if (path2.slice(0, 1) == "/" || path2.length === 0) {
+function pathNames(obj, path3) {
+  const regx = /\/{2,9}/g, names = path3.replace(regx, "/").split("/");
+  if (path3.slice(0, 1) == "/" || path3.length === 0) {
     names.splice(0, 1);
   }
-  if (path2.slice(-1) == "/") {
+  if (path3.slice(-1) == "/") {
     names.splice(names.length - 1, 1);
   }
   return names;
@@ -9194,7 +9194,7 @@ var protocol2 = Socket.protocol;
 // ../../node_modules/socket.io-client/build/esm-debug/url.js
 var import_debug7 = __toESM(require_src(), 1);
 var debug7 = (0, import_debug7.default)("socket.io-client:url");
-function url(uri, path2 = "", loc) {
+function url(uri, path3 = "", loc) {
   let obj = uri;
   loc = loc || typeof location !== "undefined" && location;
   if (null == uri)
@@ -9228,7 +9228,7 @@ function url(uri, path2 = "", loc) {
   obj.path = obj.path || "/";
   const ipv6 = obj.host.indexOf(":") !== -1;
   const host = ipv6 ? "[" + obj.host + "]" : obj.host;
-  obj.id = obj.protocol + "://" + host + ":" + obj.port + path2;
+  obj.id = obj.protocol + "://" + host + ":" + obj.port + path3;
   obj.href = obj.protocol + "://" + host + (loc && loc.port === obj.port ? "" : ":" + obj.port);
   return obj;
 }
@@ -9878,9 +9878,9 @@ var Socket2 = class extends Emitter {
    * @return a Promise that will be fulfilled when the server acknowledges the event
    */
   emitWithAck(ev, ...args) {
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       const fn = (arg1, arg2) => {
-        return arg1 ? reject(arg1) : resolve(arg2);
+        return arg1 ? reject(arg1) : resolve2(arg2);
       };
       fn.withError = true;
       args.push(fn);
@@ -10852,8 +10852,8 @@ function lookup(uri, opts) {
   const parsed = url(uri, opts.path || "/socket.io");
   const source = parsed.source;
   const id = parsed.id;
-  const path2 = parsed.path;
-  const sameNamespace = cache[id] && path2 in cache[id]["nsps"];
+  const path3 = parsed.path;
+  const sameNamespace = cache[id] && path3 in cache[id]["nsps"];
   const newConnection = opts.forceNew || opts["force new connection"] || false === opts.multiplex || sameNamespace;
   let io;
   if (newConnection) {
@@ -11751,6 +11751,16 @@ var Admin = class {
     );
   }
 };
+function isFile(input) {
+  return typeof input.arrayBuffer === "function";
+}
+function buildFormDataFromPayload(payload) {
+  const formData = new FormData();
+  const part = payload.data instanceof Uint8Array ? payload.data : new Uint8Array(payload.data);
+  const blob = new Blob([part], { type: payload.mimeType });
+  formData.append("file", blob, payload.filename);
+  return formData;
+}
 var Users = class {
   constructor(http, logger2) {
     this.http = http;
@@ -11837,14 +11847,22 @@ var Users = class {
   async updateProfile(data) {
     return this.http.patch("/users/me/profile", data);
   }
-  async uploadAvatar(file) {
-    const formData = new FormData();
-    formData.append("file", file);
+  async uploadAvatar(input) {
+    const payload = isFile(input) ? {
+      data: new Uint8Array(await input.arrayBuffer()),
+      mimeType: input.type,
+      filename: input.name
+    } : input;
+    const formData = buildFormDataFromPayload(payload);
     return this.http.upload("/users/me/profile/avatar", formData);
   }
-  async uploadCoverImage(file) {
-    const formData = new FormData();
-    formData.append("file", file);
+  async uploadCoverImage(input) {
+    const payload = isFile(input) ? {
+      data: new Uint8Array(await input.arrayBuffer()),
+      mimeType: input.type,
+      filename: input.name
+    } : input;
+    const formData = buildFormDataFromPayload(payload);
     return this.http.upload("/users/me/profile/cover", formData);
   }
   async removeAvatar() {
@@ -11984,19 +12002,18 @@ var Lobbies = class {
     return this.http.delete(`/lobbies/admin/${lobbyId}`);
   }
   /**
-   * Play again: Create a new lobby, start deposits, and prepare deposit transaction
-   * Returns the lobby and unsigned transaction that needs to be signed
+   * Play again: Create a new lobby and prepare deposit in one flow.
+   * Returns the lobby and unsigned transaction that needs to be signed.
    * @param gameType - The game type to play again
    * @param betAmount - The bet amount (same as previous game)
    * @param escrow - The escrow service instance (from sdk.escrow)
    */
   async playAgain(gameType, betAmount, escrow) {
     const lobby = await this.createLobby(gameType, betAmount);
-    await escrow.startDeposits(lobby.id);
-    const prepareResponse = await escrow.prepareDepositTransaction(lobby.id);
+    const { transaction } = await escrow.prepareAndStartDeposit(lobby.id);
     return {
       lobby,
-      unsignedTransaction: prepareResponse.transaction
+      unsignedTransaction: transaction
     };
   }
 };
@@ -12179,7 +12196,7 @@ async function withRetry(fn, options = {}) {
   throw lastError;
 }
 function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
 }
 var DEFAULT_RETRY_OPTIONS = {
   maxAttempts: 3,
@@ -12860,6 +12877,17 @@ var Escrow = class {
       `/escrow/lobby/${lobbyId}/deposit/prepare`
     );
   }
+  /**
+   * Combined prepare-and-start: validates lobby, transitions waiting→preparing,
+   * initializes depositStatus, and prepares the unsigned transaction in one call.
+   * Eliminates one HTTP round-trip vs startDeposits() + prepareDepositTransaction().
+   */
+  async prepareAndStartDeposit(lobbyId) {
+    return this.http.post(
+      `/escrow/lobby/${lobbyId}/deposit/prepare-and-start`,
+      {}
+    );
+  }
   /**
    * Submit a signed deposit transaction
    * The transaction will be submitted to the Solana network and confirmed
@@ -12890,7 +12918,7 @@ var Escrow = class {
     );
   }
   /**
-   * One-call lobby deposit: start deposits, prepare, sign, submit, and poll until
+   * One-call lobby deposit: prepare-and-start, sign, submit, and poll until
    * the current user's deposit is confirmed. Requires sdk.wallet.setSigner() to be set.
    * Returns when all required deposits are confirmed and the lobby can proceed to queue.
    *
@@ -12902,8 +12930,7 @@ var Escrow = class {
         "No signer configured. Use sdk.wallet.setSigner(...) first."
       );
     }
-    await this.startDeposits(lobbyId);
-    const { transaction } = await this.prepareDepositTransaction(lobbyId);
+    const { transaction } = await this.prepareAndStartDeposit(lobbyId);
     const unsignedTx = Transaction5.from(base64ToBytes(transaction));
     let signature;
     if (this.wallet.isSignAndSendMode()) {
@@ -12925,7 +12952,7 @@ var Escrow = class {
       if (status.allConfirmed && status.canProceedToQueue) {
         return {
           signature,
-          status: "pending",
+          status: "confirmed",
           canProceedToQueue: true
         };
       }
@@ -12937,6 +12964,39 @@ var Escrow = class {
       canProceedToQueue: false
     };
   }
+  /**
+   * Zero-polling deposit variant using server-side awaitConfirmation.
+   * 2 HTTP calls total, 0 client-side polling. Ideal for agents.
+   *
+   * Automatically uses signAndSendTransaction or signTransaction based on signer capability.
+   */
+  async depositForLobbySync(lobbyId) {
+    if (!this.wallet.hasSigner()) {
+      throw new Error(
+        "No signer configured. Use sdk.wallet.setSigner(...) first."
+      );
+    }
+    const { transaction } = await this.prepareAndStartDeposit(lobbyId);
+    const unsignedTx = Transaction5.from(base64ToBytes(transaction));
+    let signature;
+    if (this.wallet.isSignAndSendMode()) {
+      signature = await this.wallet.signAndSendTransaction(unsignedTx);
+      await this.http.post(
+        `/escrow/lobby/${lobbyId}/deposit/confirm-signature?awaitConfirmation=true`,
+        { signature }
+      );
+    } else {
+      const signedTx = await this.wallet.signTransaction(unsignedTx);
+      const signedBase64 = bytesToBase64(
+        signedTx.serialize({ requireAllSignatures: false })
+      );
+      const result = await this.http.post(`/escrow/lobby/${lobbyId}/deposit/submit?awaitConfirmation=true`, {
+        signedTransaction: signedBase64
+      });
+      signature = result.signature;
+    }
+    return { signature, status: "confirmed", canProceedToQueue: true };
+  }
   async claimLobbyDepositRefund(lobbyId, depositSignature) {
     return this.http.post(
       `/escrow/lobby/${lobbyId}/deposit/${depositSignature}/claim-refund`,
@@ -12949,33 +13009,6 @@ var Escrow = class {
       {}
     );
   }
-  /**
-   * Submit a signed deposit transaction and wait until the lobby is queued/active.
-   *
-   * Note: the backend may auto-transition the lobby to the queue once deposits are confirmed.
-   * In that case, calling /join-queue from the client would be redundant and can fail with
-   * "Current status: queued".
-   * @param lobbyId - The lobby ID
-   * @param signedTransaction - The signed transaction (base64 encoded)
-   * @param lobbies - The lobbies service instance (from sdk.lobbies) to read lobby status
-   */
-  async submitDepositAndJoinQueue(lobbyId, signedTransaction, lobbies) {
-    await this.submitDeposit(lobbyId, signedTransaction);
-    const MAX_WAIT_TIME = 3e4;
-    const POLL_INTERVAL = 1e3;
-    const startTime = Date.now();
-    while (Date.now() - startTime < MAX_WAIT_TIME) {
-      const status = await this.getDepositStatus(lobbyId);
-      if (status.allConfirmed && status.canProceedToQueue) {
-        const lobby = await lobbies.getLobby(lobbyId);
-        if (lobby.status === "queued" || lobby.status === "active") {
-          return lobby;
-        }
-      }
-      await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL));
-    }
-    throw new Error("Deposit confirmation timeout");
-  }
 };
 var Daily = class {
   constructor(http, logger2 = logger) {
@@ -13431,12 +13464,12 @@ var BaseWsTransport = class {
     if (this.connectionState.connected) {
       return Promise.resolve();
     }
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       const timeoutId = setTimeout(() => {
         this.waiters.delete(waiter);
         reject(new Error("WebSocket connection timed out"));
       }, timeoutMs);
-      const waiter = { resolve, reject, timeoutId };
+      const waiter = { resolve: resolve2, reject, timeoutId };
       this.waiters.add(waiter);
     });
   }
@@ -13602,8 +13635,14 @@ var _StandaloneWsTransport = class _StandaloneWsTransport2 extends BaseWsTranspo
         connecting: false,
         error: null
       });
+      const wasReconnect = this.reconnectAttempts > 0;
       this.reconnectAttempts = 0;
       this.onReconnect();
+      if (wasReconnect) {
+        this.dispatchEvent("connection:reconnected", {
+          timestamp: Date.now()
+        });
+      }
     });
     socket.on("disconnect", (reason) => {
       this.updateConnectionState({ connected: false, connecting: false });
@@ -13745,7 +13784,8 @@ function createLobbyStore(transport2) {
   const store = createSdkStore({
     lobbiesById: {},
     matchedEvent: null,
-    typingByLobbyId: {}
+    typingByLobbyId: {},
+    depositStatusByLobbyId: {}
   });
   const setBaseState = (lobbies) => {
     const lobbiesById = {};
@@ -13825,6 +13865,15 @@ function createLobbyStore(transport2) {
           };
         });
         break;
+      case "lobby:deposit:updated":
+        store.updateState((state) => ({
+          ...state,
+          depositStatusByLobbyId: {
+            ...state.depositStatusByLobbyId,
+            [event.payload.lobbyId]: event.payload
+          }
+        }));
+        break;
       case "lobby:typing:start":
       case "lobby:typing:stop":
         store.updateState((state) => {
@@ -13853,12 +13902,22 @@ function createLobbyStore(transport2) {
       }
     }
   );
+  const subscribeDepositUpdate = (lobbyId, callback) => store.subscribeSelector(
+    (state) => state.depositStatusByLobbyId[lobbyId],
+    () => {
+      const data = store.getState().depositStatusByLobbyId[lobbyId];
+      if (data) {
+        callback(data);
+      }
+    }
+  );
   return {
     store,
     setBaseState,
     applyWsEvent,
     joinLobby,
-    subscribeMatched
+    subscribeMatched,
+    subscribeDepositUpdate
   };
 }
 function createGameStore(transport2) {
@@ -14140,7 +14199,6 @@ function createGameActionsStore(transport2) {
           ...current,
           roundState: {
             ...current.roundState,
-            phase: "completed",
             timeRemaining: 0,
             actions: timedOutUser ? {
               ...current.roundState.actions,
@@ -14185,6 +14243,22 @@ function createGameActionsStore(transport2) {
         updateState(gameId, updated);
         break;
       }
+      case "game:move": {
+        const { gameId, fen, turn, currentPlayerId, status, winnerId } = event.payload;
+        if (!gameId) return;
+        const current = store.getState().statesByGameId[gameId];
+        if (!isNonRpsState(current)) return;
+        const updated = {
+          ...current,
+          fen,
+          turn,
+          currentPlayerId,
+          status,
+          ...winnerId != null && { winnerId }
+        };
+        updateState(gameId, updated);
+        break;
+      }
       case "game:state": {
         const gameId = event.payload.gameId ?? event.payload.state.gameId;
         if (!gameId) return;
@@ -14652,6 +14726,7 @@ var WS_EVENT_NAMES = [
   "lobby:queue:joined",
   "lobby:queue:cancelled",
   "lobby:matched",
+  "lobby:deposit:updated",
   "lobby:typing:start",
   "lobby:typing:stop",
   "game:updated",
@@ -14728,6 +14803,11 @@ function decodeWsEvent(eventName, payload) {
         event: "lobby:matched",
         payload
       };
+    case "lobby:deposit:updated":
+      return {
+        event: "lobby:deposit:updated",
+        payload
+      };
     case "lobby:typing:start":
     case "lobby:typing:stop":
       return {
@@ -15184,6 +15264,17 @@ var SAFETY_RULES = [
 ];
 
 // ../dim-agent-core/src/tools/auth.ts
+var WALLET_LINKAGE_NOTE = "DIM is noncustodial. Your DIM wallet is the Solana address shown here; it was configured with a base58 private key at setup. Signing is done locally where this instance runs, using that private key and DIM's wallet package.";
+async function getSpectateUrl(client) {
+  if (!client.currentUserId) return null;
+  try {
+    const user = await client.sdk.users.getUserById(client.currentUserId);
+    const u = user;
+    return u?.username ? `https://dim.cool/spectate/${u.username}` : null;
+  } catch {
+    return null;
+  }
+}
 async function login(client) {
   try {
     const result = await client.authenticate();
@@ -15213,6 +15304,7 @@ async function login(client) {
       userId: result.userId,
       username: result.username ?? null,
       walletAddress: client.walletAddress,
+      walletNote: WALLET_LINKAGE_NOTE,
       safetyRules: SAFETY_RULES,
       nextSteps
     };
@@ -15246,7 +15338,11 @@ async function getProfile(client) {
       };
     }
     const user = await client.sdk.users.getUserById(client.currentUserId);
-    return { data: user };
+    const profile = {
+      ...typeof user === "object" && user !== null ? user : {},
+      walletAddress: client.walletAddress
+    };
+    return { data: profile };
   } catch (error) {
     return {
       error: `Failed to get profile: ${error instanceof Error ? error.message : String(error)}`,
@@ -15447,12 +15543,31 @@ async function listDmThreads(client) {
 }
 
 // ../dim-agent-core/src/tools/wallet.ts
+async function getWalletAddress(client) {
+  try {
+    return {
+      data: {
+        walletAddress: client.walletAddress,
+        walletNote: WALLET_LINKAGE_NOTE
+      }
+    };
+  } catch (error) {
+    return {
+      error: `Failed to get wallet address: ${error instanceof Error ? error.message : String(error)}`,
+      isError: true
+    };
+  }
+}
 async function getBalance(client) {
   try {
     const balance = await client.sdk.wallet.getBalances();
     const usdcDollars = balance.usdc / 1e6;
     return {
-      data: { ...balance, usdcFormatted: `$${usdcDollars.toFixed(2)}` }
+      data: {
+        ...balance,
+        usdcFormatted: `$${usdcDollars.toFixed(2)}`,
+        walletAddress: client.walletAddress
+      }
     };
   } catch (error) {
     return {
@@ -15519,7 +15634,10 @@ async function getWalletActivity(client, args) {
       limit: args.limit || 20
     });
     const claimable = activity.items.filter((i) => i.claimable === true);
-    const data = { ...activity };
+    const data = {
+      ...activity,
+      walletAddress: client.walletAddress
+    };
     if (claimable.length > 0) {
       data.hint = `You have ${claimable.length} claimable item(s). Call dim_claim_funds with the activityId to claim each one.`;
       data.claimableItems = claimable.map((i) => ({
@@ -15728,9 +15846,8 @@ function buildGameOverHint(state) {
   const winnerId = state.winnerId;
   const wonAmount = state.wonAmount;
   const isDraw = state.draw === true || winnerId == null;
-  if (isDraw) return "Game over \u2014 it was a draw.";
-  const amountStr = wonAmount != null ? ` Won $${(wonAmount / 1e6).toFixed(2)}.` : "";
-  return `Game over. Winner: ${winnerId}.${amountStr}`;
+  const result = isDraw ? "Game over \u2014 it was a draw." : `Game over. Winner: ${winnerId}.${wonAmount != null ? ` Won $${(wonAmount / 1e6).toFixed(2)}.` : ""}`;
+  return `${result} You can request a rematch with dim_request_rematch, or check dim_check_notifications for new activity.`;
 }
 async function fetchNewGameChat(client, gameId) {
   try {
@@ -15838,13 +15955,13 @@ async function createLobby(client, args) {
 }
 async function depositForLobby(client, args) {
   try {
-    const result = await client.sdk.escrow.depositForLobby(args.lobbyId);
+    const result = await client.sdk.escrow.depositForLobbySync(args.lobbyId);
     return {
       data: {
         signature: result.signature,
         status: result.status,
         canProceedToQueue: result.canProceedToQueue,
-        hint: result.canProceedToQueue ? "Deposit confirmed. Call dim_join_queue when ready (and when all players have deposited if 2-player)." : "Deposit submitted. Poll dim_get_deposit_status or try dim_join_queue once all players have deposited."
+        hint: "Deposit confirmed. The server auto-joins the queue when all players have deposited."
       }
     };
   } catch (error) {
@@ -15875,13 +15992,15 @@ async function joinQueue(client, args) {
     await client.ensureConnected();
     const lobby = await client.sdk.lobbies.joinQueue(args.lobbyId);
     const matched = lobby.status === "active" && lobby.gameId;
+    const spectateUrl = matched ? await getSpectateUrl(client) : null;
     return {
       data: {
         lobbyId: lobby.id,
         status: lobby.status,
         gameId: lobby.gameId || null,
         matched: !!matched,
-        hint: matched ? `Game started! Call dim_game_loop with gameId "${lobby.gameId}" to play.` : "Waiting for an opponent. Poll dim_get_lobby to check for a match."
+        ...spectateUrl && { spectateUrl },
+        hint: matched ? `Game started! Call dim_game_loop with gameId "${lobby.gameId}" to play.${spectateUrl ? ` Tell the user they can spectate at ${spectateUrl}` : ""}` : "Waiting for an opponent. Poll dim_get_lobby to check for a match."
       }
     };
   } catch (error) {
@@ -15996,13 +16115,12 @@ async function gameLoop(client, args) {
     const store = client.sdk.gameActionsStore;
     const timeout = 3e5;
     const start = Date.now();
-    let state = store.store.getState().statesByGameId[gameId];
-    if (!state) {
-      const fetched = await client.sdk.games.getGameState(gameId);
-      store.setBaseState(gameId, fetched);
-      store.joinGame(gameId);
-      state = fetched;
-    }
+    await client.ensureConnected();
+    store.joinGame(gameId);
+    const fetched = await client.sdk.games.getGameState(gameId);
+    store.setBaseState(gameId, fetched);
+    let state = fetched;
+    let lastRefresh = Date.now();
     while (Date.now() - start < timeout) {
       state = store.store.getState().statesByGameId[gameId];
       if (state?.status === "completed") {
@@ -16012,17 +16130,22 @@ async function gameLoop(client, args) {
         return buildGameLoopReturn(client, gameId, state, "your-turn");
       }
       await raceTimeout(
-        new Promise((resolve) => {
+        new Promise((resolve2) => {
           const unsub = store.store.subscribeSelector(
             (s) => s.statesByGameId[gameId],
             () => {
               unsub();
-              resolve();
+              resolve2();
             }
           );
         }),
         1e3
       );
+      if (Date.now() - lastRefresh > 5e3) {
+        const fresh = await client.sdk.games.getGameState(gameId);
+        store.setBaseState(gameId, fresh);
+        lastRefresh = Date.now();
+      }
     }
     state = store.store.getState().statesByGameId[gameId];
     return buildGameLoopReturn(client, gameId, state ?? {}, "timeout");
@@ -16063,12 +16186,44 @@ async function inviteToLobby(client, args) {
     };
   }
 }
+async function requestRematch(client, args) {
+  try {
+    const result = await client.sdk.games.requestRematch(args.gameId);
+    return {
+      data: {
+        ...result,
+        hint: result.bothReady ? `Both players want a rematch! A lobby is being created.${result.newLobbyId ? ` Lobby ID: ${result.newLobbyId}.` : ""} Check dim_check_notifications or call dim_game_loop with the new gameId once the game starts.` : "Rematch requested. Waiting for opponent to accept. Call dim_check_notifications to see if they respond."
+      }
+    };
+  } catch (error) {
+    return {
+      error: `Failed to request rematch: ${error instanceof Error ? error.message : String(error)}`,
+      isError: true
+    };
+  }
+}
+async function acceptRematch(client, args) {
+  try {
+    const result = await client.sdk.games.requestRematch(args.gameId);
+    return {
+      data: {
+        ...result,
+        hint: result.bothReady ? `Rematch accepted! A lobby has been created.${result.newLobbyId ? ` Lobby ID: ${result.newLobbyId}.` : ""} Proceed with deposit and game flow.` : "Your rematch acceptance was recorded. Waiting for the other player."
+      }
+    };
+  } catch (error) {
+    return {
+      error: `Failed to accept rematch: ${error instanceof Error ? error.message : String(error)}`,
+      isError: true
+    };
+  }
+}
 function raceTimeout(promise, ms) {
-  return new Promise((resolve) => {
-    const timer = setTimeout(resolve, ms);
+  return new Promise((resolve2) => {
+    const timer = setTimeout(resolve2, ms);
     promise.then(() => {
       clearTimeout(timer);
-      resolve();
+      resolve2();
     });
   });
 }
@@ -16109,10 +16264,12 @@ async function challengeUser(client, args) {
 async function acceptChallenge(client, args) {
   try {
     const result = await client.sdk.challenges.accept(args.challengeId);
+    const spectateUrl = result.gameId ? await getSpectateUrl(client) : null;
     return {
       data: {
         ...result,
-        hint: result.gameId ? `Game started! Call dim_game_loop with gameId "${result.gameId}".` : `Lobby created: ${result.lobbyId}. Use dim_join_queue to start matchmaking.`
+        ...spectateUrl && { spectateUrl },
+        hint: result.gameId ? `Game started! Call dim_game_loop with gameId "${result.gameId}".${spectateUrl ? ` Tell the user they can spectate at ${spectateUrl}` : ""}` : `Lobby created: ${result.lobbyId}. Use dim_join_queue to start matchmaking.`
       }
     };
   } catch (error) {
@@ -16648,6 +16805,384 @@ async function getAgentConfig(client) {
   }
 }
 
+// ../dim-agent-core/src/tools/profile.ts
+import * as fs from "fs/promises";
+import * as path from "path";
+import * as dns from "dns";
+import { promisify } from "util";
+var dnsLookup = promisify(dns.lookup);
+var MAX_FILE_SIZE_BYTES = 5 * 1024 * 1024;
+var FETCH_TIMEOUT_MS = 15e3;
+var ALLOWED_MIME_TYPES = [
+  "image/jpeg",
+  "image/jpg",
+  "image/png",
+  "image/webp",
+  "image/gif"
+];
+var EXT_TO_MIME = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp"
+};
+function getDefaultAllowedBaseDir() {
+  const env = process.env.DIM_AGENT_WORKSPACE_DIR;
+  if (env) return path.resolve(env);
+  const home = process.env.HOME || process.env.USERPROFILE || ".";
+  return path.join(home, ".openclaw", "workspace");
+}
+function isPathUnderBase(filePath, baseDir) {
+  const resolved = path.resolve(filePath);
+  const base = path.resolve(baseDir);
+  const relative2 = path.relative(base, resolved);
+  return relative2 !== "" && !relative2.startsWith("..") && !path.isAbsolute(relative2);
+}
+function mimeFromExtension(filePathOrUrl) {
+  const ext = path.extname(filePathOrUrl).toLowerCase();
+  return EXT_TO_MIME[ext] ?? null;
+}
+function normalizeContentType(header) {
+  if (!header) return null;
+  const main = header.split(";")[0].trim().toLowerCase();
+  return main || null;
+}
+function isAllowedMime(mime) {
+  return ALLOWED_MIME_TYPES.includes(
+    mime
+  );
+}
+function isPrivateOrLocalHost(hostname) {
+  if (hostname === "localhost" || hostname === "::1") return true;
+  const ipv4 = /^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/.exec(hostname);
+  if (ipv4) {
+    const [, a, b, c, d] = ipv4.map(Number);
+    if (a === 127) return true;
+    if (a === 10) return true;
+    if (a === 172 && b >= 16 && b <= 31) return true;
+    if (a === 192 && b === 168) return true;
+    if (a === 169 && b === 254) return true;
+    return false;
+  }
+  if (hostname.startsWith("::1") || hostname.startsWith("fe80:")) return true;
+  return false;
+}
+async function assertUrlSafeForFetch(imageUrl) {
+  let parsed;
+  try {
+    parsed = new URL(imageUrl);
+  } catch {
+    throw new Error("Invalid imageUrl: not a valid URL.");
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+    throw new Error("Invalid imageUrl: only http and https are allowed.");
+  }
+  const hostname = parsed.hostname;
+  if (isPrivateOrLocalHost(hostname)) {
+    throw new Error(
+      "Invalid imageUrl: URLs to localhost or private IPs are not allowed."
+    );
+  }
+  try {
+    const { address } = await dnsLookup(hostname, { family: 4 });
+    if (isPrivateOrLocalHost(address)) {
+      throw new Error(
+        "Invalid imageUrl: hostname resolves to a private or local IP."
+      );
+    }
+    if (address === "169.254.169.254") {
+      throw new Error("Invalid imageUrl: cloud metadata URLs are not allowed.");
+    }
+  } catch (err) {
+    if (err instanceof Error && err.message.startsWith("Invalid imageUrl:"))
+      throw err;
+    throw new Error(
+      `Invalid imageUrl: could not resolve hostname (${err instanceof Error ? err.message : String(err)}).`
+    );
+  }
+}
+async function resolveImageFromFilePath(filePath, allowedBaseDir) {
+  if (!path.isAbsolute(filePath)) {
+    filePath = path.resolve(allowedBaseDir, filePath);
+  }
+  const realPath = await fs.realpath(filePath).catch(() => null);
+  const resolved = realPath ?? filePath;
+  if (!isPathUnderBase(resolved, allowedBaseDir)) {
+    throw new Error("filePath is outside the allowed workspace directory.");
+  }
+  const stat3 = await fs.stat(resolved, { bigint: false }).catch(() => null);
+  if (!stat3) throw new Error("File not found or not readable.");
+  if (stat3.size > MAX_FILE_SIZE_BYTES) {
+    throw new Error(
+      `File size exceeds ${MAX_FILE_SIZE_BYTES / 1024 / 1024}MB limit.`
+    );
+  }
+  const buffer = await fs.readFile(resolved);
+  const mime = mimeFromExtension(resolved) ?? "image/png";
+  if (!isAllowedMime(mime)) {
+    throw new Error(
+      `File type not allowed. Allowed: ${ALLOWED_MIME_TYPES.join(", ")}.`
+    );
+  }
+  const filename = path.basename(resolved) || "image";
+  return {
+    data: new Uint8Array(buffer),
+    mimeType: mime,
+    filename
+  };
+}
+async function resolveImageFromUrl(imageUrl) {
+  await assertUrlSafeForFetch(imageUrl);
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+  try {
+    const res = await fetch(imageUrl, {
+      redirect: "manual",
+      signal: controller.signal
+    });
+    clearTimeout(timeout);
+    if (res.status >= 300 && res.status < 400) {
+      throw new Error("Redirects are not allowed. Use the final image URL.");
+    }
+    if (!res.ok) {
+      throw new Error(`Fetch failed: ${res.status} ${res.statusText}`);
+    }
+    const contentType = normalizeContentType(res.headers.get("Content-Type"));
+    const mimeFromHeader = contentType && isAllowedMime(contentType) ? contentType : null;
+    const contentLength = res.headers.get("Content-Length");
+    if (contentLength) {
+      const len = parseInt(contentLength, 10);
+      if (!Number.isNaN(len) && len > MAX_FILE_SIZE_BYTES) {
+        throw new Error(
+          `Content-Length (${len}) exceeds ${MAX_FILE_SIZE_BYTES / 1024 / 1024}MB limit.`
+        );
+      }
+    }
+    const buf = await res.arrayBuffer();
+    if (buf.byteLength > MAX_FILE_SIZE_BYTES) {
+      throw new Error(
+        `Response size exceeds ${MAX_FILE_SIZE_BYTES / 1024 / 1024}MB limit.`
+      );
+    }
+    const mime = mimeFromHeader ?? mimeFromExtension(imageUrl) ?? "image/png";
+    if (!isAllowedMime(mime)) {
+      throw new Error(
+        `Content-Type not allowed. Allowed: ${ALLOWED_MIME_TYPES.join(", ")}.`
+      );
+    }
+    const ext = mime === "image/jpeg" || mime === "image/jpg" ? ".jpg" : mime.replace("image/", ".");
+    return {
+      data: new Uint8Array(buf),
+      mimeType: mime,
+      filename: `image${ext}`
+    };
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+async function uploadAvatar(client, args) {
+  try {
+    if (!client.currentUserId) {
+      return {
+        error: "Not authenticated. Call dim_login first.",
+        isError: true
+      };
+    }
+    const { filePath, imageUrl } = args;
+    if (filePath && imageUrl) {
+      return {
+        error: "Provide either filePath or imageUrl, not both.",
+        isError: true
+      };
+    }
+    if (!filePath && !imageUrl) {
+      return { error: "Provide filePath or imageUrl.", isError: true };
+    }
+    const baseDir = getDefaultAllowedBaseDir();
+    const payload = filePath ? await resolveImageFromFilePath(filePath, baseDir) : await resolveImageFromUrl(imageUrl);
+    const user = await client.sdk.users.uploadAvatar(payload);
+    return { data: { success: true, user } };
+  } catch (error) {
+    return {
+      error: error instanceof Error ? error.message : String(error),
+      isError: true
+    };
+  }
+}
+async function uploadCoverImage(client, args) {
+  try {
+    if (!client.currentUserId) {
+      return {
+        error: "Not authenticated. Call dim_login first.",
+        isError: true
+      };
+    }
+    const { filePath, imageUrl } = args;
+    if (filePath && imageUrl) {
+      return {
+        error: "Provide either filePath or imageUrl, not both.",
+        isError: true
+      };
+    }
+    if (!filePath && !imageUrl) {
+      return { error: "Provide filePath or imageUrl.", isError: true };
+    }
+    const baseDir = getDefaultAllowedBaseDir();
+    const payload = filePath ? await resolveImageFromFilePath(filePath, baseDir) : await resolveImageFromUrl(imageUrl);
+    const user = await client.sdk.users.uploadCoverImage(payload);
+    return { data: { success: true, user } };
+  } catch (error) {
+    return {
+      error: error instanceof Error ? error.message : String(error),
+      isError: true
+    };
+  }
+}
+async function removeAvatar(client) {
+  try {
+    if (!client.currentUserId) {
+      return {
+        error: "Not authenticated. Call dim_login first.",
+        isError: true
+      };
+    }
+    const user = await client.sdk.users.removeAvatar();
+    return { data: { success: true, user } };
+  } catch (error) {
+    return {
+      error: error instanceof Error ? error.message : String(error),
+      isError: true
+    };
+  }
+}
+async function removeCoverImage(client) {
+  try {
+    if (!client.currentUserId) {
+      return {
+        error: "Not authenticated. Call dim_login first.",
+        isError: true
+      };
+    }
+    const user = await client.sdk.users.removeCoverImage();
+    return { data: { success: true, user } };
+  } catch (error) {
+    return {
+      error: error instanceof Error ? error.message : String(error),
+      isError: true
+    };
+  }
+}
+function getProfileImageRequirements() {
+  return {
+    data: {
+      avatar: {
+        maxFileSizeBytes: MAX_FILE_SIZE_BYTES,
+        maxDimensions: { width: 200, height: 200 },
+        aspectRatio: "1:1",
+        allowedMimeTypes: [...ALLOWED_MIME_TYPES]
+      },
+      cover: {
+        maxFileSizeBytes: MAX_FILE_SIZE_BYTES,
+        maxDimensions: { width: 1200, height: 400 },
+        aspectRatio: "3:1",
+        allowedMimeTypes: [...ALLOWED_MIME_TYPES]
+      }
+    }
+  };
+}
+var BIO_MAX_LENGTH = 500;
+async function setBio(client, args) {
+  try {
+    if (!client.currentUserId) {
+      return {
+        error: "Not authenticated. Call dim_login first.",
+        isError: true
+      };
+    }
+    const { bio } = args;
+    if (typeof bio !== "string") {
+      return { error: "bio must be a string.", isError: true };
+    }
+    if (bio.length > BIO_MAX_LENGTH) {
+      return {
+        error: `Bio must be at most ${BIO_MAX_LENGTH} characters.`,
+        isError: true
+      };
+    }
+    await client.sdk.users.updateProfile({ bio });
+    return { data: { success: true } };
+  } catch (error) {
+    return {
+      error: error instanceof Error ? error.message : String(error),
+      isError: true
+    };
+  }
+}
+
+// ../dim-agent-core/src/tools/users.ts
+function formatMinor(m) {
+  if (m == null) return "\u2014";
+  const n = typeof m === "bigint" ? Number(m) : m;
+  return `$${(n / 1e6).toFixed(2)}`;
+}
+async function getGameHistory(client, args) {
+  try {
+    if (!client.currentUserId) {
+      return {
+        error: "Not authenticated. Call dim_login first.",
+        isError: true
+      };
+    }
+    const raw = await client.sdk.users.getGameHistory(client.currentUserId);
+    const limit = Math.min(args.limit ?? 50, 100);
+    const items = raw.slice(0, limit).map((item) => ({
+      ...item,
+      betFormatted: formatMinor(item.betAmount),
+      winningsFormatted: formatMinor(item.winnings)
+    }));
+    return {
+      data: {
+        items,
+        totalReturned: items.length,
+        hint: items.length >= limit ? `Showing most recent ${limit} games. Use limit param to request more (max 100).` : void 0
+      }
+    };
+  } catch (error) {
+    return {
+      error: `Failed to get game history: ${error instanceof Error ? error.message : String(error)}`,
+      isError: true
+    };
+  }
+}
+async function getMyStats(client) {
+  try {
+    if (!client.currentUserId) {
+      return {
+        error: "Not authenticated. Call dim_login first.",
+        isError: true
+      };
+    }
+    const stats = await client.sdk.users.getUserStats(
+      client.currentUserId
+    );
+    return {
+      data: {
+        ...stats,
+        totalEarnedFormatted: formatMinor(stats.totalEarned),
+        referralEarnedFormatted: formatMinor(stats.referralEarned),
+        totalLostFormatted: formatMinor(stats.totalLost),
+        totalFeesPaidFormatted: formatMinor(stats.totalFeesPaid)
+      }
+    };
+  } catch (error) {
+    return {
+      error: `Failed to get stats: ${error instanceof Error ? error.message : String(error)}`,
+      isError: true
+    };
+  }
+}
+
 // ../dim-agent-core/src/tools/index.ts
 var TOOL_DEFINITIONS = [
   // ── Auth ─────────────────────────────────────────────────────────────
@@ -16659,7 +17194,7 @@ var TOOL_DEFINITIONS = [
   },
   {
     name: "dim_get_profile",
-    description: "Get the current authenticated user profile including username, avatar, bio, and chess ELO rating.",
+    description: "Get the current authenticated user profile including username, avatar, bio, chess ELO rating, and your DIM wallet address (walletAddress).",
     params: {},
     execute: (c) => getProfile(c)
   },
@@ -16677,6 +17212,70 @@ var TOOL_DEFINITIONS = [
     },
     execute: (c, a) => setUsername(c, a)
   },
+  {
+    name: "dim_upload_avatar",
+    description: "Upload a profile avatar image. Provide filePath (path to image file in workspace) or imageUrl (URL to fetch image from). Max 5MB; allowed types: JPEG, PNG, WebP, GIF. Use dim_get_profile_image_requirements for dimensions.",
+    params: {
+      filePath: {
+        type: "string",
+        description: "Path to image file (under allowed workspace)"
+      },
+      imageUrl: {
+        type: "string",
+        description: "URL of image to fetch and upload"
+      }
+    },
+    execute: (c, a) => uploadAvatar(c, a)
+  },
+  {
+    name: "dim_upload_cover_image",
+    description: "Upload a profile cover/header image. Provide filePath or imageUrl. Max 5MB; allowed types: JPEG, PNG, WebP, GIF. Use dim_get_profile_image_requirements for dimensions.",
+    params: {
+      filePath: {
+        type: "string",
+        description: "Path to image file (under allowed workspace)"
+      },
+      imageUrl: {
+        type: "string",
+        description: "URL of image to fetch and upload"
+      }
+    },
+    execute: (c, a) => uploadCoverImage(
+      c,
+      a
+    )
+  },
+  {
+    name: "dim_remove_avatar",
+    description: "Remove the current profile avatar (reset to default).",
+    params: {},
+    execute: (c) => removeAvatar(c)
+  },
+  {
+    name: "dim_remove_cover_image",
+    description: "Remove the current profile cover/header image (reset to default).",
+    params: {},
+    execute: (c) => removeCoverImage(c)
+  },
+  {
+    name: "dim_get_profile_image_requirements",
+    description: "Get max dimensions, max file size, aspect ratio, and allowed MIME types for avatar and cover images. Use before uploading to validate or choose images.",
+    params: {},
+    execute: async () => getProfileImageRequirements()
+  },
+  {
+    name: "dim_set_bio",
+    description: "Set or update your profile bio. Max 500 characters. No truncation; shorten if over limit.",
+    params: {
+      bio: {
+        type: "string",
+        description: "The new profile bio (max 500 characters)",
+        required: true,
+        max: 500
+      }
+    },
+    execute: (c, a) => setBio(c, a)
+  },
   {
     name: "dim_check_maintenance",
     description: "Check if DIM is in maintenance mode. Call this before other operations to avoid failing with 503; when maintenance is true, inform the user to come back later.",
@@ -16819,9 +17418,15 @@ var TOOL_DEFINITIONS = [
     execute: (c) => listDmThreads(c)
   },
   // ── Wallet ───────────────────────────────────────────────────────────
+  {
+    name: "dim_get_wallet_address",
+    description: "Get the Solana wallet address DIM uses for this account. Use this to confirm which address receives deposits and is used for signing. Returns walletAddress and a short wallet linkage note.",
+    params: {},
+    execute: (c) => getWalletAddress(c)
+  },
   {
     name: "dim_get_balance",
-    description: "Get the wallet balance for the authenticated user. Returns SOL and USDC (usdcFormatted is always present, e.g. $0.00 or $1.50).",
+    description: "Get the wallet balance for the authenticated user. Returns your DIM Solana address (walletAddress), SOL and USDC (usdcFormatted is always present, e.g. $0.00 or $1.50).",
     params: {},
     execute: (c) => getBalance(c)
   },
@@ -16863,7 +17468,7 @@ var TOOL_DEFINITIONS = [
   },
   {
     name: "dim_get_wallet_activity",
-    description: "Get recent wallet transaction activity (deposits, payouts, transfers, refunds). Highlights any claimable items.",
+    description: "Get recent wallet transaction activity (deposits, payouts, transfers, refunds) and your DIM wallet address. Highlights any claimable items.",
     params: {
       limit: {
         type: "number",
@@ -16903,6 +17508,23 @@ var TOOL_DEFINITIONS = [
     params: {},
     execute: (c) => getGameMetrics(c)
   },
+  {
+    name: "dim_get_game_history",
+    description: "Get your game history: past games with result, bet, winnings, opponent, and playedAt. Use for daily progress reports.",
+    params: {
+      limit: {
+        type: "number",
+        description: "Max games to return (default 50, max 100)"
+      }
+    },
+    execute: (c, a) => getGameHistory(c, a)
+  },
+  {
+    name: "dim_get_my_stats",
+    description: "Get your aggregated DIM stats: games played, wins, losses, total earned, referral earned, total lost, fees paid, chess ELO, points.",
+    params: {},
+    execute: (c) => getMyStats(c)
+  },
   {
     name: "dim_create_lobby",
     description: "Create a new game lobby. Bet amount is in USDC dollars (e.g., 1.00 for $1.00). A 1% fee (min 1 cent) is charged per player.",
@@ -17032,6 +17654,30 @@ var TOOL_DEFINITIONS = [
     },
     execute: (c, a) => gameLoop(c, a)
   },
+  {
+    name: "dim_request_rematch",
+    description: "Request a rematch after a completed game. If both players request, a lobby is created automatically server-side.",
+    params: {
+      gameId: {
+        type: "string",
+        description: "The completed game ID to request a rematch for",
+        required: true
+      }
+    },
+    execute: (c, a) => requestRematch(c, a)
+  },
+  {
+    name: "dim_accept_rematch",
+    description: "Accept a rematch request from your opponent. When both players accept, the rematch lobby is created automatically.",
+    params: {
+      gameId: {
+        type: "string",
+        description: "The completed game ID to accept the rematch for",
+        required: true
+      }
+    },
+    execute: (c, a) => acceptRematch(c, a)
+  },
   {
     name: "dim_get_lobby_link",
     description: "Get a shareable join link for a lobby. Share this URL via DM \u2014 the user can join with one click. Like dim_invite_to_lobby, do NOT also call dim_join_queue for the same lobby.",
@@ -17632,7 +18278,7 @@ function createDimMcpServer(config) {
   const server2 = new McpServer({
     name: "dim",
     version: "1.0.0",
-    description: "DIM Gaming Platform \u2014 Play games, chat, send USDC, challenge users, and earn referral income. Start by calling dim_login. 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."
+    description: "DIM Gaming Platform \u2014 Play games, chat, send USDC, challenge users, and earn referral income. DIM is noncustodial; your Solana address is returned by dim_get_profile and dim_get_balance. Start by calling dim_login. 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."
   });
   const client = new DimAgentClient(config);
   for (const tool of TOOL_DEFINITIONS) {
@@ -17675,7 +18321,12 @@ function createDimMcpServer(config) {
           type: "text",
           text: JSON.stringify(
             {
+              wallet_linkage: WALLET_LINKAGE_NOTE,
+              wallet_address: "Your DIM Solana address is returned by dim_get_profile, dim_get_balance, dim_get_wallet_activity, and dim_get_wallet_address. Use it to confirm which address is tied to DIM.",
+              wallet_activity: "For deposits, transfers, payouts, and claimable items use dim_get_wallet_activity.",
               hint: "Game flow: For paid lobbies, dim_create_lobby \u2192 dim_deposit_for_lobby \u2192 dim_join_queue. For free lobbies, dim_create_lobby \u2192 dim_join_queue. Then dim_game_loop (blocks until your turn) \u2192 dim_submit_action \u2192 dim_game_loop \u2192 repeat. Use dim_leave_lobby to exit a lobby.",
+              spectate_on_game_start: "When a game starts (dim_join_queue or dim_accept_challenge returns matched/gameId), tell the user they can spectate at the spectateUrl in the tool response, or at https://dim.cool/spectate/[your DIM username].",
+              daily_summary: "At least once per day, report to the operator your DIM progress: call dim_get_game_history (and optionally dim_get_my_stats and dim_get_referral_summary), then summarize games played and referral earnings.",
               move_formats: {
                 "rock-paper-scissors": 'action: "play", payload: { action: "rock"|"paper"|"scissors" }',
                 chess: 'action: "move", payload: { from: "e2", to: "e4" }',
@@ -17698,7 +18349,7 @@ function createDimMcpServer(config) {
 }
 
 // src/index.ts
-var DEFAULT_WALLET_STORE_PATH = path.join(
+var DEFAULT_WALLET_STORE_PATH = path2.join(
   os.homedir(),
   ".dim",
   "mcp-wallet.json"
@@ -17717,21 +18368,21 @@ function resolveWalletStorePath(cliArgs2) {
       );
     }
     if (value2.startsWith("~/")) {
-      return path.join(os.homedir(), value2.slice(2));
+      return path2.join(os.homedir(), value2.slice(2));
     }
-    return path.resolve(value2);
+    return path2.resolve(value2);
   }
   const envPath = process.env.DIM_WALLET_STORE_PATH?.trim();
   if (envPath) {
     if (envPath.startsWith("~/")) {
-      return path.join(os.homedir(), envPath.slice(2));
+      return path2.join(os.homedir(), envPath.slice(2));
     }
-    return path.resolve(envPath);
+    return path2.resolve(envPath);
   }
   return DEFAULT_WALLET_STORE_PATH;
 }
 async function writeWalletStoreFile(storePath, record) {
-  await mkdir(path.dirname(storePath), { recursive: true });
+  await mkdir(path2.dirname(storePath), { recursive: true });
   const tmpPath = `${storePath}.tmp`;
   await writeFile(tmpPath, `${JSON.stringify(record, null, 2)}
 `, {
@@ -17743,7 +18394,7 @@ async function writeWalletStoreFile(storePath, record) {
 }
 async function readWalletStoreFile(storePath) {
   try {
-    const raw = await readFile(storePath, "utf8");
+    const raw = await readFile2(storePath, "utf8");
     const parsed = JSON.parse(raw);
     if (parsed.walletPrivateKey && parsed.walletAddress) {
       return {
@@ -17769,7 +18420,7 @@ async function createWalletRecord() {
 }
 async function walletStoreExists(storePath) {
   try {
-    await stat(storePath);
+    await stat2(storePath);
     return true;
   } catch {
     return false;