@forgeax/game 0.3.2 → 0.3.4

package/dist/main.js

@@ -2946,7 +2946,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.2",
+  gameVersion: "0.3.4",
   gameBin: "forgeax-game",
   engineSdkPackage: ENGINE_SDK_PACKAGE,
   engineSdkVersion: ENGINE_VERSION,
@@ -3349,13 +3349,24 @@ 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.2", "forgeax-game", "mcp"]
+    args: ["-y", "-p", "@forgeax/game@0.3.4", "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"]
   };
 }
 
@@ -3494,6 +3505,16 @@ ${suffix ? `
 function hasTomlTable(content, header) {
   return [...content.matchAll(HEADER_RE)].some((match) => sameHeader(match[1], header));
 }
+function readTomlTable(content, header) {
+  const headerLines = [...content.matchAll(HEADER_RE)];
+  const ownedIndexes = headerLines.flatMap((match, index) => sameHeader(match[1], header) ? [index] : []);
+  if (ownedIndexes.length !== 1)
+    return;
+  const ownedIndex = ownedIndexes[0];
+  const owned = headerLines[ownedIndex];
+  const next = headerLines[ownedIndex + 1];
+  return content.slice(owned.index, next?.index ?? content.length);
+}
 function hasCompetingTomlDefinition(content, header) {
   const headerLines = [...content.matchAll(HEADER_RE)];
   return hasCompetingInlineOwner(content, header, headerLines);
@@ -3794,20 +3815,57 @@ function validateTomlSyntax(source) {
   if (brackets.length)
     throw new Error("unterminated TOML array or inline table");
 }
-function mergeJsonConfig(existing, spec, entry) {
+function validTomlTableHeader(line) {
+  const arrayTable = line.startsWith("[[");
+  const openingWidth = arrayTable ? 2 : 1;
+  let quote;
+  for (let index = openingWidth;index < line.length; index++) {
+    const char = line[index];
+    if (quote === "basic") {
+      if (char === "\\") {
+        index++;
+        continue;
+      }
+      if (char === '"')
+        quote = undefined;
+      continue;
+    }
+    if (quote === "literal") {
+      if (char === "'")
+        quote = undefined;
+      continue;
+    }
+    if (char === '"') {
+      quote = "basic";
+      continue;
+    }
+    if (char === "'") {
+      quote = "literal";
+      continue;
+    }
+    const closes = arrayTable ? line.startsWith("]]", index) : char === "]";
+    if (!closes)
+      continue;
+    const body = line.slice(openingWidth, index).trim();
+    const suffix = line.slice(index + openingWidth);
+    return body.length > 0 && /^[ \t]*(?:#.*)?$/.test(suffix);
+  }
+  return false;
+}
+function mergeJsonConfig(existing, spec, entry, serverKey = SERVER_KEY) {
   const path = spec.path("");
   const mapKey = spec.serverMapKey ?? ["mcpServers"];
   const wanted = JSON.stringify(entry);
   if (!existing || existing.trim() === "") {
     if (existing && JSON_WHITESPACE.test(existing)) {
-      let nested2 = { [SERVER_KEY]: entry };
+      let nested2 = { [serverKey]: entry };
       for (let index = mapKey.length - 1;index >= 0; index--) {
         nested2 = { [mapKey[index]]: nested2 };
       }
       return { content: `${existing}${JSON.stringify(nested2)}
 `, changed: true };
     }
-    let nested = { [SERVER_KEY]: entry };
+    let nested = { [serverKey]: entry };
     for (let index = mapKey.length - 1;index >= 0; index--) {
       nested = { [mapKey[index]]: nested };
     }
@@ -3822,7 +3880,7 @@ function mergeJsonConfig(existing, spec, entry) {
     const key = mapKey[index];
     const found = jsonMember(members, key, path);
     if (!found) {
-      let nested = { [SERVER_KEY]: entry };
+      let nested = { [serverKey]: entry };
       for (let nestedIndex = mapKey.length - 1;nestedIndex >= index; nestedIndex--) {
         nested = { [mapKey[nestedIndex]]: nested };
       }
@@ -3836,29 +3894,29 @@ function mergeJsonConfig(existing, spec, entry) {
     members = nestedMembers;
   }
   const mapMembers = members;
-  const owned = jsonMember(mapMembers, SERVER_KEY, `${path}.${mapKey.join(".")}`);
+  const owned = jsonMember(mapMembers, serverKey, `${path}.${mapKey.join(".")}`);
   if (owned) {
     let before;
     try {
       before = JSON.parse(source.slice(owned.value.start, owned.value.end));
     } catch {
-      throw new Error(`${path}.mcpServers.${SERVER_KEY} is not valid JSON`);
+      throw new Error(`${path}.mcpServers.${serverKey} is not valid JSON`);
     }
     if (JSON.stringify(before) === wanted)
       return { content: existing, changed: false };
     return { content: replaceJsonValue(source, owned.value, wanted), changed: true };
   }
   return {
-    content: appendJsonMember(source, container, mapMembers, SERVER_KEY, wanted),
+    content: appendJsonMember(source, container, mapMembers, serverKey, wanted),
     changed: true
   };
 }
-function mergeTomlConfig(existing, entry) {
+function mergeTomlConfig(existing, entry, serverKey = SERVER_KEY) {
   if (existing !== undefined && existing.trim() !== "") {
     validateTomlSyntax(existing);
     for (const [index, line] of existing.split(/\r?\n/).entries()) {
       const trimmed = line.trim();
-      if (trimmed.startsWith("[") && !/^\[{1,2}[^\]\r\n]+\]{1,2}[ \t]*(?:#.*)?$/.test(trimmed)) {
+      if (trimmed.startsWith("[") && !validTomlTableHeader(trimmed)) {
         throw new Error(`line ${index + 1} has an invalid TOML table header`);
       }
     }
@@ -3870,10 +3928,47 @@ function mergeTomlConfig(existing, entry) {
   const args = entry.args;
   if (Array.isArray(args))
     body.push(`args = ${encodeTomlStringArray(args)}`);
-  const content = upsertTomlTable(existing ?? "", { header: `mcp_servers.${SERVER_KEY}`, body });
+  const content = upsertTomlTable(existing ?? "", { header: `mcp_servers.${serverKey}`, body });
   return { content, changed: content !== (existing ?? "") };
 }
-function inspectConfig(spec, projectRoot, launch) {
+function jsonServerEntry(parsed, spec, serverKey) {
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed))
+    return;
+  let cursor = parsed;
+  for (const key of spec.serverMapKey ?? ["mcpServers"]) {
+    if (typeof cursor !== "object" || cursor === null || Array.isArray(cursor))
+      return;
+    cursor = cursor[key];
+  }
+  if (typeof cursor !== "object" || cursor === null || Array.isArray(cursor))
+    return;
+  return cursor[serverKey];
+}
+function gameVersionFromEntryText(entry) {
+  const pinned = entry.match(/@forgeax\/game@([0-9A-Za-z][0-9A-Za-z.+_-]*)/);
+  if (pinned)
+    return pinned[1];
+  if (entry.includes("@forgeax/game"))
+    return "unversioned";
+  return "local/custom";
+}
+function configuredGameVersion(spec, projectRoot, serverKey = SERVER_KEY) {
+  const path = spec.path(projectRoot);
+  if (!existsSync7(path))
+    return;
+  try {
+    const existing = readFileSync11(path, "utf8");
+    if (spec.format === "toml") {
+      const table = readTomlTable(existing, `mcp_servers.${serverKey}`);
+      return table === undefined ? undefined : gameVersionFromEntryText(table);
+    }
+    const entry = jsonServerEntry(JSON.parse(existing), spec, serverKey);
+    return entry === undefined ? undefined : gameVersionFromEntryText(JSON.stringify(entry));
+  } catch {
+    return;
+  }
+}
+function inspectConfig(spec, projectRoot, launch, serverKey = SERVER_KEY) {
   const path = spec.path(projectRoot);
   if (!existsSync7(path))
     return { path, state: "missing" };
@@ -3881,7 +3976,7 @@ function inspectConfig(spec, projectRoot, launch) {
   try {
     existing = readFileSync11(path, "utf8");
     if (spec.format === "toml") {
-      const header = `mcp_servers.${SERVER_KEY}`;
+      const header = `mcp_servers.${serverKey}`;
       if (!hasTomlTable(existing, header)) {
         if (hasCompetingTomlDefinition(existing, header)) {
           return {
@@ -3894,24 +3989,14 @@ function inspectConfig(spec, projectRoot, launch) {
       }
       return {
         path,
-        state: mergeTomlConfig(existing, buildEntry(spec, launch)).changed ? "different" : "current"
+        state: mergeTomlConfig(existing, buildEntry(spec, launch), serverKey).changed ? "different" : "current"
       };
     }
     const parsed = JSON.parse(existing);
     if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
       return { path, state: "invalid", detail: "top level is not a JSON object" };
     }
-    let cursor = parsed;
-    for (const key of spec.serverMapKey ?? ["mcpServers"]) {
-      if (typeof cursor !== "object" || cursor === null || Array.isArray(cursor)) {
-        return { path, state: "not_configured" };
-      }
-      cursor = cursor[key];
-    }
-    if (typeof cursor !== "object" || cursor === null || Array.isArray(cursor)) {
-      return { path, state: "not_configured" };
-    }
-    const entry = cursor[SERVER_KEY];
+    const entry = jsonServerEntry(parsed, spec, serverKey);
     if (entry === undefined)
       return { path, state: "not_configured" };
     return {
@@ -3922,11 +4007,11 @@ function inspectConfig(spec, projectRoot, launch) {
     return { path, state: "invalid", detail: error instanceof Error ? error.message : String(error) };
   }
 }
-function applyConfig(spec, projectRoot, launch) {
+function applyConfig(spec, projectRoot, launch, serverKey = SERVER_KEY) {
   const path = spec.path(projectRoot);
   const existing = existsSync7(path) ? readFileSync11(path, "utf8") : undefined;
   const entry = buildEntry(spec, launch);
-  const merged = spec.format === "toml" ? mergeTomlConfig(existing, entry) : mergeJsonConfig(existing, spec, entry);
+  const merged = spec.format === "toml" ? mergeTomlConfig(existing, entry, serverKey) : mergeJsonConfig(existing, spec, entry, serverKey);
   if (!merged.changed)
     return { path, changed: false };
   mkdirSync7(dirname8(path), { recursive: true });
@@ -3938,14 +4023,14 @@ function applyConfig(spec, projectRoot, launch) {
   writeFileSync7(path, merged.content);
   return { path, changed: true, ...backup ? { backup } : {} };
 }
-function removeConfig(spec, projectRoot) {
+function removeConfig(spec, projectRoot, serverKey = SERVER_KEY) {
   const path = spec.path(projectRoot);
   if (!existsSync7(path))
     return { path, changed: false };
   const existing = readFileSync11(path, "utf8");
   let content;
   if (spec.format === "toml") {
-    content = removeTomlTable(existing, `mcp_servers.${SERVER_KEY}`);
+    content = removeTomlTable(existing, `mcp_servers.${serverKey}`);
   } else {
     let parsed;
     try {
@@ -3960,9 +4045,9 @@ function removeConfig(spec, projectRoot) {
         return { path, changed: false };
       cursor = next;
     }
-    if (!(SERVER_KEY in cursor))
+    if (!(serverKey in cursor))
       return { path, changed: false };
-    delete cursor[SERVER_KEY];
+    delete cursor[serverKey];
     content = `${JSON.stringify(parsed, null, 2)}
 `;
   }
@@ -4184,14 +4269,18 @@ 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 = "0c3fc5d448b94efadb7fe03ee48ef3d8964434c2789505297a99c3a2715dd83b";
+var K0_PACKAGE_SHA256 = "4937fe00e2b919319c70c82db53ebe359b275ed662c026153ecb97f7601262b4";
 var RESULT_SCHEMA_SHA256 = "ab6e5e1e794d5428efef362fe32d4c54b6541e12539bae5f6ff27680c9f380ba";
 var RECEIPT_SCHEMA_SHA256 = "e0dc9e9fe9872f09af9fca6d0c17d22aca63c2b546c55c0b669c581f7059b9c4";
 var ASSET3D_PROVIDER_COMMIT = "c181c48fbffc933a7ce9a0836f7878ca5e6d77e1";
 var BUNDLED_ASSET3D_PROVIDERS = Object.freeze({
   "darwin-arm64": {
-    sha256: "c8d2afd7ba68ae4b3540c927a2ff7133a82ea90975d09cab1d10b003fbbdeed3",
+    sha256: "9492c507a3afe5cafcd50b5f782b313c8716c2e52f5def06592c6a100c0459db",
     relativePath: "asset3d/provider/asset3d-search-provider-c181c48fbffc933a7ce9a0836f7878ca5e6d77e1-darwin-arm64.tar.gz"
+  },
+  "linux-x64": {
+    sha256: "e6ac3df76c8b82f9fe2c063dd3f221324a9dad5176fd52535a5144b0ff6002d8",
+    relativePath: "asset3d/provider/asset3d-search-provider-c181c48fbffc933a7ce9a0836f7878ca5e6d77e1-linux-x64.tar.gz"
   }
 });
 var INSTALL_SCHEMA = "forgeax.asset3d-install/1.0.0";
@@ -4501,9 +4590,19 @@ function filesUnder2(root, directory = root) {
     })();
   });
 }
-function launchEntries(projectRoot, providerCache, origins, gamePluginLaunch, catalogBaseUrl, awApiBaseUrl, awCredentialFile) {
+function asset3dProxyLaunch(gamePluginLaunch) {
+  if (gamePluginLaunch.args.at(-1) !== "mcp") {
+    throw new Error("asset3d_game_plugin_launch_invalid: expected MCP launch suffix");
+  }
+  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",
@@ -4514,8 +4613,8 @@ function launchEntries(projectRoot, providerCache, origins, gamePluginLaunch, ca
     },
     "asset3d-search": {
       type: "stdio",
-      command: resolve10(providerCache, "bin", "asset3d-search"),
-      args: [],
+      command: proxyLaunch.command,
+      args: proxyLaunch.args,
       env: {
         FBX2GLTF_BIN: resolve10(providerCache, "bin", "FBX2glTF"),
         MCP_SHARED_PATH: workspace,
@@ -4524,6 +4623,7 @@ function launchEntries(projectRoot, providerCache, origins, gamePluginLaunch, ca
         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 } }
@@ -4697,7 +4797,11 @@ async function publishAsset3d(options, provisioned) {
   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");
@@ -4713,9 +4817,14 @@ async function publishAsset3d(options, provisioned) {
     command: realpathSync7(options.executable ?? process.argv[1]),
     args: ["mcp"]
   };
-  const entries = launchEntries(projectRoot, provisioned.cache, origins, gamePluginLaunch, catalogBaseUrl, awApiBaseUrl, awCredentialFile);
-  if (options.verifyMcp !== false)
-    await verifyProviderMcp(entries["asset3d-search"]);
+  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))];
@@ -4767,6 +4876,37 @@ function prepareAsset3dProvider(options) {
 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");
@@ -5013,6 +5153,9 @@ function forgeaxRoot(projectRoot) {
 function journalPath(projectRoot, execution) {
   return resolve11(forgeaxRoot(projectRoot), "asset3d-transactions", `${execution}.json`);
 }
+function providerResultPath(projectRoot, execution) {
+  return resolve11(forgeaxRoot(projectRoot), "asset3d-results", `${execution}.json`);
+}
 function readInstall(projectRoot) {
   let manifest;
   try {
@@ -5072,6 +5215,36 @@ function beginAsset3d(projectRootInput, queries, options = {}) {
 `);
   return { execution, output_dir: relativeOutput };
 }
+function asset3dSearchOutputDir(projectRootInput, execution, queries) {
+  const projectRoot = realpathSync8(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 = resolve11(forgeaxRoot(projectRoot), "asset3d-quarantine", outputDir);
+  if (journal.allowedQuarantineRoot !== expectedRoot || !existsSync9(expectedRoot) || realpathSync8(expectedRoot) !== expectedRoot) {
+    throw new Error("asset3d_search_output_identity_mismatch");
+  }
+  return outputDir;
+}
+function recordAsset3dProviderResult(projectRootInput, execution, providerResult) {
+  const projectRoot = realpathSync8(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(resolve11(forgeaxRoot(projectRoot), "asset3d-results"));
+  atomicWrite(providerResultPath(projectRoot, execution), providerResult, 384);
+  updateJournal(projectRoot, journal, { state: "provider_complete" });
+}
 function fileBytesChecked(root, entry) {
   const source = resolve11(root, entry.path);
   if (!confined4(root, source))
@@ -5354,14 +5527,23 @@ function commitAsset3d(options) {
   const projectRoot = realpathSync8(options.projectRoot);
   const install = readInstall(projectRoot);
   let journal = readJournal(projectRoot, options.execution);
-  if (journal.state !== "begun" && journal.state !== "validated")
+  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 = readFileSync13(providerResultPath(projectRoot, options.execution));
+    } catch {
+      throw new Error("asset3d_provider_result_missing: call search_asset for this execution first");
+    }
+  }
   let result;
   try {
-    result = parseProviderResult(options.providerResult, install.providerCommit, install.originSetDigest);
+    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);
@@ -5373,6 +5555,7 @@ function commitAsset3d(options) {
     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"
@@ -5392,6 +5575,7 @@ function commitAsset3d(options) {
     }
   }
   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 {
@@ -5409,6 +5593,7 @@ function abortAsset3d(projectRootInput, execution) {
     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 };
 }
@@ -5445,13 +5630,14 @@ import { existsSync as existsSync10 } from "node:fs";
 import { resolve as resolve12 } 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_PRODUCTION_SERVICE_ROOT = "http://lb-pl74wsqg-5wi8ujmy1fq2746r.clb.usw-tencentclb.com:8008/trpc.oasismetric.omcontentserver.http";
-function normalizeAwServiceRoot(input) {
+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) AW gateway or service URL");
+    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");
@@ -5464,11 +5650,16 @@ function normalizeAwServiceRoot(input) {
   parsed.pathname = path;
   return parsed.toString().replace(/\/$/, "");
 }
-function resolveAwServiceRoot(explicit) {
-  const configured = explicit || process.env.FORGEAX_ASSET_LIBRARY_BASE_URL || DEFAULT_AW_PRODUCTION_SERVICE_ROOT;
-  return normalizeAwServiceRoot(configured);
+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 checkAwProviderAccess(options) {
+function checkAssetLibraryProviderAccess(options) {
   const command = resolve12(options.providerCache, "bin", "asset3d-search");
   if (!existsSync10(command))
     throw new Error("asset3d_provider_not_prepared");
@@ -5480,6 +5671,7 @@ function checkAwProviderAccess(options) {
       ...process.env,
       ASSET3D_CATALOG_BASE_URL: "",
       AW_API_BASE_URL: options.serviceRoot,
+      AW_API_DEPOT_NAME: options.depotName,
       AW_API_CREDENTIAL_FILE: resolve12(options.credentialFile),
       AW_API_SANDBOX_KEY: ""
     }
@@ -5496,7 +5688,7 @@ function checkAwProviderAccess(options) {
   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 AW service address, internal network, and Sandbox Key`);
+    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");
@@ -5644,6 +5836,256 @@ function writeAwCredential(pathInput, keyInput) {
   };
 }
 
+// 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.4" }
+          }
+        };
+      } 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.`,
+    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) || args.queries.some((query) => typeof query !== "string")) {
+    throw new Error("asset3d_queries_invalid");
+  }
+  const outputDir = asset3dSearchOutputDir(projectRoot, args.execution, args.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((resolve14, reject) => {
+    child.once("error", reject);
+    child.once("close", (code, signal) => resolve14(code ?? (signal ? 1 : 0)));
+  });
+}
+
 // src/cli/dispatch.ts
 var HELP = `ForgeaX game development plugin
 
@@ -5656,14 +6098,15 @@ Usage:
   forgeax-game preview stop [--game <slug>] [--target-dir <path>] [--json]
   forgeax-game devkit install
   forgeax-game agents update
-  forgeax-game asset3d enable [--base-url <AW gateway/service URL>] [--ide ${CLIENT_CHOICES.join(",")}]
+  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> --provider-result-stdin --json [--refresh]
+  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.
@@ -6090,6 +6533,16 @@ async function doctorCommand(args) {
   return warnings === 0 ? 0 : 1;
 }
 var UPDATE_USAGE = "usage: forgeax-game update [--ide codex,claude,cursor,...]";
+function versionCommand(args) {
+  if (args.length > 0)
+    throw new Error("usage: forgeax-game version");
+  process.stdout.write(`${RELEASE_IDENTITY.gamePackage} ${RELEASE_IDENTITY.gameVersion}
+`);
+  return 0;
+}
+function formatVersionTransition(previousVersion, currentVersion = RELEASE_IDENTITY.gameVersion) {
+  return previousVersion === currentVersion ? currentVersion : `${previousVersion ?? "unknown"} -> ${currentVersion}`;
+}
 async function updateCommand(args) {
   const requested = parseIdeSelector(args, UPDATE_USAGE);
   const project = resolveProject();
@@ -6114,8 +6567,9 @@ async function updateCommand(args) {
 `);
   await verifyLaunch(launch);
   for (const client of configured) {
+    const previousVersion = configuredGameVersion(client, root);
     const result = applyConfig(client, root, launch);
-    process.stdout.write(`${result.changed ? "UPDATED" : "CURRENT"} ${client.label}: ${result.path}
+    process.stdout.write(`${result.changed ? "UPDATED" : "CURRENT"} ${client.label}: ${result.path} (plugin ${formatVersionTransition(previousVersion)})
 `);
   }
   if (project.root) {
@@ -6156,15 +6610,32 @@ function canonicalAsset3dClients(value) {
     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 an AW gateway/service URL");
+        throw new Error("--base-url requires a gateway/service URL");
       baseUrl = value;
       continue;
     }
@@ -6183,14 +6654,31 @@ function parseAsset3dEnableArgs(args) {
       ideArgs.push(arg);
       continue;
     }
-    throw new Error("usage: forgeax-game asset3d enable [--base-url <AW gateway/service URL>] [--ide codex,claude,cursor,...]");
+    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 };
+  return { requested: parseIdeSelector(ideArgs, "invalid --ide selector"), baseUrl, library };
 }
 async function asset3dCommand(args) {
   const [operation, ...rest] = args;
-  const projectRoot = requireProject();
   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);
@@ -6198,7 +6686,23 @@ async function asset3dCommand(args) {
       if (selection.selected.length === 0) {
         throw new Error("asset3d_client_missing: run `forgeax-game install --ide <client>` before enabling Asset3D");
       }
-      const serviceRoot = resolveAwServiceRoot(parsed.baseUrl);
+      const bridge = asset3dLaunchSpec("npx");
+      for (const id of selection.selected) {
+        const client = findClient(id);
+        if (!client)
+          throw new Error(`asset3d_client_invalid: ${id}`);
+        const state = inspectConfig(client, projectRoot, bridge, ASSET3D_SERVER_KEY);
+        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}`;
@@ -6216,20 +6720,37 @@ async function asset3dCommand(args) {
       const credentialWrite = writeAwCredential(credentialFile, credential.key);
       const clients = selection.selected.filter((id) => (id in SKILL_MOUNTS));
       try {
-        const access = checkAwProviderAccess({ providerCache: preparedCache, serviceRoot, credentialFile });
+        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("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, bridge, 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}; service=${access.serviceRoot}; authentication=${access.authentication}; skillFiles=${result.skillFiles}
+        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) {
@@ -6242,6 +6763,7 @@ async function asset3dCommand(args) {
       let expectedSha256;
       let catalogBaseUrl;
       let awApiBaseUrl;
+      let awDepotName;
       let awCredentialFile;
       const downloadOrigins = [];
       let clients;
@@ -6252,7 +6774,7 @@ async function asset3dCommand(args) {
           replaceOwned = true;
           continue;
         }
-        if (arg === "--provider-bundle" || arg === "--sha256" || arg === "--download-origin" || arg === "--catalog-base-url" || arg === "--aw-base-url" || arg === "--aw-credential-file" || arg === "--ide") {
+        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`);
@@ -6265,7 +6787,9 @@ async function asset3dCommand(args) {
           else if (arg === "--catalog-base-url")
             catalogBaseUrl = value;
           else if (arg === "--aw-base-url")
-            awApiBaseUrl = resolveAwServiceRoot(value);
+            awApiBaseUrl = normalizeAssetLibraryServiceRoot(value);
+          else if (arg === "--aw-depot-name")
+            awDepotName = parseAssetLibraryId(value);
           else if (arg === "--aw-credential-file")
             awCredentialFile = resolve14(value);
           else
@@ -6283,6 +6807,7 @@ async function asset3dCommand(args) {
         downloadOrigins,
         ...catalogBaseUrl ? { catalogBaseUrl } : {},
         ...awApiBaseUrl ? { awApiBaseUrl } : {},
+        ...awDepotName ? { awDepotName } : {},
         ...awCredentialFile ? { awCredentialFile } : {},
         ...clients ? { clients } : {},
         replaceOwned
@@ -6333,11 +6858,16 @@ async function asset3dCommand(args) {
           execution = rest[++index];
           continue;
         }
-        throw new Error("usage: forgeax-game asset3d commit --execution <uuid> --provider-result-stdin --json [--refresh]");
+        throw new Error("usage: forgeax-game asset3d commit --execution <uuid> --json [--provider-result-stdin] [--refresh]");
       }
-      if (!execution || !stdin)
-        throw new Error("usage: forgeax-game asset3d commit --execution <uuid> --provider-result-stdin --json [--refresh]");
-      const result = commitAsset3d({ projectRoot, execution, providerResult: await readBoundedStdin(), refresh });
+      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;
     }
@@ -6388,6 +6918,10 @@ async function runCli(argv) {
       return asset3dCommand(args);
     case "update":
       return updateCommand(args);
+    case "version":
+    case "--version":
+    case "-v":
+      return versionCommand(args);
     case "help":
     case "--help":
     case "-h":