@idosgames/mcp 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 iDos Games
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,49 @@
+# @idosgames/mcp
+
+An MCP server that serves the **iDosGames Module & Skills Registry** to AI coding agents
+(Claude Code, Codex, Cursor, …). It lets an agent discover and pull composable game **modules** and
+the **host scaffold**, and load **skills** for `@idosgames/core`, the module contract, and
+composition.
+
+## Add it to your agent
+
+Runs over stdio via `npx` — no install needed:
+
+```jsonc
+{
+  "mcpServers": {
+    "idosgames": {
+      "command": "npx",
+      "args": ["-y", "@idosgames/mcp"],
+    },
+  },
+}
+```
+
+- **Claude Code**: `claude mcp add idosgames -- npx -y @idosgames/mcp`
+- **Cursor / Codex / others**: add the JSON above to the client's MCP config.
+
+The registry is bundled in the package, so it works offline. To point at the hosted registry instead
+(always the newest, published to the CDN by `npm run push:registry`), set:
+
+```
+IDOSGAMES_REGISTRY_URL=https://cloud.idosgames.com/drive/registry/latest
+```
+
+## Tools
+
+| Tool                | Purpose                                                      |
+| ------------------- | ------------------------------------------------------------ |
+| `list_modules`      | Catalog of modules (id, name, type, engine, genre, deps)     |
+| `get_module {id}`   | One module's full source + install/registration instructions |
+| `list_skills`       | Available skills (name + description)                        |
+| `get_skill {name}`  | A skill's full `SKILL.md` + reference files                  |
+| `get_host_scaffold` | The host-shell files for a new project                       |
+| `get_manifest`      | `@idosgames` runtime packages + exact versions               |
+| `search {query}`    | Keyword search over modules and skills                       |
+
+Tools **return** content; the agent writes files into its own project (standard MCP pattern). A
+typical flow: `get_host_scaffold` → write to root → `get_module {id}` for each chosen module → write
+to `src/modules/{id}/` and register in `src/modules.ts` → install `get_manifest` versions.
+
+See `docs/composable-modules-architecture.md` in the monorepo for the full design.

package/dist/cli.js

@@ -0,0 +1,204 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/server.ts
+import { Server } from "@modelcontextprotocol/sdk/server";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+
+// src/registry.ts
+import { readFileSync } from "fs";
+import { join } from "path";
+import { fileURLToPath } from "url";
+function resolveSource() {
+  const url = process.env["IDOSGAMES_REGISTRY_URL"];
+  if (url) return { kind: "url", base: url.replace(/\/+$/, "") };
+  const dir = process.env["IDOSGAMES_REGISTRY_DIR"];
+  if (dir) return { kind: "dir", base: dir };
+  const here = fileURLToPath(new URL(".", import.meta.url));
+  return { kind: "dir", base: join(here, "..", "registry") };
+}
+var source = resolveSource();
+async function readJson(relPath) {
+  if (source.kind === "url") {
+    const res = await fetch(`${source.base}/${relPath}`);
+    if (!res.ok) throw new Error(`registry: ${relPath} -> HTTP ${res.status}`);
+    return await res.json();
+  }
+  return JSON.parse(readFileSync(join(source.base, relPath), "utf8"));
+}
+var indexCache = null;
+async function getIndex() {
+  if (!indexCache) indexCache = await readJson("index.json");
+  return indexCache;
+}
+var getModule = (id) => readJson(`modules/${id}.json`);
+var getSkill = (name) => readJson(`skills/${name}.json`);
+var getHost = () => readJson("host.json");
+function moduleExportName(id) {
+  const parts = id.split(/[-_]/).filter(Boolean);
+  return parts.map((p, i) => i === 0 ? p : p[0].toUpperCase() + p.slice(1)).join("") + "Module";
+}
+
+// src/server.ts
+var TOOLS = [
+  {
+    name: "list_modules",
+    description: "List the composable iDosGames game/app modules in the catalog (id, name, type, engine, genre, dependency count). Use before get_module to pick what to add.",
+    inputSchema: { type: "object", properties: {} }
+  },
+  {
+    name: "get_module",
+    description: "Get one module's full source (a map of files) plus install instructions. Write each file under src/modules/{id}/, install its dependencies, and register it in src/modules.ts. Requires a host scaffold in the project (see get_host_scaffold).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        id: { type: "string", description: "Module id, e.g. board-game" }
+      },
+      required: ["id"]
+    }
+  },
+  {
+    name: "list_skills",
+    description: "List available skills (name + description). Skills are instructions for working with @idosgames/core services, the module contract, and composition. Use get_skill to load one.",
+    inputSchema: { type: "object", properties: {} }
+  },
+  {
+    name: "get_skill",
+    description: "Get one skill's full SKILL.md content and its reference files. Load the relevant skill before writing code against that part of the SDK.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        name: {
+          type: "string",
+          description: "Skill name, e.g. currency-system"
+        }
+      },
+      required: ["name"]
+    }
+  },
+  {
+    name: "get_host_scaffold",
+    description: "Get the host-shell scaffold (index.html, main.tsx, empty src/modules.ts, config) for a NEW project. Write these to the project root, then add modules with get_module.",
+    inputSchema: { type: "object", properties: {} }
+  },
+  {
+    name: "get_manifest",
+    description: "Get the @idosgames runtime packages and their exact versions (core, wallet, module-sdk, react, app-shell). Install these so a seeded host/module resolves its imports.",
+    inputSchema: { type: "object", properties: {} }
+  },
+  {
+    name: "search",
+    description: "Keyword search across modules and skills (id, name, genre, engine, description). Returns matching catalog entries.",
+    inputSchema: {
+      type: "object",
+      properties: { query: { type: "string", description: "Free-text query" } },
+      required: ["query"]
+    }
+  }
+];
+var json = (value) => ({
+  content: [{ type: "text", text: JSON.stringify(value, null, 2) }]
+});
+var fail = (message) => ({
+  content: [{ type: "text", text: message }],
+  isError: true
+});
+function argString(args, key) {
+  const v = args?.[key];
+  return typeof v === "string" && v.trim() ? v.trim() : null;
+}
+function createServer() {
+  const server = new Server(
+    { name: "idosgames", version: "0.1.0" },
+    { capabilities: { tools: {} } }
+  );
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: TOOLS
+  }));
+  server.setRequestHandler(CallToolRequestSchema, async (req) => {
+    const { name, arguments: args } = req.params;
+    try {
+      switch (name) {
+        case "list_modules": {
+          const index = await getIndex();
+          return json(index.modules);
+        }
+        case "get_module": {
+          const id = argString(args, "id");
+          if (!id) return fail("get_module requires an 'id'.");
+          const mod = await getModule(id);
+          const exportName = moduleExportName(id);
+          return json({
+            ...mod,
+            instructions: [
+              `Write each file to src/modules/${id}/{path}.`,
+              `Install dependencies: ${Object.entries(mod.dependencies).map(([n, v]) => `${n}@${v}`).join(", ")}.`,
+              `Register in src/modules.ts: import { ${exportName} } from "./modules/${id}"; and add ${exportName} to the modules array.`
+            ].join(" ")
+          });
+        }
+        case "list_skills": {
+          const index = await getIndex();
+          return json(index.skills);
+        }
+        case "get_skill": {
+          const skill = argString(args, "name");
+          if (!skill) return fail("get_skill requires a 'name'.");
+          return json(await getSkill(skill));
+        }
+        case "get_host_scaffold": {
+          const host = await getHost();
+          return json({
+            ...host,
+            instructions: "Write each file to the project root. src/modules.ts starts empty; add modules with get_module."
+          });
+        }
+        case "get_manifest": {
+          const index = await getIndex();
+          return json({
+            runtimePackages: index.runtimePackages,
+            generatedFromCommit: index.generatedFromCommit
+          });
+        }
+        case "search": {
+          const query = argString(args, "query");
+          if (!query) return fail("search requires a 'query'.");
+          const tokens = query.toLowerCase().split(/\s+/).filter(Boolean);
+          const index = await getIndex();
+          const hit = (text) => tokens.every((t) => text.includes(t));
+          const modules = index.modules.filter(
+            (m) => hit(
+              `${m.id} ${m.name} ${m.genre ?? ""} ${m.engine} ${m.type}`.toLowerCase()
+            )
+          );
+          const skills = index.skills.filter(
+            (s) => hit(`${s.name} ${s.description}`.toLowerCase())
+          );
+          return json({ modules, skills });
+        }
+        default:
+          return fail(`Unknown tool: ${name}`);
+      }
+    } catch (err) {
+      return fail(err instanceof Error ? err.message : String(err));
+    }
+  });
+  return server;
+}
+
+// src/cli.ts
+async function main() {
+  const server = createServer();
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error("[idosgames-mcp] ready (stdio)");
+}
+main().catch((err) => {
+  console.error("[idosgames-mcp] fatal:", err);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@idosgames/mcp",
+  "version": "0.1.0",
+  "description": "MCP server that serves the iDosGames Module & Skills Registry to AI coding agents (Claude Code, Codex, Cursor…): list/pull composable game modules and the host scaffold, and load skills for @idosgames/core, the module contract, and composition.",
+  "type": "module",
+  "license": "MIT",
+  "author": "iDos Games",
+  "homepage": "https://github.com/iDos-Games/iDosGamesSDK_TS#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/iDos-Games/iDosGamesSDK_TS.git",
+    "directory": "packages/mcp"
+  },
+  "bugs": {
+    "url": "https://github.com/iDos-Games/iDosGamesSDK_TS/issues"
+  },
+  "keywords": [
+    "idosgames",
+    "mcp",
+    "model-context-protocol",
+    "ai",
+    "gamedev",
+    "skills"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "bin": {
+    "idosgames-mcp": "./dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "registry",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "sync:registry": "node ../../scripts/sync-registry.mjs",
+    "build": "npm run sync:registry && tsup",
+    "typecheck": "tsc --noEmit -p tsconfig.json"
+  },
+  "//": "The registry is bundled into the package (registry/) so `npx @idosgames/mcp` works offline. Set IDOSGAMES_REGISTRY_URL to serve a hosted registry instead (once cloud.idosgames.com/registry is live).",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.0"
+  }
+}

package/registry/host.json

@@ -0,0 +1,41 @@
+{
+  "id": "host-starter",
+  "files": [
+    {
+      "path": "index.html",
+      "content": "<!doctype html>\n<html lang=\"en\">\n  <head>\n    <meta charset=\"utf-8\" />\n    <meta name=\"viewport\" content=\"width=device-width, initial-scale=1\" />\n    <title>Host Shell · IDosGames SDK</title>\n    <style>\n      html,\n      body,\n      #app {\n        margin: 0;\n        height: 100%;\n        background: #0c0a18;\n      }\n    </style>\n  </head>\n  <body>\n    <div id=\"app\"></div>\n    <script type=\"module\" src=\"/src/main.tsx\"></script>\n  </body>\n</html>\n"
+    },
+    {
+      "path": "package.json",
+      "content": "{\n  \"name\": \"@idosgames/host-starter\",\n  \"version\": \"0.0.0\",\n  \"private\": true,\n  \"type\": \"module\",\n  \"description\": \"The seed project for the AI Coder: a host shell that composes feature modules. Fresh projects start here with zero modules; the developer/agent plugs modules into src/modules.ts.\",\n  \"scripts\": {\n    \"dev\": \"vite\",\n    \"build\": \"vite build\",\n    \"preview\": \"vite preview\",\n    \"typecheck\": \"tsc --noEmit -p tsconfig.json\"\n  },\n  \"//\": \"Versions are pinned exactly: this is a seed for AI Coder projects, which build offline against a dependency allowlist baked at these versions (see scripts/pack-builder.mjs). Modules bring their own engine deps (three/phaser) when added.\",\n  \"dependencies\": {\n    \"@idosgames/app-shell\": \"0.1.0\",\n    \"@idosgames/core\": \"0.1.1\",\n    \"@idosgames/module-sdk\": \"0.1.0\",\n    \"@idosgames/react\": \"0.1.0\",\n    \"react\": \"19.2.7\",\n    \"react-dom\": \"19.2.7\"\n  },\n  \"devDependencies\": {\n    \"@types/react\": \"19.2.17\",\n    \"@types/react-dom\": \"19.2.3\",\n    \"@vitejs/plugin-react\": \"4.7.0\",\n    \"typescript\": \"5.9.3\",\n    \"vite\": \"5.4.21\"\n  }\n}\n"
+    },
+    {
+      "path": "src/config.ts",
+      "content": "// Demo configuration — always targets the real backend (https://api.idosgames.com).\n// The title is resolved at runtime, in this order:\n//   1. ?titleID= / ?buildKey= on the launch URL — how the platform parameterizes a hosted build\n//   2. templates/host-starter/.env.local (VITE_IDOS_TITLE_ID / VITE_IDOS_BUILD_KEY)\n//   3. the public demo title\n// Resolving at runtime rather than build time lets one build serve both a staged preview and prod.\n\nimport { ENV_TITLE_ID, ENV_BUILD_KEY } from \"./env\";\n\nconst launchParams =\n  typeof window === \"undefined\"\n    ? null\n    : new URLSearchParams(window.location.search);\n\nexport const TITLE_ID =\n  launchParams?.get(\"titleID\") ?? (ENV_TITLE_ID || \"URLV9SUP\");\nexport const BUILD_KEY = launchParams?.get(\"buildKey\") ?? ENV_BUILD_KEY;\n"
+    },
+    {
+      "path": "src/env.ts",
+      "content": "// Env совместимое СРАЗУ с двумя сборщиками:\n//   1. настоящий vite (standalone-dev, прод, контейнер-билд build-runner) — значения приезжают из\n//      vite.config через define в глобал __IDOS_ENV__ (см. vite.config.ts);\n//   2. классический бандлер превью (Sandpack) — он падает на самом токене `import.meta`, поэтому\n//      его здесь быть не должно. Глобала __IDOS_ENV__ у него нет → `typeof` вернёт \"undefined\",\n//      берём дефолты.\ntype IdosEnv = {\n  DEV?: boolean;\n  TITLE_ID?: string;\n  BUILD_KEY?: string;\n  WALLETCONNECT_PROJECT_ID?: string;\n};\n\ndeclare const __IDOS_ENV__: IdosEnv | undefined;\n\nconst env: IdosEnv =\n  typeof __IDOS_ENV__ !== \"undefined\" && __IDOS_ENV__ ? __IDOS_ENV__ : {};\n\nexport const IS_DEV = env.DEV ?? false;\nexport const ENV_TITLE_ID = env.TITLE_ID ?? \"\";\nexport const ENV_BUILD_KEY = env.BUILD_KEY ?? \"\";\nexport const ENV_WALLETCONNECT_PROJECT_ID = env.WALLETCONNECT_PROJECT_ID ?? \"\";\n"
+    },
+    {
+      "path": "src/main.tsx",
+      "content": "import { createIDosGamesClient } from \"@idosgames/core\";\nimport { mountHost } from \"@idosgames/app-shell\";\nimport { modules } from \"./modules\";\nimport { TITLE_ID, BUILD_KEY } from \"./config\";\nimport { IS_DEV } from \"./env\";\n\nconst app = document.getElementById(\"app\");\nif (!app) throw new Error(\"#app container not found\");\n\n// Always runs against the real backend (https://api.idosgames.com) via the global fetch.\nconst client = createIDosGamesClient({\n  titleID: TITLE_ID,\n  buildKey: BUILD_KEY.length > 0 ? BUILD_KEY : undefined,\n  throttleMs: 0,\n});\n\nclient.on(\"error:global\", (message) => {\n  console.error(\"[idos] global error:\", message);\n});\nclient.on(\"error:connection\", (message) => {\n  console.error(\"[idos] connection error:\", message);\n});\n\nvoid (async () => {\n  app.textContent = `Connecting to api.idosgames.com (title ${TITLE_ID})…`;\n\n  const login = await client.auth.loginWithDeviceID();\n  if (!login.ok) {\n    app.textContent = `Login failed [${login.reason}]: ${login.error}`;\n    return;\n  }\n  app.textContent = \"\";\n  if (IS_DEV) {\n    (\n      globalThis as typeof globalThis & { idosClient?: typeof client }\n    ).idosClient = client;\n  }\n\n  // Host owns the single client + login; modules are plugged in and share this session.\n  mountHost({ container: app, client, modules });\n})();\n"
+    },
+    {
+      "path": "src/modules.ts",
+      "content": "import type { Module } from \"@idosgames/module-sdk\";\n\n// The list of feature modules this project composes. A fresh project starts empty and shows the\n// host's \"no modules\" state. Add a module by copying it into src/modules/<id>/ and registering it\n// here — the AI Coder seeder appends to this array, and you can also edit it by hand.\n//\n// Example, after copying a module into src/modules/board-game/:\n//   import { boardGameModule } from \"./modules/board-game\";\n//   export const modules: Module[] = [boardGameModule];\nexport const modules: Module[] = [];\n"
+    },
+    {
+      "path": "src/vite-env.d.ts",
+      "content": "/// <reference types=\"vite/client\" />\n"
+    },
+    {
+      "path": "tsconfig.json",
+      "content": "{\n  \"$schema\": \"https://json.schemastore.org/tsconfig\",\n  // Self-contained on purpose: this template is copied out of the monorepo (as the seed for an AI\n  // Coder project) and must typecheck on its own, so it does not `extends` tsconfig.base.json. Keep\n  // the shared options below in sync with tsconfig.base.json.\n  \"compilerOptions\": {\n    \"target\": \"ES2022\",\n    \"lib\": [\"ES2022\", \"DOM\", \"DOM.Iterable\"],\n    \"module\": \"ESNext\",\n    \"moduleResolution\": \"Bundler\",\n\n    \"strict\": true,\n    \"noUncheckedIndexedAccess\": true,\n    \"noImplicitOverride\": true,\n    \"noFallthroughCasesInSwitch\": true,\n    \"useUnknownInCatchVariables\": true,\n\n    \"verbatimModuleSyntax\": true,\n    \"isolatedModules\": true,\n    \"esModuleInterop\": true,\n    \"resolveJsonModule\": true,\n    \"skipLibCheck\": true,\n    \"forceConsistentCasingInFileNames\": true,\n\n    \"noEmit\": true,\n    \"jsx\": \"react-jsx\",\n\n    // Inside the monorepo these point typecheck at the SDK/host source, so no SDK build is needed.\n    // Outside it the paths do not exist and TypeScript falls back to node_modules resolution.\n    \"paths\": {\n      \"@idosgames/core\": [\"../../packages/core/src/index.ts\"],\n      \"@idosgames/module-sdk\": [\"../../packages/module-sdk/src/index.ts\"],\n      \"@idosgames/react\": [\"../../packages/react/src/index.ts\"],\n      \"@idosgames/app-shell\": [\"../../packages/app-shell/src/index.ts\"]\n    }\n  },\n  \"include\": [\"src\"]\n}\n"
+    },
+    {
+      "path": "vite.config.ts",
+      "content": "import { existsSync } from \"node:fs\";\nimport { fileURLToPath } from \"node:url\";\nimport { defineConfig, loadEnv } from \"vite\";\nimport react from \"@vitejs/plugin-react\";\n\nconst fromHere = (path: string): string =>\n  fileURLToPath(new URL(path, import.meta.url));\n\n// Inside this monorepo, resolve the @idosgames/* packages to their source for instant HMR (no SDK/\n// host rebuild needed in dev). A standalone copy of this template — a cloned starter, or an AI Coder\n// project built in a container — has no such paths and resolves each package from node_modules.\nconst sourceAliases: Record<string, string> = {\n  \"@idosgames/core\": fromHere(\"../../packages/core/src/index.ts\"),\n  \"@idosgames/module-sdk\": fromHere(\"../../packages/module-sdk/src/index.ts\"),\n  \"@idosgames/react\": fromHere(\"../../packages/react/src/index.ts\"),\n  \"@idosgames/app-shell\": fromHere(\"../../packages/app-shell/src/index.ts\"),\n};\n\nexport default defineConfig(({ mode }) => {\n  const env = loadEnv(mode, process.cwd(), \"\");\n  const alias = Object.fromEntries(\n    Object.entries(sourceAliases).filter(([, path]) => existsSync(path)),\n  );\n  return {\n    plugins: [react()],\n    resolve: { alias },\n    server: { port: 5180 },\n    // Env is injected via the __IDOS_ENV__ global (not import.meta.env) so the same files build under\n    // both real vite and the classic preview bundler (Sandpack), which can't parse import.meta.\n    // See src/env.ts.\n    define: {\n      __IDOS_ENV__: JSON.stringify({\n        DEV: mode !== \"production\",\n        TITLE_ID: env.VITE_IDOS_TITLE_ID ?? \"\",\n        BUILD_KEY: env.VITE_IDOS_BUILD_KEY ?? \"\",\n        WALLETCONNECT_PROJECT_ID: env.VITE_WALLETCONNECT_PROJECT_ID ?? \"\",\n      }),\n    },\n  };\n});\n"
+    }
+  ]
+}

package/registry/index.json

@@ -0,0 +1,215 @@
+{
+  "generatedFromCommit": "626cd3965e7bcafd925bf0ddccdcb92359469a4e",
+  "runtimePackages": {
+    "@idosgames/core": "0.1.1",
+    "@idosgames/wallet": "0.1.1",
+    "@idosgames/module-sdk": "0.1.0",
+    "@idosgames/react": "0.1.0",
+    "@idosgames/app-shell": "0.1.0"
+  },
+  "host": {
+    "id": "host-starter",
+    "fileCount": 9
+  },
+  "modules": [
+    {
+      "id": "currency-hud",
+      "name": "Wallet HUD",
+      "type": "app",
+      "engine": "dom",
+      "dependencies": {
+        "@idosgames/core": "0.1.1",
+        "@idosgames/module-sdk": "0.1.0",
+        "@idosgames/react": "0.1.0",
+        "react": "19.2.7"
+      },
+      "fileCount": 3
+    },
+    {
+      "id": "board-game",
+      "name": "Board Game",
+      "type": "game",
+      "engine": "three",
+      "genre": "board",
+      "dependencies": {
+        "@idosgames/core": "0.1.1",
+        "@idosgames/module-sdk": "0.1.0",
+        "@idosgames/react": "0.1.0",
+        "@idosgames/wallet": "0.1.1",
+        "@solana/wallet-adapter-base": "0.9.27",
+        "@solana/wallet-adapter-react": "0.15.39",
+        "@tanstack/react-query": "5.101.2",
+        "react": "19.2.7",
+        "react-dom": "19.2.7",
+        "three": "0.185.1",
+        "viem": "2.55.2",
+        "wagmi": "3.7.2"
+      },
+      "fileCount": 24
+    },
+    {
+      "id": "idle-rpg",
+      "name": "Idle RPG",
+      "type": "game",
+      "engine": "phaser",
+      "genre": "idle-rpg",
+      "dependencies": {
+        "@idosgames/core": "0.1.1",
+        "@idosgames/module-sdk": "0.1.0",
+        "@idosgames/react": "0.1.0",
+        "@idosgames/wallet": "0.1.1",
+        "@solana/wallet-adapter-base": "0.9.27",
+        "@solana/wallet-adapter-react": "0.15.39",
+        "@tanstack/react-query": "5.101.2",
+        "phaser": "4.2.1",
+        "react": "19.2.7",
+        "react-dom": "19.2.7",
+        "viem": "2.55.2",
+        "wagmi": "3.7.2"
+      },
+      "fileCount": 16
+    },
+    {
+      "id": "voxelcraft",
+      "name": "VoxelCraft",
+      "type": "game",
+      "engine": "three",
+      "genre": "sandbox",
+      "dependencies": {
+        "@idosgames/module-sdk": "0.1.0",
+        "three": "0.185.1"
+      },
+      "fileCount": 37
+    }
+  ],
+  "skills": [
+    {
+      "name": "authentication",
+      "description": "Log players into a game on the iDosGames TypeScript SDK (@idosgames/core) via client.auth (AuthenticationService): guest/device-id login, email register & login, Google/Telegram/platform-token login, password reset, auto login on relaunch, session refresh, logout, and client-side email/password validation. Use this whenever the user is working in the iDosGames TS SDK or its game templates (board-game, idle-rpg) and asks about logging a player in, sessions, registration, guest accounts, device-id login, Telegram login, Google login, platform-token login, forgot/reset password, auto-login, isLoggedIn, or otherwise touches client.auth, AuthenticationService, or AuthContext — even if they don't name the module explicitly."
+    },
+    {
+      "name": "blockchain-system",
+      "description": "Bridge in-game assets on-chain in a game on the iDosGames TypeScript SDK (@idosgames/core) via client.blockchain (BlockchainService): load blockchain network/config definitions, load the player's on-chain state (linked wallets, pending withdrawals, KYC, stats), deposit a token or NFT from a wallet into the game, request a token or NFT withdrawal out to a wallet, read on-chain transaction history, retry a still-pending withdrawal's signature, confirm a withdrawal's on-chain tx hash, and donate crypto to the developer or a users' pool. Use this whenever the user is working in the iDosGames TS SDK or its game templates (board-game, idle-rpg) and wants crypto wallets, NFT deposits/withdrawals, token bridging, on-chain asset transfers, KYC status, or otherwise touches client.blockchain, BlockchainService, BlockchainDefinitions, UserBlockchainState, DepositTokenResponse, TokenWithdrawalResponse, or NFTWithdrawalResponse — even if they don't name the module explicitly."
+    },
+    {
+      "name": "character-system",
+      "description": "Build a character / hero system in a game on the iDosGames TypeScript SDK (@idosgames/core) via client.character (CharacterService): load the hero roster and title definitions, unlock or purchase characters, upgrade character levels/ranks and per-character stats, equip and unequip gear into slots, and read the server-authoritative Power score. Use this whenever the user is working in the iDosGames TS SDK or its game templates (board-game, idle-rpg) and wants character screens, hero rosters, stat/level/rank upgrade UIs, equipment or loadout systems, or otherwise touches client.character, CharacterService, CharacterModel, CharacterDefinitions, StatLevels, or character Power — even if they don't name the module explicitly."
+    },
+    {
+      "name": "cloud-code",
+      "description": "Call custom server-side game logic on the iDosGames TypeScript SDK (@idosgames/core) via client.cloudCode (CloudCodeService): execute a title-defined cloud script by name with an arbitrary JSON args payload and get back its arbitrary JSON result. Use this whenever the user wants to run custom/bespoke server logic, a \"cloud script\", \"cloud function\", \"server callable\", crafting/trading/matchmaking logic not covered by a dedicated SDK module, or otherwise touches client.cloudCode, CloudCodeService, or ExecuteCloudCodeResponse — even if they don't name the module explicitly."
+    },
+    {
+      "name": "collection-system",
+      "description": "Build a collection / sticker-album / TCG system in a game on the iDosGames TypeScript SDK (@idosgames/core) via client.collection (CollectionService): open collectible packs and pity-driven collection chests, spend \"joker\" wildcards to fill a specific slot, claim set-completion rewards (single + batch) and the collection Grand Prize, and run peer-to-peer collectible trading (send/cancel/accept/decline trade offers, list my/incoming offers). Use this whenever the user is working in the iDosGames TS SDK or its game templates (board-game, idle-rpg) and wants a sticker album, TCG-style collection/set-completion screen, pack-opening UI, duplicate/pity systems, or player-to-player item trading — or otherwise touches client.collection, CollectionService, CollectionDefinitions, UserCollectionState, or trade offers — even if they don't name the module explicitly."
+    },
+    {
+      "name": "coop-event-system",
+      "description": "Build a cooperative / group event system in a game on the iDosGames TypeScript SDK (@idosgames/core) via client.coopEvent (CoopEventService): load coop event chain definitions, look up which event in a chain is currently active, load the player's own coop-event state, join or create a matchmade group, spin/contribute toward the group's shared BuildObjects goal, claim a per-member object reward or the group's grand prize, and leave a group. Use this whenever the user is working in the iDosGames TS SDK or its game templates (board-game, idle-rpg) and wants a co-op event, group event, team event, alliance-style shared-goal feature, spin-to-contribute mechanic, or otherwise touches client.coopEvent, CoopEventService, CoopEventDefinitions, CoopGroupDocument, UserCoopEventState, or CoopSpinResponse — even if they don't name the module explicitly."
+    },
+    {
+      "name": "craft-system",
+      "description": "Build a crafting / trade-up system in a game on the iDosGames TypeScript SDK (@idosgames/core) via client.craft (CraftService): load craft recipe definitions and execute a craft that burns input item instances (trade-up by rarity or trade-up by collection) to produce a rolled output item. Use this whenever the user is working in the iDosGames TS SDK or its game templates (board-game, idle-rpg) and wants item-fusion / trade-up / salvage UIs, or otherwise touches client.craft, CraftService, CraftDefinitions, CraftDefinition, or CraftResponse — even if they don't name the module explicitly."
+    },
+    {
+      "name": "currency-system",
+      "description": "Convert between currencies in a game on the iDosGames TypeScript SDK (@idosgames/core) via client.currency (CurrencyService): virtual-currency to virtual-currency (VC↔VC) conversion, and crypto-source conversion (crypto→VC or crypto→crypto). This is also the canonical home for the SDK-wide shared ResourceConsume/ResourceGrant/ResourceOperation/ResourceEntry cost-and-reward types used by every other module (Store, Character, Craft, Lootbox, Blockchain, …). Use this whenever the user is working in the iDosGames TS SDK or its game templates (board-game, idle-rpg) and wants a currency-exchange screen, gold-to-gems conversion, crypto conversion, or otherwise touches client.currency, CurrencyService, ConvertResponse, CryptoConvertResponse, ResourceConsume, ResourceGrant, ResourceOperation, or ResourceEntry — even if they don't name the module explicitly."
+    },
+    {
+      "name": "deal-offer-system",
+      "description": "Build a personalized / targeted deal-offer system in a game on the iDosGames TypeScript SDK (@idosgames/core) via client.dealOffer (DealOfferService): load slot and offer definitions, load the player's deal-offer state, fetch the currently active deals per slot, dismiss a deal, execute a node in an offer's graph (purchase / free claim / rewarded-video / info step), record an impression (show event), and claim a milestone reward (single or batch). Use this whenever the user is working in the iDosGames TS SDK or its game templates (board-game, idle-rpg) and wants limited-time offer popups, IAP funnels, \"special offer\" slots, node/graph-based offer chains, rewarded-video offer steps, offer milestone/progress bars, or otherwise touches client.dealOffer, DealOfferService, DealOfferDefinitions, DealNodeDefinition, UserDealOffersState, ActiveDealSlotInfo, or ExecuteNodeResponse — even if they don't name the module explicitly."
+    },
+    {
+      "name": "dev-test-loop",
+      "description": "Run the боево (real) create→configure→generate→test→fix loop when building or improving a game feature on the iDosGames TypeScript SDK (@idosgames/core). Provision the DEV title ({TitleID}-DEV), implement the feature with the SDK and the per-module skills (character-system, store-system, quest-system, …), apply the title config for every module used, generate content (image/audio/3D) if needed, then run `npm run verify` (@idosgames/harness) against the DEV title and fix until it goes green. Use this whenever the user wants to build, add, or improve a game feature end-to-end, test a feature against the backend, close the loop, or otherwise wants the work to end in a green verify run against a real sandbox rather than just written code — even if they don't name the loop."
+    },
+    {
+      "name": "game-loop-system",
+      "description": "Build a board-style core game loop on the iDosGames TypeScript SDK (@idosgames/core) via client.gameLoop (GameLoopService): roll dice around a board, attack/raid other players' or bots' cities, build up buildings, resolve Special (Instant/Timed) tile choices, and run the cooperative Community Chest group meter. Use this whenever the user is working in the iDosGames TS SDK or its game templates (board-game, idle-rpg) and wants a dice/roll board loop, an attack or raid/heist mini-game, city building, survival/Special tile events, or a co-op group-progress feature — or otherwise touches client.gameLoop, GameLoopService, GameLoopModels, BoardLoopState, BoardLoopDefinition, or CommunityChest — even if they don't name the module explicitly. templates/board-game is built entirely on this module."
+    },
+    {
+      "name": "idosgames-compose-modules",
+      "description": "Merge several iDosGames modules into one game — combine genres (e.g. board-game + idle-rpg), share progress across modes, and add always-on chrome. Use this whenever a developer wants to COMBINE or MERGE multiple iDosGames templates/modules into a single title, switch between game modes, share currency/inventory across modules, or asks how the Mode Router, the nav-bar, activeOnly panels, the cross-module event bus, or host-level shared state work. Builds on idosgames-getting-started (scaffolding) and idosgames-module-contract (a single module)."
+    },
+    {
+      "name": "idosgames-getting-started",
+      "description": "Start a new game or app on the iDosGames composable-module architecture: scaffold the host shell and plug in feature modules (board-game, idle-rpg, voxelcraft, currency-hud, …). Use this whenever a developer wants to CREATE an iDosGames project from scratch, add an iDosGames game module to a project, or asks how @idosgames/app-shell, @idosgames/module-sdk, the host shell, mountHost, or src/modules.ts fit together. Pairs with idosgames-module-contract (writing a module) and idosgames-compose-modules (merging several). If pulling modules over MCP, use the @idosgames/mcp tools get_host_scaffold / get_module / get_manifest."
+    },
+    {
+      "name": "idosgames-module-contract",
+      "description": "Write or modify an iDosGames feature module against the module contract in @idosgames/module-sdk: the Module manifest, ModuleContext, EngineScene (Three/Phaser/vanilla), UiPanel (React), route registration, and the shared controller-box bridge between an imperative scene and React panels. Use this whenever a developer authors a NEW module, edits an existing one (board-game, idle-rpg, voxelcraft, currency-hud), or asks about defineModule, registerScene/registerPanel/registerRoute, activate/suspend, SceneMountContext, or the {camelCase(id)}Module export convention."
+    },
+    {
+      "name": "item-system",
+      "description": "Work with items on the iDosGames TypeScript SDK (@idosgames/core) via client.item (ItemService) and the shared Item data model: upgrade an item instance's level (single or batch, optionally consuming fodder instances), and understand ItemDefinition / item catalogs / stackable vs unstackable item instances / equipment rules — the vocabulary Character (equipment), Marketplace (listings), Craft (recipes), Lootbox (rewards), and Store (purchase grants) all build on. Use this whenever the user is working in the iDosGames TS SDK or its game templates (board-game, idle-rpg) and wants item upgrade/leveling UIs, inventory screens, item definitions/catalogs, stackable/unstackable item instances, item rarity/tags, NFT-bound items, or otherwise touches client.item, ItemService, ItemDefinition, ItemCatalog, UnstackableItemInstanceState, or InventoryV2 — even if they don't name the module explicitly."
+    },
+    {
+      "name": "leaderboard-system",
+      "description": "Build a leaderboard / ranking system in a game on the iDosGames TypeScript SDK (@idosgames/core) via client.leaderboard (LeaderboardService): load leaderboard definitions, load a leaderboard's top list (+ batch), load the player's own progress (+ batch), submit a score (direct or from a trigger source, + batch), claim the cycle/instance-end rank reward (+ batch), claim a milestone reward (+ batch), claim every reward across many leaderboards in one call, fetch a combined top-list+progress overview (batch), and load a friends-filtered leaderboard view. Use this whenever the user is working in the iDosGames TS SDK or its game templates (board-game, idle-rpg) and wants ranking screens, PvP/score leaderboards, seasonal or cyclic ladders, rank-reward or milestone-reward UIs, or otherwise touches client.leaderboard, LeaderboardService, LeaderboardDefinitions, UserLeaderboardProgress, GetMyProgressResponse, or leaderboard cycles/brackets — even if they don't name the module explicitly."
+    },
+    {
+      "name": "lootbox-system",
+      "description": "Build a lootbox / gacha / loot-crate system in a game on the iDosGames TypeScript SDK (@idosgames/core) via client.lootbox (LootboxService): load lootbox definitions (reward slots, weighted pools, price options, pity rules) and open one or many boxes for randomized rewards, including hard-pity tracking. Use this whenever the user is working in the iDosGames TS SDK or its game templates (board-game, idle-rpg) and wants loot crate / gacha / mystery box UIs, reward-pool or drop-rate config, pity-counter or bad-luck-protection systems, or otherwise touches client.lootbox, LootboxService, LootboxDefinitions, LootboxRewardSlot, LootboxPityRule, or UserLootboxState — even if they don't name the module explicitly."
+    },
+    {
+      "name": "marketplace-system",
+      "description": "Build a player-to-player marketplace in a game on the iDosGames TypeScript SDK (@idosgames/core) via client.marketplace (MarketplaceService): browse offers grouped/by item, create and buy fixed-price listings, create auctions and place bids and claim settlement, create/cancel/fill buy orders, create/accept/decline/cancel direct trades (P2P gifts/swaps), read my-state (my offers, leading bids, incoming/outgoing trades, claimables), page through trade history, and claim back escrow from expired or unsettled offers. Use this whenever the user is working in the iDosGames TS SDK or its game templates (board-game, idle-rpg) and wants an auction house, player market, trading post, buy-order/limit-order board, gifting/trading between players, or otherwise touches client.marketplace, MarketplaceService, MarketplaceOfferView, MarketOfferType, MarketplaceAuctionState, or MarketplaceSettlementResponse — even if they don't name the module explicitly."
+    },
+    {
+      "name": "match-system",
+      "description": "Build a PvP match system in a game on the iDosGames TypeScript SDK (@idosgames/core) via client.match (MatchService): create/update/cancel an open PvP match offer with an entry cost, resolve an instant server-side battle, save a client-side battle strategy (attack/defense zone picks per round), and list/paginate the player's own matches or matches available to join. Use this whenever the user is working in the iDosGames TS SDK or its game templates (board-game, idle-rpg) and wants PvP matchmaking, duel/arena screens, entry-cost battles, attack-zone strategy pickers, battle logs, or otherwise touches client.match, MatchService, MatchModels, PvPMatch, BattleStepConfig, InstantBattleResponse, or BattleResult — even if they don't name the module explicitly."
+    },
+    {
+      "name": "multiplayer-realtime",
+      "description": "Build realtime peer-to-peer multiplayer in a game on the iDosGames TypeScript SDK (@idosgames/core) via client.multiplayer (MultiplayerService): create/join/leave/close rooms, list public rooms, relay WebRTC SDP offer/answer + ICE candidates between room members, long-poll for signals/chat/presence envelopes, send server-relayed chat, and publish member ready/lobby state. This is a signaling and room-lifecycle relay for WebRTC — not a gameplay/economy module. Use this whenever the user is working in the iDosGames TS SDK or its game templates and wants realtime multiplayer rooms/lobbies, WebRTC signaling, peer-to-peer connection setup, a poll loop for realtime events, in-room chat, or ready-check/lobby-state UIs, or otherwise touches client.multiplayer, MultiplayerService, MultiplayerModels, RoomSnapshotResponse, RealtimeEnvelope, or EnvelopeType — even if they don't name the module explicitly."
+    },
+    {
+      "name": "premium-system",
+      "description": "Build a premium / subscription / VIP-tier system in a game on the iDosGames TypeScript SDK (@idosgames/core) via client.premium (PremiumService): load premium tier definitions, load the player's active subscriptions, activate a free trial, purchase a premium tier with virtual/item cost, or complete a real-money IAP subscription purchase (App Store / Google Play receipt validation). This is the player's subscription/IAP tier that other modules (Store cost discounts via ResourceConsume.PremiumDiscounts, reward/lootbox grant multipliers via ResourceGrant.PremiumTiers, segment gates via SegmentGate.MinPremiumTier) read to unlock perks. Use whenever the user wants a subscription/VIP/battle-pass-tier paywall, IAP receipt validation, trial flows, or touches client.premium, PremiumService, PremiumDefinition, MaxActiveTier, or premium discounts/multipliers — even if they don't name the module explicitly."
+    },
+    {
+      "name": "quest-system",
+      "description": "Build a quest / daily-task system in a game on the iDosGames TypeScript SDK (@idosgames/core) via client.quest (QuestService): load quest and cycle definitions, load the player's quest progress state, add progress toward a metric, claim a completed quest's reward, claim a points-track milestone reward, claim a group-completion (grand) reward, and refresh cycles (dailies/ weeklies) forward. Use this whenever the user is working in the iDosGames TS SDK or its game templates (board-game, idle-rpg) and wants daily/weekly quest screens, task lists, objective/progress trackers, battle-pass-style points tracks, milestone reward ladders, quest-group completion bonuses, or otherwise touches client.quest, QuestService, QuestDefinitions, UserQuestState, QuestPointsTrackView, or MilestoneDefinition — even if they don't name the module explicitly."
+    },
+    {
+      "name": "referral-system",
+      "description": "Build a referral / invite-a-friend system in a game on the iDosGames TypeScript SDK (@idosgames/core) via client.referral (ReferralService): load referral config (activation reward, staged follower-count invite rewards, spend-kickback rules), load the player's own referral state (who they're subscribed to, follower count, claimed invite rewards), activate someone else's referral code, and claim a staged invite reward. Use this whenever the user is working in the iDosGames TS SDK or its game templates (board-game, idle-rpg) and wants invite-friend / referral-code / refer-a-friend UIs, follower-milestone reward screens, or otherwise touches client.referral, ReferralService, ReferralDefinitions, UserReferralState, or referral codes — even if they don't name the module explicitly."
+    },
+    {
+      "name": "reward-system",
+      "description": "Build daily-login, idle/offline-income, comeback, and generic claimable reward systems in a game on the iDosGames TypeScript SDK (@idosgames/core) via client.reward (RewardService): load reward definitions and the player's reward state, claim a daily-calendar login-streak reward, collect accrued idle/offline income, claim a \"welcome back\" comeback bonus, claim a generic one-shot or repeating reward, and read the milestone reward multiplier. Use this whenever the user is working in the iDosGames TS SDK or its game templates (board-game, idle-rpg) and wants a daily rewards calendar, login streak, idle/AFK income, offline earnings, a \"welcome back\" bonus, achievement/quest-style claim buttons, or otherwise touches client.reward, RewardService, RewardModels, RewardDefinitions, DailyCalendarDefinition, IdleAccrualDefinition, ComebackRewardDefinition, or ClaimRewardDefinition — even if they don't name the module explicitly."
+    },
+    {
+      "name": "season-system",
+      "description": "Build a season / battle-pass-style meta-progression system in a game on the iDosGames TypeScript SDK (@idosgames/core) via client.season (SeasonService): load season chain definitions, fetch the currently active season in a chain, load the player's per-chain season state, grant status tokens (season XP/points) that advance a tier track, and claim a reached tier's reward. Use this whenever the user is working in the iDosGames TS SDK or its game templates (board-game, idle-rpg) and wants a season pass, battle pass, status track, tier-reward system, seasonal meta-progression, or otherwise touches client.season, SeasonService, SeasonDefinitions, SeasonChainDefinition, SeasonTierDefinition, ActiveSeasonInfo, or UserSeasonState — even if they don't name the module explicitly."
+    },
+    {
+      "name": "social-system",
+      "description": "Build a friends / social system in a game on the iDosGames TypeScript SDK (@idosgames/core) via client.social (SocialService): load the friends list, incoming friend requests, and recommended friends, send/accept/decline friend requests, remove a friend, and read the social activity timeline (attacks, raids, friend-adds). Use this whenever the user is working in the iDosGames TS SDK or its game templates (board-game, idle-rpg) and wants a friends list screen, friend-request inbox, add-friend flow, recommended friends / player search, or an activity feed, or otherwise touches client.social, SocialService, SocialModels, FriendPublicProfile, or the social timeline — even if they don't name the module explicitly."
+    },
+    {
+      "name": "store-system",
+      "description": "Build a store / shop system in a game on the iDosGames TypeScript SDK (@idosgames/core) via client.store (StoreService): load storefront and offer (SKU) definitions, load the player's purchase counters, and purchase one or many offers (currency/item packs, bundles, cosmetics) with virtual/item cost. Use this whenever the user is working in the iDosGames TS SDK or its game templates (board-game, idle-rpg) and wants a shop/store screen, IAP-style SKU catalogs, purchase-limit UI (daily/total caps), or otherwise touches client.store, StoreService, StoreDefinitions, StoreOfferDefinition, or offer purchasing — even if they don't name the module explicitly."
+    },
+    {
+      "name": "timed-boost-system",
+      "description": "Build temporary player boosts (XP/resource/stat multipliers) in a game on the iDosGames TypeScript SDK (@idosgames/core) via client.timedBoost (TimedBoostService): load boost definitions (manual, scheduled \"happy hour\", chained, and auto-triggered), activate a manual boost, read the player's currently-active boost instances, read currently-active global boost windows, and clean up expired boosts. Use this whenever the user is working in the iDosGames TS SDK or its game templates (board-game, idle-rpg) and wants temporary multiplier/buff systems, double-XP or double-reward events, happy-hour style scheduled bonuses, boost stacking rules, or otherwise touches client.timedBoost, TimedBoostService, TimedBoostDefinitions, ActiveTimedBoost, or TimedBoostStackingPolicy — even if they don't name the module explicitly."
+    },
+    {
+      "name": "timed-event-system",
+      "description": "Build a time-boxed live-ops event system in a game on the iDosGames TypeScript SDK (@idosgames/core) via client.timedEvent (TimedEventService): load active events and their title-wide definitions, read the player's per-event-instance token progress, spend event tokens (single + batch), grant event tokens (single + batch, server/trigger-driven), and claim milestone rewards as token balances cross thresholds (single, batch, and claim-all). Use this whenever the user is working in the iDosGames TS SDK or its game templates (board-game, idle-rpg) and wants limited-time events, seasonal/live-ops event screens, event-token or event-currency progress bars, milestone/reward-track UIs, chain/rotation events, Coin-Master-style bonus windows, or otherwise touches client.timedEvent, TimedEventService, TimedEventDefinitions, ActiveEventInfo, EventTokenProgress, or MilestoneDefinition — even if they don't name the module explicitly."
+    },
+    {
+      "name": "title-system",
+      "description": "Fetch the iDosGames TypeScript SDK (@idosgames/core) title-level bootstrap config via client.title (TitleService): the full title public configuration bundle, title-wide public custom data, server time, and the standalone currency/item definitions endpoints. Also documents the config-section registry (`client.data.config.getSection<T>(\"Section\")`) that every other module's skill depends on. Use this whenever the user is working in the iDosGames TS SDK or its game templates (board-game, idle-rpg) and wants app boot/init sequences, server time sync, title-wide custom data, or otherwise touches client.title, TitleService, TitlePublicConfigurationModel, getTitlePublicConfiguration, or the title-level GetCurrencyDefinitions / GetItemDefinitions calls — even if they don't name the module explicitly."
+    },
+    {
+      "name": "user-custom-data",
+      "description": "Build a generic per-player key-value data store in a game on the iDosGames TypeScript SDK (@idosgames/core) via client.userCustomData (UserCustomDataService): set/get/delete private (only-you-readable) and public (readable-by-others) string keys, batch set/delete many keys atomically, batch-read public data for many players at once, and load the title's schema-managed key registry. Use this whenever the user is working in the iDosGames TS SDK or its game templates (board-game, idle-rpg) and wants player settings/preferences storage, profile flair or badges visible to other players, arbitrary save-data slots, or otherwise touches client.userCustomData, UserCustomDataService, UserCustomDataModels, CustomDataBucket, or UserCustomDataRecord — even if they don't name the module explicitly."
+    },
+    {
+      "name": "user-profile",
+      "description": "Work with the player's own account/session state in the iDosGames TS SDK (@idosgames/core) via client.user (UserService): bootstrap the whole per-player cache at login (ClientState — title config + every module's user state), load the raw inventory snapshot (currencies, items, unstackable instances), read usage-time / session stats, change the username, and delete the account. Use this whenever the user is working in the iDosGames TS SDK or its game templates (board-game, idle-rpg) and wants login/session bootstrapping, a profile or account screen, usage-time / playtime tracking, username changes, account deletion, raw inventory reads, or otherwise touches client.user, UserService, ClientState, UserState, UserInventoryState, UsageTimeStats, or client.data.user.state — even if they don't name the module explicitly."
+    }
+  ]
+}