paralith-mcp 0.1.0 → 0.3.0

package/dist/server.mjs

@@ -1,20 +1,21 @@
 #!/usr/bin/env node
-
-// src/server.mjs
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-
-// src/runtime.mjs
-import fs2 from "node:fs";
-import path2 from "node:path";
-import { fileURLToPath, pathToFileURL } from "node:url";
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 
 // ../../backend/native/ans104.mjs
 import crypto from "node:crypto";
-var enc = new TextEncoder();
-var sha384 = (b) => crypto.createHash("sha384").update(b).digest();
-var sha256 = (b) => crypto.createHash("sha256").update(b).digest();
-var b64url = (b) => Buffer.from(b).toString("base64url");
-var b64urlDec = (s) => Buffer.from(s, "base64url");
 function deepHash(value) {
   if (Array.isArray(value)) {
     const tag2 = enc.encode(`list${value.length}`);
@@ -102,7 +103,6 @@ async function signDataItem(jwk, item) {
     data
   ]);
 }
-var jwkToAddress = (jwk) => b64url(sha256(b64urlDec(jwk.n)));
 function walletShim(jwk) {
   const address = jwkToAddress(jwk);
   return {
@@ -122,6 +122,18 @@ function walletShim(jwk) {
     }
   };
 }
+var enc, sha384, sha256, b64url, b64urlDec, jwkToAddress;
+var init_ans104 = __esm({
+  "../../backend/native/ans104.mjs"() {
+    "use strict";
+    enc = new TextEncoder();
+    sha384 = (b) => crypto.createHash("sha384").update(b).digest();
+    sha256 = (b) => crypto.createHash("sha256").update(b).digest();
+    b64url = (b) => Buffer.from(b).toString("base64url");
+    b64urlDec = (s) => Buffer.from(s, "base64url");
+    jwkToAddress = (jwk) => b64url(sha256(b64urlDec(jwk.n)));
+  }
+});
 
 // src/keys.mjs
 import crypto2 from "node:crypto";
@@ -134,7 +146,6 @@ import { mnemonicToAccount } from "viem/accounts";
 import { Keypair } from "@solana/web3.js";
 import { Ed25519Keypair } from "@mysten/sui/keypairs/ed25519";
 import { getKeyFromMnemonic } from "arweave-mnemonic-keys";
-var CACHE_DIR = process.env.PARALITH_MCP_HOME || path.join(os.homedir(), ".paralith", "mcp");
 function readPhrase(env = process.env) {
   const raw = env.PARALITH_MNEMONIC ?? (env.PARALITH_MNEMONIC_FILE ? fs.readFileSync(env.PARALITH_MNEMONIC_FILE, "utf8") : null);
   if (!raw) {
@@ -161,60 +172,260 @@ function slip10(seed, derivation) {
 async function aoJwk(phrase, env) {
   if (env.PARALITH_AO_JWK) return JSON.parse(fs.readFileSync(env.PARALITH_AO_JWK, "utf8"));
   const id = crypto2.createHash("sha256").update(phrase).digest("hex").slice(0, 24);
-  const file = path.join(CACHE_DIR, `ao-${id}.json`);
+  const file = path.join(HOME, `ao-${id}.json`);
   if (fs.existsSync(file)) return JSON.parse(fs.readFileSync(file, "utf8"));
   const jwk = await getKeyFromMnemonic(phrase);
-  fs.mkdirSync(CACHE_DIR, { recursive: true, mode: 448 });
+  fs.mkdirSync(HOME, { recursive: true, mode: 448 });
   fs.writeFileSync(file, JSON.stringify(jwk), { mode: 384 });
   return jwk;
 }
-async function deriveWallets(phrase, env = process.env) {
+function chainWallets(phrase) {
   const evm = mnemonicToAccount(phrase, { path: "m/44'/60'/0'/0/0" });
   const solana = Keypair.fromSeed(slip10(mnemonicToSeedSync(phrase), "m/44'/501'/0'/0'"));
   const sui = Ed25519Keypair.deriveKeypair(phrase, "m/44'/784'/0'/0'/0'");
-  const jwk = await aoJwk(phrase, env);
   return {
-    ao: { jwk, address: jwkToAddress(jwk) },
     base: { account: evm, address: evm.address },
     solana: { keypair: solana, address: solana.publicKey.toBase58() },
     sui: { keypair: sui, address: sui.getPublicKey().toSuiAddress() }
   };
 }
-var publicAddresses = (w) => ({
-  ao: w.ao.address,
-  base: w.base.address,
-  solana: w.solana.address,
-  sui: w.sui.address
+async function deriveWallets(phrase, env = process.env) {
+  const jwk = await aoJwk(phrase, env);
+  return { ao: { jwk, address: jwkToAddress(jwk) }, ...chainWallets(phrase) };
+}
+var HOME, publicAddresses;
+var init_keys = __esm({
+  "src/keys.mjs"() {
+    "use strict";
+    init_ans104();
+    HOME = process.env.PARALITH_MCP_HOME || path.join(os.homedir(), ".paralith", "mcp");
+    publicAddresses = (w) => ({
+      ao: w.ao.address,
+      base: w.base.address,
+      solana: w.solana.address,
+      sui: w.sui.address
+    });
+  }
+});
+
+// src/agents.mjs
+import fs2 from "node:fs";
+import path2 from "node:path";
+function readAgents() {
+  try {
+    return JSON.parse(fs2.readFileSync(FILE, "utf8"));
+  } catch {
+    return {};
+  }
+}
+function saveAgent(name, entry) {
+  const all = readAgents();
+  all[name] = { ...all[name], ...entry, addresses: { ...all[name]?.addresses, ...entry.addresses } };
+  fs2.mkdirSync(HOME, { recursive: true, mode: 448 });
+  fs2.writeFileSync(FILE, `${JSON.stringify(all, null, 2)}
+`);
+  return all[name];
+}
+var FILE;
+var init_agents = __esm({
+  "src/agents.mjs"() {
+    "use strict";
+    init_keys();
+    FILE = path2.join(HOME, "agents.json");
+  }
+});
+
+// src/setup.mjs
+var setup_exports = {};
+__export(setup_exports, {
+  setup: () => setup,
+  upsertToml: () => upsertToml
+});
+import fs3 from "node:fs";
+import os2 from "node:os";
+import path3 from "node:path";
+import { spawnSync } from "node:child_process";
+import { generateMnemonic } from "@scure/bip39";
+import { wordlist as wordlist2 } from "@scure/bip39/wordlists/english.js";
+function run(cli, args) {
+  const r = WIN ? spawnSync([cli, ...args].map((a) => /[\s"&|<>^]/.test(a) ? `"${a}"` : a).join(" "), { shell: true, encoding: "utf8" }) : spawnSync(cli, args, { encoding: "utf8" });
+  return { ok: r.status === 0, out: `${r.stdout ?? ""}${r.stderr ?? ""}`.trim() };
+}
+function desktopConfig() {
+  const dir = WIN ? path3.join(process.env.APPDATA ?? path3.join(os2.homedir(), "AppData", "Roaming"), "Claude") : process.platform === "darwin" ? path3.join(os2.homedir(), "Library", "Application Support", "Claude") : path3.join(os2.homedir(), ".config", "Claude");
+  return path3.join(dir, "claude_desktop_config.json");
+}
+function upsertToml(text, env) {
+  const kept = [];
+  let skipping = false;
+  for (const line of text.split(/\r?\n/)) {
+    const header = /^\s*\[/.test(line);
+    if (header) skipping = /^\s*\[\s*mcp_servers\.(paralith|"paralith")\s*[\].]/.test(line);
+    if (!skipping) kept.push(line);
+  }
+  const s = JSON.stringify;
+  const block = [
+    "[mcp_servers.paralith]",
+    `command = ${s(LAUNCH.command)}`,
+    `args = [${LAUNCH.args.map(s).join(", ")}]`,
+    "startup_timeout_sec = 120",
+    // first run downloads the package
+    "tool_timeout_sec = 1200",
+    // a bridge deposit waits for the relayer
+    "",
+    "[mcp_servers.paralith.env]",
+    ...Object.entries(env).map(([k, v]) => `${k} = ${s(v)}`)
+  ];
+  const body = kept.join("\n").replace(/\s+$/, "");
+  return `${body ? `${body}
+
+` : ""}${block.join("\n")}
+`;
+}
+function writeToml(file, env) {
+  fs3.mkdirSync(path3.dirname(file), { recursive: true });
+  fs3.writeFileSync(file, upsertToml(fs3.existsSync(file) ? fs3.readFileSync(file, "utf8") : "", env));
+}
+function phraseFile(agent) {
+  const file = path3.join(HOME, "agents", `${agent}.txt`);
+  if (!fs3.existsSync(file)) {
+    fs3.mkdirSync(path3.dirname(file), { recursive: true, mode: 448 });
+    fs3.writeFileSync(file, `${generateMnemonic(wordlist2, 256)}
+`, { mode: 384 });
+  }
+  return file;
+}
+async function setup(argv) {
+  const only = argv.find((a) => a.startsWith("--only"))?.split("=")[1]?.split(",") ?? (argv.includes("--only") ? argv[argv.indexOf("--only") + 1]?.split(",") : null);
+  const unknown = (only ?? []).filter((c) => !CLIENTS[c]);
+  if (unknown.length) throw new Error(`Unknown app: ${unknown.join(", ")}. Choose from ${Object.keys(CLIENTS).join(", ")}.`);
+  const done = [];
+  for (const [id, client] of Object.entries(CLIENTS)) {
+    if (only ? !only.includes(id) : !client.found()) continue;
+    const file = phraseFile(client.wallet);
+    const chain = chainWallets(readPhrase({ PARALITH_MNEMONIC_FILE: file }));
+    saveAgent(client.wallet, {
+      phraseFile: slash(file),
+      addresses: { base: chain.base.address, solana: chain.solana.address, sui: chain.sui.address }
+    });
+    try {
+      client.connect({ PARALITH_MNEMONIC_FILE: slash(file), PARALITH_AGENT: client.wallet });
+      done.push(client.label);
+      console.log(`\u2713 ${client.label} connected (wallet: ${client.wallet})`);
+    } catch (error) {
+      console.log(`\u2717 ${client.label}: ${error.message.split("\n")[0]}`);
+    }
+  }
+  if (!done.length) {
+    console.log("No agent app found. Install Claude Code, Claude Desktop, Codex or Grok, or name one with --only.");
+    return;
+  }
+  const agents = readAgents();
+  console.log("\nFund these to bridge (gas only; playing and trading need nothing):");
+  for (const name of new Set(Object.values(CLIENTS).filter((c) => done.includes(c.label)).map((c) => c.wallet))) {
+    const a = agents[name].addresses;
+    console.log(`
+  ${name}
+    Base (ETH)   ${a.base}
+    Solana (SOL) ${a.solana}
+    Sui (SUI)    ${a.sui}`);
+  }
+  console.log(`
+Phrases: ${slash(path3.join(HOME, "agents"))} (back them up; anything funded is spendable by the agent).`);
+  console.log(`Restart ${done.join(", ")}, then say: "Play Rune Realm and show me." Ask any of them "how are my agents doing?"`);
+}
+var WIN, NPX, LAUNCH, slash, installed, CLIENTS;
+var init_setup = __esm({
+  "src/setup.mjs"() {
+    "use strict";
+    init_keys();
+    init_agents();
+    WIN = process.platform === "win32";
+    NPX = ["npx", "-y", "paralith-mcp@latest"];
+    LAUNCH = WIN ? { command: "cmd", args: ["/c", ...NPX] } : { command: NPX[0], args: NPX.slice(1) };
+    slash = (p) => p.replace(/\\/g, "/");
+    installed = (cli) => run(cli, ["--version"]).ok;
+    CLIENTS = {
+      claude: {
+        label: "Claude Code",
+        wallet: "claude",
+        found: () => installed("claude"),
+        connect(env) {
+          run("claude", ["mcp", "remove", "paralith", "--scope", "user"]);
+          const r = run("claude", [
+            "mcp",
+            "add",
+            "paralith",
+            "--scope",
+            "user",
+            ...Object.entries(env).flatMap(([k, v]) => ["-e", `${k}=${v}`]),
+            "--",
+            LAUNCH.command,
+            ...LAUNCH.args
+          ]);
+          if (!r.ok) throw new Error(r.out);
+        }
+      },
+      "claude-desktop": {
+        label: "Claude Desktop",
+        wallet: "claude",
+        found: () => fs3.existsSync(path3.dirname(desktopConfig())),
+        connect(env) {
+          const file = desktopConfig();
+          const config = fs3.existsSync(file) ? JSON.parse(fs3.readFileSync(file, "utf8")) : {};
+          config.mcpServers = { ...config.mcpServers, paralith: { ...LAUNCH, env } };
+          fs3.writeFileSync(file, `${JSON.stringify(config, null, 2)}
+`);
+        }
+      },
+      codex: {
+        label: "Codex",
+        wallet: "codex",
+        found: () => installed("codex") || fs3.existsSync(path3.join(os2.homedir(), ".codex")),
+        connect: (env) => writeToml(path3.join(os2.homedir(), ".codex", "config.toml"), env)
+      },
+      grok: {
+        label: "Grok",
+        wallet: "grok",
+        found: () => installed("grok") || fs3.existsSync(path3.join(os2.homedir(), ".grok")),
+        connect: (env) => writeToml(path3.join(os2.homedir(), ".grok", "config.toml"), env)
+      }
+    };
+  }
 });
 
 // src/runtime.mjs
-var HERE = path2.dirname(fileURLToPath(import.meta.url));
-var DIST = fs2.existsSync(path2.join(HERE, "graph.json")) ? HERE : path2.join(HERE, "..", "dist");
-var graph = JSON.parse(fs2.readFileSync(path2.join(DIST, "graph.json"), "utf8"));
-var NODE = graph.node.replace(/\/$/, "");
-var chains = JSON.parse(fs2.readFileSync(path2.join(DIST, "chains.json"), "utf8"));
-var PROCESS_ALIASES = {
-  game: graph.processes.game,
-  rune: graph.processes.rune,
-  pusd: graph.processes.pusd,
-  ...graph.processes.dao ? { dao: graph.processes.dao } : {},
-  "game-venue": graph.processes.internalVenue,
-  "token-venue": graph.processes.externalVenue,
-  ...Object.fromEntries(Object.entries(graph.processes.elements ?? {}).map(([k, v]) => [`${k}-token`, v]))
-};
-var ID = /^[A-Za-z0-9_-]{43}$/;
+var runtime_exports = {};
+__export(runtime_exports, {
+  ID: () => ID,
+  NODE: () => NODE,
+  PROCESS_ALIASES: () => PROCESS_ALIASES,
+  READ_ONLY: () => READ_ONLY,
+  chains: () => chains,
+  formatAtoms: () => formatAtoms,
+  graph: () => graph,
+  parseAmount: () => parseAmount,
+  processId: () => processId,
+  readAtoms: () => readAtoms,
+  readKey: () => readKey,
+  runtime: () => runtime,
+  sleep: () => sleep,
+  until: () => until
+});
+import fs4 from "node:fs";
+import path4 from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
 function processId(nameOrId) {
   if (ID.test(nameOrId)) return nameOrId;
   const id = PROCESS_ALIASES[nameOrId];
   if (!id) throw new Error(`Unknown process "${nameOrId}". Use a 43-character id or one of: ${Object.keys(PROCESS_ALIASES).join(", ")}`);
   return id;
 }
-var READ_ONLY = !process.env.PARALITH_MNEMONIC && !process.env.PARALITH_MNEMONIC_FILE;
-var loaded = null;
 function runtime() {
   loaded ??= (async () => {
     const wallets = READ_ONLY ? null : await deriveWallets(readPhrase());
-    const api = await import(pathToFileURL(path2.join(DIST, "client.mjs")).href);
+    if (wallets && process.env.PARALITH_AGENT) saveAgent(process.env.PARALITH_AGENT, { addresses: publicAddresses(wallets) });
+    const api = await import(pathToFileURL(path4.join(DIST, "client.mjs")).href);
     if (wallets) api.swarmWalletSlot.wallet = walletShim(wallets.ao.jwk);
     return { api, wallets };
   })();
@@ -223,7 +434,6 @@ function runtime() {
   });
   return loaded;
 }
-var HTML = /^\s*(?:<!doctype\s+html|<html|<head|<body)/i;
 async function readKey(process2, key, node = NODE) {
   const res = await fetch(
     `${node}/${processId(process2)}~process@1.0/now/${key}`,
@@ -263,7 +473,6 @@ function parseAmount(text, decimals = 6) {
   if (atoms <= 0n) throw new Error("Amount must be positive");
   return atoms;
 }
-var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
 async function until(what, read, done, timeoutMs = 6e5, everyMs = 3e3) {
   const deadline = Date.now() + timeoutMs;
   for (; ; ) {
@@ -273,19 +482,43 @@ async function until(what, read, done, timeoutMs = 6e5, everyMs = 3e3) {
     await sleep(everyMs);
   }
 }
-
-// src/build.mjs
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { z as z7 } from "zod";
+var HERE, DIST, graph, NODE, chains, PROCESS_ALIASES, ID, READ_ONLY, loaded, HTML, sleep;
+var init_runtime = __esm({
+  "src/runtime.mjs"() {
+    "use strict";
+    init_ans104();
+    init_keys();
+    init_agents();
+    HERE = path4.dirname(fileURLToPath(import.meta.url));
+    DIST = fs4.existsSync(path4.join(HERE, "graph.json")) ? HERE : path4.join(HERE, "..", "dist");
+    graph = JSON.parse(fs4.readFileSync(path4.join(DIST, "graph.json"), "utf8"));
+    NODE = graph.node.replace(/\/$/, "");
+    chains = JSON.parse(fs4.readFileSync(path4.join(DIST, "chains.json"), "utf8"));
+    PROCESS_ALIASES = {
+      game: graph.processes.game,
+      rune: graph.processes.rune,
+      pusd: graph.processes.pusd,
+      ...graph.processes.dao ? { dao: graph.processes.dao } : {},
+      "game-venue": graph.processes.internalVenue,
+      "token-venue": graph.processes.externalVenue,
+      ...Object.fromEntries(Object.entries(graph.processes.elements ?? {}).map(([k, v]) => [`${k}-token`, v]))
+    };
+    ID = /^[A-Za-z0-9_-]{43}$/;
+    READ_ONLY = !process.env.PARALITH_MNEMONIC && !process.env.PARALITH_MNEMONIC_FILE;
+    loaded = null;
+    HTML = /^\s*(?:<!doctype\s+html|<html|<head|<body)/i;
+    sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+  }
+});
 
 // src/tool.mjs
 import { z } from "zod";
-function tool(server, name, description, inputSchema, run, annotations = {}, view = null) {
+function tool(server, name, description, inputSchema, run2, annotations = {}, view = null) {
   if (READ_ONLY && annotations !== READ) return;
   const schema = view ? { ...inputSchema, full: z.boolean().optional().describe("Return the raw record instead of the compact view.") } : inputSchema;
   server.registerTool(name, { description, inputSchema: schema, annotations }, async (args) => {
     try {
-      const raw = await run(args ?? {});
+      const raw = await run2(args ?? {});
       const value = view && !args?.full ? await view(raw) : raw;
       const text = typeof value === "string" ? value : JSON.stringify(value, bigints, 2);
       return { content: [{ type: "text", text: text ?? "null" }] };
@@ -294,7 +527,6 @@ function tool(server, name, description, inputSchema, run, annotations = {}, vie
     }
   });
 }
-var bigints = (_k, v) => typeof v === "bigint" ? v.toString() : v;
 function explain(error) {
   const name = error?.name ?? "";
   const message = error?.message ?? String(error);
@@ -305,16 +537,19 @@ The message WAS accepted (slot ${error?.slot ?? "?"}); its result could not be c
   }
   return message;
 }
-var READ = { readOnlyHint: true, openWorldHint: true };
-var OWN = { readOnlyHint: true, openWorldHint: true };
-var WRITE = { readOnlyHint: false, destructiveHint: false, openWorldHint: true };
-
-// src/game.mjs
-import { z as z2 } from "zod";
+var bigints, READ, OWN, WRITE;
+var init_tool = __esm({
+  "src/tool.mjs"() {
+    "use strict";
+    init_runtime();
+    bigints = (_k, v) => typeof v === "bigint" ? v.toString() : v;
+    READ = { readOnlyHint: true, openWorldHint: true };
+    OWN = { readOnlyHint: true, openWorldHint: true };
+    WRITE = { readOnlyHint: false, destructiveHint: false, openWorldHint: true };
+  }
+});
 
 // src/views.mjs
-var iso = (ms) => ms ? new Date(Number(ms)).toISOString() : void 0;
-var uses = (moves) => Object.fromEntries(Object.entries(moves ?? {}).map(([n, m]) => [n, m?.count ?? m]));
 function companion(m) {
   if (!m) return void 0;
   return {
@@ -332,7 +567,6 @@ function companion(m) {
     ...m.status?.until_time > Date.now() ? { busyUntil: iso(m.status.until_time) } : {}
   };
 }
-var EXTRAS = ["rewards", "lootResult", "dailyClaimed", "economyResult", "withdrawal", "arenaLast", "lastHunt", "listing", "error"];
 function player(p) {
   if (!p) return p;
   const companions = { ...p.monsters ?? {}, ...p.collection ?? {} };
@@ -401,19 +635,27 @@ function battle(b, address) {
     recentTurns: turns
   };
 }
-function hunt(run) {
-  if (!run || typeof run !== "object") return run;
-  const { battle: fight, encounter, ...rest } = run;
+function hunt(run2) {
+  if (!run2 || typeof run2 !== "object") return run2;
+  const { battle: fight, encounter, ...rest } = run2;
   return {
     ...rest,
     ...encounter ? { encounter: companion(encounter) } : {},
-    ...fight ? { battle: battle(fight, run.playerId) } : {}
+    ...fight ? { battle: battle(fight, run2.playerId) } : {}
   };
 }
+var iso, uses, EXTRAS;
+var init_views = __esm({
+  "src/views.mjs"() {
+    "use strict";
+    iso = (ms) => ms ? new Date(Number(ms)).toISOString() : void 0;
+    uses = (moves) => Object.fromEntries(Object.entries(moves ?? {}).map(([n, m]) => [n, m?.count ?? m]));
+    EXTRAS = ["rewards", "lootResult", "dailyClaimed", "economyResult", "withdrawal", "arenaLast", "lastHunt", "listing", "error"];
+  }
+});
 
 // src/game.mjs
-var FACTIONS = ["Sky Nomads", "Aqua Guardians", "Inferno Blades", "Stone Titans"];
-var BERRIES = ["air_berry", "fire_berry", "rock_berry", "water_berry"];
+import { z as z2 } from "zod";
 async function me() {
   const { api, wallets } = await runtime();
   return { api, address: wallets?.ao.address };
@@ -768,7 +1010,6 @@ function registerGame(server) {
     WRITE
   );
 }
-var asPlayer = (r) => r?.address && r?.inventory ? player(r) : r;
 async function battleView(b) {
   return b?.id ? battle(b, (await me()).address) : b;
 }
@@ -784,16 +1025,26 @@ async function attackView(p) {
     ...arenaLast ? { arenaLast } : {}
   };
 }
-var huntView = (r) => r?.runId ? hunt(r) : asPlayer(r);
 function need(value, name) {
   if (value === void 0 || value === null || value === "") throw new Error(`${name} is required for this action`);
   return value;
 }
+var FACTIONS, BERRIES, asPlayer, huntView;
+var init_game = __esm({
+  "src/game.mjs"() {
+    "use strict";
+    init_runtime();
+    init_tool();
+    init_views();
+    FACTIONS = ["Sky Nomads", "Aqua Guardians", "Inferno Blades", "Stone Titans"];
+    BERRIES = ["air_berry", "fire_berry", "rock_berry", "water_berry"];
+    asPlayer = (r) => r?.address && r?.inventory ? player(r) : r;
+    huntView = (r) => r?.runId ? hunt(r) : asPlayer(r);
+  }
+});
 
 // src/exchange.mjs
 import { z as z3 } from "zod";
-var VENUE = z3.enum(["game", "token"]).describe("game: items vs Gold. token: element tokens vs TEST-RUNE.");
-var venueProcess = (venue) => venue === "game" ? graph.processes.internalVenue : graph.processes.externalVenue;
 async function terms(venue) {
   const { api } = await runtime();
   const process2 = venueProcess(venue);
@@ -816,7 +1067,6 @@ function toWire(t, m, price, quantity) {
   if (perLot <= 0n) throw new Error("Price is below one quote atom per lot.");
   return { lots: (baseAtoms / lot).toString(), perLot: perLot.toString() };
 }
-var human = (t, free) => Object.fromEntries(Object.entries(free ?? {}).map(([asset, atoms]) => [asset, formatAtoms(atoms, t.den(asset))]));
 function registerExchange(server) {
   tool(
     server,
@@ -971,6 +1221,17 @@ function registerExchange(server) {
     WRITE
   );
 }
+var VENUE, venueProcess, human;
+var init_exchange = __esm({
+  "src/exchange.mjs"() {
+    "use strict";
+    init_runtime();
+    init_tool();
+    VENUE = z3.enum(["game", "token"]).describe("game: items vs Gold. token: element tokens vs TEST-RUNE.");
+    venueProcess = (venue) => venue === "game" ? graph.processes.internalVenue : graph.processes.externalVenue;
+    human = (t, free) => Object.fromEntries(Object.entries(free ?? {}).map(([asset, atoms]) => [asset, formatAtoms(atoms, t.den(asset))]));
+  }
+});
 
 // src/bridge.mjs
 import crypto3 from "node:crypto";
@@ -987,11 +1248,6 @@ import {
 } from "@solana/web3.js";
 import { SuiGrpcClient } from "@mysten/sui/grpc";
 import { Transaction as SuiTransaction, coinWithBalance } from "@mysten/sui/transactions";
-var DAILY_FAUCET = 100000000n;
-var DAY_MS = 864e5;
-var CHAIN = z4.enum(["base", "solana", "sui"]);
-var PUSD = graph.processes.pusd;
-var faucetToken = (cfg) => (cfg.tokens ?? []).find((t) => t.faucet) ?? cfg.tokens?.[0];
 function baseChain(w) {
   const cfg = chains.base;
   const token = faucetToken(cfg);
@@ -1152,11 +1408,23 @@ function suiChain(w) {
     }
   };
 }
+async function gasOf(name, address) {
+  if (name === "base") {
+    const rpc = process.env.PARALITH_BASE_RPC || chains.base.rpc;
+    const pub = createPublicClient({ chain: { ...base, id: chains.base.chainId }, transport: http(rpc) });
+    return `${formatEther(await pub.getBalance({ address }))} ETH`;
+  }
+  if (name === "solana") {
+    const conn = new Connection(process.env.PARALITH_SOLANA_RPC || chains.solana.rpc, "confirmed");
+    return `${await conn.getBalance(new PublicKey(address)) / 1e9} SOL`;
+  }
+  const client = new SuiGrpcClient({ network: chains.sui.network, baseUrl: process.env.PARALITH_SUI_RPC || chains.sui.rpc });
+  return `${Number((await client.getBalance({ owner: address })).balance.balance) / 1e9} SUI`;
+}
 async function chainFor(name) {
   const { wallets } = await runtime();
   return { base: baseChain, solana: solanaChain, sui: suiChain }[name](wallets);
 }
-var pusdBalance = (address) => readAtoms(PUSD, `balance-${address}`);
 function registerBridge(server) {
   tool(
     server,
@@ -1280,28 +1548,32 @@ function registerBridge(server) {
     READ
   );
 }
+var DAILY_FAUCET, DAY_MS, CHAIN, PUSD, faucetToken, pusdBalance;
+var init_bridge = __esm({
+  "src/bridge.mjs"() {
+    "use strict";
+    init_runtime();
+    init_tool();
+    DAILY_FAUCET = 100000000n;
+    DAY_MS = 864e5;
+    CHAIN = z4.enum(["base", "solana", "sui"]);
+    PUSD = graph.processes.pusd;
+    faucetToken = (cfg) => (cfg.tokens ?? []).find((t) => t.faucet) ?? cfg.tokens?.[0];
+    pusdBalance = (address) => readAtoms(PUSD, `balance-${address}`);
+  }
+});
 
 // src/dao.mjs
 import { z as z5 } from "zod";
-var RUNE = graph.processes.rune;
-var DEN = 6;
 function daoProcess() {
   const id = process.env.PARALITH_DAO || graph.processes.dao;
   if (!ID.test(id ?? "")) throw new Error("The DAO is not deployed yet. Read the design at https://docs.paralithmarkets.com/dao/governance");
   return id;
 }
-var tags = (record) => Object.entries(record).filter(([, v]) => v !== void 0 && v !== "").map(([name, value]) => ({ name, value: String(value) }));
 async function stakeOf(address) {
   const row = await readKey(daoProcess(), `stake-${address}`);
   return row ?? { active: "0", cooling: "0", releaseAt: 0, lockedUntil: 0, votes: {} };
 }
-var runeView = (row) => row && {
-  ...row,
-  active: formatAtoms(row.active ?? 0, DEN),
-  cooling: formatAtoms(row.cooling ?? 0, DEN),
-  ...row.releaseAt ? { releaseAt: new Date(row.releaseAt).toISOString() } : {},
-  ...row.lockedUntil ? { lockedUntil: new Date(row.lockedUntil).toISOString() } : {}
-};
 async function send(record, options = {}) {
   const { api } = await runtime();
   const reply = await api.rawSend(tags(record), { process: daoProcess(), node: NODE, ...options });
@@ -1419,11 +1691,11 @@ function registerDao(server) {
       exec_process: z5.string().regex(ID).optional().describe("Process the passed proposal sends its one message to."),
       exec_tags: z5.record(z5.string(), z5.string()).optional().describe('Tags of that message, e.g. {"Action": "Admin.SetRules", ...}. At most 16; required with exec_process.')
     },
-    async ({ title, body, link, exec_process, exec_tags }) => send({
+    async ({ title, body, link: link2, exec_process, exec_tags }) => send({
       Action: "Propose",
       Title: title,
       Body: body,
-      Link: link,
+      Link: link2,
       "Exec-Process": exec_process,
       "Exec-Tags": exec_tags && JSON.stringify(exec_tags)
     }),
@@ -1446,13 +1718,27 @@ function registerDao(server) {
     WRITE
   );
 }
+var RUNE, DEN, tags, runeView;
+var init_dao = __esm({
+  "src/dao.mjs"() {
+    "use strict";
+    init_runtime();
+    init_tool();
+    RUNE = graph.processes.rune;
+    DEN = 6;
+    tags = (record) => Object.entries(record).filter(([, v]) => v !== void 0 && v !== "").map(([name, value]) => ({ name, value: String(value) }));
+    runeView = (row) => row && {
+      ...row,
+      active: formatAtoms(row.active ?? 0, DEN),
+      cooling: formatAtoms(row.cooling ?? 0, DEN),
+      ...row.releaseAt ? { releaseAt: new Date(row.releaseAt).toISOString() } : {},
+      ...row.lockedUntil ? { lockedUntil: new Date(row.lockedUntil).toISOString() } : {}
+    };
+  }
+});
 
 // src/vaults.mjs
 import { z as z6 } from "zod";
-var VENUE2 = z6.enum(["game", "token"]).describe("game: items vs Gold. token: element tokens vs TEST-RUNE.");
-var STRATEGY = z6.enum(["amm", "active", "grid"]).describe("amm: passive, steady, close to holding. active: concentrated, best sideways, loses most in trends. grid: fixed steps, best range-bound, loses in trends.");
-var venueProcess2 = (venue) => venue === "game" ? graph.processes.internalVenue : graph.processes.externalVenue;
-var DAY_MS2 = 864e5;
 async function terms2(venue) {
   const { api } = await runtime();
   const process2 = venueProcess2(venue);
@@ -1465,8 +1751,6 @@ function marketFor2(t, item) {
   if (!entry) throw new Error(`No market for "${item}". Markets: ${Object.keys(t.markets).join(", ")}`);
   return { id: entry[0], ...entry[1] };
 }
-var pct = (part, whole) => BigInt(whole || 0) > 0n ? `${(Number(BigInt(part || 0) * 10000n / BigInt(whole)) / 100).toFixed(2)}%` : "0%";
-var iso2 = (ms) => ms && Number(ms) > 0 ? new Date(Number(ms)).toISOString() : void 0;
 function vaultView(t, m, v) {
   const b = (atoms) => formatAtoms(atoms ?? 0, t.den(m.base));
   const q = (atoms) => formatAtoms(atoms ?? 0, t.den(m.quote));
@@ -1624,30 +1908,219 @@ function registerVaults(server) {
     WRITE
   );
 }
+var VENUE2, STRATEGY, venueProcess2, DAY_MS2, pct, iso2;
+var init_vaults = __esm({
+  "src/vaults.mjs"() {
+    "use strict";
+    init_runtime();
+    init_tool();
+    VENUE2 = z6.enum(["game", "token"]).describe("game: items vs Gold. token: element tokens vs TEST-RUNE.");
+    STRATEGY = z6.enum(["amm", "active", "grid"]).describe("amm: passive, steady, close to holding. active: concentrated, best sideways, loses most in trends. grid: fixed steps, best range-bound, loses in trends.");
+    venueProcess2 = (venue) => venue === "game" ? graph.processes.internalVenue : graph.processes.externalVenue;
+    DAY_MS2 = 864e5;
+    pct = (part, whole) => BigInt(whole || 0) > 0n ? `${(Number(BigInt(part || 0) * 10000n / BigInt(whole)) / 100).toFixed(2)}%` : "0%";
+    iso2 = (ms) => ms && Number(ms) > 0 ? new Date(Number(ms)).toISOString() : void 0;
+  }
+});
 
-// src/build.mjs
-var DOCS = process.env.PARALITH_DOCS_URL || "https://docs.paralithmarkets.com";
-var INSTRUCTIONS = `Paralith on AO (HyperBEAM): Rune Realm (a companion game), two order books, and the PUSD bridge.
-Everything is TEST-prefixed while unreleased. Reads are free; every write is a signed message (a few seconds round trip, longer under load).
+// src/show.mjs
+import fs5 from "node:fs";
+import path5 from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+import { z as z7 } from "zod";
+import { registerAppResource, registerAppTool, RESOURCE_MIME_TYPE } from "@modelcontextprotocol/ext-apps/server";
+function viewHtml() {
+  for (const file of [path5.join(HERE2, "view.html"), path5.join(HERE2, "..", "dist", "view.html")]) {
+    if (fs5.existsSync(file)) return fs5.readFileSync(file, "utf8");
+  }
+  throw new Error("view.html is missing: run npm run build");
+}
+function need2(args, key) {
+  if (!args[key]) throw new Error(`${key} is required to show this.`);
+  return args[key];
+}
+async function ownAddress() {
+  if (READ_ONLY) return void 0;
+  const { wallets } = await runtime();
+  return wallets?.ao.address;
+}
+function registerShow(server) {
+  const csp = { frameDomains: [GAME, TRADE] };
+  registerAppResource(
+    server,
+    "Paralith view",
+    URI,
+    { description: "Live game and exchange visuals." },
+    async () => ({ contents: [{ uri: URI, mimeType: RESOURCE_MIME_TYPE, text: viewHtml(), _meta: { ui: { csp } } }] })
+  );
+  registerAppTool(server, "show", {
+    description: "Show something with the game's and exchange's own visuals, live: battle (follows a player's arena fights, animated), companion (card), hunt, market (order book and chart), vault, position, bridge (transfers). Returns a link; clients that support MCP Apps also display it inline. Address defaults to yours.",
+    inputSchema: {
+      what: z7.enum(Object.keys(VIEWS)),
+      address: z7.string().optional().describe("AO address; omit for yours."),
+      monster_id: z7.string().optional().describe("companion: which one; omit for the active companion."),
+      battle_id: z7.string().optional().describe("battle: a specific battle, with worker."),
+      worker: z7.string().optional().describe("battle: the battle worker process id."),
+      venue: z7.enum(["game", "token"]).optional().describe("market/vault/position. Default token."),
+      market: z7.string().optional().describe("market/vault: the market, as exchange_markets lists it."),
+      vault: z7.enum(["amm", "active", "grid"]).optional(),
+      chain: z7.enum(["base", "solana", "sui"]).optional().describe("bridge: with tx, one transfer."),
+      tx: z7.string().optional()
+    },
+    annotations: { readOnlyHint: true, openWorldHint: true },
+    _meta: { ui: { resourceUri: URI } }
+  }, async (args) => {
+    try {
+      const view = VIEWS[args.what]({ ...args, address: args.address ?? await ownAddress() });
+      return { structuredContent: { what: args.what, view }, content: [{ type: "text", text: `${args.what}: ${view}` }] };
+    } catch (error) {
+      return { isError: true, content: [{ type: "text", text: error.message }] };
+    }
+  });
+}
+var GAME, TRADE, URI, HERE2, link, VIEWS;
+var init_show = __esm({
+  "src/show.mjs"() {
+    "use strict";
+    init_runtime();
+    GAME = (process.env.PARALITH_GAME_URL || "https://game.paralithmarkets.com").replace(/\/$/, "");
+    TRADE = (process.env.PARALITH_TRADE_URL || "https://trade.paralithmarkets.com").replace(/\/$/, "");
+    URI = "ui://paralith/view";
+    HERE2 = path5.dirname(fileURLToPath2(import.meta.url));
+    link = (base2, page, params) => {
+      const query = new URLSearchParams(Object.entries(params).filter(([, v]) => v !== void 0 && v !== ""));
+      return `${base2}/embed/${page}${query.size ? `?${query}` : ""}`;
+    };
+    VIEWS = {
+      battle: (a) => a.battle_id && a.worker ? link(GAME, "battle", { w: a.worker, b: a.battle_id, a: a.address }) : link(GAME, "battle", { a: need2(a, "address") }),
+      companion: (a) => link(GAME, "companion", { a: need2(a, "address"), m: a.monster_id }),
+      hunt: (a) => link(GAME, "hunt", { a: need2(a, "address") }),
+      market: (a) => link(TRADE, "market", { venue: a.venue ?? "token", m: need2(a, "market") }),
+      vault: (a) => link(TRADE, "vault", { venue: a.venue ?? "token", m: need2(a, "market"), v: a.vault ?? "amm" }),
+      position: (a) => link(TRADE, "position", { venue: a.venue ?? "token", a: need2(a, "address") }),
+      bridge: (a) => link(TRADE, "bridge", { a: a.address, chain: a.chain, tx: a.tx })
+    };
+  }
+});
 
-Start: wallet -> game_player. No account? game_join (pick a faction).
-Core loop: game_daily once a day; game_companion feed/play/quest/claim to keep energy and happiness up and earn exp and Gold;
-game_level_up when exp allows; game_learn_move when an offer is pending.
-Arena: arena_enter (25 energy + 25 happiness, 4 fights), arena_fight mode=bot, then arena_attack each round
-(read arena_battle for moves and uses left; Rally and Mend are free once each), arena_end leave when done.
-Hunt: hunt_begin -> hunt_act search -> attack until defeated -> capture (1-3 Rune + a Scroll) or decline -> end.
-Markets: exchange_markets / exchange_book / exchange_order on venue "game" (items vs Gold) or "token" (elements vs TEST-RUNE).
-Vaults (pooled liquidity, one amm/active/grid per market): vault_list, vault_position, vault_deposit, vault_shares (withdraw/lock/burn), vault_fund, vault_crank.
-Rune: rune_move withdraw (game -> token) / deposit (token -> game). Bridge: bridge_balances, bridge_faucet, bridge_deposit, bridge_redeem.
-DAO (stake TEST-RUNE; a passed proposal may send one attached message): dao_info, dao_proposals, dao_stake stake/unstake/withdraw, dao_propose, dao_vote.
+// src/progress.mjs
+import { z as z8 } from "zod";
+async function targets(who) {
+  const { wallets } = await runtime();
+  const agents = readAgents();
+  const self = wallets && { name: process.env.PARALITH_AGENT ?? "you", addresses: publicAddresses(wallets) };
+  if (!who || who === "me") {
+    if (!self) throw new Error("This server has no wallet; pass who: an AO address.");
+    return [self];
+  }
+  if (who === "all") {
+    const list = Object.entries(agents).map(([name, a]) => ({ name, addresses: a.addresses }));
+    if (self && !list.some((t) => t.name === self.name)) list.unshift(self);
+    if (!list.length) throw new Error("No agents are set up here. Run: npx -y paralith-mcp@latest setup");
+    return list;
+  }
+  if (agents[who]) return [{ name: who, addresses: agents[who].addresses }];
+  if (ID.test(who)) return [{ name: who, addresses: { ao: who } }];
+  throw new Error(`"${who}" is not an agent here (${Object.keys(agents).join(", ") || "none"}) or an AO address.`);
+}
+async function report({ name, addresses: a }) {
+  const { api } = await runtime();
+  const out = { agent: name, addresses: a };
+  const todo = [];
+  const gas = Object.fromEntries(await Promise.all(["base", "solana", "sui"].filter((c) => a[c]).map(async (c) => [c, await gasOf(c, a[c]).catch(() => "unreadable")])));
+  if (Object.keys(gas).length) out.gas = gas;
+  if (!a.ao) {
+    out.note = "AO key not derived yet: it appears once this agent's app has started the server.";
+    return out;
+  }
+  const [p, tokens, venues, redemptions] = await Promise.all([
+    api.readPlayer(a.ao).catch(() => null),
+    Promise.all(Object.entries({ rune: graph.processes.rune, pusd: graph.processes.pusd, ...graph.processes.elements }).map(async ([t, id]) => [t, await readAtoms(id, `balance-${a.ao}`).catch(() => 0n)])),
+    Promise.all(Object.entries(VENUES).map(async ([v, pid]) => [
+      v,
+      await api.readVenuePosition(pid, a.ao).catch(() => null),
+      await api.readVenueVaultPositions(pid, a.ao).catch(() => null)
+    ])),
+    readKey("pusd", "withdrawals").catch(() => null)
+  ]);
+  if (!p) {
+    out.game = { joined: false };
+    todo.push("Join the game (game_join).");
+  } else {
+    const raw = p.monsters?.[p.activeId] ?? p.collection?.[p.activeId];
+    const c = companion(raw);
+    out.game = {
+      faction: p.faction,
+      gold: p.gold,
+      rune: p.inventory?.rune ?? 0,
+      companion: c && { name: c.name, level: c.level, exp: c.exp, energy: c.energy, happiness: c.happiness },
+      arena: { wins: p.wins ?? 0, losses: p.losses ?? 0, rating: p.rating, sessionBattlesLeft: p.battlesRemaining ?? 0 },
+      ...p.battleFleet ? { inBattle: p.battleFleet.battleId } : {},
+      ...p.hunt ? { onHunt: p.hunt.runId } : {}
+    };
+    if (!p.dailyReadyAt || Number(p.dailyReadyAt) <= Date.now()) todo.push("Daily crate is ready (game_daily).");
+    if (count(p.lootboxes)) todo.push(`${count(p.lootboxes)} loot box(es) to open (game_lootbox).`);
+    if (raw && Number(raw.exp ?? 0) >= Number(raw.nextLevelExp ?? Infinity)) todo.push("Companion can level up (game_level_up).");
+    if (c && (c.energy < 25 || c.happiness < 25)) todo.push("Companion is below the arena's 25 energy/happiness: feed or play.");
+  }
+  const held = Object.fromEntries(tokens.filter(([, v]) => v > 0n).map(([t, v]) => [t, formatAtoms(v)]));
+  if (Object.keys(held).length) out.tokens = held;
+  const trading = {};
+  for (const [v, pos, vaults] of venues) {
+    const row = {};
+    if (pos?.orders?.length) row.openOrders = pos.orders.length;
+    if (pos?.fills?.length) row.recentFills = pos.fills.length;
+    const shares = Object.entries(vaults ?? {}).flatMap(([m, r]) => Object.entries(r).filter(([, x]) => BigInt(x?.shares ?? 0) > 0n).map(([s]) => `${m} ${s}`));
+    if (shares.length) row.vaults = shares;
+    if (Object.keys(row).length) trading[v] = row;
+  }
+  if (Object.keys(trading).length) out.trading = trading;
+  const pending = (redemptions ?? []).filter((w) => w.account === a.ao && w.status !== "released");
+  if (pending.length) out.bridge = { pendingRedemptions: pending.length };
+  if (Object.keys(gas).length && Object.values(gas).every((g) => /^0 /.test(g))) {
+    todo.push("No chain gas yet: fund an address above to bridge.");
+  }
+  if (todo.length) out.todo = todo;
+  return out;
+}
+function registerProgress(server) {
+  tool(
+    server,
+    "progress",
+    'How an agent is doing, in one free read: game (companion, Gold, Rune, arena record, live battle or hunt), tokens, open orders and vault shares on both venues, pending bridge redemptions, chain gas, and what needs doing next. who: omit for yourself, "all" for every agent set up on this machine, an agent name (claude, codex, grok) or an AO address.',
+    { who: z8.string().optional() },
+    async ({ who }) => {
+      const list = await Promise.all((await targets(who)).map(report));
+      return list.length === 1 ? list[0] : list;
+    },
+    READ
+  );
+}
+var VENUES, count;
+var init_progress = __esm({
+  "src/progress.mjs"() {
+    "use strict";
+    init_runtime();
+    init_tool();
+    init_agents();
+    init_keys();
+    init_bridge();
+    init_views();
+    VENUES = { game: graph.processes.internalVenue, token: graph.processes.externalVenue };
+    count = (x) => Array.isArray(x) ? x.length : Object.values(x ?? {}).reduce((n, v) => n + Number(v || 0), 0);
+  }
+});
 
-Rules: if a tool says a write WAS accepted but unconfirmed, never resend it; re-read state instead.
-A refusal ({"error": ...}) costs nothing. Use game_catalog for exact costs and move stats; docs at ${DOCS}/llms-full.txt.`;
-var READ_ONLY_NOTE = `This endpoint is READ-ONLY: it explains the protocol and reads live state for any address.
-To play, trade or bridge, run the local server with a wallet phrase: ${DOCS}/ai/mcp`;
+// src/build.mjs
+var build_exports = {};
+__export(build_exports, {
+  buildServer: () => buildServer
+});
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z as z9 } from "zod";
 function buildServer() {
   const server = new McpServer(
-    { name: "paralith", version: "0.1.0" },
+    { name: "paralith", version: "0.3.0" },
     { instructions: READ_ONLY ? `${READ_ONLY_NOTE}
 
 ${INSTRUCTIONS}` : INSTRUCTIONS }
@@ -1678,7 +2151,7 @@ ${INSTRUCTIONS}` : INSTRUCTIONS }
     server,
     "read_state",
     `Read any published key of any process, free: /<process>~process@1.0/now/<key>. process is an id or an alias (${Object.keys(PROCESS_ALIASES).join(", ")}). Returns null when absent.`,
-    { process: z7.string(), key: z7.string() },
+    { process: z9.string(), key: z9.string() },
     async ({ process: process2, key }) => readKey(process2, key),
     READ
   );
@@ -1687,10 +2160,10 @@ ${INSTRUCTIONS}` : INSTRUCTIONS }
     "send_message",
     "Escape hatch: sign and send a raw message to any process and return its reply. Prefer the specific tools; use this only for an action they do not cover. Tag values must be strings; never use a tag named Target.",
     {
-      process: z7.string(),
-      tags: z7.record(z7.string(), z7.string()).describe('e.g. {"Action": "Pass.Info"}'),
-      data: z7.string().optional(),
-      push_outbox: z7.boolean().optional().describe("Deliver the messages this one emits to other processes (e.g. a Transfer to a process).")
+      process: z9.string(),
+      tags: z9.record(z9.string(), z9.string()).describe('e.g. {"Action": "Pass.Info"}'),
+      data: z9.string().optional(),
+      push_outbox: z9.boolean().optional().describe("Deliver the messages this one emits to other processes (e.g. a Transfer to a process).")
     },
     async ({ process: process2, tags: tags2, data, push_outbox }) => {
       if (Object.keys(tags2).some((k) => k.toLowerCase() === "target")) throw new Error("Target is not a usable tag name.");
@@ -1719,9 +2192,58 @@ ${INSTRUCTIONS}` : INSTRUCTIONS }
   registerBridge(server);
   registerDao(server);
   registerVaults(server);
+  registerShow(server);
+  registerProgress(server);
   return server;
 }
+var DOCS, INSTRUCTIONS, READ_ONLY_NOTE;
+var init_build = __esm({
+  "src/build.mjs"() {
+    "use strict";
+    init_runtime();
+    init_keys();
+    init_tool();
+    init_game();
+    init_exchange();
+    init_bridge();
+    init_dao();
+    init_vaults();
+    init_show();
+    init_progress();
+    DOCS = process.env.PARALITH_DOCS_URL || "https://docs.paralithmarkets.com";
+    INSTRUCTIONS = `Paralith on AO (HyperBEAM): Rune Realm (a companion game), two order books, and the PUSD bridge.
+Everything is TEST-prefixed while unreleased. Reads are free; every write is a signed message (a few seconds round trip, longer under load).
+
+Start: wallet -> game_player. No account? game_join (pick a faction).
+Core loop: game_daily once a day; game_companion feed/play/quest/claim to keep energy and happiness up and earn exp and Gold;
+game_level_up when exp allows; game_learn_move when an offer is pending.
+Arena: arena_enter (25 energy + 25 happiness, 4 fights), arena_fight mode=bot, then arena_attack each round
+(read arena_battle for moves and uses left; Rally and Mend are free once each), arena_end leave when done.
+Hunt: hunt_begin -> hunt_act search -> attack until defeated -> capture (1-3 Rune + a Scroll) or decline -> end.
+Markets: exchange_markets / exchange_book / exchange_order on venue "game" (items vs Gold) or "token" (elements vs TEST-RUNE).
+Vaults (pooled liquidity, one amm/active/grid per market): vault_list, vault_position, vault_deposit, vault_shares (withdraw/lock/burn), vault_fund, vault_crank.
+Rune: rune_move withdraw (game -> token) / deposit (token -> game). Bridge: bridge_balances, bridge_faucet, bridge_deposit, bridge_redeem.
+DAO (stake TEST-RUNE; a passed proposal may send one attached message): dao_info, dao_proposals, dao_stake stake/unstake/withdraw, dao_propose, dao_vote.
+
+To report how you (or every agent set up on this machine) are doing, call progress (who: "all" for every agent); it also lists what needs doing next.
+
+To let the user SEE something (an arena fight as it happens, a companion, a hunt, a market's book and chart, a vault, a position, bridge transfers), call show: it returns a live link and displays inline where the client supports it.
+
+Rules: if a tool says a write WAS accepted but unconfirmed, never resend it; re-read state instead.
+A refusal ({"error": ...}) costs nothing. Use game_catalog for exact costs and move stats; docs at ${DOCS}/llms-full.txt.`;
+    READ_ONLY_NOTE = `This endpoint is READ-ONLY: it explains the protocol and reads live state for any address.
+To play, trade or bridge, run the local server with a wallet phrase: ${DOCS}/ai/mcp`;
+  }
+});
 
 // src/server.mjs
-await buildServer().connect(new StdioServerTransport());
-runtime().catch((error) => console.error(`paralith-mcp: ${error.message}`));
+if (process.argv[2] === "setup") {
+  const { setup: setup2 } = await Promise.resolve().then(() => (init_setup(), setup_exports));
+  await setup2(process.argv.slice(3));
+} else {
+  const { StdioServerTransport } = await import("@modelcontextprotocol/sdk/server/stdio.js");
+  const { runtime: runtime2 } = await Promise.resolve().then(() => (init_runtime(), runtime_exports));
+  const { buildServer: buildServer2 } = await Promise.resolve().then(() => (init_build(), build_exports));
+  await buildServer2().connect(new StdioServerTransport());
+  runtime2().catch((error) => console.error(`paralith-mcp: ${error.message}`));
+}