@forgeax/game 0.3.6 → 0.3.8

package/dist/main.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/main.ts
-import { resolve as resolve17 } from "node:path";
+import { resolve as resolve14 } from "node:path";
 
 // src/mcp/protocol.ts
 var MCP_PROTOCOL_VERSION = "2024-11-05";
@@ -416,11 +416,10 @@ reasoning and game-code edits; the plugin owns the exact Engine Preview adapter.
   public https URL, or a local file path when COS is configured (it is uploaded and
   passed as a short-lived presigned URL). They need \`FORGEAX_LITELLM_API_KEY\` (and
   \`FORGEAX_COS_*\` for local-file image-to-3D) in the environment.
-- Reusing an existing/library/stock/licensed 3D asset requires the project-local
-  \`asset3d-search/search_asset\` MCP tool. If it is absent, report exactly
-  \`BLOCKED(asset-library-tools-missing)\`; do not call procedural geometry an asset
-  library and do not silently substitute generation. \`forgeax_generate_3d\` is only
-  for an explicitly bespoke asset or a user-approved fallback after an empty search.
+- Reusing a library 3D asset: read the installed \`art-3d-asset-library\` Skill
+  and use its pinned CLI to search candidates and import the selected ID.
+  If not enabled, report the missing setup. Do not relabel procedural geometry
+  or generated models as library results.
 - Creating a game, switching the active game, installing or upgrading the plugin:
   these are one-time operations and are CLI subcommands, not MCP tools. Run
   \`npx -y @forgeax/game <init|use|doctor|devkit|upgrade>\`.
@@ -514,6 +513,7 @@ function sameFile(left, right) {
 }
 function copySkill(source, destination) {
   const destinationIsSymlink = existsSync(destination) && lstatSync(destination).isSymbolicLink();
+  const linksToSource = destinationIsSymlink && realpathSync2(source) === realpathSync2(destination);
   if (!destinationIsSymlink && existsSync(destination) && realpathSync2(source) === realpathSync2(destination))
     return false;
   const files = filesUnder(source);
@@ -521,9 +521,11 @@ function copySkill(source, destination) {
   if (!changed)
     return false;
   if (existsSync(destination)) {
-    const backup = `${destination}.bak.latest`;
-    rmSync(backup, { recursive: true, force: true });
-    cpSync(destination, backup, { recursive: true });
+    if (!linksToSource) {
+      const backup = `${destination}.bak.latest`;
+      rmSync(backup, { recursive: true, force: true });
+      cpSync(destination, backup, { recursive: true });
+    }
     rmSync(destination, { recursive: true, force: true });
   }
   for (const path of files) {
@@ -2286,7 +2288,6 @@ import { existsSync as existsSync5, mkdirSync as mkdirSync5, readFileSync as rea
 import { basename as basename2, extname as extname2, join as join7, relative as relative5 } from "node:path";
 
 // src/gen/config.ts
-var DEFAULT_LITELLM_BASE_URL = "http://21.214.33.175:4000";
 var DEFAULT_MODELS = {
   textToImage: "gemini-3-pro-image",
   textTo3d: "tripo-3d-text",
@@ -2297,11 +2298,15 @@ function env(name) {
   return value ? value : undefined;
 }
 function resolveLiteLlmConfig() {
-  const baseUrl = (env("FORGEAX_LITELLM_BASE_URL") ?? DEFAULT_LITELLM_BASE_URL).replace(/\/+$/, "");
   const apiKey = env("FORGEAX_LITELLM_API_KEY");
   if (!apiKey) {
     throw new Error("FORGEAX_LITELLM_API_KEY is not set. Export the LiteLLM key so the asset tools can reach the gateway, e.g. `export FORGEAX_LITELLM_API_KEY=sk-...`.");
   }
+  const configuredBaseUrl = env("FORGEAX_LITELLM_BASE_URL");
+  if (!configuredBaseUrl) {
+    throw new Error("FORGEAX_LITELLM_BASE_URL is not set. Set the LiteLLM gateway URL before using the asset generation tools.");
+  }
+  const baseUrl = configuredBaseUrl.replace(/\/+$/, "");
   return {
     baseUrl,
     apiKey,
@@ -2680,13 +2685,13 @@ async function generate3dTool(args, cwd) {
   const image = typeof args.image === "string" ? args.image.trim() : "";
   if (!prompt && !image)
     throw new Error("Provide `prompt` (text-to-3D) or `image` (image-to-3D).");
-  const cfg = resolveLiteLlmConfig();
   const targetDir = typeof args.target_dir === "string" ? args.target_dir : cwd;
   const { dir, root, slug } = assetsDirFor(targetDir, typeof args.game === "string" ? args.game : undefined);
+  const imageUrl = image ? await resolveImageUrlFor3d(image, slug) : undefined;
+  const cfg = resolveLiteLlmConfig();
   let result;
   let mode;
-  if (image) {
-    const imageUrl = await resolveImageUrlFor3d(image, slug);
+  if (imageUrl) {
     const model = typeof args.model === "string" && args.model.trim() ? args.model.trim() : cfg.models.imageTo3d;
     result = await generate3dFromImageUrl(cfg, { model, imageUrl, prompt: prompt || undefined, onProgress: logProgress("image-to-3D") });
     mode = "image-to-3D";
@@ -2945,6 +2950,68 @@ function gameFileTools() {
     }
   ];
 }
+// package.json
+var package_default = {
+  packageManager: "bun@1.4.0",
+  name: "@forgeax/game",
+  version: "0.3.8",
+  private: false,
+  type: "module",
+  description: "@forgeax/game — an MCP/CLI connector for exact released ForgeaX Engine games and Engine-owned Preview.",
+  main: "./dist/main.js",
+  bin: {
+    "forgeax-game": "dist/main.js",
+    game: "dist/main.js"
+  },
+  engines: {
+    node: ">=22.13.0"
+  },
+  publishConfig: {
+    access: "public",
+    registry: "https://registry.npmjs.org/"
+  },
+  files: [
+    "dist",
+    "assets",
+    "docs/asset3d.md",
+    "docs/plugin-integration-standard.md",
+    "README.md"
+  ],
+  scripts: {
+    build: "bun build.mjs",
+    "release:check": "bun scripts/check-package-artifact.ts",
+    acceptance: "bun scripts/accept-packed-consumer.ts",
+    "release:publish": "bun scripts/publish-package.ts",
+    prepack: "bun build.mjs",
+    typecheck: "tsc --noEmit",
+    test: "bun test test/*.test.ts",
+    start: "bun src/main.ts",
+    "mcp:inspect": "npx @modelcontextprotocol/inspector node dist/main.js"
+  },
+  keywords: [
+    "forgeax",
+    "mcp",
+    "model-context-protocol",
+    "game-development",
+    "codex",
+    "claude-code"
+  ],
+  license: "MIT",
+  dependencies: {
+    "@forgeax/engine-sdk": "0.1.26",
+    pnpm: "11.7.0"
+  },
+  devDependencies: {
+    fflate: "0.8.2",
+    "@types/bun": "^1.2.0",
+    typescript: "^5.9.2"
+  },
+  directories: {
+    doc: "docs",
+    test: "test"
+  },
+  author: ""
+};
 
 // src/install/release-manifest.ts
 var RELEASE_IDENTITY_SCHEMA = "forgeax.game.release-identity/1";
@@ -2953,7 +3020,7 @@ var RELEASE_IDENTITY_MIME = "application/vnd.forgeax.game-release-identity+json"
 var RELEASE_IDENTITY = Object.freeze({
   schema: RELEASE_IDENTITY_SCHEMA,
   gamePackage: "@forgeax/game",
-  gameVersion: "0.3.5",
+  gameVersion: package_default.version,
   gameBin: "forgeax-game",
   engineSdkPackage: ENGINE_SDK_PACKAGE,
   engineSdkVersion: ENGINE_VERSION,
@@ -3233,9 +3300,8 @@ async function startHttpMcpServer(spec, options) {
 }
 
 // src/cli/dispatch.ts
-import { existsSync as existsSync12, readFileSync as readFileSync17, writeFileSync as writeFileSync12 } from "node:fs";
-import { arch as arch2, homedir as homedir5, platform as platform2 } from "node:os";
-import { join as join12, resolve as resolve16 } from "node:path";
+import { existsSync as existsSync9, readFileSync as readFileSync14, writeFileSync as writeFileSync10 } from "node:fs";
+import { join as join11 } from "node:path";
 
 // src/install/clients.ts
 import { homedir as homedir2 } from "node:os";
@@ -3356,30 +3422,19 @@ function findClient(id) {
   return CLIENTS.find((client) => client.id === id || client.aliases?.includes(id));
 }
 var SERVER_KEY = "forgeax";
-var ASSET3D_SERVER_KEY = "asset3d-search";
 function launchSpec(mode) {
   if (mode === "local") {
     return { command: process.execPath, args: [resolve9(process.argv[1] ?? ""), "mcp"] };
   }
   return {
     command: "npx",
-    args: ["-y", "-p", "@forgeax/game@0.3.5", "forgeax-game", "mcp"]
-  };
-}
-function asset3dLaunchSpec(mode) {
-  const launch = launchSpec(mode);
-  if (launch.args.at(-1) !== "mcp") {
-    throw new Error("asset3d_game_plugin_launch_invalid: expected MCP launch suffix");
-  }
-  return {
-    command: launch.command,
-    args: [...launch.args.slice(0, -1), "asset3d", "mcp"]
+    args: ["-y", "-p", `@forgeax/game@${RELEASE_IDENTITY.gameVersion}`, "forgeax-game", "mcp"]
   };
 }
 
 // src/install/write-config.ts
 import { copyFileSync as copyFileSync2, existsSync as existsSync7, mkdirSync as mkdirSync7, readFileSync as readFileSync11, writeFileSync as writeFileSync7 } from "node:fs";
-import { dirname as dirname8 } from "node:path";
+import { basename as basename3, dirname as dirname8, isAbsolute as isAbsolute3, resolve as resolve10 } from "node:path";
 
 // src/install/toml-section.ts
 var HEADER_RE = /^[ \t]*\[([^[\]\r\n]+)\][ \t]*(?:#[^\r\n]*)?\r?$/gm;
@@ -4030,7 +4085,7 @@ function applyConfig(spec, projectRoot, launch, serverKey = SERVER_KEY) {
   writeFileSync7(path, merged.content);
   return { path, changed: true, ...backup ? { backup } : {} };
 }
-function removeConfig(spec, projectRoot, serverKey = SERVER_KEY) {
+function removeConfig(spec, projectRoot, serverKey = SERVER_KEY, backupSuffix = ".bak.latest") {
   const path = spec.path(projectRoot);
   if (!existsSync7(path))
     return { path, changed: false };
@@ -4060,11 +4115,56 @@ function removeConfig(spec, projectRoot, serverKey = SERVER_KEY) {
   }
   if (content === existing)
     return { path, changed: false };
-  const backup = `${path}.bak.latest`;
+  const backup = `${path}${backupSuffix}`;
   copyFileSync2(path, backup);
   writeFileSync7(path, content);
   return { path, changed: true, backup };
 }
+function retireAsset3dConfig(spec, projectRoot) {
+  const key = "asset3d-search";
+  const path = spec.path(projectRoot);
+  if (!existsSync7(path))
+    return "absent";
+  try {
+    const text = readFileSync11(path, "utf8");
+    let entry;
+    if (spec.format === "toml") {
+      const table = readTomlTable(text, `mcp_servers.${key}`);
+      if (table === undefined) {
+        return hasCompetingTomlDefinition(text, `mcp_servers.${key}`) ? "preserved" : "absent";
+      }
+      const command2 = table.match(/^command\s*=\s*(".*")\s*$/m)?.[1];
+      const args2 = table.match(/^args\s*=\s*(\[.*\])\s*$/m)?.[1];
+      if (!command2 || !args2)
+        return "preserved";
+      entry = { command: JSON.parse(command2), args: JSON.parse(args2) };
+      const expected = readTomlTable(mergeTomlConfig(undefined, entry, key).content, `mcp_servers.${key}`);
+      if (table.trim() !== expected?.trim() || /^\s*\[.*asset3d-search.*\.\s*[\w"']/m.test(text))
+        return "preserved";
+    } else {
+      entry = jsonServerEntry(JSON.parse(text), spec, key);
+      if (entry === undefined)
+        return "absent";
+    }
+    if (!entry || typeof entry !== "object")
+      return "preserved";
+    const command = spec.commandShape === "argv" && Array.isArray(entry.command) ? entry.command[0] : entry.command;
+    const args = spec.commandShape === "argv" && Array.isArray(entry.command) ? entry.command.slice(1) : entry.args;
+    if (typeof command !== "string" || !Array.isArray(args) || !args.every((x) => typeof x === "string"))
+      return "preserved";
+    const published = command === "npx" && args.length === 6 && args[0] === "-y" && args[1] === "-p" && /^@forgeax\/game@\d+\.\d+\.\d+(?:-[\w.-]+)?$/.test(args[2]) && args[3] === "forgeax-game" && args[4] === "asset3d" && args[5] === "mcp";
+    let local = false;
+    if (isAbsolute3(command) && /^(node|node.exe)$/.test(basename3(command)) && args.length === 3 && isAbsolute3(args[0]) && args[1] === "asset3d" && args[2] === "mcp" && basename3(args[0]) === "main.js" && basename3(dirname8(args[0])) === "dist") {
+      const pkg = JSON.parse(readFileSync11(resolve10(dirname8(args[0]), "..", "package.json"), "utf8"));
+      local = pkg.name === "@forgeax/game";
+    }
+    if (!(published || local) || inspectConfig(spec, projectRoot, { command, args }, key).state !== "current")
+      return "preserved";
+    return removeConfig(spec, projectRoot, key, ".asset3d-retired.bak").changed ? "removed" : "absent";
+  } catch {
+    return "preserved";
+  }
+}
 
 // src/install/verify.ts
 import { spawn as spawn2 } from "node:child_process";
@@ -4075,8 +4175,8 @@ function commandText(launch) {
   return [launch.command, ...launch.args].map((part) => JSON.stringify(part)).join(" ");
 }
 function rpcRequest(child, pending, id, method, params = {}) {
-  return new Promise((resolve10, reject) => {
-    pending.set(id, resolve10);
+  return new Promise((resolve11, reject) => {
+    pending.set(id, resolve11);
     child.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", id, method, params })}
 `, (error) => {
       if (!error)
@@ -4141,11 +4241,11 @@ async function verifyLaunchInternal(launch, timeoutMs, requireReleaseIdentity) {
       }
       if (typeof response.id !== "number")
         continue;
-      const resolve10 = pending.get(response.id);
-      if (!resolve10)
+      const resolve11 = pending.get(response.id);
+      if (!resolve11)
         continue;
       pending.delete(response.id);
-      resolve10(response);
+      resolve11(response);
     }
   });
   const timeout = new Promise((_, reject) => {
@@ -4249,52 +4349,91 @@ async function verifyLaunchInternal(launch, timeoutMs, requireReleaseIdentity) {
   }
 }
 
-// src/asset3d/install.ts
-import { spawn as spawn3, spawnSync as spawnSync3 } from "node:child_process";
-import { createHash as createHash7 } from "node:crypto";
-import {
-  chmodSync as chmodSync4,
-  copyFileSync as copyFileSync3,
-  existsSync as existsSync8,
-  lstatSync as lstatSync7,
-  mkdirSync as mkdirSync9,
-  mkdtempSync as mkdtempSync2,
-  readFileSync as readFileSync12,
-  readdirSync as readdirSync6,
-  realpathSync as realpathSync7,
-  renameSync as renameSync6,
-  rmSync as rmSync5,
-  unlinkSync as unlinkSync2,
-  writeFileSync as writeFileSync9
-} from "node:fs";
-import { homedir as homedir3, platform, arch } from "node:os";
-import { basename as basename3, dirname as dirname10, isAbsolute as isAbsolute3, join as join10, relative as relative8, resolve as resolve10, sep as sep5 } from "node:path";
-import { fileURLToPath as fileURLToPath3 } from "node:url";
-
-// src/asset3d/constants.ts
-import { createHash as createHash6 } from "node:crypto";
-var PROVIDER_BUNDLE_SCHEMA = "forgeax.asset3d-provider-bundle/1.0.0";
-var PROVIDER_RESULT_SCHEMA = "forgeax.asset3d-search-result/1.0.0";
-var PROVIDER_RECEIPT_SCHEMA = "forgeax.asset3d-search-receipt/1.0.0";
-var K0_PACKAGE_SHA256 = "4937fe00e2b919319c70c82db53ebe359b275ed662c026153ecb97f7601262b4";
-var RESULT_SCHEMA_SHA256 = "f97a9aa8b2ce0662c37d314211aae52951cbd0b76b3a7c140dc608be4712c415";
-var RECEIPT_SCHEMA_SHA256 = "e0dc9e9fe9872f09af9fca6d0c17d22aca63c2b546c55c0b669c581f7059b9c4";
-var ASSET3D_PROVIDER_COMMIT = "a274238712c1dced99e4aa3148a0d15904ce2a90";
-var BUNDLED_ASSET3D_PROVIDERS = Object.freeze({
-  "darwin-arm64": {
-    sha256: "4f2d971c037a32eaed20e51e13a88bff91d2ea8f4d37894526c089376c3bacba",
-    relativePath: "asset3d/provider/asset3d-search-provider-a274238712c1dced99e4aa3148a0d15904ce2a90-darwin-arm64.tar.gz"
-  },
-  "linux-x64": {
-    sha256: "af97e7e267b558960156175c840c3c2d2cd7aabf68f1f72c7d64b6d50742a79e",
-    relativePath: "asset3d/provider/asset3d-search-provider-a274238712c1dced99e4aa3148a0d15904ce2a90-linux-x64.tar.gz"
+// src/devkit/engine-mounts.ts
+import { lstatSync as lstatSync7, readFileSync as readFileSync12, readdirSync as readdirSync6, readlinkSync as readlinkSync2, rmdirSync, unlinkSync as unlinkSync2, writeFileSync as writeFileSync8 } from "node:fs";
+import { dirname as dirname9, join as join10, resolve as resolve11 } from "node:path";
+var HOSTS = {
+  ".agents/skills": ["codex"],
+  ".claude/skills": ["claude"],
+  ".cursor/skills": ["cursor"],
+  ".codebuddy/skills": ["codebuddy", "workbuddy"],
+  ".workbuddy/skills": ["workbuddy"]
+};
+function pruneUnselectedEngineMounts(root, clients) {
+  const manifestPath = join10(root, ".forgeax", "skill-install-manifest.json");
+  const regular = (path) => {
+    try {
+      const stat = lstatSync7(path);
+      return stat.isFile() && !stat.isSymbolicLink();
+    } catch {
+      return false;
+    }
+  };
+  const directory = (path) => {
+    try {
+      const stat = lstatSync7(path);
+      return stat.isDirectory() && !stat.isSymbolicLink();
+    } catch {
+      return false;
+    }
+  };
+  if (!directory(join10(root, ".forgeax")) || !regular(manifestPath))
+    return [];
+  let manifest;
+  try {
+    manifest = JSON.parse(readFileSync12(manifestPath, "utf8"));
+  } catch {
+    return [];
   }
-});
-var INSTALL_SCHEMA = "forgeax.asset3d-install/1.0.0";
-var TRANSACTION_SCHEMA = "forgeax.asset3d-transaction/1.0.0";
-var PROVENANCE_SCHEMA = "forgeax.asset3d-provenance/1.0.0";
-var MAX_JSON_BYTES = 1024 * 1024;
-var SKILL_MOUNTS = Object.freeze({
+  if (!manifest || manifest.schemaVersion !== "1.0.0" || manifest.sourceRoot !== "skills" || !Array.isArray(manifest.mounts))
+    return [];
+  const removed = [];
+  for (const mount of manifest.mounts) {
+    if (!mount || typeof mount.root !== "string" || !Object.hasOwn(HOSTS, mount.root))
+      continue;
+    const hosts = HOSTS[mount.root];
+    if (!hosts || hosts.some((host) => clients.includes(host)) || !Array.isArray(mount.skills))
+      continue;
+    if (!mount.skills.length || !mount.skills.every((id) => /^forgeax-engine-[a-z0-9-]+$/.test(id)) || new Set(mount.skills).size !== mount.skills.length)
+      continue;
+    const path = join10(root, mount.root);
+    if (!directory(dirname9(path)) || !directory(path))
+      continue;
+    const expected = [".gitignore", ...mount.skills].sort();
+    if (JSON.stringify(readdirSync6(path).sort()) !== JSON.stringify(expected))
+      continue;
+    const ignore = join10(path, ".gitignore");
+    const expectedIgnore = ["# BEGIN FORGEAX MANAGED SKILLS", ...mount.skills.map((id) => `/${id}`), "# END FORGEAX MANAGED SKILLS", ""].join(`
+`);
+    if (!regular(ignore) || readFileSync12(ignore, "utf8") !== expectedIgnore)
+      continue;
+    if (!mount.skills.every((id) => {
+      const link = join10(path, id);
+      return lstatSync7(link).isSymbolicLink() && resolve11(path, readlinkSync2(link)) === resolve11(root, "skills", id);
+    }))
+      continue;
+    for (const id of mount.skills)
+      unlinkSync2(join10(path, id));
+    unlinkSync2(ignore);
+    rmdirSync(path);
+    if (readdirSync6(dirname9(path)).length === 0)
+      rmdirSync(dirname9(path));
+    removed.push(mount.root);
+  }
+  if (removed.length) {
+    manifest.mounts = manifest.mounts.filter((mount) => !mount || !removed.includes(mount.root));
+    writeFileSync8(manifestPath, `${JSON.stringify(manifest, null, 2)}
+`);
+  }
+  return removed;
+}
+
+// src/extensions/manager.ts
+import { createHash as createHash6, randomUUID as randomUUID4 } from "node:crypto";
+import { existsSync as existsSync8, lstatSync as lstatSync8, mkdirSync as mkdirSync8, readFileSync as readFileSync13, readdirSync as readdirSync7, realpathSync as realpathSync7, renameSync as renameSync5, rmSync as rmSync5, rmdirSync as rmdirSync2, writeFileSync as writeFileSync9 } from "node:fs";
+import { dirname as dirname10, isAbsolute as isAbsolute4, relative as relative8, resolve as resolve12, sep as sep5 } from "node:path";
+import { fileURLToPath as fileURLToPath3, pathToFileURL } from "node:url";
+var mounts = {
   codex: ".agents/skills",
   claude: ".claude/skills",
   cursor: ".cursor/skills",
@@ -4304,2124 +4443,326 @@ var SKILL_MOUNTS = Object.freeze({
   vscode: ".vscode/skills",
   zcode: ".zcode/skills",
   opencode: ".config/opencode/skills"
-});
-function sha2562(value) {
-  return createHash6("sha256").update(value).digest("hex");
-}
-function canonicalJson(value) {
-  if (value === null || typeof value !== "object")
-    return JSON.stringify(value);
-  if (Array.isArray(value))
-    return `[${value.map(canonicalJson).join(",")}]`;
-  return `{${Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, entry]) => `${JSON.stringify(key)}:${canonicalJson(entry)}`).join(",")}}`;
-}
-
-// src/asset3d/fs.ts
-import { closeSync as closeSync2, fsyncSync, mkdirSync as mkdirSync8, openSync as openSync2, renameSync as renameSync5, writeFileSync as writeFileSync8 } from "node:fs";
-import { dirname as dirname9 } from "node:path";
-function ensurePrivateDir(path) {
-  mkdirSync8(path, { recursive: true, mode: 448 });
-}
-function atomicWrite(path, data, mode = 384) {
-  ensurePrivateDir(dirname9(path));
-  const temp = `${path}.tmp-${process.pid}-${crypto.randomUUID()}`;
-  const fd = openSync2(temp, "wx", mode);
-  try {
-    writeFileSync8(fd, data);
-    fsyncSync(fd);
-  } finally {
-    closeSync2(fd);
-  }
-  renameSync5(temp, path);
-  const dirFd = openSync2(dirname9(path), "r");
-  try {
-    fsyncSync(dirFd);
-  } finally {
-    closeSync2(dirFd);
-  }
-}
-
-// src/asset3d/origins.ts
-import { domainToASCII } from "node:url";
-function canonicalIpv4(host) {
-  const parts = host.split(".");
-  if (parts.length !== 4 || parts.some((part) => !/^\d{1,3}$/.test(part)))
-    return;
-  const values = parts.map(Number);
-  if (values.some((value) => value > 255))
-    throw new Error("download_origin_invalid: invalid IPv4 address");
-  return values.join(".");
-}
-function canonicalizeOrigins(inputs) {
-  if (inputs.length < 1 || inputs.length > 8) {
-    throw new Error("download_origin_count_invalid: expected 1..8 --download-origin values");
-  }
-  const values = inputs.map((input) => {
-    const lexical = /^(https?):\/\/(\[[0-9A-Fa-f:.]+\]|[^:/?#@]+):(\d{1,5})$/.exec(input);
-    if (!lexical) {
-      throw new Error("download_origin_invalid: expected exact scheme://host:port without path, query, fragment, or userinfo");
-    }
-    let parsed;
+};
+var reserved = new Set(["install", "init", "uninstall", "update", "use", "doctor", "preview", "devkit", "agents", "help", "version"]);
+var validId = (id) => /^[a-z][a-z0-9-]{0,63}$/.test(id) && !reserved.has(id);
+var digest = (data) => createHash6("sha256").update(data).digest("hex");
+function safe(root, path) {
+  const target = resolve12(root, path);
+  const rel = relative8(root, target);
+  if (!rel || rel === ".." || rel.startsWith(`..${sep5}`) || isAbsolute4(rel))
+    throw new Error("extension_path_escape");
+  let cursor = root;
+  for (const part of rel.split(sep5)) {
+    cursor = resolve12(cursor, part);
     try {
-      parsed = new URL(input);
-    } catch {
-      throw new Error("download_origin_invalid: malformed URL");
-    }
-    if (parsed.protocol !== "http:" && parsed.protocol !== "https:")
-      throw new Error("download_origin_invalid: http or https required");
-    if (parsed.username || parsed.password || parsed.pathname !== "/" || parsed.search || parsed.hash) {
-      throw new Error("download_origin_invalid: userinfo/path/query/fragment is forbidden");
-    }
-    const port = Number(lexical[3]);
-    if (!Number.isInteger(port) || port < 1 || port > 65535)
-      throw new Error("download_origin_invalid: explicit port must be 1..65535");
-    let host = lexical[2];
-    if (host === "*" || host.includes("*"))
-      throw new Error("download_origin_invalid: wildcard host is forbidden");
-    if (host.startsWith("[") && host.endsWith("]")) {
-      const normalized = new URL(`${parsed.protocol}//${host}:${port}`).hostname;
-      host = normalized.startsWith("[") ? normalized.toLowerCase() : `[${normalized.toLowerCase()}]`;
-    } else {
-      host = canonicalIpv4(host) ?? domainToASCII(host.replace(/\.$/, "")).toLowerCase();
-      if (!host)
-        throw new Error("download_origin_invalid: host cannot be canonicalized");
+      if (lstatSync8(cursor).isSymbolicLink())
+        throw new Error("extension_symlink_not_allowed");
+    } catch (error) {
+      if (error.code !== "ENOENT")
+        throw error;
     }
-    return `${lexical[1]}://${host}:${port}`;
-  }).sort();
-  if (new Set(values).size !== values.length)
-    throw new Error("download_origin_duplicate: canonical duplicates are forbidden");
-  const compactJson = canonicalJson(values);
-  return { values, compactJson, digest: sha2562(compactJson) };
-}
-
-// src/asset3d/install.ts
-var K0_FILES = [
-  "PLATFORM.md",
-  "PLATFORM.planning.md",
-  "PLATFORM.implementation.md",
-  "PLATFORM.verification.md",
-  "reference.md",
-  "package.json",
-  "scripts/pack-deterministic.mjs",
-  "scripts/validate-workflow.mjs",
-  "scripts/workflow.test.mjs"
-];
-var SKILL_ID = "art-3d-asset-library";
-function packagedAsset3dProvider(relativePathInput, assetsRootInput) {
-  const assetsRoot = realpathSync7(assetsRootInput ?? defaultAssetsRoot());
-  const relativePath = relativePathInput.replaceAll("\\", "/");
-  if (!relativePath || relativePath.startsWith("/") || relativePath.split("/").some((part) => part === "" || part === "." || part === "..")) {
-    throw new Error("asset3d_bundled_provider_path_invalid");
   }
-  const candidate = resolve10(assetsRoot, relativePath);
-  if (!confined3(assetsRoot, candidate) || !existsSync8(candidate)) {
-    throw new Error("asset3d_bundled_provider_missing: reinstall @forgeax/game");
-  }
-  const metadata = lstatSync7(candidate);
-  if (!metadata.isFile() || metadata.isSymbolicLink()) {
-    throw new Error("asset3d_bundled_provider_invalid: expected a regular package file");
-  }
-  return realpathSync7(candidate);
+  return target;
 }
-function confined3(root, candidate) {
-  const rel = relative8(root, candidate);
-  return rel === "" || !isAbsolute3(rel) && rel !== ".." && !rel.startsWith(`..${sep5}`);
+function write(path, content) {
+  mkdirSync8(dirname10(path), { recursive: true });
+  const temp = `${path}.${randomUUID4()}.tmp`;
+  writeFileSync9(temp, content, { mode: 384 });
+  renameSync5(temp, path);
 }
-function defaultAssetsRoot() {
-  const here = dirname10(fileURLToPath3(import.meta.url));
-  const candidates = [resolve10(here, "..", "assets"), resolve10(here, "..", "..", "assets")];
-  const found = candidates.find((candidate) => existsSync8(join10(candidate, "asset3d", "vibegame-art-3d-asset-library-2.0.0.tgz")));
-  if (!found)
-    throw new Error("asset3d_package_assets_missing: packaged K0 artifact is unavailable");
-  return found;
+function json2(path) {
+  const bytes = readFileSync13(path);
+  if (bytes.length > 1024 * 1024)
+    throw new Error("extension_state_too_large");
+  return JSON.parse(bytes.toString());
 }
-function digestFile(path) {
-  return createHash7("sha256").update(readFileSync12(path)).digest("hex");
+function extensionRoot() {
+  const here = dirname10(fileURLToPath3(import.meta.url));
+  return [resolve12(here, "../assets/extensions"), resolve12(here, "../../extensions")].find(existsSync8) ?? resolve12(here, "../assets/extensions");
 }
-function tarOutput(archive, member) {
-  const result = spawnSync3("tar", ["-xOzf", archive, member], { encoding: null, maxBuffer: 2 * 1024 * 1024 });
-  if (result.status !== 0 || !result.stdout) {
-    throw new Error(`provider_bundle_invalid: cannot read ${member}`);
+function discoverExtensions(root = extensionRoot()) {
+  if (!existsSync8(root))
+    return [];
+  const found = [];
+  for (const id of readdirSync7(root)) {
+    if (!validId(id))
+      continue;
+    const directory = safe(root, id);
+    if (!lstatSync8(directory).isDirectory())
+      continue;
+    const value = json2(safe(directory, "extension.json"));
+    if (value.schemaVersion !== 1 || value.id !== id || typeof value.version !== "string" || !/^\d+\.\d+\.\d+$/.test(value.version) || typeof value.cli !== "string" || !value.cli.endsWith(".mjs") || !Array.isArray(value.skills) || !value.skills.length || value.skills.some((s) => typeof s !== "string" || !/^skills\/[a-z][a-z0-9-]*$/.test(s))) {
+      throw new Error(`extension_manifest_invalid: ${id}`);
+    }
+    safe(directory, value.cli);
+    for (const skill of value.skills)
+      safe(directory, skill + "/SKILL.md");
+    found.push({ ...value, directory });
   }
-  return result.stdout;
+  return found;
 }
-function readBundleManifest(archive) {
-  let manifest;
+function extensionState(root, id) {
+  if (!validId(id))
+    throw new Error("extension_id_invalid");
+  return safe(root, `.forgeax/extensions/${id}`);
+}
+function installation(root, id) {
+  const path = safe(root, `.forgeax/extensions/${id}/install.json`);
+  if (!existsSync8(path))
+    return;
+  const record = json2(path);
+  if (record.schemaVersion !== 1 || record.id !== id || !Array.isArray(record.files))
+    throw new Error("extension_install_invalid");
+  for (const file of record.files) {
+    if (typeof file.path !== "string" || !/^[a-f0-9]{64}$/.test(file.sha256) || !Object.values(mounts).some((mount) => file.path.startsWith(mount + "/")) || !file.path.endsWith("/SKILL.md"))
+      throw new Error("extension_install_invalid");
+    safe(root, file.path);
+  }
+  return record;
+}
+async function load(extension) {
+  let entry = safe(extension.directory, extension.cli);
+  if (!existsSync8(entry) && existsSync8(entry.replace(/\.mjs$/, ".ts")))
+    entry = entry.replace(/\.mjs$/, ".ts");
+  const mod = await import(pathToFileURL(entry).href);
+  if (typeof mod.check !== "function" || typeof mod.run !== "function")
+    throw new Error("extension_cli_invalid");
+  return mod;
+}
+function context(root, id) {
+  return { projectRoot: root, stateDir: extensionState(root, id), packageVersion: RELEASE_IDENTITY.gameVersion };
+}
+function lock(root) {
+  const path = safe(realpathSync7(root), ".forgeax/extension-operation.lock");
+  mkdirSync8(dirname10(path), { recursive: true });
   try {
-    manifest = JSON.parse(tarOutput(archive, "bundle-manifest.json").toString("utf8"));
+    mkdirSync8(path);
   } catch {
-    throw new Error("provider_bundle_invalid: bundle-manifest.json is not valid JSON");
-  }
-  if (!manifest || typeof manifest !== "object" || Array.isArray(manifest)) {
-    throw new Error("provider_bundle_invalid: bundle manifest must be an object");
-  }
-  return manifest;
-}
-function currentTarget() {
-  const os = platform() === "win32" ? "windows" : platform();
-  const cpu = arch() === "x64" || arch() === "arm64" ? arch() : arch();
-  return `${os}-${cpu}`;
-}
-function validateBundleIdentity(manifest) {
-  if (manifest.schema !== PROVIDER_BUNDLE_SCHEMA)
-    throw new Error("provider_bundle_invalid: schema mismatch");
-  if (manifest.providerCommit !== ASSET3D_PROVIDER_COMMIT)
-    throw new Error("provider_bundle_invalid: provider commit mismatch");
-  if (manifest.resultSchema?.sha256 !== RESULT_SCHEMA_SHA256 || manifest.receiptSchema?.sha256 !== RECEIPT_SCHEMA_SHA256) {
-    throw new Error("provider_bundle_invalid: checked schema digest mismatch");
-  }
-  if (manifest.python !== ">=3.11,<3.13" || typeof manifest.entryPoint !== "string") {
-    throw new Error("provider_bundle_invalid: runtime contract mismatch");
-  }
-  if (manifest.target !== currentTarget()) {
-    throw new Error(`provider_platform_mismatch: bundle target ${String(manifest.target)} cannot run on ${currentTarget()}`);
+    throw new Error("extension_busy: another operation or an interrupted lock requires attention");
   }
+  return () => rmdirSync2(path);
 }
-function choosePython(requested) {
-  const candidates = requested ? [requested] : ["python3.12", "python3.11", "python3"];
-  for (const candidate of candidates) {
-    const result = spawnSync3(candidate, ["-c", 'import sys; print(f"{sys.version_info.major}.{sys.version_info.minor}")'], { encoding: "utf8" });
-    if (result.status === 0 && /^(3\.11|3\.12)\s*$/.test(result.stdout))
-      return candidate;
-  }
-  throw new Error("provider_python_unsupported: system Python 3.11 or 3.12 is required");
+var userState = () => resolve12(process.env.FORGEAX_USER_STATE_DIR ?? resolve12(configuredHome(), ".forgeax"));
+var registryPath = () => resolve12(userState(), "extension-projects.json");
+function registeredProjects() {
+  if (!existsSync8(registryPath()))
+    return [];
+  const value = json2(registryPath());
+  if (!Array.isArray(value) || value.some((p) => typeof p !== "string" || !isAbsolute4(p)))
+    throw new Error("extension_registry_invalid");
+  return value;
 }
-function validProvision(cache, expectedDigest) {
-  if (!existsSync8(cache))
-    return false;
-  try {
-    const manifest = JSON.parse(readFileSync12(join10(cache, "bundle-manifest.json"), "utf8"));
-    return manifest.schema === PROVIDER_BUNDLE_SCHEMA && manifest.providerCommit === ASSET3D_PROVIDER_COMMIT && (manifest.archiveSha256 === undefined || manifest.archiveSha256 === expectedDigest) && existsSync8(join10(cache, "venv", "bin", "python")) && existsSync8(join10(cache, "asset3d-search", "server.py")) && existsSync8(join10(cache, "bin", "asset3d-search"));
-  } catch {
-    return false;
-  }
+function register(root, enabled) {
+  mkdirSync8(userState(), { recursive: true });
+  safe(realpathSync7(userState()), "extension-projects.json");
+  const projects = new Set(registeredProjects());
+  enabled ? projects.add(root) : projects.delete(root);
+  if (projects.size)
+    write(registryPath(), JSON.stringify([...projects]) + `
+`);
+  else if (existsSync8(registryPath()))
+    rmSync5(registryPath());
 }
-function provisionBundle(archive, expectedDigest, cacheRoot, requestedPython) {
-  const actual = digestFile(archive);
-  if (!/^[a-f0-9]{64}$/.test(expectedDigest) || actual !== expectedDigest) {
-    throw new Error(`provider_bundle_digest_mismatch: expected ${expectedDigest}, got ${actual}`);
-  }
-  const manifest = readBundleManifest(archive);
-  validateBundleIdentity(manifest);
-  const cache = resolve10(cacheRoot, expectedDigest);
-  if (validProvision(cache, expectedDigest))
-    return { cache: realpathSync7(cache), manifest };
-  if (existsSync8(cache))
-    throw new Error("provider_cache_invalid: existing digest cache is incomplete or mismatched");
-  ensurePrivateDir(cacheRoot);
-  const stage = mkdtempSync2(join10(cacheRoot, ".provision-"));
+async function enableExtension(rootInput, extension, hosts, args, localEntry) {
+  const release = lock(rootInput);
   try {
-    const verifier = join10(stage, "verify_asset3d_bundle.py");
-    writeFileSync9(verifier, tarOutput(archive, "verify/verify_asset3d_bundle.py"), { mode: 448, flag: "wx" });
-    const python = choosePython(requestedPython);
-    const result = spawnSync3(python, [verifier, "--archive", archive, "--sha256", expectedDigest, "--provision", cache, "--python", python, "--json"], {
-      encoding: "utf8",
-      maxBuffer: 4 * 1024 * 1024
-    });
-    if (result.status !== 0)
-      throw new Error(`provider_provision_failed: ${result.stderr.trim() || result.stdout.trim() || `exit ${result.status}`}`);
-    if (!validProvision(cache, expectedDigest))
-      throw new Error("provider_provision_failed: verifier did not publish a complete cache");
+    return await enableUnlocked(rootInput, extension, hosts, args, localEntry);
   } finally {
-    rmSync5(stage, { recursive: true, force: true });
-  }
-  return { cache: realpathSync7(cache), manifest };
-}
-function useProvisionedCache(providerCache, expectedDigest) {
-  if (!/^[a-f0-9]{64}$/.test(expectedDigest))
-    throw new Error("provider_bundle_digest_invalid");
-  const cache = resolve10(providerCache);
-  if (basename3(cache) !== expectedDigest || !validProvision(cache, expectedDigest)) {
-    throw new Error("asset3d_provider_not_prepared: run the released Asset3D provider installer first");
+    release();
+  }
+}
+async function enableUnlocked(rootInput, extension, hosts, args, localEntry) {
+  const root = realpathSync7(rootInput);
+  const state = extensionState(root, extension.id);
+  const previous = installation(root, extension.id);
+  if (!hosts.length || hosts.some((host) => !mounts[host]))
+    throw new Error("extension_host_required: select installed agents with --ide");
+  const command = localEntry ? `node '${realpathSync7(localEntry).replaceAll("'", "'\\''")}' ${extension.id}` : `npx -y @forgeax/game@${RELEASE_IDENTITY.gameVersion} ${extension.id}`;
+  const files = hosts.flatMap((host) => extension.skills.map((skill) => {
+    const content = readFileSync13(safe(extension.directory, `${skill}/SKILL.md`), "utf8").replaceAll("{{CLI}}", command);
+    return { path: `${mounts[host]}/${skill.slice("skills/".length)}/SKILL.md`, sha256: digest(content), content };
+  }));
+  for (const file of files) {
+    const target = safe(root, file.path);
+    if (existsSync8(target) && digest(readFileSync13(target)) !== previous?.files.find((f) => f.path === file.path)?.sha256) {
+      throw new Error("extension_skill_conflict: " + file.path);
+    }
   }
-  let manifest;
+  const cli = await load(extension);
+  const config = await cli.check(context(root, extension.id), args);
+  const targets = new Map;
+  const remember = (path) => {
+    targets.set(path, existsSync8(path) ? readFileSync13(path) : undefined);
+  };
+  for (const file of files)
+    remember(safe(root, file.path));
+  remember(safe(root, `.forgeax/extensions/${extension.id}/config.json`));
+  remember(safe(root, `.forgeax/extensions/${extension.id}/install.json`));
   try {
-    manifest = JSON.parse(readFileSync12(join10(cache, "bundle-manifest.json"), "utf8"));
-  } catch {
-    throw new Error("provider_cache_invalid: bundle manifest is not valid JSON");
+    write(resolve12(state, "config.json"), JSON.stringify(config) + `
+`);
+    for (const file of files)
+      write(safe(root, file.path), file.content);
+    const record = {
+      schemaVersion: 1,
+      id: extension.id,
+      version: extension.version,
+      packageVersion: RELEASE_IDENTITY.gameVersion,
+      files: [...previous?.files.filter((f) => !files.some((n) => n.path === f.path)) ?? [], ...files.map(({ path, sha256: sha2562 }) => ({ path, sha256: sha2562 }))]
+    };
+    write(resolve12(state, "install.json"), JSON.stringify(record) + `
+`);
+    register(root, true);
+  } catch (error) {
+    for (const [path, old] of targets) {
+      if (old)
+        write(path, old.toString());
+      else if (existsSync8(path))
+        rmSync5(path);
+    }
+    throw error;
   }
-  validateBundleIdentity(manifest);
-  return { cache: realpathSync7(cache), manifest };
-}
-function extractK0(tgz, member) {
-  return tarOutput(tgz, `package/${member}`);
+  return { enabled: true, id: extension.id, version: extension.version, skillFiles: files.length };
 }
-function readInstallManifest(path) {
+function disableExtension(rootInput, id) {
+  const release = lock(rootInput);
   try {
-    const parsed = JSON.parse(readFileSync12(path, "utf8"));
-    return parsed.schemaVersion === INSTALL_SCHEMA ? parsed : undefined;
-  } catch {
-    return;
+    return disableUnlocked(rootInput, id);
+  } finally {
+    release();
   }
 }
-function recoverInstallPublication(forgeax) {
-  const journal = resolve10(forgeax, "asset3d-install.journal.json");
-  if (!existsSync8(journal))
-    return;
-  let record;
-  try {
-    record = JSON.parse(readFileSync12(journal, "utf8"));
-  } catch {
-    throw new Error("asset3d_install_recovery_invalid: malformed install journal");
-  }
-  const config = resolve10(forgeax, "mcp.json");
-  const manifest = resolve10(forgeax, "asset3d-install.json");
-  const complete = typeof record.configDigest === "string" && typeof record.manifestDigest === "string" && existsSync8(config) && existsSync8(manifest) && digestFile(config) === record.configDigest && digestFile(manifest) === record.manifestDigest;
-  if (!complete) {
-    const restore = (path, existed) => {
-      const backup = `${path}.bak.latest`;
-      if (existed === true && existsSync8(backup))
-        copyFileSync3(backup, path);
-      else if (existed === false)
-        rmSync5(path, { force: true });
-      else
-        throw new Error("asset3d_install_recovery_invalid: prior generation cannot be proven");
-    };
-    restore(config, record.previousConfig);
-    restore(manifest, record.previousManifest);
+function disableUnlocked(rootInput, id) {
+  const root = realpathSync7(rootInput);
+  const previous = installation(root, id);
+  if (!previous)
+    return { disabled: true, id, removed: 0, backups: [] };
+  const backups = [];
+  let removed = 0;
+  for (const file of previous.files) {
+    const path = safe(root, file.path);
+    if (existsSync8(path)) {
+      if (digest(readFileSync13(path)) !== file.sha256) {
+        const backup = safe(root, `.forgeax/extension-backups/${id}/${randomUUID4()}/${file.path}`);
+        mkdirSync8(dirname10(backup), { recursive: true });
+        renameSync5(path, backup);
+        backups.push(backup);
+      } else
+        rmSync5(path);
+      removed++;
+    }
+    try {
+      rmdirSync2(dirname10(path));
+    } catch {}
   }
-  unlinkSync2(journal);
+  rmSync5(extensionState(root, id), { recursive: true });
+  const installed = installedExtensions(root);
+  if (!installed.length)
+    register(root, false);
+  return { disabled: true, id, removed, backups };
 }
-function entryDigest(value) {
-  return sha2562(canonicalJson(value));
+function installedExtensions(root) {
+  const dir = safe(root, ".forgeax/extensions");
+  return existsSync8(dir) ? readdirSync7(dir).filter((id) => validId(id) && installation(root, id)) : [];
 }
-function filesUnder2(root, directory = root) {
-  if (!existsSync8(directory))
-    return [];
-  return readdirSync6(directory, { withFileTypes: true }).flatMap((entry) => {
-    const path = resolve10(directory, entry.name);
-    if (entry.isSymbolicLink())
-      throw new Error(`owned_skill_collision: symlink ${path}`);
-    return entry.isDirectory() ? filesUnder2(root, path) : entry.isFile() ? [path] : (() => {
-      throw new Error(`owned_skill_collision: special file ${path}`);
-    })();
-  });
+function disableAllExtensions(root) {
+  return installedExtensions(root).map((id) => disableExtension(root, id));
 }
-function asset3dProxyLaunch(gamePluginLaunch) {
-  if (gamePluginLaunch.args.at(-1) !== "mcp") {
-    throw new Error("asset3d_game_plugin_launch_invalid: expected MCP launch suffix");
+async function runExtension(root, extension, args) {
+  const release = lock(root);
+  try {
+    const record = installation(root, extension.id);
+    if (!record)
+      throw new Error("extension_not_enabled: run " + extension.id + " enable");
+    if (record.version !== extension.version || record.packageVersion !== RELEASE_IDENTITY.gameVersion)
+      throw new Error("extension_version_mismatch: enable with this version");
+    return await (await load(extension)).run(context(root, extension.id), args);
+  } finally {
+    release();
   }
-  return {
-    command: gamePluginLaunch.command,
-    args: [...gamePluginLaunch.args.slice(0, -1), "asset3d", "mcp"]
-  };
 }
-function launchEntries(projectRoot, providerCache, origins, gamePluginLaunch, catalogBaseUrl, awApiBaseUrl, awDepotName, awCredentialFile) {
-  const quarantine = resolve10(projectRoot, ".forgeax", "asset3d-quarantine");
-  const workspace = resolve10(quarantine, "workspace");
-  const proxyLaunch = asset3dProxyLaunch(gamePluginLaunch);
-  return {
-    forgeax: {
-      type: "stdio",
-      command: gamePluginLaunch.command,
-      args: gamePluginLaunch.args,
-      env: {},
-      toolCallTimeoutsMs: { default: 30000, tools: { forgeax_run_current_game: 165000 } }
-    },
-    "asset3d-search": {
-      type: "stdio",
-      command: proxyLaunch.command,
-      args: proxyLaunch.args,
-      env: {
-        FBX2GLTF_BIN: resolve10(providerCache, "bin", "FBX2glTF"),
-        MCP_SHARED_PATH: workspace,
-        MCP_WORKSPACE_ROOT: workspace,
-        MCP_GAME_RUNTIME_ROOT: resolve10(quarantine, "game-runtime"),
-        AW_DOWNLOAD_ORIGINS: origins.compactJson,
-        ...catalogBaseUrl ? { ASSET3D_CATALOG_BASE_URL: catalogBaseUrl } : {},
-        ...awApiBaseUrl ? { AW_API_BASE_URL: awApiBaseUrl } : {},
-        ...awDepotName ? { AW_API_DEPOT_NAME: awDepotName } : {},
-        ...awCredentialFile ? { AW_API_CREDENTIAL_FILE: awCredentialFile } : {}
-      },
-      toolCallTimeoutsMs: { default: 30000, tools: { search_asset: 195000 } }
+
+// src/cli/dispatch.ts
+var HELP = `ForgeaX game development plugin
+
+Usage:
+  forgeax-game install [--ide ${CLIENT_CHOICES.join(",")}] [--local]
+  forgeax-game uninstall [--ide ...] [--purge]
+  forgeax-game uninstall --all-projects [--ide ...]
+  forgeax-game <extension> enable [--ide ...] [--local] [extension options]
+  forgeax-game <extension> disable
+  forgeax-game <extension> <operation> [options]
+  forgeax-game init
+  forgeax-game use <slug>
+  forgeax-game doctor
+  forgeax-game preview stop [--game <slug>] [--target-dir <path>] [--json]
+  forgeax-game devkit install
+  forgeax-game agents update
+  forgeax-game update [--ide ...]
+  forgeax-game version
+  forgeax-game help
+
+With no arguments, forgeax-game runs the stdio MCP server.
+`;
+function parseInstallArgs(args) {
+  let mode = "npx";
+  let ids;
+  for (let i = 0;i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--local") {
+      mode = "local";
+      continue;
     }
-  };
-}
-function mergeConfig(path, entries, previous, replaceOwned) {
-  let config = {};
-  let original = "";
-  if (existsSync8(path)) {
-    original = readFileSync12(path, "utf8");
-    try {
-      config = JSON.parse(original);
-    } catch {
-      throw new Error("project_mcp_config_invalid: top-level JSON is malformed");
+    if (arg === "--ide") {
+      const value = args[++i];
+      if (!value)
+        throw new Error("--ide requires a comma-separated client list");
+      ids = value.split(",").map((id) => id.trim()).filter(Boolean);
+      continue;
     }
-    if (!config || typeof config !== "object" || Array.isArray(config))
-      throw new Error("project_mcp_config_invalid: top-level must be an object");
-  }
-  const current = config.mcpServers;
-  if (current !== undefined && (!current || typeof current !== "object" || Array.isArray(current))) {
-    throw new Error("project_mcp_config_invalid: mcpServers must be an object");
-  }
-  const servers = { ...current ?? {} };
-  for (const name of ["forgeax", "asset3d-search"]) {
-    const existing = servers[name];
-    if (existing === undefined || entryDigest(existing) === entryDigest(entries[name]))
+    if (arg.startsWith("--ide=")) {
+      ids = arg.slice("--ide=".length).split(",").map((id) => id.trim()).filter(Boolean);
       continue;
-    const priorDigest = previous?.configEntryDigests[name];
-    if (!replaceOwned || !priorDigest || entryDigest(existing) !== priorDigest) {
-      throw new Error(`mcp_server_conflict: ${name} differs from the owned entry`);
     }
+    throw new Error(`unknown install option: ${arg}`);
   }
-  servers.forgeax = entries.forgeax;
-  servers["asset3d-search"] = entries["asset3d-search"];
-  const next = { ...config, mcpServers: servers };
-  const bytes = `${JSON.stringify(next, null, 2)}
-`;
-  return {
-    bytes,
-    digests: { forgeax: entryDigest(entries.forgeax), "asset3d-search": entryDigest(entries["asset3d-search"]) },
-    changed: bytes !== original
-  };
+  const selected = ids ?? [...CLIENT_IDS];
+  if (selected.length === 0)
+    throw new Error("--ide did not name any clients");
+  const uniqueNames = [...new Set(selected)];
+  const unknown = uniqueNames.filter((id) => !findClient(id));
+  if (unknown.length) {
+    throw new Error(`unknown client${unknown.length === 1 ? "" : "s"}: ${unknown.join(", ")}. Choose from ${CLIENT_CHOICES.join(", ")}.`);
+  }
+  const clients = uniqueNames.map((id) => findClient(id));
+  return { clients: [...new Map(clients.map((client) => [client.id, client])).values()], mode };
 }
-function installSkills(projectRoot, tgz, clients, previous) {
-  const prior = new Map(previous?.skills.map((entry) => [entry.path, entry]));
-  const owned = [];
-  let changed = false;
-  for (const client of clients) {
-    const mount = SKILL_MOUNTS[client];
-    const destination = resolve10(projectRoot, mount, SKILL_ID);
-    const adapter = readFileSync12(resolve10(dirname10(tgz), "adapter", "SKILL.md"));
-    const projected = [...K0_FILES.map((file) => [`legacy/${file}`, extractK0(tgz, file)]), ["SKILL.md", adapter]];
-    if (existsSync8(destination)) {
-      const priorOwned = new Set(previous?.skills.filter((entry) => confined3(destination, entry.path)).map((entry) => entry.path) ?? []);
-      const unexpected = filesUnder2(destination).filter((path) => !priorOwned.has(path));
-      if (unexpected.length)
-        throw new Error(`owned_skill_collision: ${unexpected[0]}`);
-    }
-    for (const [file, bytes] of projected) {
-      const path = resolve10(destination, file);
-      if (!confined3(destination, path))
-        throw new Error("skill_path_escape");
-      const digest = sha2562(bytes);
-      const old = prior.get(path);
-      if (existsSync8(path) && digestFile(path) !== digest && (!old || digestFile(path) !== old.sha256)) {
-        throw new Error(`owned_skill_collision: ${path}`);
-      }
-      owned.push({ mount, path, sha256: digest, bytes: bytes.byteLength });
-    }
-    const allCurrent = projected.every(([file, bytes]) => {
-      const path = resolve10(destination, file);
-      return existsSync8(path) && digestFile(path) === sha2562(bytes);
-    });
-    if (allCurrent)
-      continue;
-    ensurePrivateDir(dirname10(destination));
-    const stage = `${destination}.stage-${process.pid}-${crypto.randomUUID()}`;
-    mkdirSync9(stage, { recursive: false, mode: 448 });
-    try {
-      for (const [file, bytes] of projected) {
-        const target = resolve10(stage, file);
-        mkdirSync9(dirname10(target), { recursive: true, mode: 448 });
-        atomicWrite(target, bytes, 384);
-      }
-      const backup = `${destination}.replace-${process.pid}-${crypto.randomUUID()}`;
-      if (existsSync8(destination))
-        renameSync6(destination, backup);
-      try {
-        renameSync6(stage, destination);
-      } catch (error) {
-        if (existsSync8(backup))
-          renameSync6(backup, destination);
-        throw error;
-      }
-      if (existsSync8(backup))
-        rmSync5(backup, { recursive: true, force: true });
-      changed = true;
-    } finally {
-      if (existsSync8(stage))
-        rmSync5(stage, { recursive: true, force: true });
-    }
+function requireProject() {
+  const project = resolveProject();
+  if (!project.root) {
+    throw new Error(`no released Engine game found searching upward from ${project.searchedFrom}; run this command inside a game created by the released Engine SDK`);
   }
-  return { owned, changed };
-}
-async function verifyProviderMcp(entry) {
-  const child = spawn3(entry.command, [...entry.args], { stdio: ["pipe", "pipe", "pipe"], env: { ...process.env, ...entry.env } });
-  let buffer = "";
-  let stderr = "";
-  let protocolError;
-  const responses = new Map;
-  child.stdout.setEncoding("utf8");
-  child.stdout.on("data", (chunk) => {
-    buffer += chunk;
-    for (;; ) {
-      const newline = buffer.indexOf(`
-`);
-      if (newline < 0)
-        break;
-      const line = buffer.slice(0, newline).trim();
-      buffer = buffer.slice(newline + 1);
-      try {
-        const value = JSON.parse(line);
-        if (typeof value.id === "number")
-          responses.get(value.id)?.(value);
-      } catch {
-        protocolError = "provider_mcp_stdout_invalid";
-      }
-    }
-  });
-  child.stderr.setEncoding("utf8");
-  child.stderr.on("data", (chunk) => {
-    stderr = `${stderr}${chunk}`.slice(-8192);
-  });
-  const request2 = (id, method, params = {}) => new Promise((resolveResponse, reject) => {
-    responses.set(id, resolveResponse);
-    child.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", id, method, params })}
-`, (error) => error && reject(error));
-  });
-  const timeout = new Promise((_, reject) => setTimeout(() => reject(new Error("provider_mcp_handshake_timeout")), 8000));
-  try {
-    const initialized = await Promise.race([request2(1, "initialize", { protocolVersion: "2024-11-05", capabilities: {}, clientInfo: { name: "forgeax-game-installer", version: "1" } }), timeout]);
-    if (protocolError)
-      throw new Error(protocolError);
-    if (initialized.error)
-      throw new Error("provider_mcp_initialize_failed");
-    const listed = await Promise.race([request2(2, "tools/list"), timeout]);
-    if (protocolError)
-      throw new Error(protocolError);
-    const tools = (listed.result?.tools ?? []).map((tool) => tool.name);
-    if (!tools.includes("search_asset"))
-      throw new Error("provider_mcp_tool_missing: search_asset");
-  } catch (error) {
-    throw new Error(`${error instanceof Error ? error.message : String(error)}${stderr.trim() ? `: ${stderr.trim()}` : ""}`);
-  } finally {
-    child.stdin.end();
-    if (child.exitCode === null && child.signalCode === null)
-      child.kill("SIGTERM");
-  }
-}
-async function publishAsset3d(options, provisioned) {
-  const projectRoot = realpathSync7(options.projectRoot);
-  const forgeax = resolve10(projectRoot, ".forgeax");
-  ensurePrivateDir(forgeax);
-  chmodSync4(forgeax, 448);
-  recoverInstallPublication(forgeax);
-  const origins = canonicalizeOrigins(options.downloadOrigins);
-  const catalogBaseUrl = options.catalogBaseUrl ? canonicalizeOrigins([options.catalogBaseUrl]).values[0] : undefined;
-  if (catalogBaseUrl && !origins.values.includes(catalogBaseUrl)) {
-    throw new Error("catalog_origin_not_authorized: --catalog-base-url must also be a --download-origin");
-  }
-  if (Boolean(options.awApiBaseUrl) !== Boolean(options.awCredentialFile)) {
-    throw new Error("asset3d_aw_config_invalid: AW API base URL and credential file must be configured together");
-  }
-  if (options.awDepotName && !options.awApiBaseUrl) {
-    throw new Error("asset3d_aw_config_invalid: depot name requires an AW API base URL");
-  }
-  const awApiBaseUrl = options.awApiBaseUrl;
-  const awDepotName = awApiBaseUrl ? options.awDepotName ?? "aw" : undefined;
-  const awCredentialFile = options.awCredentialFile ? resolve10(options.awCredentialFile) : undefined;
-  if (awCredentialFile && !isAbsolute3(options.awCredentialFile)) {
-    throw new Error("asset3d_credential_path_invalid: absolute path required");
-  }
-  const assetsRoot = options.assetsRoot ?? defaultAssetsRoot();
-  const asset3dAssets = existsSync8(resolve10(assetsRoot, "asset3d", "vibegame-art-3d-asset-library-2.0.0.tgz")) ? resolve10(assetsRoot, "asset3d") : assetsRoot;
-  const k0 = resolve10(asset3dAssets, "vibegame-art-3d-asset-library-2.0.0.tgz");
-  if (digestFile(k0) !== K0_PACKAGE_SHA256)
-    throw new Error("k0_package_digest_mismatch");
-  const manifestPath = resolve10(forgeax, "asset3d-install.json");
-  const previous = readInstallManifest(manifestPath);
-  const gamePluginLaunch = options.gamePluginLaunch ?? {
-    command: realpathSync7(options.executable ?? process.argv[1]),
-    args: ["mcp"]
-  };
-  const entries = launchEntries(projectRoot, provisioned.cache, origins, gamePluginLaunch, catalogBaseUrl, awApiBaseUrl, awDepotName, awCredentialFile);
-  if (options.verifyMcp !== false) {
-    await verifyProviderMcp({
-      ...entries["asset3d-search"],
-      command: resolve10(provisioned.cache, "bin", "asset3d-search"),
-      args: []
-    });
-  }
-  const configPath = resolve10(forgeax, "mcp.json");
-  const merged = mergeConfig(configPath, entries, previous, options.replaceOwned === true);
-  const clients = [...new Set(options.clients ?? Object.keys(SKILL_MOUNTS))];
-  const skills = installSkills(projectRoot, k0, clients, previous);
-  const installManifest = {
-    schemaVersion: INSTALL_SCHEMA,
-    providerBundleDigest: options.expectedSha256,
-    providerCommit: provisioned.manifest.providerCommit,
-    providerCache: provisioned.cache,
-    k0TgzDigest: K0_PACKAGE_SHA256,
-    originSetDigest: origins.digest,
-    configEntryDigests: merged.digests,
-    skills: skills.owned
-  };
-  const manifestBytes = `${JSON.stringify(installManifest, null, 2)}
-`;
-  const unchanged = previous !== undefined && canonicalJson(previous) === canonicalJson(installManifest) && !merged.changed && !skills.changed;
-  if (!unchanged) {
-    const journal = resolve10(forgeax, "asset3d-install.journal.json");
-    const previousConfig = existsSync8(configPath);
-    const previousManifest = existsSync8(manifestPath);
-    atomicWrite(journal, `${JSON.stringify({ schemaVersion: 1, state: "publishing", configDigest: sha2562(merged.bytes), manifestDigest: sha2562(manifestBytes), previousConfig, previousManifest })}
-`);
-    if (existsSync8(configPath))
-      copyFileSync3(configPath, `${configPath}.bak.latest`);
-    if (existsSync8(manifestPath))
-      copyFileSync3(manifestPath, `${manifestPath}.bak.latest`);
-    if (merged.changed)
-      atomicWrite(configPath, merged.bytes);
-    atomicWrite(manifestPath, manifestBytes);
-    unlinkSync2(journal);
-  }
-  return { changed: !unchanged, providerCache: provisioned.cache, providerCommit: provisioned.manifest.providerCommit, originSetDigest: origins.digest, configPath, skillFiles: skills.owned.length };
-}
-async function installAsset3d(options) {
-  if (/^https?:/i.test(options.providerBundle))
-    throw new Error("asset3d_remote_artifact_unsupported");
-  const archive = realpathSync7(options.providerBundle);
-  const cacheRoot = resolve10(options.cacheRoot ?? join10(homedir3(), ".forgeax", "providers", "asset3d-search"));
-  return publishAsset3d(options, provisionBundle(archive, options.expectedSha256, cacheRoot, options.python));
-}
-function prepareAsset3dProvider(options) {
-  if (/^https?:/i.test(options.providerBundle))
-    throw new Error("asset3d_remote_artifact_unsupported");
-  const archive = realpathSync7(options.providerBundle);
-  const cacheRoot = resolve10(options.cacheRoot ?? join10(homedir3(), ".forgeax", "providers", "asset3d-search"));
-  return provisionBundle(archive, options.expectedSha256, cacheRoot, options.python).cache;
-}
-async function installProvisionedAsset3d(options) {
-  return publishAsset3d(options, useProvisionedCache(options.providerCache, options.expectedSha256));
-}
-function asset3dProviderLaunch(projectRootInput) {
-  const projectRoot = realpathSync7(projectRootInput);
-  const manifest = readInstallManifest(resolve10(projectRoot, ".forgeax", "asset3d-install.json"));
-  if (!manifest)
-    throw new Error("asset3d_not_installed");
-  let config;
-  try {
-    config = JSON.parse(readFileSync12(resolve10(projectRoot, ".forgeax", "mcp.json"), "utf8"));
-  } catch {
-    throw new Error("project_mcp_config_invalid");
-  }
-  const entry = config?.mcpServers?.["asset3d-search"];
-  if (!entry || typeof entry !== "object" || Array.isArray(entry) || entryDigest(entry) !== manifest.configEntryDigests["asset3d-search"]) {
-    throw new Error("asset3d_provider_config_unowned");
-  }
-  const launch = entry;
-  const expectedCommand = resolve10(manifest.providerCache, "bin", "asset3d-search");
-  if (!existsSync8(expectedCommand) || !launch.env || typeof launch.env !== "object" || Array.isArray(launch.env)) {
-    throw new Error("asset3d_provider_config_invalid");
-  }
-  const env3 = Object.fromEntries(Object.entries(launch.env).map(([name, value]) => {
-    if (typeof value !== "string")
-      throw new Error("asset3d_provider_config_invalid");
-    return [name, value];
-  }));
-  return {
-    command: expectedCommand,
-    args: [],
-    env: env3
-  };
-}
-function uninstallAsset3d(projectRootInput) {
-  const projectRoot = realpathSync7(projectRootInput);
-  const forgeax = resolve10(projectRoot, ".forgeax");
-  const manifestPath = resolve10(forgeax, "asset3d-install.json");
-  const manifest = readInstallManifest(manifestPath);
-  if (!manifest)
-    return { removed: 0, modified: [] };
-  const modified = [];
-  let removed = 0;
-  for (const skill of manifest.skills) {
-    if (!existsSync8(skill.path))
-      continue;
-    if (digestFile(skill.path) !== skill.sha256) {
-      modified.push(skill.path);
-      continue;
-    }
-    unlinkSync2(skill.path);
-    removed++;
-  }
-  const configPath = resolve10(forgeax, "mcp.json");
-  if (existsSync8(configPath)) {
-    const config = JSON.parse(readFileSync12(configPath, "utf8"));
-    const servers = config.mcpServers;
-    if (servers && typeof servers === "object" && !Array.isArray(servers)) {
-      const next = { ...servers };
-      for (const name of ["forgeax", "asset3d-search"]) {
-        if (next[name] !== undefined && entryDigest(next[name]) === manifest.configEntryDigests[name]) {
-          delete next[name];
-          removed++;
-        } else if (next[name] !== undefined)
-          modified.push(`mcpServers.${name}`);
-      }
-      atomicWrite(configPath, `${JSON.stringify({ ...config, mcpServers: next }, null, 2)}
-`);
-    }
-  }
-  if (modified.length === 0)
-    unlinkSync2(manifestPath);
-  return { removed, modified };
-}
-
-// src/asset3d/transaction.ts
-import { spawnSync as spawnSync4 } from "node:child_process";
-import { randomUUID as randomUUID4 } from "node:crypto";
-import {
-  closeSync as closeSync3,
-  constants,
-  cpSync as cpSync2,
-  existsSync as existsSync9,
-  fstatSync,
-  lstatSync as lstatSync9,
-  mkdirSync as mkdirSync10,
-  openSync as openSync4,
-  readFileSync as readFileSync14,
-  readdirSync as readdirSync7,
-  realpathSync as realpathSync9,
-  renameSync as renameSync7,
-  rmSync as rmSync6,
-  statSync as statSync6,
-  unlinkSync as unlinkSync3,
-  writeFileSync as writeFileSync10
-} from "node:fs";
-import { isAbsolute as isAbsolute5, relative as relative10, resolve as resolve12, sep as sep7 } from "node:path";
-
-// src/asset3d/schema.ts
-var ID = /^[A-Za-z0-9._-]{1,128}$/;
-var DIGEST = /^[a-f0-9]{64}$/;
-var ERROR_CODES = new Set([
-  "asset_not_found",
-  "asset_identity_missing",
-  "search_timeout",
-  "search_upstream_error",
-  "download_timeout",
-  "download_origin_rejected",
-  "download_too_large",
-  "archive_rejected",
-  "conversion_failed",
-  "digest_failed",
-  "batch_timeout",
-  "internal_error"
-]);
-var ROLES = new Set(["primary-pack", "auxiliary-pack", "primary-model", "animation", "auxiliary-model", "texture", "metadata"]);
-function exactKeys(record, allowed, field) {
-  const extras = Object.keys(record).filter((key) => !allowed.includes(key));
-  if (extras.length)
-    throw new Error(`provider_result_invalid: unknown ${field} fields`);
-}
-function safeRelativePath(value) {
-  if (typeof value !== "string" || value.length < 1 || value.length > 512 || value.startsWith("/") || value.includes("\\")) {
-    throw new Error("provider_result_invalid: manifest path must be relative POSIX");
-  }
-  const parts = value.split("/");
-  if (parts.some((part) => !part || part === "." || part === ".."))
-    throw new Error("provider_result_invalid: unsafe manifest path");
-  return value;
-}
-function number(value, min, max, field) {
-  if (!Number.isInteger(value) || value < min || value > max)
-    throw new Error(`provider_result_invalid: ${field}`);
-  return value;
-}
-function text(value, min, max, field) {
-  if (typeof value !== "string" || [...value].length < min || [...value].length > max)
-    throw new Error(`provider_result_invalid: ${field}`);
-  return value;
-}
-function aggregate(entries) {
-  const bytes = entries.map((entry) => `${entry.path}\x00${entry.bytes}\x00${entry.sha256}
-`).join("");
-  return sha2562(bytes);
-}
-function parseProviderResult(input, expectedCommit, expectedOriginSetDigest) {
-  const bytes = typeof input === "string" ? Buffer.byteLength(input) : input.byteLength;
-  if (bytes > MAX_JSON_BYTES)
-    throw new Error("provider_result_too_large: stdin exceeds 1 MiB");
-  let raw;
-  try {
-    raw = JSON.parse(typeof input === "string" ? input : Buffer.from(input).toString("utf8"));
-  } catch {
-    throw new Error("provider_result_invalid: stdin is not JSON");
-  }
-  if (!raw || typeof raw !== "object" || Array.isArray(raw))
-    throw new Error("provider_result_invalid: top-level object required");
-  const root = raw;
-  exactKeys(root, ["schemaVersion", "total", "succeeded", "failed", "results", "receipt"], "top-level");
-  if (root.schemaVersion !== PROVIDER_RESULT_SCHEMA)
-    throw new Error("provider_result_invalid: schemaVersion");
-  const total = number(root.total, 1, 16, "total");
-  const succeeded = number(root.succeeded, 0, total, "succeeded");
-  const failed = number(root.failed, 0, total, "failed");
-  if (succeeded + failed !== total || !Array.isArray(root.results) || root.results.length !== total)
-    throw new Error("provider_result_invalid: counts");
-  let receipt;
-  if (root.receipt !== undefined) {
-    if (!root.receipt || typeof root.receipt !== "object" || Array.isArray(root.receipt)) {
-      throw new Error("provider_result_invalid: receipt object required");
-    }
-    const value = root.receipt;
-    exactKeys(value, ["schemaVersion", "provider", "providerCommit", "originSetDigest"], "receipt");
-    if (value.schemaVersion !== PROVIDER_RECEIPT_SCHEMA || value.provider !== "ea-3d" || value.providerCommit !== expectedCommit || value.originSetDigest !== expectedOriginSetDigest) {
-      throw new Error("provider_result_invalid: receipt identity");
-    }
-    receipt = {
-      schemaVersion: PROVIDER_RECEIPT_SCHEMA,
-      provider: "ea-3d",
-      providerCommit: expectedCommit,
-      originSetDigest: expectedOriginSetDigest
-    };
-  }
-  if (succeeded > 0 && receipt === undefined)
-    throw new Error("provider_result_invalid: success receipt required");
-  const indices = new Set;
-  let okCount = 0;
-  const results = root.results.map((candidate) => {
-    if (!candidate || typeof candidate !== "object" || Array.isArray(candidate))
-      throw new Error("provider_result_invalid: result row");
-    const row = candidate;
-    const queryIndex = number(row.queryIndex, 0, total - 1, "queryIndex");
-    if (indices.has(queryIndex))
-      throw new Error("provider_result_invalid: duplicate queryIndex");
-    indices.add(queryIndex);
-    const query = text(row.query, 1, 200, "query");
-    if (row.status === "error") {
-      exactKeys(row, ["status", "queryIndex", "query", "code", "retryable", "message"], "error");
-      if (typeof row.code !== "string" || !ERROR_CODES.has(row.code) || typeof row.retryable !== "boolean")
-        throw new Error("provider_result_invalid: error row");
-      const message = text(row.message, 0, 256, "message");
-      return { status: "error", queryIndex, query, code: row.code, retryable: row.retryable, message };
-    }
-    if (row.status !== "ok")
-      throw new Error("provider_result_invalid: status");
-    const isPack = row.deliveredFormat === "pack";
-    const primaryKey = isPack ? "primaryPack" : "primaryModel";
-    const primaryRole = isPack ? "primary-pack" : "primary-model";
-    exactKeys(row, ["status", "queryIndex", "query", "provider", "providerAssetId", "assetName", "deliveredFormat", "sha256", "bytes", primaryKey, "manifest", "originSetDigest", "downloaded_to"], "success");
-    okCount++;
-    if (row.provider !== "ea-3d" || row.deliveredFormat !== "glb" && !isPack || typeof row.providerAssetId !== "string" || !ID.test(row.providerAssetId) || row.providerAssetId === "." || row.providerAssetId === "..") {
-      throw new Error("provider_result_invalid: success identity");
-    }
-    const assetName = text(row.assetName, 1, 128, "assetName");
-    const itemBytes = number(row.bytes, 1, 268435456, "bytes");
-    if (typeof row.sha256 !== "string" || !DIGEST.test(row.sha256))
-      throw new Error("provider_result_invalid: aggregate digest");
-    if (!Array.isArray(row.manifest) || row.manifest.length < 1 || row.manifest.length > 1024)
-      throw new Error("provider_result_invalid: manifest count");
-    const seen = new Set;
-    const manifest = row.manifest.map((entry) => {
-      if (!entry || typeof entry !== "object" || Array.isArray(entry))
-        throw new Error("provider_result_invalid: manifest entry");
-      const item = entry;
-      exactKeys(item, ["path", "role", "bytes", "sha256"], "manifest");
-      const path = safeRelativePath(item.path);
-      if (seen.has(path))
-        throw new Error("provider_result_invalid: duplicate manifest path");
-      seen.add(path);
-      if (typeof item.role !== "string" || !ROLES.has(item.role))
-        throw new Error("provider_result_invalid: manifest role");
-      const role = item.role;
-      const entryBytes = number(item.bytes, 1, 134217728, "manifest bytes");
-      if (typeof item.sha256 !== "string" || !DIGEST.test(item.sha256))
-        throw new Error("provider_result_invalid: manifest digest");
-      if ((role === "primary-model" || role === "animation" || role === "auxiliary-model") && !path.toLowerCase().endsWith(".glb")) {
-        throw new Error("provider_result_invalid: model entry must be GLB");
-      }
-      if ((role === "primary-pack" || role === "auxiliary-pack") && (!isPack || !/\.pack\.(json|ts)$/i.test(path))) {
-        throw new Error("provider_result_invalid: pack entry must be authored Pack");
-      }
-      if (isPack && role === "primary-model")
-        throw new Error("provider_result_invalid: multiple primary formats");
-      return { path, role, bytes: entryBytes, sha256: item.sha256 };
-    });
-    const sorted = [...manifest].sort((left, right) => Buffer.from(left.path).compare(Buffer.from(right.path)));
-    if (manifest.some((entry, index) => entry.path !== sorted[index].path))
-      throw new Error("provider_result_invalid: manifest must be UTF-8 path sorted");
-    const primary = manifest.filter((entry) => entry.role === primaryRole);
-    if (primary.length !== 1 || row[primaryKey] !== primary[0].path)
-      throw new Error("provider_result_invalid: primary model");
-    if (manifest.reduce((sum, entry) => sum + entry.bytes, 0) !== itemBytes || aggregate(manifest) !== row.sha256) {
-      throw new Error("provider_result_invalid: byte or aggregate digest mismatch");
-    }
-    if (row.originSetDigest !== expectedOriginSetDigest)
-      throw new Error("provider_result_invalid: originSetDigest identity");
-    return {
-      status: "ok",
-      queryIndex,
-      query,
-      provider: "ea-3d",
-      providerAssetId: row.providerAssetId,
-      assetName,
-      sha256: row.sha256,
-      bytes: itemBytes,
-      ...isPack ? { deliveredFormat: "pack", primaryPack: row.primaryPack } : { deliveredFormat: "glb", primaryModel: row.primaryModel },
-      manifest,
-      originSetDigest: expectedOriginSetDigest,
-      ...row.downloaded_to === undefined ? {} : { downloaded_to: row.downloaded_to }
-    };
-  });
-  if (okCount !== succeeded || total - okCount !== failed)
-    throw new Error("provider_result_invalid: status counts");
-  return { schemaVersion: PROVIDER_RESULT_SCHEMA, total, succeeded, failed, results, ...receipt ? { receipt } : {} };
-}
-
-// src/asset3d/pack-readback.ts
-import { lstatSync as lstatSync8, readFileSync as readFileSync13, realpathSync as realpathSync8 } from "node:fs";
-import { isAbsolute as isAbsolute4, relative as relative9, resolve as resolve11, sep as sep6 } from "node:path";
-var UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
-function object(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value))
-    throw new Error("engine_pack_readback_invalid");
-  return value;
-}
-function readPackBuildCatalog(projectRoot, sourcePaths, buildValue) {
-  const build = object(buildValue);
-  const runtime = object(build.runtime);
-  if (build.schemaVersion !== "1.0.0" || !Array.isArray(build.artifacts) || build.artifacts.length > 1e4) {
-    throw new Error("engine_pack_build_manifest_invalid");
-  }
-  const dist = resolve11(projectRoot, "dist");
-  const canonicalDist = realpathSync8(dist);
-  if (canonicalDist !== resolve11(realpathSync8(projectRoot), "dist") || lstatSync8(dist).isSymbolicLink()) {
-    throw new Error("engine_pack_build_path_escape");
-  }
-  const artifacts = new Map;
-  let total = 0;
-  for (const raw of build.artifacts) {
-    const entry = object(raw);
-    const path = safeRelativePath(entry.path);
-    if (artifacts.has(path) || !Number.isSafeInteger(entry.bytes) || entry.bytes < 0 || entry.bytes > 256 * 1024 * 1024 || typeof entry.sha256 !== "string" || !/^[a-f0-9]{64}$/.test(entry.sha256)) {
-      throw new Error("engine_pack_build_manifest_invalid");
-    }
-    total += entry.bytes;
-    if (total > 1024 * 1024 * 1024)
-      throw new Error("engine_pack_build_too_large");
-    const file = resolve11(dist, path);
-    const rel = relative9(canonicalDist, realpathSync8(file));
-    if (isAbsolute4(rel) || rel === ".." || rel.startsWith(`..${sep6}`))
-      throw new Error("engine_pack_build_path_escape");
-    const stat = lstatSync8(file);
-    if (!stat.isFile() || stat.isSymbolicLink() || stat.size !== entry.bytes)
-      throw new Error("engine_pack_build_file_invalid");
-    const bytes = readFileSync13(file);
-    if (sha2562(bytes) !== entry.sha256)
-      throw new Error("engine_pack_build_digest_mismatch");
-    artifacts.set(path, path.endsWith(".json") ? bytes : Buffer.alloc(0));
-  }
-  const indexPath = safeRelativePath(runtime.packIndexUrl);
-  const indexBytes = artifacts.get(indexPath);
-  if (!indexBytes || indexBytes.length > 16 * 1024 * 1024)
-    throw new Error("engine_pack_catalog_missing");
-  const index = JSON.parse(indexBytes.toString("utf8"));
-  if (!Array.isArray(index))
-    throw new Error("engine_pack_catalog_invalid");
-  const sources = new Set(sourcePaths);
-  const rows = [];
-  const seen = new Set;
-  const inspect = [];
-  for (const raw of index) {
-    const row = object(raw);
-    if (typeof row.sourcePath !== "string" || !sources.has(row.sourcePath))
-      continue;
-    if (typeof row.guid !== "string" || !UUID.test(row.guid) || seen.has(row.guid) || typeof row.kind !== "string" || typeof row.packageUrl !== "string" || !row.packageUrl.startsWith("/") || row.packageUrl.startsWith("//")) {
-      throw new Error("engine_pack_catalog_invalid");
-    }
-    seen.add(row.guid);
-    const packagePath = safeRelativePath(row.packageUrl.slice(1));
-    const bytes = artifacts.get(packagePath);
-    if (!bytes || bytes.length > 16 * 1024 * 1024)
-      throw new Error("engine_pack_product_missing");
-    const pack = object(JSON.parse(bytes.toString("utf8")));
-    if (!Array.isArray(pack.assets))
-      throw new Error("engine_pack_product_invalid");
-    const matches = pack.assets.map(object).filter((asset) => asset.guid === row.guid && asset.kind === row.kind);
-    if (matches.length !== 1)
-      throw new Error("engine_pack_product_guid_missing");
-    rows.push({
-      guid: row.guid,
-      kind: row.kind,
-      source: row.sourcePath,
-      sourcePath: row.sourcePath,
-      ...typeof row.name === "string" ? { name: row.name } : {},
-      packageUrl: row.packageUrl
-    });
-    inspect.push({ guid: row.guid, kind: row.kind, packagePath, packageSha256: sha2562(bytes), verified: true });
-  }
-  if (!rows.some((row) => row.kind === "scene" || row.kind === "mesh"))
-    throw new Error("engine_pack_readback_missing_renderable");
-  return {
-    authority: "engine-build-catalog",
-    verify: { artifacts: artifacts.size, bytes: total, catalogSha256: sha2562(indexBytes) },
-    list: rows,
-    rows,
-    inspect
-  };
-}
-
-// src/asset3d/transaction.ts
-function confined4(root, candidate) {
-  const rel = relative10(root, candidate);
-  return rel === "" || !isAbsolute5(rel) && rel !== ".." && !rel.startsWith(`..${sep7}`);
-}
-function forgeaxRoot(projectRoot) {
-  return resolve12(projectRoot, ".forgeax");
-}
-function journalPath(projectRoot, execution) {
-  return resolve12(forgeaxRoot(projectRoot), "asset3d-transactions", `${execution}.json`);
-}
-function providerResultPath(projectRoot, execution) {
-  return resolve12(forgeaxRoot(projectRoot), "asset3d-results", `${execution}.json`);
-}
-function readInstall(projectRoot) {
-  let manifest;
-  try {
-    manifest = JSON.parse(readFileSync14(resolve12(forgeaxRoot(projectRoot), "asset3d-install.json"), "utf8"));
-  } catch {
-    throw new Error("asset3d_not_installed");
-  }
-  if (manifest.schemaVersion !== INSTALL_SCHEMA || manifest.providerCommit.length !== 40)
-    throw new Error("asset3d_install_manifest_invalid");
-  return manifest;
-}
-function readJournal(projectRoot, execution) {
-  if (!/^[0-9a-f-]{36}$/.test(execution))
-    throw new Error("asset3d_execution_invalid");
-  let journal;
-  try {
-    journal = JSON.parse(readFileSync14(journalPath(projectRoot, execution), "utf8"));
-  } catch {
-    throw new Error("asset3d_execution_not_found");
-  }
-  if (journal.schemaVersion !== TRANSACTION_SCHEMA || journal.execution !== execution)
-    throw new Error("asset3d_journal_invalid");
-  return journal;
-}
-function updateJournal(projectRoot, journal, patch) {
-  const next = { ...journal, ...patch };
-  atomicWrite(journalPath(projectRoot, journal.execution), `${JSON.stringify(next, null, 2)}
-`);
-  return next;
-}
-function beginAsset3d(projectRootInput, queries, options = {}) {
-  const projectRoot = realpathSync9(projectRootInput);
-  if (queries.length < 1 || queries.length > 16 || queries.some((query) => [...query].length < 1 || [...query].length > 200)) {
-    throw new Error("asset3d_queries_invalid: expected 1..16 queries of 1..200 characters");
-  }
-  const install = readInstall(projectRoot);
-  const release = resolveEngineRelease(projectRoot, options.carrierPluginRoot === undefined ? {} : { pluginRoot: options.carrierPluginRoot });
-  const execution = randomUUID4();
-  const relativeOutput = `workspace/asset3d/${execution}`;
-  const quarantine = resolve12(projectRoot, ".forgeax", "asset3d-quarantine");
-  const allowedQuarantineRoot = resolve12(quarantine, relativeOutput);
-  ensurePrivateDir(resolve12(projectRoot, ".forgeax", "asset3d-transactions"));
-  ensurePrivateDir(allowedQuarantineRoot);
-  const journal = {
-    schemaVersion: TRANSACTION_SCHEMA,
-    execution,
-    queryDigest: sha2562(canonicalJson(queries)),
-    providerCommit: install.providerCommit,
-    engineVersion: release.version,
-    engineCommit: release.commit,
-    allowedQuarantineRoot,
-    requestedCount: queries.length,
-    createdAt: new Date().toISOString(),
-    state: "begun"
-  };
-  atomicWrite(journalPath(projectRoot, execution), `${JSON.stringify(journal, null, 2)}
-`);
-  return { execution, output_dir: relativeOutput };
-}
-function asset3dSearchOutputDir(projectRootInput, execution, queries) {
-  const projectRoot = realpathSync9(projectRootInput);
-  const journal = readJournal(projectRoot, execution);
-  if (journal.state !== "begun") {
-    throw new Error(`asset3d_execution_state_invalid: ${journal.state}`);
-  }
-  if (queries.length !== journal.requestedCount || sha2562(canonicalJson(queries)) !== journal.queryDigest) {
-    throw new Error("asset3d_search_query_identity_mismatch");
-  }
-  const outputDir = `workspace/asset3d/${execution}`;
-  const expectedRoot = resolve12(forgeaxRoot(projectRoot), "asset3d-quarantine", outputDir);
-  if (journal.allowedQuarantineRoot !== expectedRoot || !existsSync9(expectedRoot) || realpathSync9(expectedRoot) !== expectedRoot) {
-    throw new Error("asset3d_search_output_identity_mismatch");
-  }
-  return outputDir;
-}
-function recordAsset3dProviderResult(projectRootInput, execution, providerResult) {
-  const projectRoot = realpathSync9(projectRootInput);
-  const journal = readJournal(projectRoot, execution);
-  if (journal.state !== "begun") {
-    throw new Error(`asset3d_execution_state_invalid: ${journal.state}`);
-  }
-  const bytes = Buffer.byteLength(providerResult);
-  if (bytes < 1 || bytes > MAX_JSON_BYTES) {
-    throw new Error("provider_result_too_large: expected 1 byte..1 MiB");
-  }
-  ensurePrivateDir(resolve12(forgeaxRoot(projectRoot), "asset3d-results"));
-  atomicWrite(providerResultPath(projectRoot, execution), providerResult, 384);
-  updateJournal(projectRoot, journal, { state: "provider_complete" });
-}
-function fileBytesChecked(root, entry) {
-  const source = resolve12(root, entry.path);
-  if (!confined4(root, source))
-    throw new Error("asset_manifest_escape");
-  const canonicalRoot = realpathSync9(root);
-  const canonicalSource = realpathSync9(source);
-  if (!confined4(canonicalRoot, canonicalSource))
-    throw new Error("asset_manifest_escape");
-  const before = lstatSync9(source);
-  if (!before.isFile() || before.isSymbolicLink())
-    throw new Error("asset_manifest_not_regular");
-  const fd = openSync4(source, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
-  try {
-    const opened = fstatSync(fd);
-    if (!opened.isFile() || opened.size !== entry.bytes)
-      throw new Error("asset_manifest_bytes_mismatch");
-    const bytes = readFileSync14(fd);
-    if (sha2562(bytes) !== entry.sha256)
-      throw new Error("asset_manifest_digest_mismatch");
-    return bytes;
-  } finally {
-    closeSync3(fd);
-  }
-}
-function acquireLock2(projectRoot, assetId, timeoutMs) {
-  const root = resolve12(forgeaxRoot(projectRoot), "asset3d-locks");
-  ensurePrivateDir(root);
-  const path = resolve12(root, `${assetId}.lock`);
-  const token = randomUUID4();
-  const deadline = Date.now() + timeoutMs;
-  for (;; ) {
-    try {
-      const fd = openSync4(path, "wx", 384);
-      writeFileSync10(fd, `${JSON.stringify({ token, pid: process.pid, acquiredAt: new Date().toISOString() })}
-`);
-      closeSync3(fd);
-      return () => {
-        try {
-          const current = JSON.parse(readFileSync14(path, "utf8"));
-          if (current.token === token)
-            unlinkSync3(path);
-        } catch {}
-      };
-    } catch (error) {
-      if (error.code !== "EEXIST")
-        throw error;
-      if (Date.now() >= deadline)
-        throw new Error("asset_busy");
-      Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, Math.min(100, deadline - Date.now()));
-    }
-  }
-}
-function engineCommand(projectRoot, args, carrierPluginRoot) {
-  const release = resolveEngineRelease(projectRoot, carrierPluginRoot === undefined ? {} : { pluginRoot: carrierPluginRoot });
-  const result = spawnSync4(process.execPath, [release.cliPath, ...args], {
-    cwd: projectRoot,
-    encoding: "utf8",
-    maxBuffer: 1024 * 1024 + 1,
-    timeout: 150000
-  });
-  const stdout = result.stdout ?? "";
-  if (Buffer.byteLength(stdout) > 1024 * 1024)
-    throw new Error("engine_envelope_too_large");
-  const lines = stdout.split(`
-`).filter((line) => line.length > 0);
-  if (lines.length !== 1 || !stdout.endsWith(`
-`))
-    throw new Error("engine_terminal_envelope_invalid");
-  let envelope;
-  try {
-    envelope = JSON.parse(lines[0]);
-  } catch {
-    throw new Error("engine_terminal_envelope_invalid");
-  }
-  if (envelope.schemaVersion !== "1.0.0" || typeof envelope.command !== "string" || typeof envelope.ok !== "boolean") {
-    throw new Error("engine_terminal_envelope_invalid");
-  }
-  if (result.status !== 0 || envelope.ok !== true) {
-    throw new Error(`engine_${String(envelope.command).replace(".", "_")}_failed:${canonicalJson(envelope.error ?? { exitCode: result.status })}`);
-  }
-  return envelope;
-}
-function engineAddedRows(projectRoot, asset) {
-  let subAssets = asset.subAssets;
-  if (!Array.isArray(subAssets)) {
-    if (typeof asset.metaPath !== "string")
-      throw new Error("engine_readback_missing_meta");
-    const metaPath = resolve12(projectRoot, asset.metaPath);
-    if (!confined4(projectRoot, metaPath))
-      throw new Error("engine_readback_meta_escape");
-    const canonical = realpathSync9(metaPath);
-    const info = lstatSync9(metaPath);
-    if (!confined4(projectRoot, canonical) || !info.isFile() || info.isSymbolicLink()) {
-      throw new Error("engine_readback_meta_invalid");
-    }
-    let meta;
-    try {
-      meta = JSON.parse(readFileSync14(metaPath, "utf8"));
-    } catch {
-      throw new Error("engine_readback_meta_invalid");
-    }
-    if (!Array.isArray(meta.subAssets))
-      throw new Error("engine_readback_missing_subassets");
-    subAssets = meta.subAssets.filter((row) => row !== null && typeof row === "object" && !Array.isArray(row));
-  }
-  const projectPath = (value) => {
-    if (typeof value !== "string")
-      return value;
-    const absolute = resolve12(projectRoot, value);
-    if (!confined4(projectRoot, absolute))
-      throw new Error("engine_readback_path_escape");
-    return relative10(projectRoot, absolute).split(sep7).join("/");
-  };
-  return subAssets.map((row) => ({ source: projectPath(asset.source), metaPath: projectPath(asset.metaPath), reused: asset.reused, ...row }));
-}
-function engineReadback(projectRoot, assetRelative, add, carrierPluginRoot) {
-  const verify = engineCommand(projectRoot, ["asset", "verify", "--json"], carrierPluginRoot);
-  const list = engineCommand(projectRoot, ["asset", "list", "--json"], carrierPluginRoot);
-  const addAssets = add?.value?.assets ?? [];
-  const rows = addAssets.flatMap((asset) => engineAddedRows(projectRoot, asset));
-  const guids = [...new Set(rows.flatMap((row) => typeof row.guid === "string" ? [row.guid] : []))];
-  if (add && guids.length === 0)
-    throw new Error("engine_readback_missing_guid");
-  const inspect = guids.map((guid) => engineCommand(projectRoot, ["asset", "inspect", guid, "--json"], carrierPluginRoot).value);
-  const listed = Array.isArray(list.value) ? list.value : Array.isArray(list.value?.assets) ? list.value.assets : [];
-  for (const guid of guids)
-    if (!listed.some((entry) => entry.guid === guid))
-      throw new Error("engine_catalog_readback_missing");
-  return { ...add ? { add: add.value } : {}, verify: verify.value, list: listed, inspect, rows };
-}
-function packReadback(projectRoot, item, carrierPluginRoot) {
-  const release = resolveEngineRelease(projectRoot, carrierPluginRoot === undefined ? {} : { pluginRoot: carrierPluginRoot });
-  const result = spawnSync4(process.execPath, [release.cliPath, "build", "--json"], {
-    cwd: projectRoot,
-    encoding: "utf8",
-    timeout: 150000,
-    maxBuffer: 8 * 1024 * 1024
-  });
-  if (result.error || result.status !== 0)
-    throw new Error("engine_pack_build_failed");
-  const envelope = parseEnvelope(result.stdout, "build");
-  const prefix = `assets/3d/ea-3d/${item.providerAssetId}/`;
-  return readPackBuildCatalog(projectRoot, item.manifest.map((entry) => prefix + entry.path), envelope.value);
-}
-function priorProvenance(destination) {
-  try {
-    return JSON.parse(readFileSync14(resolve12(destination, ".forgeax-asset.json"), "utf8"));
-  } catch {
-    return;
-  }
-}
-function liveFilesMatch(destination, item) {
-  return item.manifest.every((entry) => {
-    const path = resolve12(destination, entry.path);
-    try {
-      return confined4(destination, path) && statSync6(path).isFile() && statSync6(path).size === entry.bytes && sha2562(readFileSync14(path)) === entry.sha256;
-    } catch {
-      return false;
-    }
-  });
-}
-function quarantineFiles(root, directory = root) {
-  const files = [];
-  for (const name of readdirSync7(directory)) {
-    const path = resolve12(directory, name);
-    const info = lstatSync9(path);
-    if (info.isSymbolicLink())
-      throw new Error("asset_quarantine_symlink_rejected");
-    if (info.isDirectory())
-      files.push(...quarantineFiles(root, path));
-    else if (info.isFile())
-      files.push(relative10(root, path).split(sep7).join("/"));
-    else
-      throw new Error("asset_quarantine_special_file_rejected");
-  }
-  return files;
-}
-function validateQuarantine(journal, items) {
-  const root = realpathSync9(journal.allowedQuarantineRoot);
-  const expected = items.flatMap((item) => item.manifest.map((entry) => entry.path)).sort();
-  if (new Set(expected).size !== expected.length)
-    throw new Error("provider_result_invalid: cross-item manifest collision");
-  const actual = quarantineFiles(root).sort();
-  if (canonicalJson(actual) !== canonicalJson(expected))
-    throw new Error("asset_quarantine_undeclared_file");
-}
-function stageItem(projectRoot, journal, item, destination, prior) {
-  const root = realpathSync9(journal.allowedQuarantineRoot);
-  const stageRoot = resolve12(forgeaxRoot(projectRoot), "asset3d-staging", journal.execution, item.providerAssetId);
-  rmSync6(stageRoot, { recursive: true, force: true });
-  ensurePrivateDir(resolve12(stageRoot, ".."));
-  if (existsSync9(destination))
-    cpSync2(destination, stageRoot, { recursive: true, errorOnExist: true, force: false });
-  else
-    ensurePrivateDir(stageRoot);
-  const nextPaths = new Set(item.manifest.map((entry) => entry.path));
-  const previousFiles = Array.isArray(prior?.files) ? prior.files : [];
-  for (const previous of previousFiles) {
-    if (typeof previous.relativePath !== "string" || nextPaths.has(previous.relativePath))
-      continue;
-    const stale = resolve12(stageRoot, previous.relativePath);
-    if (!confined4(stageRoot, stale))
-      throw new Error("asset_provenance_path_escape");
-    rmSync6(stale, { force: true });
-    rmSync6(`${stale}.meta.json`, { force: true });
-  }
-  for (const entry of item.manifest) {
-    const target = resolve12(stageRoot, entry.path);
-    if (!confined4(stageRoot, target))
-      throw new Error("asset_manifest_escape");
-    mkdirSync10(resolve12(target, ".."), { recursive: true, mode: 448 });
-    atomicWrite(target, fileBytesChecked(root, entry), 384);
-  }
-  return stageRoot;
-}
-function provenance(item, install, readback, refreshed) {
-  const rows = readback.rows;
-  const sourcePrefix = `assets/3d/ea-3d/${item.providerAssetId}/`;
-  return {
-    schemaVersion: PROVENANCE_SCHEMA,
-    provider: "ea-3d",
-    providerAssetId: item.providerAssetId,
-    providerCommit: install.providerCommit,
-    originSetDigest: install.originSetDigest,
-    aggregateSha256: item.sha256,
-    bytes: item.bytes,
-    deliveredFormat: item.deliveredFormat,
-    ...item.deliveredFormat === "pack" ? { primaryPack: item.primaryPack } : { primaryModel: item.primaryModel },
-    engine: { version: ENGINE_VERSION, commit: ENGINE_COMMIT },
-    refreshed,
-    files: item.manifest.map((entry) => ({
-      relativePath: entry.path,
-      role: entry.role,
-      sha256: entry.sha256,
-      bytes: entry.bytes,
-      engineRows: rows.filter((row) => row.source === `${sourcePrefix}${entry.path}`)
-    })),
-    catalog: { verify: readback.verify, list: readback.list, inspect: readback.inspect }
-  };
-}
-function commitItem(projectRoot, initialJournal, install, item, refresh, lockTimeoutMs, carrierPluginRoot) {
-  const destination = resolve12(projectRoot, "assets", "3d", "ea-3d", item.providerAssetId);
-  const assetRoot = resolve12(projectRoot, "assets", "3d", "ea-3d");
-  ensurePrivateDir(assetRoot);
-  if (!confined4(assetRoot, destination))
-    throw new Error("asset_destination_escape");
-  const releaseLock = acquireLock2(projectRoot, item.providerAssetId, lockTimeoutMs);
-  let journal = initialJournal;
-  try {
-    const prior = priorProvenance(destination);
-    const priorDigest = typeof prior?.aggregateSha256 === "string" ? prior.aggregateSha256 : undefined;
-    if (priorDigest === item.sha256 && liveFilesMatch(destination, item)) {
-      const priorRows = Array.isArray(prior?.files) ? prior.files.flatMap((entry) => entry.engineRows ?? []) : [];
-      const baseReadback = item.deliveredFormat === "pack" ? packReadback(projectRoot, item, carrierPluginRoot) : engineReadback(projectRoot, `assets/3d/ea-3d/${item.providerAssetId}`, undefined, carrierPluginRoot);
-      const guids = priorRows.flatMap((row) => typeof row.guid === "string" ? [row.guid] : []);
-      const listed = Array.isArray(baseReadback.list) ? baseReadback.list : [];
-      if (guids.length === 0 || guids.some((guid) => !listed.some((entry) => entry.guid === guid)))
-        throw new Error("asset_reuse_readback_failed");
-      const readback = item.deliveredFormat === "pack" ? baseReadback : { ...baseReadback, inspect: guids.map((guid) => engineCommand(projectRoot, ["asset", "inspect", guid, "--json"], carrierPluginRoot).value) };
-      journal = updateJournal(projectRoot, journal, { state: "committed", previousDigest: priorDigest, newDigest: item.sha256 });
-      return { providerAssetId: item.providerAssetId, digest: item.sha256, bytes: item.bytes, reused: true, refreshed: false, sourcePath: relative10(projectRoot, destination), provenancePath: relative10(projectRoot, resolve12(destination, ".forgeax-asset.json")), engine: { version: ENGINE_VERSION, commit: ENGINE_COMMIT }, catalog: readback, rows: priorRows };
-    }
-    if (priorDigest && priorDigest !== item.sha256 && !refresh)
-      throw new Error("asset_changed");
-    const stage = stageItem(projectRoot, journal, item, destination, prior);
-    const backup = resolve12(forgeaxRoot(projectRoot), "asset3d-backups", journal.execution, item.providerAssetId);
-    ensurePrivateDir(resolve12(backup, ".."));
-    journal = updateJournal(projectRoot, journal, { state: "committing", destination, backupPath: existsSync9(destination) ? backup : undefined, previousDigest: priorDigest, newDigest: item.sha256 });
-    if (existsSync9(destination))
-      renameSync7(destination, backup);
-    renameSync7(stage, destination);
-    try {
-      const assetRelative = `assets/3d/ea-3d/${item.providerAssetId}`;
-      const readback = item.deliveredFormat === "pack" ? packReadback(projectRoot, item, carrierPluginRoot) : engineReadback(projectRoot, assetRelative, engineCommand(projectRoot, ["asset", "add", assetRelative, "--reimport-policy", "semantic-only", "--json"], carrierPluginRoot), carrierPluginRoot);
-      if (item.deliveredFormat === "pack" && !liveFilesMatch(destination, item))
-        throw new Error("engine_pack_source_changed");
-      atomicWrite(resolve12(destination, ".forgeax-asset.json"), `${JSON.stringify(provenance(item, install, readback, priorDigest !== undefined), null, 2)}
-`);
-      journal = updateJournal(projectRoot, journal, { state: "engine_verified" });
-      if (existsSync9(backup))
-        rmSync6(backup, { recursive: true, force: true });
-      journal = updateJournal(projectRoot, journal, { state: "committed" });
-      return { providerAssetId: item.providerAssetId, digest: item.sha256, bytes: item.bytes, reused: false, refreshed: priorDigest !== undefined, sourcePath: assetRelative, provenancePath: `${assetRelative}/.forgeax-asset.json`, engine: { version: ENGINE_VERSION, commit: ENGINE_COMMIT }, catalog: readback, rows: readback.rows };
-    } catch (error) {
-      rmSync6(destination, { recursive: true, force: true });
-      if (existsSync9(backup))
-        renameSync7(backup, destination);
-      updateJournal(projectRoot, journal, { state: "rolled_back", error: error instanceof Error ? error.message.slice(0, 256) : "engine failure" });
-      throw error;
-    }
-  } finally {
-    releaseLock();
-  }
-}
-function commitAsset3d(options) {
-  const projectRoot = realpathSync9(options.projectRoot);
-  const install = readInstall(projectRoot);
-  let journal = readJournal(projectRoot, options.execution);
-  if (journal.state !== "begun" && journal.state !== "provider_complete" && journal.state !== "validated") {
-    throw new Error(`asset3d_execution_state_invalid: ${journal.state}`);
-  }
-  if (journal.providerCommit !== install.providerCommit || journal.engineCommit !== ENGINE_COMMIT || journal.engineVersion !== ENGINE_VERSION) {
-    throw new Error("asset3d_execution_identity_mismatch");
-  }
-  let providerResult = options.providerResult;
-  if (providerResult === undefined) {
-    try {
-      providerResult = readFileSync14(providerResultPath(projectRoot, options.execution));
-    } catch {
-      throw new Error("asset3d_provider_result_missing: call search_asset for this execution first");
-    }
-  }
-  let result;
-  try {
-    result = parseProviderResult(providerResult, install.providerCommit, install.originSetDigest);
-    if (result.total !== journal.requestedCount)
-      throw new Error("provider_result_invalid: requested count mismatch");
-    const orderedQueries = [...result.results].sort((left, right) => left.queryIndex - right.queryIndex).map((item) => item.query);
-    if (sha2562(canonicalJson(orderedQueries)) !== journal.queryDigest) {
-      throw new Error("provider_result_invalid: query identity mismatch");
-    }
-    const successes = result.results.filter((item) => item.status === "ok");
-    validateQuarantine(journal, successes);
-    journal = updateJournal(projectRoot, journal, { state: "validated" });
-  } catch (error) {
-    rmSync6(journal.allowedQuarantineRoot, { recursive: true, force: true });
-    rmSync6(providerResultPath(projectRoot, options.execution), { force: true });
-    updateJournal(projectRoot, journal, {
-      state: "failed",
-      error: error instanceof Error ? error.message.slice(0, 256) : "provider validation failed"
-    });
-    throw error;
-  }
-  const terminal = [];
-  for (const item of result.results) {
-    if (item.status === "error") {
-      terminal.push(item);
-      continue;
-    }
-    try {
-      terminal.push({ status: "ok", ...commitItem(projectRoot, journal, install, item, options.refresh === true, options.lockTimeoutMs ?? 30000, options.carrierPluginRoot) });
-    } catch (error) {
-      terminal.push({ status: "error", providerAssetId: item.providerAssetId, code: error instanceof Error ? error.message.split(":", 1)[0] : "internal_error", retryable: false });
-    }
-  }
-  rmSync6(journal.allowedQuarantineRoot, { recursive: true, force: true });
-  rmSync6(providerResultPath(projectRoot, options.execution), { force: true });
-  const failed = terminal.filter((entry) => entry.status === "error").length;
-  updateJournal(projectRoot, journal, { state: failed === 0 ? "complete" : "failed" });
-  return {
-    schemaVersion: "forgeax.asset3d-commit-result/1.0.0",
-    execution: journal.execution,
-    succeeded: terminal.filter((entry) => entry.status === "ok").length,
-    failed,
-    results: terminal
-  };
-}
-function abortAsset3d(projectRootInput, execution) {
-  const projectRoot = realpathSync9(projectRootInput);
-  const journal = readJournal(projectRoot, execution);
-  if (journal.state === "committed" || journal.state === "complete" || journal.state === "engine_verified") {
-    throw new Error("asset3d_execution_already_committed");
-  }
-  rmSync6(journal.allowedQuarantineRoot, { recursive: true, force: true });
-  rmSync6(providerResultPath(projectRoot, execution), { force: true });
-  updateJournal(projectRoot, journal, { state: "aborted" });
-  return { execution, aborted: true };
-}
-function doctorAsset3d(projectRootInput, options = {}) {
-  const projectRoot = realpathSync9(projectRootInput);
-  const install = readInstall(projectRoot);
-  const release = resolveEngineRelease(projectRoot, options.carrierPluginRoot === undefined ? {} : { pluginRoot: options.carrierPluginRoot });
-  const recovered = [];
-  const root = resolve12(forgeaxRoot(projectRoot), "asset3d-transactions");
-  if (existsSync9(root))
-    for (const file of readdirSync7(root).filter((name) => name.endsWith(".json"))) {
-      try {
-        const path = resolve12(root, file);
-        const journal = JSON.parse(readFileSync14(path, "utf8"));
-        if (journal.schemaVersion !== TRANSACTION_SCHEMA || journal.state !== "committing" || !journal.destination)
-          continue;
-        const assetsRoot = resolve12(projectRoot, "assets", "3d", "ea-3d");
-        const backupsRoot = resolve12(forgeaxRoot(projectRoot), "asset3d-backups");
-        if (!confined4(assetsRoot, journal.destination) || journal.backupPath && !confined4(backupsRoot, journal.backupPath))
-          continue;
-        rmSync6(journal.destination, { recursive: true, force: true });
-        if (journal.backupPath && existsSync9(journal.backupPath))
-          renameSync7(journal.backupPath, journal.destination);
-        updateJournal(projectRoot, journal, { state: "rolled_back", error: "stale_committing_recovered" });
-        recovered.push(journal.execution);
-      } catch {}
-    }
-  return { installed: true, recovered, engine: { version: release.version, commit: release.commit }, provider: { commit: install.providerCommit, cache: install.providerCache, live: existsSync9(resolve12(install.providerCache, "venv", "bin", "python")) } };
-}
-
-// src/asset3d/aw-access.ts
-import { spawnSync as spawnSync5 } from "node:child_process";
-import { existsSync as existsSync10 } from "node:fs";
-import { resolve as resolve13 } from "node:path";
-var AW_SERVICE_PATH = "/trpc.oasismetric.omcontentserver.http";
-var ACCESS_CHECK_SCHEMA = "forgeax.asset3d-access-check/1.0.0";
-var DEFAULT_AW_PUBLIC_SERVICE_ROOT = "http://lb-pl74wsqg-5wi8ujmy1fq2746r.clb.usw-tencentclb.com:8008/trpc.oasismetric.omcontentserver.http";
-var DEFAULT_EA_LOCAL_SERVICE_ROOT = "http://test-ultrongw.woa.com/trpc.oasismetric.omcontentserver.http";
-function normalizeAssetLibraryServiceRoot(input) {
-  let parsed;
-  try {
-    parsed = new URL(input);
-  } catch {
-    throw new Error("asset3d_base_url_invalid: expected an HTTP(S) EA gateway or service URL");
-  }
-  if (!["http:", "https:"].includes(parsed.protocol) || parsed.username || parsed.password || parsed.search || parsed.hash) {
-    throw new Error("asset3d_base_url_invalid: credentials, query, and fragment are forbidden");
-  }
-  let path = parsed.pathname.replace(/\/+$/, "");
-  if (path.endsWith(`${AW_SERVICE_PATH}/HybridSearch`))
-    path = path.slice(0, -"/HybridSearch".length);
-  else if (!path.endsWith(AW_SERVICE_PATH))
-    path = `${path}${AW_SERVICE_PATH}`;
-  parsed.pathname = path;
-  return parsed.toString().replace(/\/$/, "");
-}
-function resolveAssetLibrarySelection(options = {}) {
-  const library = options.library || process.env.FORGEAX_ASSET_LIBRARY || "aw";
-  if (library !== "aw" && library !== "ea") {
-    throw new Error("asset3d_library_invalid: expected aw or ea");
-  }
-  const defaultRoot = library === "ea" ? DEFAULT_EA_LOCAL_SERVICE_ROOT : DEFAULT_AW_PUBLIC_SERVICE_ROOT;
-  const configured = options.baseUrl || process.env.FORGEAX_ASSET_LIBRARY_BASE_URL || defaultRoot;
-  return { library, serviceRoot: normalizeAssetLibraryServiceRoot(configured) };
-}
-function checkAssetLibraryProviderAccess(options) {
-  const command = resolve13(options.providerCache, "bin", "asset3d-search");
-  if (!existsSync10(command))
-    throw new Error("asset3d_provider_not_prepared");
-  const result = spawnSync5(command, ["--check-aw-access"], {
-    encoding: "utf8",
-    timeout: 45000,
-    maxBuffer: 128 * 1024,
-    env: {
-      ...process.env,
-      ASSET3D_CATALOG_BASE_URL: "",
-      AW_API_BASE_URL: options.serviceRoot,
-      AW_API_DEPOT_NAME: options.depotName,
-      AW_API_CREDENTIAL_FILE: resolve13(options.credentialFile),
-      AW_API_SANDBOX_KEY: ""
-    }
-  });
-  let payload;
-  try {
-    payload = JSON.parse(result.stdout);
-  } catch {
-    throw new Error("asset3d_access_validation_failed: Provider returned an invalid response");
-  }
-  if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
-    throw new Error("asset3d_access_validation_failed: Provider returned an invalid response");
-  }
-  const envelope = payload;
-  if (result.status !== 0 || envelope.ok !== true) {
-    const code = envelope.error?.code === "asset3d_access_validation_inconclusive" ? "asset3d_access_validation_inconclusive" : "asset3d_api_key_invalid_or_unavailable";
-    throw new Error(`${code}: verify the selected asset-library service, network access, and Sandbox Key`);
-  }
-  if (envelope.schemaVersion !== ACCESS_CHECK_SCHEMA || envelope.value?.authentication !== "sandbox-key" || !Array.isArray(envelope.value.downloadOrigins)) {
-    throw new Error("asset3d_access_validation_failed: Provider returned an invalid response");
-  }
-  const origins = canonicalizeOrigins(envelope.value.downloadOrigins).values;
-  return { serviceRoot: options.serviceRoot, authentication: "sandbox-key", downloadOrigins: origins };
-}
-
-// src/asset3d/credentials.ts
-import { chmodSync as chmodSync5, existsSync as existsSync11, lstatSync as lstatSync10, readFileSync as readFileSync15, statSync as statSync7, unlinkSync as unlinkSync4 } from "node:fs";
-import { homedir as homedir4 } from "node:os";
-import { dirname as dirname11, isAbsolute as isAbsolute6, resolve as resolve14 } from "node:path";
-var AW_CREDENTIAL_SCHEMA = "forgeax.asset3d-credential/1.0.0";
-var AW_KEY_ENV = "FORGEAX_ASSET3D_AW_SANDBOX_KEY";
-var MAX_CREDENTIAL_BYTES = 4096;
-function validateKey(value) {
-  if (!value || value.length > 2048 || [...value].some((character) => {
-    const code = character.charCodeAt(0);
-    return code < 32 || code === 127;
-  })) {
-    throw new Error("asset3d_api_key_invalid: expected a non-empty printable key");
-  }
-  return value;
-}
-function defaultAwCredentialFile() {
-  const configured = process.env.FORGEAX_ASSET3D_CREDENTIAL_FILE;
-  return resolve14(configured || resolve14(homedir4(), ".forgeax", "credentials", "asset3d-aw.json"));
-}
-function readAwCredential(pathInput) {
-  const path = resolve14(pathInput);
-  if (!isAbsolute6(pathInput))
-    throw new Error("asset3d_credential_path_invalid: absolute path required");
-  if (!existsSync11(path))
-    return;
-  try {
-    const metadata = lstatSync10(path);
-    const wrongOwner = typeof process.getuid === "function" && metadata.uid !== process.getuid();
-    if (!metadata.isFile() || metadata.isSymbolicLink() || wrongOwner)
-      throw new Error;
-    if ((metadata.mode & 63) !== 0 || metadata.size < 1 || metadata.size > MAX_CREDENTIAL_BYTES)
-      throw new Error;
-    const parsed = JSON.parse(readFileSync15(path, "utf8"));
-    if (Object.keys(parsed).sort().join(",") !== "provider,sandboxKey,schemaVersion")
-      throw new Error;
-    if (parsed.schemaVersion !== AW_CREDENTIAL_SCHEMA || parsed.provider !== "aw" || typeof parsed.sandboxKey !== "string")
-      throw new Error;
-    return validateKey(parsed.sandboxKey);
-  } catch {
-    throw new Error("asset3d_credential_invalid: credential file must be an owned 0600 regular file with the supported schema");
-  }
-}
-async function promptAwKey() {
-  if (!process.stdin.isTTY || !process.stdout.isTTY || typeof process.stdin.setRawMode !== "function") {
-    throw new Error(`asset3d_api_key_required: set ${AW_KEY_ENV} or rerun in an interactive terminal`);
-  }
-  process.stdout.write("AW Asset3D Sandbox Key (input hidden): ");
-  const input = process.stdin;
-  const previousRaw = input.isRaw;
-  input.setRawMode(true);
-  input.resume();
-  input.setEncoding("utf8");
-  try {
-    const value = await new Promise((resolveValue, reject) => {
-      let collected = "";
-      const onData = (chunk) => {
-        for (const character of chunk) {
-          if (character === "\x03") {
-            input.off("data", onData);
-            reject(new Error("asset3d_api_key_input_cancelled"));
-            return;
-          }
-          if (character === "\r" || character === `
-`) {
-            input.off("data", onData);
-            resolveValue(collected);
-            return;
-          }
-          if (character === "" || character === "\b")
-            collected = collected.slice(0, -1);
-          else
-            collected += character;
-        }
-      };
-      input.on("data", onData);
-    });
-    process.stdout.write(`
-`);
-    return validateKey(value);
-  } finally {
-    input.setRawMode(previousRaw ?? false);
-    input.pause();
-  }
-}
-async function acquireAwKey(path) {
-  const fromEnvironment = process.env[AW_KEY_ENV];
-  if (fromEnvironment)
-    return { key: validateKey(fromEnvironment), source: "environment" };
-  const stored = readAwCredential(path);
-  if (stored)
-    return { key: stored, source: "stored" };
-  return { key: await promptAwKey(), source: "prompt" };
-}
-function writeAwCredential(pathInput, keyInput) {
-  if (!isAbsolute6(pathInput))
-    throw new Error("asset3d_credential_path_invalid: absolute path required");
-  const path = resolve14(pathInput);
-  const key = validateKey(keyInput);
-  const parent = dirname11(path);
-  ensurePrivateDir(parent);
-  const parentMetadata = lstatSync10(parent);
-  const wrongParentOwner = typeof process.getuid === "function" && parentMetadata.uid !== process.getuid();
-  if (!parentMetadata.isDirectory() || parentMetadata.isSymbolicLink() || wrongParentOwner) {
-    throw new Error("asset3d_credential_path_invalid: parent must be an owned regular directory");
-  }
-  chmodSync5(parent, 448);
-  const existed = existsSync11(path);
-  if (existed)
-    readAwCredential(path);
-  const previous = existed ? readFileSync15(path) : undefined;
-  const previousMode = existed ? statSync7(path).mode & 511 : undefined;
-  const bytes = `${JSON.stringify({ schemaVersion: AW_CREDENTIAL_SCHEMA, provider: "aw", sandboxKey: key }, null, 2)}
-`;
-  const changed = !previous || !previous.equals(Buffer.from(bytes));
-  if (changed)
-    atomicWrite(path, bytes, 384);
-  chmodSync5(path, 384);
-  let active = true;
-  return {
-    path,
-    changed,
-    commit() {
-      active = false;
-    },
-    rollback() {
-      if (!active || !changed)
-        return;
-      if (previous) {
-        atomicWrite(path, previous, previousMode ?? 384);
-        chmodSync5(path, previousMode ?? 384);
-      } else {
-        unlinkSync4(path);
-      }
-      active = false;
-    }
-  };
-}
-
-// src/asset3d/mcp-proxy.ts
-import { spawn as spawn4 } from "node:child_process";
-async function runDormantAsset3dMcp() {
-  let buffer = "";
-  process.stdin.setEncoding("utf8");
-  for await (const chunk of process.stdin) {
-    buffer += chunk;
-    for (;; ) {
-      const newline = buffer.indexOf(`
-`);
-      if (newline < 0)
-        break;
-      const line = buffer.slice(0, newline);
-      buffer = buffer.slice(newline + 1);
-      if (!line.trim())
-        continue;
-      let request2;
-      try {
-        request2 = JSON.parse(line);
-      } catch {
-        process.stdout.write(`${JSON.stringify({ jsonrpc: "2.0", id: null, error: { code: -32700, message: "Parse error" } })}
-`);
-        continue;
-      }
-      if (request2.id === undefined)
-        continue;
-      let response;
-      if (request2.method === "initialize") {
-        const params = request2.params;
-        const protocolVersion = params && typeof params === "object" && !Array.isArray(params) && typeof params.protocolVersion === "string" ? params.protocolVersion : "2024-11-05";
-        response = {
-          jsonrpc: "2.0",
-          id: request2.id,
-          result: {
-            protocolVersion,
-            capabilities: { tools: {} },
-            serverInfo: { name: "asset3d-search", version: "0.3.5" }
-          }
-        };
-      } else if (request2.method === "tools/list") {
-        response = { jsonrpc: "2.0", id: request2.id, result: { tools: [] } };
-      } else {
-        response = { jsonrpc: "2.0", id: request2.id, error: { code: -32601, message: "Method not found" } };
-      }
-      process.stdout.write(`${JSON.stringify(response)}
-`);
-    }
-  }
-  return 0;
-}
-function requestKey(id) {
-  return typeof id === "string" || typeof id === "number" ? JSON.stringify(id) : undefined;
-}
-function searchToolError(id, error) {
-  const message = error instanceof Error ? error.message : String(error);
-  return {
-    jsonrpc: "2.0",
-    id,
-    result: {
-      content: [{ type: "text", text: message.slice(0, 512) }],
-      isError: true
-    }
-  };
-}
-function rewriteSearchTool(tool) {
-  if (tool.name !== "search_asset")
-    return tool;
-  const schema = tool.inputSchema;
-  if (!schema || typeof schema !== "object" || Array.isArray(schema))
-    return tool;
-  const inputSchema = schema;
-  const properties = inputSchema.properties;
-  if (!properties || typeof properties !== "object" || Array.isArray(properties))
-    return tool;
-  const { output_dir: _outputDir, ...safeProperties } = properties;
-  const required = Array.isArray(inputSchema.required) ? inputSchema.required.filter((field) => typeof field === "string" && field !== "output_dir") : [];
-  return {
-    ...tool,
-    description: `${typeof tool.description === "string" ? `${tool.description} ` : ""}Run forgeax-game asset3d begin first and pass its execution ID. The bridge injects the transaction-owned output directory. For native Pack preservation select output_format=asset when advertised; glb explicitly requests conversion.`,
-    inputSchema: {
-      ...inputSchema,
-      properties: {
-        ...safeProperties,
-        execution: {
-          type: "string",
-          pattern: "^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$",
-          description: "Execution ID returned by forgeax-game asset3d begin for these exact queries."
-        }
-      },
-      required: [...new Set([...required, "execution"])]
-    }
-  };
-}
-function rewriteAsset3dToolsList(response) {
-  const result = response.result;
-  if (!result || typeof result !== "object" || Array.isArray(result))
-    return response;
-  const tools = result.tools;
-  if (!Array.isArray(tools))
-    return response;
-  return {
-    ...response,
-    result: {
-      ...result,
-      tools: tools.map((tool) => tool && typeof tool === "object" && !Array.isArray(tool) ? rewriteSearchTool(tool) : tool)
-    }
-  };
-}
-function transformAsset3dSearchCall(projectRoot, request2) {
-  if (request2.method !== "tools/call")
-    return request2;
-  const params = request2.params;
-  if (!params || typeof params !== "object" || Array.isArray(params))
-    return request2;
-  const call = params;
-  if (call.name !== "search_asset")
-    return request2;
-  const rawArguments = call.arguments;
-  if (!rawArguments || typeof rawArguments !== "object" || Array.isArray(rawArguments)) {
-    throw new Error("asset3d_search_arguments_invalid");
-  }
-  const args = rawArguments;
-  if (typeof args.execution !== "string") {
-    throw new Error("asset3d_execution_required: run `forgeax-game asset3d begin` first");
-  }
-  if (!Array.isArray(args.queries)) {
-    throw new Error("asset3d_queries_invalid");
-  }
-  const queries = args.queries.map((query) => {
-    if (typeof query === "string")
-      return query;
-    if (query && typeof query === "object" && !Array.isArray(query)) {
-      const selected = query;
-      if (Object.keys(selected).every((key) => key === "content" || key === "assetId") && typeof selected.content === "string" && typeof selected.assetId === "string" && /^[A-Za-z0-9._-]{1,128}$/.test(selected.assetId) && ![".", ".."].includes(selected.assetId)) {
-        return selected.content;
-      }
-    }
-    throw new Error("asset3d_queries_invalid");
-  });
-  const outputDir = asset3dSearchOutputDir(projectRoot, args.execution, queries);
-  const { execution: _execution, output_dir: _callerOutput, ...providerArguments } = args;
-  return {
-    ...request2,
-    params: {
-      ...call,
-      arguments: {
-        ...providerArguments,
-        output_dir: outputDir
-      }
-    }
-  };
-}
-async function runAsset3dMcpProxy(projectRoot, launch) {
-  const child = spawn4(launch.command, [...launch.args], {
-    stdio: ["pipe", "pipe", "pipe"],
-    env: { ...process.env, ...launch.env }
-  });
-  child.stderr.pipe(process.stderr);
-  const toolsListRequests = new Set;
-  const searchExecutions = new Map;
-  let inputBuffer = "";
-  let outputBuffer = "";
-  process.stdin.setEncoding("utf8");
-  process.stdin.on("data", (chunk) => {
-    inputBuffer += chunk;
-    for (;; ) {
-      const newline = inputBuffer.indexOf(`
-`);
-      if (newline < 0)
-        break;
-      const line = inputBuffer.slice(0, newline);
-      inputBuffer = inputBuffer.slice(newline + 1);
-      if (!line.trim())
-        continue;
-      let request2;
-      try {
-        request2 = JSON.parse(line);
-        const key = requestKey(request2.id);
-        if (request2.method === "tools/list" && key)
-          toolsListRequests.add(key);
-        const params = request2.params;
-        if (key && request2.method === "tools/call" && params && typeof params === "object" && !Array.isArray(params) && params.name === "search_asset") {
-          const args = params.arguments;
-          if (args && typeof args === "object" && !Array.isArray(args) && typeof args.execution === "string") {
-            searchExecutions.set(key, args.execution);
-          }
-        }
-        request2 = transformAsset3dSearchCall(projectRoot, request2);
-      } catch (error) {
-        let id = null;
-        try {
-          id = JSON.parse(line).id ?? null;
-        } catch {}
-        process.stdout.write(`${JSON.stringify(searchToolError(id, error))}
-`);
-        continue;
-      }
-      child.stdin.write(`${JSON.stringify(request2)}
-`);
-    }
-  });
-  process.stdin.on("end", () => child.stdin.end());
-  child.stdout.setEncoding("utf8");
-  child.stdout.on("data", (chunk) => {
-    outputBuffer += chunk;
-    for (;; ) {
-      const newline = outputBuffer.indexOf(`
-`);
-      if (newline < 0)
-        break;
-      const line = outputBuffer.slice(0, newline);
-      outputBuffer = outputBuffer.slice(newline + 1);
-      if (!line.trim())
-        continue;
-      try {
-        let response = JSON.parse(line);
-        const key = requestKey(response.id);
-        if (key && toolsListRequests.delete(key))
-          response = rewriteAsset3dToolsList(response);
-        const execution = key ? searchExecutions.get(key) : undefined;
-        if (key && execution) {
-          searchExecutions.delete(key);
-          try {
-            const result = response.result;
-            if (!result || typeof result !== "object" || Array.isArray(result) || result.isError === true) {
-              throw new Error("asset3d_provider_result_missing");
-            }
-            const content = result.content;
-            if (!Array.isArray(content) || content.length !== 1) {
-              throw new Error("asset3d_provider_result_invalid");
-            }
-            const text2 = content[0];
-            if (!text2 || typeof text2 !== "object" || Array.isArray(text2) || text2.type !== "text" || typeof text2.text !== "string") {
-              throw new Error("asset3d_provider_result_invalid");
-            }
-            recordAsset3dProviderResult(projectRoot, execution, text2.text);
-          } catch (error) {
-            response = searchToolError(response.id, error);
-          }
-        }
-        process.stdout.write(`${JSON.stringify(response)}
-`);
-      } catch {
-        process.stderr.write(`asset3d_provider_mcp_stdout_invalid
-`);
-        child.kill("SIGTERM");
-      }
-    }
-  });
-  const stopChild = () => {
-    if (child.exitCode === null && child.signalCode === null)
-      child.kill("SIGTERM");
-  };
-  process.once("SIGINT", stopChild);
-  process.once("SIGTERM", stopChild);
-  return await new Promise((resolve15, reject) => {
-    child.once("error", reject);
-    child.once("close", (code, signal) => resolve15(code ?? (signal ? 1 : 0)));
-  });
-}
-
-// src/asset3d/host-config.ts
-function asset3dHostMode(client, root) {
-  return inspectConfig(client, root, launchSpec("local")).state === "current" ? "local" : "npx";
-}
-function inspectAsset3dHost(client, root, mode = asset3dHostMode(client, root)) {
-  const launch = asset3dLaunchSpec(mode);
-  const status = inspectConfig(client, root, launch, ASSET3D_SERVER_KEY);
-  if (status.state !== "different")
-    return status;
-  const published = asset3dLaunchSpec("npx");
-  if (mode === "local" && inspectConfig(client, root, published, ASSET3D_SERVER_KEY).state === "current") {
-    return { ...status, state: "outdated" };
-  }
-  const previous = configuredGameVersion(client, root, ASSET3D_SERVER_KEY);
-  const current = published.args.find((arg) => arg.startsWith("@forgeax/game@"))?.slice("@forgeax/game@".length);
-  if (!previous || !current || !/^\d+\.\d+\.\d+$/.test(previous) || !/^\d+\.\d+\.\d+$/.test(current))
-    return status;
-  const oldParts = previous.split(".").map(Number);
-  const newParts = current.split(".").map(Number);
-  const differing = oldParts.findIndex((part, index) => part !== newParts[index]);
-  if (differing < 0 || oldParts[differing] >= newParts[differing])
-    return status;
-  const oldLaunch = { ...published, args: published.args.map((arg) => arg === `@forgeax/game@${current}` ? `@forgeax/game@${previous}` : arg) };
-  if (inspectConfig(client, root, oldLaunch, ASSET3D_SERVER_KEY).state !== "current")
-    return status;
-  return { ...status, state: "outdated" };
-}
-function refreshAsset3dHost(client, root) {
-  const status = inspectAsset3dHost(client, root);
-  if (status.state === "outdated") {
-    const result = applyConfig(client, root, asset3dLaunchSpec(asset3dHostMode(client, root)), ASSET3D_SERVER_KEY);
-    process.stdout.write(`UPDATED ${client.label} Asset3D bridge: ${result.path}
-`);
-  } else if (status.state === "different" || status.state === "invalid") {
-    process.stderr.write(`WARN ${client.label}: existing ${ASSET3D_SERVER_KEY} configuration was preserved; it is not a recognized older package launcher.
-`);
-  }
-}
-
-// src/devkit/engine-mounts.ts
-import { lstatSync as lstatSync11, readFileSync as readFileSync16, readdirSync as readdirSync8, readlinkSync as readlinkSync2, rmdirSync, unlinkSync as unlinkSync5, writeFileSync as writeFileSync11 } from "node:fs";
-import { dirname as dirname12, join as join11, resolve as resolve15 } from "node:path";
-var HOSTS = {
-  ".agents/skills": ["codex"],
-  ".claude/skills": ["claude"],
-  ".cursor/skills": ["cursor"],
-  ".codebuddy/skills": ["codebuddy", "workbuddy"],
-  ".workbuddy/skills": ["workbuddy"]
-};
-function pruneUnselectedEngineMounts(root, clients) {
-  const manifestPath = join11(root, ".forgeax", "skill-install-manifest.json");
-  const regular = (path) => {
-    try {
-      const stat = lstatSync11(path);
-      return stat.isFile() && !stat.isSymbolicLink();
-    } catch {
-      return false;
-    }
-  };
-  const directory = (path) => {
-    try {
-      const stat = lstatSync11(path);
-      return stat.isDirectory() && !stat.isSymbolicLink();
-    } catch {
-      return false;
-    }
-  };
-  if (!directory(join11(root, ".forgeax")) || !regular(manifestPath))
-    return [];
-  let manifest;
-  try {
-    manifest = JSON.parse(readFileSync16(manifestPath, "utf8"));
-  } catch {
-    return [];
-  }
-  if (!manifest || manifest.schemaVersion !== "1.0.0" || manifest.sourceRoot !== "skills" || !Array.isArray(manifest.mounts))
-    return [];
-  const removed = [];
-  for (const mount of manifest.mounts) {
-    if (!mount || typeof mount.root !== "string" || !Object.hasOwn(HOSTS, mount.root))
-      continue;
-    const hosts = HOSTS[mount.root];
-    if (!hosts || hosts.some((host) => clients.includes(host)) || !Array.isArray(mount.skills))
-      continue;
-    if (!mount.skills.length || !mount.skills.every((id) => /^forgeax-engine-[a-z0-9-]+$/.test(id)) || new Set(mount.skills).size !== mount.skills.length)
-      continue;
-    const path = join11(root, mount.root);
-    if (!directory(dirname12(path)) || !directory(path))
-      continue;
-    const expected = [".gitignore", ...mount.skills].sort();
-    if (JSON.stringify(readdirSync8(path).sort()) !== JSON.stringify(expected))
-      continue;
-    const ignore = join11(path, ".gitignore");
-    const expectedIgnore = ["# BEGIN FORGEAX MANAGED SKILLS", ...mount.skills.map((id) => `/${id}`), "# END FORGEAX MANAGED SKILLS", ""].join(`
-`);
-    if (!regular(ignore) || readFileSync16(ignore, "utf8") !== expectedIgnore)
-      continue;
-    if (!mount.skills.every((id) => {
-      const link = join11(path, id);
-      return lstatSync11(link).isSymbolicLink() && resolve15(path, readlinkSync2(link)) === resolve15(root, "skills", id);
-    }))
-      continue;
-    for (const id of mount.skills)
-      unlinkSync5(join11(path, id));
-    unlinkSync5(ignore);
-    rmdirSync(path);
-    if (readdirSync8(dirname12(path)).length === 0)
-      rmdirSync(dirname12(path));
-    removed.push(mount.root);
-  }
-  if (removed.length) {
-    manifest.mounts = manifest.mounts.filter((mount) => !mount || !removed.includes(mount.root));
-    writeFileSync11(manifestPath, `${JSON.stringify(manifest, null, 2)}
-`);
-  }
-  return removed;
-}
-
-// src/cli/dispatch.ts
-var HELP = `ForgeaX game development plugin
-
-Usage:
-  forgeax-game install [--ide ${CLIENT_CHOICES.join(",")}] [--local]
-  forgeax-game uninstall [--ide ...] [--purge]
-  forgeax-game init
-  forgeax-game use <slug>
-  forgeax-game doctor
-  forgeax-game preview stop [--game <slug>] [--target-dir <path>] [--json]
-  forgeax-game devkit install
-  forgeax-game agents update
-  forgeax-game asset3d enable [--library aw|ea] [--base-url <gateway/service URL>] [--ide ${CLIENT_CHOICES.join(",")}]
-  forgeax-game asset3d install --provider-bundle <archive> --sha256 <hex> --download-origin <scheme://host:port> [--aw-base-url <URL> --aw-credential-file <absolute path>] [...]
-  forgeax-game asset3d uninstall
-  forgeax-game asset3d begin --query <text> [--query <text> ...] --json
-  forgeax-game asset3d commit --execution <uuid> --json [--provider-result-stdin] [--refresh]
-  forgeax-game asset3d abort --execution <uuid> --json
-  forgeax-game asset3d doctor --json
-  forgeax-game update [--ide ...]
-  forgeax-game version
-  forgeax-game help
-
-With no arguments, forgeax-game runs the stdio MCP server.
-`;
-function parseInstallArgs(args) {
-  let mode = "npx";
-  let ids;
-  for (let i = 0;i < args.length; i++) {
-    const arg = args[i];
-    if (arg === "--local") {
-      mode = "local";
-      continue;
-    }
-    if (arg === "--ide") {
-      const value = args[++i];
-      if (!value)
-        throw new Error("--ide requires a comma-separated client list");
-      ids = value.split(",").map((id) => id.trim()).filter(Boolean);
-      continue;
-    }
-    if (arg.startsWith("--ide=")) {
-      ids = arg.slice("--ide=".length).split(",").map((id) => id.trim()).filter(Boolean);
-      continue;
-    }
-    throw new Error(`unknown install option: ${arg}`);
-  }
-  const selected = ids ?? [...CLIENT_IDS];
-  if (selected.length === 0)
-    throw new Error("--ide did not name any clients");
-  const uniqueNames = [...new Set(selected)];
-  const unknown = uniqueNames.filter((id) => !findClient(id));
-  if (unknown.length) {
-    throw new Error(`unknown client${unknown.length === 1 ? "" : "s"}: ${unknown.join(", ")}. Choose from ${CLIENT_CHOICES.join(", ")}.`);
-  }
-  const clients = uniqueNames.map((id) => findClient(id));
-  return { clients: [...new Map(clients.map((client) => [client.id, client])).values()], mode };
-}
-function requireProject() {
-  const project = resolveProject();
-  if (!project.root) {
-    throw new Error(`no released Engine game found searching upward from ${project.searchedFrom}; run this command inside a game created by the released Engine SDK`);
-  }
-  return project.root;
+  return project.root;
 }
 function updateAgentsFile(root) {
-  const path = join12(root, "AGENTS.md");
-  const existing = existsSync12(path) ? readFileSync17(path, "utf8") : undefined;
+  const path = join11(root, "AGENTS.md");
+  const existing = existsSync9(path) ? readFileSync14(path, "utf8") : undefined;
   const content = upsertBlock(existing, ROUTING_TEXT);
   if (content === existing)
     return { path, changed: false };
-  writeFileSync12(path, content);
+  writeFileSync10(path, content);
   return { path, changed: true };
 }
 function removeAgentsBlock(root) {
-  const path = join12(root, "AGENTS.md");
-  if (!existsSync12(path))
+  const path = join11(root, "AGENTS.md");
+  if (!existsSync9(path))
     return { path, changed: false };
-  const existing = readFileSync17(path, "utf8");
+  const existing = readFileSync14(path, "utf8");
   const content = removeBlock(existing);
   if (content === existing)
     return { path, changed: false };
-  writeFileSync12(path, content);
+  writeFileSync10(path, content);
   return { path, changed: true };
 }
 async function installCommand(args) {
@@ -6443,7 +4784,7 @@ async function installCommand(args) {
     }
     try {
       const result = applyConfig(client, project.root ?? process.cwd(), launch);
-      refreshAsset3dHost(client, project.root ?? process.cwd());
+      retireAsset3dHost(client, project.root ?? process.cwd());
       process.stdout.write(`${result.changed ? "UPDATED" : "CURRENT"} ${client.label}: ${result.path}${result.backup ? ` (backup: ${result.backup})` : ""}
 `);
       if (client.postInstallNote)
@@ -6525,7 +4866,7 @@ async function useCommand(args) {
     throw new Error(`game ${JSON.stringify(slug)} not found. Available: ${listGames(root).join(", ") || "(none)"}`);
   }
   if (listGames(root).length > 1) {
-    writeFileSync12(join12(root, ".forgeax", "active-game.json"), `${JSON.stringify({ version: 1, slug }, null, 2)}
+    writeFileSync10(join11(root, ".forgeax", "active-game.json"), `${JSON.stringify({ version: 1, slug }, null, 2)}
 `, "utf8");
   }
   process.stdout.write(`Active game: ${slug}
@@ -6538,11 +4879,11 @@ async function previewCommand(args) {
   }
   let requested;
   let targetDir;
-  let json2 = false;
+  let json3 = false;
   for (let index = 1;index < args.length; index++) {
     const arg = args[index];
     if (arg === "--json") {
-      json2 = true;
+      json3 = true;
       continue;
     }
     if (arg === "--game" || arg === "--target-dir") {
@@ -6566,7 +4907,7 @@ async function previewCommand(args) {
     throw new Error("no matching Engine game found");
   const result = await stopEnginePreview(project.root, selectedGame2);
   const envelope = { schemaVersion: "1.0.0", command: "preview.stop", ok: true, value: { game: slug, stopped: result.stopped, stateFile: result.paths.state } };
-  process.stdout.write(json2 ? `${JSON.stringify(envelope)}
+  process.stdout.write(json3 ? `${JSON.stringify(envelope)}
 ` : `${result.stopped ? "Stopped" : "No live"} Engine Preview for ${slug}.
 `);
   return 0;
@@ -6602,13 +4943,34 @@ function configuredClientIds(projectRoot) {
 }
 async function uninstallCommand(args) {
   const purge = args.includes("--purge");
-  const rest = args.filter((arg) => arg !== "--purge");
+  const allProjects = args.includes("--all-projects");
+  const rest = args.filter((arg) => arg !== "--purge" && arg !== "--all-projects");
   const requested = parseIdeSelector(rest, "usage: forgeax-game uninstall [--ide codex,claude,...] [--purge]");
   const binding = resolveProject();
   const root = binding.root;
   const targets = requested ? requested.map((id) => id === "workbuddy" ? "codebuddy" : id) : root ? configuredClientIds(root) : [...CLIENT_IDS];
   const clients = CLIENTS.filter((client) => targets.includes(client.id));
   let failures = 0;
+  const projects = allProjects ? registeredProjects() : root ? [root] : [];
+  for (const project of projects) {
+    try {
+      const removed = disableAllExtensions(project);
+      process.stdout.write(`DISABLED ${removed.length} extensions: ${project}
+`);
+      for (const item of removed)
+        for (const backup of item.backups)
+          process.stdout.write(`BACKUP ${backup}
+`);
+      if (allProjects && project !== root) {
+        removeDevKit(project);
+        removeAgentsBlock(project);
+      }
+    } catch (error) {
+      failures++;
+      process.stderr.write(`FAIL extension cleanup: ${project}: ${error instanceof Error ? error.message : String(error)}
+`);
+    }
+  }
   for (const client of clients) {
     try {
       const result = removeConfig(client, root ?? process.cwd());
@@ -6627,7 +4989,7 @@ async function uninstallCommand(args) {
     const agents = removeAgentsBlock(root);
     process.stdout.write(`${agents.changed ? "REMOVED" : "ABSENT "} routing block: ${agents.path}
 `);
-    process.stdout.write(`KEPT    your games and project metadata: ${join12(root, ".forgeax")}
+    process.stdout.write(`KEPT    your games and project metadata: ${join11(root, ".forgeax")}
 `);
   } else {
     process.stdout.write(`INFO  no ForgeaX project bound; only client configuration was touched.
@@ -6791,6 +5153,15 @@ async function doctorCommand(args) {
   return warnings === 0 ? 0 : 1;
 }
 var UPDATE_USAGE = "usage: forgeax-game update [--ide codex,claude,cursor,...]";
+function retireAsset3dHost(client, root) {
+  const state = retireAsset3dConfig(client, root);
+  if (state === "removed")
+    process.stdout.write(`REMOVED ${client.label}: retired asset3d-search MCP; assets now use the project Skill + CLI. Restart the client.
+`);
+  if (state === "preserved")
+    process.stderr.write(`WARN ${client.label}: asset3d-search is not an exact recognized package launcher; preserved for manual review.
+`);
+}
 function versionCommand(args) {
   if (args.length > 0)
     throw new Error("usage: forgeax-game version");
@@ -6827,7 +5198,7 @@ async function updateCommand(args) {
   for (const client of configured) {
     const previousVersion = configuredGameVersion(client, root);
     const result = applyConfig(client, root, launch);
-    refreshAsset3dHost(client, root);
+    retireAsset3dHost(client, root);
     process.stdout.write(`${result.changed ? "UPDATED" : "CURRENT"} ${client.label}: ${result.path} (plugin ${formatVersionTransition(previousVersion)})
 `);
   }
@@ -6846,312 +5217,63 @@ async function updateCommand(args) {
   }
   return 0;
 }
-function asset3dEnvelope(command, ok, payload) {
-  process.stdout.write(`${JSON.stringify({ schemaVersion: "1.0.0", command, ok, ...ok ? { value: payload } : { error: payload } })}
-`);
-}
-async function readBoundedStdin() {
-  const chunks = [];
-  let total = 0;
-  for await (const chunk of process.stdin) {
-    const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
-    total += bytes.byteLength;
-    if (total > MAX_JSON_BYTES)
-      throw new Error("provider_result_too_large: stdin exceeds 1 MiB");
-    chunks.push(bytes);
-  }
-  return Buffer.concat(chunks);
-}
-function canonicalAsset3dClients(value) {
-  const values = value.split(",").map((entry) => entry.trim()).filter(Boolean).map((entry) => entry === "workbuddy" ? "codebuddy" : entry);
-  const invalid = values.filter((entry) => !(entry in SKILL_MOUNTS));
-  if (invalid.length)
-    throw new Error(`asset3d_client_invalid: ${invalid.join(", ")}`);
-  return [...new Set(values)];
-}
-function parseAssetLibraryId(value) {
-  if (value === "aw" || value === "ea")
-    return value;
-  throw new Error("asset3d_library_invalid: expected aw or ea");
-}
-function parseAsset3dEnableArgs(args) {
-  const ideArgs = [];
-  let baseUrl;
-  let library;
-  for (let index = 0;index < args.length; index++) {
-    const arg = args[index];
-    if (arg === "--library") {
-      const value = args[++index];
-      if (!value)
-        throw new Error("--library requires aw or ea");
-      library = parseAssetLibraryId(value);
-      continue;
-    }
-    if (arg.startsWith("--library=")) {
-      library = parseAssetLibraryId(arg.slice("--library=".length));
-      continue;
-    }
-    if (arg === "--base-url") {
-      const value = args[++index];
-      if (!value)
-        throw new Error("--base-url requires a gateway/service URL");
-      baseUrl = value;
-      continue;
-    }
-    if (arg.startsWith("--base-url=")) {
-      baseUrl = arg.slice("--base-url=".length);
-      continue;
-    }
-    if (arg === "--ide") {
-      const value = args[++index];
-      if (!value)
-        throw new Error("--ide requires a comma-separated client list");
-      ideArgs.push("--ide", value);
-      continue;
-    }
-    if (arg.startsWith("--ide=")) {
-      ideArgs.push(arg);
-      continue;
-    }
-    throw new Error("usage: forgeax-game asset3d enable [--library aw|ea] [--base-url <gateway/service URL>] [--ide codex,claude,cursor,...]");
-  }
-  return { requested: parseIdeSelector(ideArgs, "invalid --ide selector"), baseUrl, library };
-}
-async function asset3dCommand(args) {
+async function extensionCommand(id, args) {
   const [operation, ...rest] = args;
-  try {
-    if (operation === "mcp") {
-      if (rest.length)
-        throw new Error("usage: forgeax-game asset3d mcp");
-      const binding = resolveProject();
-      if (!binding.root)
-        return runDormantAsset3dMcp();
-      let launch;
-      try {
-        launch = asset3dProviderLaunch(binding.root);
-      } catch (error) {
-        if (error instanceof Error && error.message === "asset3d_not_installed") {
-          return runDormantAsset3dMcp();
-        }
-        throw error;
-      }
-      return runAsset3dMcpProxy(binding.root, launch);
-    }
-    const projectRoot = requireProject();
-    if (operation === "enable") {
-      const parsed = parseAsset3dEnableArgs(rest);
-      const selection = selectClients(projectRoot, parsed.requested);
-      reportMissingClients(selection.missing);
-      if (selection.selected.length === 0) {
-        throw new Error("asset3d_client_missing: run `forgeax-game install --ide <client>` before enabling Asset3D");
-      }
-      const localMode = selection.selected.some((id) => asset3dHostMode(findClient(id), projectRoot) === "local");
-      for (const id of selection.selected) {
-        const client = findClient(id);
-        if (!client)
-          throw new Error(`asset3d_client_invalid: ${id}`);
-        const state = inspectAsset3dHost(client, projectRoot);
-        if (state.state === "different") {
-          throw new Error(`asset3d_client_server_conflict: ${client.label} already has a different ${ASSET3D_SERVER_KEY} entry`);
-        }
-        if (state.state === "invalid") {
-          throw new Error(`asset3d_client_config_invalid: ${client.label}: ${state.detail ?? state.path}`);
-        }
-      }
-      const library = resolveAssetLibrarySelection({
-        library: parsed.library,
-        baseUrl: parsed.baseUrl
-      });
-      const os = platform2() === "win32" ? "windows" : platform2();
-      const cpu = arch2();
-      const target = `${os}-${cpu}`;
-      const bundled = BUNDLED_ASSET3D_PROVIDERS[target];
-      if (!bundled)
-        throw new Error(`asset3d_provider_target_unreleased: ${target}`);
-      const providerCache = resolve16(homedir5(), ".forgeax", "providers", "asset3d-search", bundled.sha256);
-      let preparedCache = providerCache;
-      if (!existsSync12(providerCache)) {
-        const providerBundle = packagedAsset3dProvider(bundled.relativePath);
-        preparedCache = prepareAsset3dProvider({ providerBundle, expectedSha256: bundled.sha256 });
-      }
-      const credentialFile = defaultAwCredentialFile();
-      const credential = await acquireAwKey(credentialFile);
-      const credentialWrite = writeAwCredential(credentialFile, credential.key);
-      const clients = selection.selected.filter((id) => (id in SKILL_MOUNTS));
-      try {
-        const access = checkAssetLibraryProviderAccess({
-          providerCache: preparedCache,
-          depotName: library.library,
-          serviceRoot: library.serviceRoot,
-          credentialFile
-        });
-        const result = await installProvisionedAsset3d({
-          projectRoot,
-          providerCache: preparedCache,
-          expectedSha256: bundled.sha256,
-          downloadOrigins: access.downloadOrigins,
-          awApiBaseUrl: access.serviceRoot,
-          awDepotName: library.library,
-          awCredentialFile: credentialFile,
-          clients,
-          gamePluginLaunch: launchSpec(localMode ? "local" : "npx"),
-          replaceOwned: true
-        });
-        for (const id of selection.selected) {
-          const client = findClient(id);
-          if (!client)
-            throw new Error(`asset3d_client_invalid: ${id}`);
-          const applied = applyConfig(client, projectRoot, asset3dLaunchSpec(asset3dHostMode(client, projectRoot)), ASSET3D_SERVER_KEY);
-          process.stdout.write(`${applied.changed ? "UPDATED" : "CURRENT"} ${client.label} Asset3D bridge: ${applied.path}
-`);
-          if (applied.changed && client.postInstallNote)
-            process.stdout.write(`  ${client.postInstallNote}
-`);
-        }
-        credentialWrite.commit();
-        process.stdout.write(`${result.changed ? "ENABLED" : "CURRENT"} Asset3D provider ${result.providerCommit}; library=${library.library}; service=${access.serviceRoot}; authentication=${access.authentication}; skillFiles=${result.skillFiles}
-`);
-        return 0;
-      } catch (error) {
-        credentialWrite.rollback();
-        throw error;
-      }
-    }
-    if (operation === "install") {
-      let providerBundle;
-      let expectedSha256;
-      let catalogBaseUrl;
-      let awApiBaseUrl;
-      let awDepotName;
-      let awCredentialFile;
-      const downloadOrigins = [];
-      let clients;
-      let replaceOwned = false;
-      for (let index = 0;index < rest.length; index++) {
-        const arg = rest[index];
-        if (arg === "--replace-owned") {
-          replaceOwned = true;
-          continue;
-        }
-        if (arg === "--provider-bundle" || arg === "--sha256" || arg === "--download-origin" || arg === "--catalog-base-url" || arg === "--aw-base-url" || arg === "--aw-depot-name" || arg === "--aw-credential-file" || arg === "--ide") {
-          const value = rest[++index];
-          if (!value)
-            throw new Error(`${arg} requires a value`);
-          if (arg === "--provider-bundle")
-            providerBundle = value;
-          else if (arg === "--sha256")
-            expectedSha256 = value;
-          else if (arg === "--download-origin")
-            downloadOrigins.push(value);
-          else if (arg === "--catalog-base-url")
-            catalogBaseUrl = value;
-          else if (arg === "--aw-base-url")
-            awApiBaseUrl = normalizeAssetLibraryServiceRoot(value);
-          else if (arg === "--aw-depot-name")
-            awDepotName = parseAssetLibraryId(value);
-          else if (arg === "--aw-credential-file")
-            awCredentialFile = resolve16(value);
-          else
-            clients = canonicalAsset3dClients(value);
-          continue;
-        }
-        throw new Error(`unknown asset3d install option: ${arg}`);
-      }
-      if (!providerBundle || !expectedSha256)
-        throw new Error("usage: forgeax-game asset3d install --provider-bundle <archive> --sha256 <hex> --download-origin <origin> [...]");
-      const result = await installAsset3d({
-        projectRoot,
-        providerBundle,
-        expectedSha256,
-        downloadOrigins,
-        ...catalogBaseUrl ? { catalogBaseUrl } : {},
-        ...awApiBaseUrl ? { awApiBaseUrl } : {},
-        ...awDepotName ? { awDepotName } : {},
-        ...awCredentialFile ? { awCredentialFile } : {},
-        ...clients ? { clients } : {},
-        replaceOwned
-      });
-      process.stdout.write(`${result.changed ? "INSTALLED" : "CURRENT"} Asset3D provider ${result.providerCommit}; originSetDigest=${result.originSetDigest}; skillFiles=${result.skillFiles}
+  const emit = (ok, value) => process.stdout.write(JSON.stringify({
+    schemaVersion: "1.0.0",
+    command: `${id}.${operation}`,
+    ok,
+    ...ok ? { value } : { error: value }
+  }) + `
 `);
-      return 0;
-    }
-    if (operation === "uninstall") {
-      if (rest.length)
-        throw new Error("usage: forgeax-game asset3d uninstall");
-      const result = uninstallAsset3d(projectRoot);
-      if (result.modified.length)
-        throw new Error(`owned_skill_modified: ${result.modified.join(", ")}`);
-      process.stdout.write(`REMOVED Asset3D owned records: ${result.removed}
+  try {
+    const extension = discoverExtensions().find((item) => item.id === id);
+    if (operation === "help" || operation === "--help") {
+      process.stdout.write(`${id}: enable [--ide ...] [--local], disable, or a business operation documented in its Skill.
 `);
       return 0;
     }
-    if (operation === "begin") {
-      const queries = [];
-      for (let index = 0;index < rest.length; index++) {
-        if (rest[index] === "--json")
-          continue;
-        if (rest[index] !== "--query" || !rest[index + 1])
-          throw new Error("usage: forgeax-game asset3d begin --query <text> [--query <text> ...] --json");
-        queries.push(rest[++index]);
-      }
-      asset3dEnvelope("asset3d.begin", true, beginAsset3d(projectRoot, queries));
-      return 0;
-    }
-    if (operation === "commit") {
-      let execution;
-      let refresh = false;
-      let stdin = false;
-      for (let index = 0;index < rest.length; index++) {
-        const arg = rest[index];
-        if (arg === "--json")
-          continue;
-        if (arg === "--refresh") {
-          refresh = true;
-          continue;
-        }
-        if (arg === "--provider-result-stdin") {
-          stdin = true;
-          continue;
-        }
-        if (arg === "--execution" && rest[index + 1]) {
-          execution = rest[++index];
-          continue;
-        }
-        throw new Error("usage: forgeax-game asset3d commit --execution <uuid> --json [--provider-result-stdin] [--refresh]");
+    const root = requireProject();
+    if (operation === "enable") {
+      const options = [];
+      let hosts;
+      let local = false;
+      for (let i = 0;i < rest.length; i++) {
+        const arg = rest[i];
+        if (arg === "--local")
+          local = true;
+        else if (arg === "--ide" || arg.startsWith("--ide=")) {
+          const value = arg === "--ide" ? rest[++i] : arg.slice(6);
+          if (!value)
+            throw new Error("extension_host_required");
+          hosts = value.split(",").map((name) => {
+            const client = findClient(name);
+            if (!client)
+              throw new Error("extension_host_invalid: " + name);
+            return client.id;
+          });
+        } else
+          options.push(arg);
       }
-      if (!execution)
-        throw new Error("usage: forgeax-game asset3d commit --execution <uuid> --json [--provider-result-stdin] [--refresh]");
-      const result = commitAsset3d({
-        projectRoot,
-        execution,
-        ...stdin ? { providerResult: await readBoundedStdin() } : {},
-        refresh
-      });
-      asset3dEnvelope("asset3d.commit", result.failed === 0, result);
-      return result.failed === 0 ? 0 : 1;
-    }
-    if (operation === "abort") {
-      const executionIndex = rest.indexOf("--execution");
-      const execution = executionIndex >= 0 ? rest[executionIndex + 1] : undefined;
-      if (!execution || rest.some((arg, index) => arg !== "--json" && index !== executionIndex && index !== executionIndex + 1))
-        throw new Error("usage: forgeax-game asset3d abort --execution <uuid> --json");
-      asset3dEnvelope("asset3d.abort", true, abortAsset3d(projectRoot, execution));
-      return 0;
-    }
-    if (operation === "doctor") {
+      const selected = [...new Set(hosts ?? selectClients(root, undefined).selected)];
+      local ||= selected.some((host) => inspectConfig(findClient(host), root, launchSpec("local")).state === "current");
+      emit(true, await enableExtension(root, extension, selected, options, local ? launchSpec("local").args[0] : undefined));
+    } else if (operation === "disable") {
       if (rest.some((arg) => arg !== "--json"))
-        throw new Error("usage: forgeax-game asset3d doctor --json");
-      asset3dEnvelope("asset3d.doctor", true, doctorAsset3d(projectRoot));
-      return 0;
+        throw new Error("extension_arguments_invalid");
+      emit(true, disableExtension(root, id));
+    } else {
+      const value = await runExtension(root, extension, args);
+      const failed = value && typeof value === "object" && "failed" in value && Number(value.failed) > 0;
+      emit(!failed, value);
+      if (failed)
+        return 1;
     }
-    throw new Error("usage: forgeax-game asset3d <enable|install|uninstall|begin|commit|abort|doctor>");
+    return 0;
   } catch (error) {
-    if (rest.includes("--json")) {
-      const message = error instanceof Error ? error.message : String(error);
-      asset3dEnvelope(`asset3d.${operation ?? "unknown"}`, false, { code: message.split(":", 1)[0], message: message.slice(0, 256) });
-      return message.startsWith("usage:") ? 2 : 1;
-    }
-    throw error;
+    const message = error instanceof Error ? error.message : String(error);
+    emit(false, { code: message.split(":")[0], message: message.slice(0, 256) });
+    return 1;
   }
 }
 async function runCli(argv) {
@@ -7173,8 +5295,6 @@ async function runCli(argv) {
       return devkitCommand(args);
     case "agents":
       return agentsCommand(args);
-    case "asset3d":
-      return asset3dCommand(args);
     case "update":
       return updateCommand(args);
     case "version":
@@ -7187,6 +5307,8 @@ async function runCli(argv) {
       process.stdout.write(HELP);
       return 0;
     default:
+      if (command && discoverExtensions().some((extension) => extension.id === command))
+        return extensionCommand(command, args);
       process.stderr.write(`Unknown command: ${command ?? "(none)"}
 
 ${HELP}`);
@@ -7254,7 +5376,7 @@ function parseMcpArgs(args) {
     } else
       throw new Error(`unknown MCP option: ${arg}`);
   }
-  return { transport, host, port, root: resolve17(root), requireAuth, allowedOrigins };
+  return { transport, host, port, root: resolve14(root), requireAuth, allowedOrigins };
 }
 async function runMcp(args) {
   const options = parseMcpArgs(args);