@forgeax/game 0.3.5 → 0.3.7

package/dist/main.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/main.ts
-import { resolve as resolve15 } from "node:path";
+import { resolve as resolve17 } from "node:path";
 
 // src/mcp/protocol.ts
 var MCP_PROTOCOL_VERSION = "2024-11-05";
@@ -427,7 +427,8 @@ reasoning and game-code edits; the plugin owns the exact Engine Preview adapter.
 
 In an empty standalone directory, \`forgeax-game init\` creates the released Engine
 game and installs this guidance. In an existing exact Engine game it refreshes the
-binding idempotently. Standalone game source belongs in \`<game-root>/src\`; Studio's
+binding idempotently. Follow \`forge.json\` and the installed Engine authoring layout
+(v2 uses \`assets/\` and \`plugins[]\`), rather than prescribing \`src/\`. Studio's
 \`.forgeax/games/<slug>\` layout is a different hosted-project boundary and must not be
 invented here. Before claiming a requested game complete, replace the Empty template
 identity in \`forge.json\`, \`package.json\`, and README, keep tests/controls accurate,
@@ -438,7 +439,12 @@ transition or rule; renaming the Empty template test is not completion.
 Any run-tool error means the game is not previewed: never curl, reuse, open, or report
 an existing localhost port. HTTP 200 is not ownership evidence. Only a successful tool
 result containing \`preview.status: ready\`, root, build digest, instance ID, and its own
-\`preview_url\` authorizes a Preview claim.
+\`preview_url\` authorizes a Preview claim, not a gameplay-verification claim.
+For playable-game requests, check the requested interactions and visible feedback
+with an available browser tool. If unavailable, report gameplay as unverified and
+provide manual checks; do not stop useful implementation or invent test results.
+Use the installed Engine contract for Host access and UI lifecycle, and verify
+requested UI is mounted rather than silently skipping it when a Host lookup fails.
 Never substitute Studio, Editor, PATH, or a source checkout for the installed Engine
 release.`;
 
@@ -2269,6 +2275,7 @@ not running check requested; no Engine child was launched.`;
     `preview.state_file: ${result.paths.state}`,
     `preview.stdout_log: ${result.paths.stdout}`,
     `preview.stderr_log: ${result.paths.stderr}`,
+    "This tool verifies Engine build and Preview ownership only; gameplay, input, and visible UI have not been tested by this tool.",
     "Open only this returned loopback URL. HTTP availability without this exact verified identity is not Preview evidence."
   ].join(`
 `);
@@ -2938,6 +2945,74 @@ function gameFileTools() {
     }
   ];
 }
+// package.json
+var package_default = {
+  packageManager: "bun@1.4.0",
+  name: "@forgeax/game",
+  version: "0.3.7",
+  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/release-0.3.0.md",
+    "docs/release-0.3.1.md",
+    "docs/release-0.3.2.md",
+    "docs/release-0.3.3.md",
+    "docs/release-0.3.4.md",
+    "docs/release-0.3.5.md",
+    "README.md"
+  ],
+  scripts: {
+    build: "bun build.mjs",
+    "release:check": "bun scripts/check-package-artifact.ts",
+    acceptance: "bun scripts/accept-packed-consumer.ts",
+    "acceptance:asset3d": "bun scripts/accept-asset3d-packed-consumer.ts",
+    "verify:asset3d-linux": "bun scripts/verify-linux-asset3d-provider.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: {
+    "@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";
@@ -2946,7 +3021,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,
@@ -3226,9 +3301,9 @@ async function startHttpMcpServer(spec, options) {
 }
 
 // src/cli/dispatch.ts
-import { existsSync as existsSync12, readFileSync as readFileSync15, writeFileSync as writeFileSync11 } from "node:fs";
+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 join11, resolve as resolve14 } from "node:path";
+import { join as join12, resolve as resolve16 } from "node:path";
 
 // src/install/clients.ts
 import { homedir as homedir2 } from "node:os";
@@ -3356,7 +3431,7 @@ function launchSpec(mode) {
   }
   return {
     command: "npx",
-    args: ["-y", "-p", "@forgeax/game@0.3.5", "forgeax-game", "mcp"]
+    args: ["-y", "-p", `@forgeax/game@${RELEASE_IDENTITY.gameVersion}`, "forgeax-game", "mcp"]
   };
 }
 function asset3dLaunchSpec(mode) {
@@ -4270,17 +4345,17 @@ 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 = "ab6e5e1e794d5428efef362fe32d4c54b6541e12539bae5f6ff27680c9f380ba";
+var RESULT_SCHEMA_SHA256 = "f97a9aa8b2ce0662c37d314211aae52951cbd0b76b3a7c140dc608be4712c415";
 var RECEIPT_SCHEMA_SHA256 = "e0dc9e9fe9872f09af9fca6d0c17d22aca63c2b546c55c0b669c581f7059b9c4";
-var ASSET3D_PROVIDER_COMMIT = "c181c48fbffc933a7ce9a0836f7878ca5e6d77e1";
+var ASSET3D_PROVIDER_COMMIT = "a274238712c1dced99e4aa3148a0d15904ce2a90";
 var BUNDLED_ASSET3D_PROVIDERS = Object.freeze({
   "darwin-arm64": {
-    sha256: "9492c507a3afe5cafcd50b5f782b313c8716c2e52f5def06592c6a100c0459db",
-    relativePath: "asset3d/provider/asset3d-search-provider-c181c48fbffc933a7ce9a0836f7878ca5e6d77e1-darwin-arm64.tar.gz"
+    sha256: "4f2d971c037a32eaed20e51e13a88bff91d2ea8f4d37894526c089376c3bacba",
+    relativePath: "asset3d/provider/asset3d-search-provider-a274238712c1dced99e4aa3148a0d15904ce2a90-darwin-arm64.tar.gz"
   },
   "linux-x64": {
-    sha256: "e6ac3df76c8b82f9fe2c063dd3f221324a9dad5176fd52535a5144b0ff6002d8",
-    relativePath: "asset3d/provider/asset3d-search-provider-c181c48fbffc933a7ce9a0836f7878ca5e6d77e1-linux-x64.tar.gz"
+    sha256: "af97e7e267b558960156175c840c3c2d2cd7aabf68f1f72c7d64b6d50742a79e",
+    relativePath: "asset3d/provider/asset3d-search-provider-a274238712c1dced99e4aa3148a0d15904ce2a90-linux-x64.tar.gz"
   }
 });
 var INSTALL_SCHEMA = "forgeax.asset3d-install/1.0.0";
@@ -4675,7 +4750,8 @@ function installSkills(projectRoot, tgz, clients, previous) {
   for (const client of clients) {
     const mount = SKILL_MOUNTS[client];
     const destination = resolve10(projectRoot, mount, SKILL_ID);
-    const projected = [...K0_FILES.map((file) => [file, extractK0(tgz, file)]), ["SKILL.md", extractK0(tgz, "PLATFORM.md")]];
+    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));
@@ -4957,19 +5033,19 @@ import {
   cpSync as cpSync2,
   existsSync as existsSync9,
   fstatSync,
-  lstatSync as lstatSync8,
+  lstatSync as lstatSync9,
   mkdirSync as mkdirSync10,
   openSync as openSync4,
-  readFileSync as readFileSync13,
+  readFileSync as readFileSync14,
   readdirSync as readdirSync7,
-  realpathSync as realpathSync8,
+  realpathSync as realpathSync9,
   renameSync as renameSync7,
   rmSync as rmSync6,
   statSync as statSync6,
   unlinkSync as unlinkSync3,
   writeFileSync as writeFileSync10
 } from "node:fs";
-import { isAbsolute as isAbsolute4, relative as relative9, resolve as resolve11, sep as sep6 } from "node:path";
+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}$/;
@@ -4988,7 +5064,7 @@ var ERROR_CODES = new Set([
   "batch_timeout",
   "internal_error"
 ]);
-var ROLES = new Set(["primary-model", "animation", "auxiliary-model", "texture", "metadata"]);
+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)
@@ -5078,9 +5154,12 @@ function parseProviderResult(input, expectedCommit, expectedOriginSetDigest) {
     }
     if (row.status !== "ok")
       throw new Error("provider_result_invalid: status");
-    exactKeys(row, ["status", "queryIndex", "query", "provider", "providerAssetId", "assetName", "deliveredFormat", "sha256", "bytes", "primaryModel", "manifest", "originSetDigest", "downloaded_to"], "success");
+    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" || typeof row.providerAssetId !== "string" || !ID.test(row.providerAssetId) || row.providerAssetId === "." || row.providerAssetId === "..") {
+    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");
@@ -5108,13 +5187,18 @@ function parseProviderResult(input, expectedCommit, expectedOriginSetDigest) {
       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 === "primary-model");
-    if (primary.length !== 1 || row.primaryModel !== primary[0].path)
+    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");
@@ -5128,10 +5212,9 @@ function parseProviderResult(input, expectedCommit, expectedOriginSetDigest) {
       provider: "ea-3d",
       providerAssetId: row.providerAssetId,
       assetName,
-      deliveredFormat: "glb",
       sha256: row.sha256,
       bytes: itemBytes,
-      primaryModel: row.primaryModel,
+      ...isPack ? { deliveredFormat: "pack", primaryPack: row.primaryPack } : { deliveredFormat: "glb", primaryModel: row.primaryModel },
       manifest,
       originSetDigest: expectedOriginSetDigest,
       ...row.downloaded_to === undefined ? {} : { downloaded_to: row.downloaded_to }
@@ -5142,24 +5225,117 @@ function parseProviderResult(input, expectedCommit, expectedOriginSetDigest) {
   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 = relative9(root, candidate);
-  return rel === "" || !isAbsolute4(rel) && rel !== ".." && !rel.startsWith(`..${sep6}`);
+  const rel = relative10(root, candidate);
+  return rel === "" || !isAbsolute5(rel) && rel !== ".." && !rel.startsWith(`..${sep7}`);
 }
 function forgeaxRoot(projectRoot) {
-  return resolve11(projectRoot, ".forgeax");
+  return resolve12(projectRoot, ".forgeax");
 }
 function journalPath(projectRoot, execution) {
-  return resolve11(forgeaxRoot(projectRoot), "asset3d-transactions", `${execution}.json`);
+  return resolve12(forgeaxRoot(projectRoot), "asset3d-transactions", `${execution}.json`);
 }
 function providerResultPath(projectRoot, execution) {
-  return resolve11(forgeaxRoot(projectRoot), "asset3d-results", `${execution}.json`);
+  return resolve12(forgeaxRoot(projectRoot), "asset3d-results", `${execution}.json`);
 }
 function readInstall(projectRoot) {
   let manifest;
   try {
-    manifest = JSON.parse(readFileSync13(resolve11(forgeaxRoot(projectRoot), "asset3d-install.json"), "utf8"));
+    manifest = JSON.parse(readFileSync14(resolve12(forgeaxRoot(projectRoot), "asset3d-install.json"), "utf8"));
   } catch {
     throw new Error("asset3d_not_installed");
   }
@@ -5172,7 +5348,7 @@ function readJournal(projectRoot, execution) {
     throw new Error("asset3d_execution_invalid");
   let journal;
   try {
-    journal = JSON.parse(readFileSync13(journalPath(projectRoot, execution), "utf8"));
+    journal = JSON.parse(readFileSync14(journalPath(projectRoot, execution), "utf8"));
   } catch {
     throw new Error("asset3d_execution_not_found");
   }
@@ -5187,7 +5363,7 @@ function updateJournal(projectRoot, journal, patch) {
   return next;
 }
 function beginAsset3d(projectRootInput, queries, options = {}) {
-  const projectRoot = realpathSync8(projectRootInput);
+  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");
   }
@@ -5195,9 +5371,9 @@ function beginAsset3d(projectRootInput, queries, options = {}) {
   const release = resolveEngineRelease(projectRoot, options.carrierPluginRoot === undefined ? {} : { pluginRoot: options.carrierPluginRoot });
   const execution = randomUUID4();
   const relativeOutput = `workspace/asset3d/${execution}`;
-  const quarantine = resolve11(projectRoot, ".forgeax", "asset3d-quarantine");
-  const allowedQuarantineRoot = resolve11(quarantine, relativeOutput);
-  ensurePrivateDir(resolve11(projectRoot, ".forgeax", "asset3d-transactions"));
+  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,
@@ -5216,7 +5392,7 @@ function beginAsset3d(projectRootInput, queries, options = {}) {
   return { execution, output_dir: relativeOutput };
 }
 function asset3dSearchOutputDir(projectRootInput, execution, queries) {
-  const projectRoot = realpathSync8(projectRootInput);
+  const projectRoot = realpathSync9(projectRootInput);
   const journal = readJournal(projectRoot, execution);
   if (journal.state !== "begun") {
     throw new Error(`asset3d_execution_state_invalid: ${journal.state}`);
@@ -5225,14 +5401,14 @@ function asset3dSearchOutputDir(projectRootInput, execution, queries) {
     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) {
+  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 = realpathSync8(projectRootInput);
+  const projectRoot = realpathSync9(projectRootInput);
   const journal = readJournal(projectRoot, execution);
   if (journal.state !== "begun") {
     throw new Error(`asset3d_execution_state_invalid: ${journal.state}`);
@@ -5241,19 +5417,19 @@ function recordAsset3dProviderResult(projectRootInput, execution, 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"));
+  ensurePrivateDir(resolve12(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);
+  const source = resolve12(root, entry.path);
   if (!confined4(root, source))
     throw new Error("asset_manifest_escape");
-  const canonicalRoot = realpathSync8(root);
-  const canonicalSource = realpathSync8(source);
+  const canonicalRoot = realpathSync9(root);
+  const canonicalSource = realpathSync9(source);
   if (!confined4(canonicalRoot, canonicalSource))
     throw new Error("asset_manifest_escape");
-  const before = lstatSync8(source);
+  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));
@@ -5261,7 +5437,7 @@ function fileBytesChecked(root, entry) {
     const opened = fstatSync(fd);
     if (!opened.isFile() || opened.size !== entry.bytes)
       throw new Error("asset_manifest_bytes_mismatch");
-    const bytes = readFileSync13(fd);
+    const bytes = readFileSync14(fd);
     if (sha2562(bytes) !== entry.sha256)
       throw new Error("asset_manifest_digest_mismatch");
     return bytes;
@@ -5270,9 +5446,9 @@ function fileBytesChecked(root, entry) {
   }
 }
 function acquireLock2(projectRoot, assetId, timeoutMs) {
-  const root = resolve11(forgeaxRoot(projectRoot), "asset3d-locks");
+  const root = resolve12(forgeaxRoot(projectRoot), "asset3d-locks");
   ensurePrivateDir(root);
-  const path = resolve11(root, `${assetId}.lock`);
+  const path = resolve12(root, `${assetId}.lock`);
   const token = randomUUID4();
   const deadline = Date.now() + timeoutMs;
   for (;; ) {
@@ -5283,7 +5459,7 @@ function acquireLock2(projectRoot, assetId, timeoutMs) {
       closeSync3(fd);
       return () => {
         try {
-          const current = JSON.parse(readFileSync13(path, "utf8"));
+          const current = JSON.parse(readFileSync14(path, "utf8"));
           if (current.token === token)
             unlinkSync3(path);
         } catch {}
@@ -5332,17 +5508,17 @@ function engineAddedRows(projectRoot, asset) {
   if (!Array.isArray(subAssets)) {
     if (typeof asset.metaPath !== "string")
       throw new Error("engine_readback_missing_meta");
-    const metaPath = resolve11(projectRoot, asset.metaPath);
+    const metaPath = resolve12(projectRoot, asset.metaPath);
     if (!confined4(projectRoot, metaPath))
       throw new Error("engine_readback_meta_escape");
-    const canonical = realpathSync8(metaPath);
-    const info = lstatSync8(metaPath);
+    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(readFileSync13(metaPath, "utf8"));
+      meta = JSON.parse(readFileSync14(metaPath, "utf8"));
     } catch {
       throw new Error("engine_readback_meta_invalid");
     }
@@ -5353,10 +5529,10 @@ function engineAddedRows(projectRoot, asset) {
   const projectPath = (value) => {
     if (typeof value !== "string")
       return value;
-    const absolute = resolve11(projectRoot, value);
+    const absolute = resolve12(projectRoot, value);
     if (!confined4(projectRoot, absolute))
       throw new Error("engine_readback_path_escape");
-    return relative9(projectRoot, absolute).split(sep6).join("/");
+    return relative10(projectRoot, absolute).split(sep7).join("/");
   };
   return subAssets.map((row) => ({ source: projectPath(asset.source), metaPath: projectPath(asset.metaPath), reused: asset.reused, ...row }));
 }
@@ -5369,24 +5545,38 @@ function engineReadback(projectRoot, assetRelative, add, carrierPluginRoot) {
   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 : [];
+  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: list.value, inspect, rows };
+  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(readFileSync13(resolve11(destination, ".forgeax-asset.json"), "utf8"));
+    return JSON.parse(readFileSync14(resolve12(destination, ".forgeax-asset.json"), "utf8"));
   } catch {
     return;
   }
 }
 function liveFilesMatch(destination, item) {
   return item.manifest.every((entry) => {
-    const path = resolve11(destination, entry.path);
+    const path = resolve12(destination, entry.path);
     try {
-      return confined4(destination, path) && statSync6(path).isFile() && statSync6(path).size === entry.bytes && sha2562(readFileSync13(path)) === entry.sha256;
+      return confined4(destination, path) && statSync6(path).isFile() && statSync6(path).size === entry.bytes && sha2562(readFileSync14(path)) === entry.sha256;
     } catch {
       return false;
     }
@@ -5395,21 +5585,21 @@ function liveFilesMatch(destination, item) {
 function quarantineFiles(root, directory = root) {
   const files = [];
   for (const name of readdirSync7(directory)) {
-    const path = resolve11(directory, name);
-    const info = lstatSync8(path);
+    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(relative9(root, path).split(sep6).join("/"));
+      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 = realpathSync8(journal.allowedQuarantineRoot);
+  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");
@@ -5418,10 +5608,10 @@ function validateQuarantine(journal, items) {
     throw new Error("asset_quarantine_undeclared_file");
 }
 function stageItem(projectRoot, journal, item, destination, prior) {
-  const root = realpathSync8(journal.allowedQuarantineRoot);
-  const stageRoot = resolve11(forgeaxRoot(projectRoot), "asset3d-staging", journal.execution, item.providerAssetId);
+  const root = realpathSync9(journal.allowedQuarantineRoot);
+  const stageRoot = resolve12(forgeaxRoot(projectRoot), "asset3d-staging", journal.execution, item.providerAssetId);
   rmSync6(stageRoot, { recursive: true, force: true });
-  ensurePrivateDir(resolve11(stageRoot, ".."));
+  ensurePrivateDir(resolve12(stageRoot, ".."));
   if (existsSync9(destination))
     cpSync2(destination, stageRoot, { recursive: true, errorOnExist: true, force: false });
   else
@@ -5431,17 +5621,17 @@ function stageItem(projectRoot, journal, item, destination, prior) {
   for (const previous of previousFiles) {
     if (typeof previous.relativePath !== "string" || nextPaths.has(previous.relativePath))
       continue;
-    const stale = resolve11(stageRoot, previous.relativePath);
+    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 = resolve11(stageRoot, entry.path);
+    const target = resolve12(stageRoot, entry.path);
     if (!confined4(stageRoot, target))
       throw new Error("asset_manifest_escape");
-    mkdirSync10(resolve11(target, ".."), { recursive: true, mode: 448 });
+    mkdirSync10(resolve12(target, ".."), { recursive: true, mode: 448 });
     atomicWrite(target, fileBytesChecked(root, entry), 384);
   }
   return stageRoot;
@@ -5457,7 +5647,8 @@ function provenance(item, install, readback, refreshed) {
     originSetDigest: install.originSetDigest,
     aggregateSha256: item.sha256,
     bytes: item.bytes,
-    primaryModel: item.primaryModel,
+    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) => ({
@@ -5471,8 +5662,8 @@ function provenance(item, install, readback, refreshed) {
   };
 }
 function commitItem(projectRoot, initialJournal, install, item, refresh, lockTimeoutMs, carrierPluginRoot) {
-  const destination = resolve11(projectRoot, "assets", "3d", "ea-3d", item.providerAssetId);
-  const assetRoot = resolve11(projectRoot, "assets", "3d", "ea-3d");
+  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");
@@ -5483,29 +5674,30 @@ function commitItem(projectRoot, initialJournal, install, item, refresh, lockTim
     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 = engineReadback(projectRoot, `assets/3d/ea-3d/${item.providerAssetId}`, undefined, carrierPluginRoot);
+      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 = { ...baseReadback, inspect: guids.map((guid) => engineCommand(projectRoot, ["asset", "inspect", guid, "--json"], carrierPluginRoot).value) };
+      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: relative9(projectRoot, destination), provenancePath: relative9(projectRoot, resolve11(destination, ".forgeax-asset.json")), engine: { version: ENGINE_VERSION, commit: ENGINE_COMMIT }, catalog: readback, rows: priorRows };
+      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 = resolve11(forgeaxRoot(projectRoot), "asset3d-backups", journal.execution, item.providerAssetId);
-    ensurePrivateDir(resolve11(backup, ".."));
+    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 add = engineCommand(projectRoot, ["asset", "add", assetRelative, "--reimport-policy", "semantic-only", "--json"], carrierPluginRoot);
-      const readback = engineReadback(projectRoot, assetRelative, add, carrierPluginRoot);
-      atomicWrite(resolve11(destination, ".forgeax-asset.json"), `${JSON.stringify(provenance(item, install, readback, priorDigest !== undefined), null, 2)}
+      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))
@@ -5524,7 +5716,7 @@ function commitItem(projectRoot, initialJournal, install, item, refresh, lockTim
   }
 }
 function commitAsset3d(options) {
-  const projectRoot = realpathSync8(options.projectRoot);
+  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") {
@@ -5536,7 +5728,7 @@ function commitAsset3d(options) {
   let providerResult = options.providerResult;
   if (providerResult === undefined) {
     try {
-      providerResult = readFileSync13(providerResultPath(projectRoot, options.execution));
+      providerResult = readFileSync14(providerResultPath(projectRoot, options.execution));
     } catch {
       throw new Error("asset3d_provider_result_missing: call search_asset for this execution first");
     }
@@ -5587,7 +5779,7 @@ function commitAsset3d(options) {
   };
 }
 function abortAsset3d(projectRootInput, execution) {
-  const projectRoot = realpathSync8(projectRootInput);
+  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");
@@ -5598,20 +5790,20 @@ function abortAsset3d(projectRootInput, execution) {
   return { execution, aborted: true };
 }
 function doctorAsset3d(projectRootInput, options = {}) {
-  const projectRoot = realpathSync8(projectRootInput);
+  const projectRoot = realpathSync9(projectRootInput);
   const install = readInstall(projectRoot);
   const release = resolveEngineRelease(projectRoot, options.carrierPluginRoot === undefined ? {} : { pluginRoot: options.carrierPluginRoot });
   const recovered = [];
-  const root = resolve11(forgeaxRoot(projectRoot), "asset3d-transactions");
+  const root = resolve12(forgeaxRoot(projectRoot), "asset3d-transactions");
   if (existsSync9(root))
     for (const file of readdirSync7(root).filter((name) => name.endsWith(".json"))) {
       try {
-        const path = resolve11(root, file);
-        const journal = JSON.parse(readFileSync13(path, "utf8"));
+        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 = resolve11(projectRoot, "assets", "3d", "ea-3d");
-        const backupsRoot = resolve11(forgeaxRoot(projectRoot), "asset3d-backups");
+        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 });
@@ -5621,13 +5813,13 @@ function doctorAsset3d(projectRootInput, options = {}) {
         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(resolve11(install.providerCache, "venv", "bin", "python")) } };
+  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 resolve12 } from "node:path";
+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";
@@ -5660,7 +5852,7 @@ function resolveAssetLibrarySelection(options = {}) {
   return { library, serviceRoot: normalizeAssetLibraryServiceRoot(configured) };
 }
 function checkAssetLibraryProviderAccess(options) {
-  const command = resolve12(options.providerCache, "bin", "asset3d-search");
+  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"], {
@@ -5672,7 +5864,7 @@ function checkAssetLibraryProviderAccess(options) {
       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_CREDENTIAL_FILE: resolve13(options.credentialFile),
       AW_API_SANDBOX_KEY: ""
     }
   });
@@ -5698,9 +5890,9 @@ function checkAssetLibraryProviderAccess(options) {
 }
 
 // src/asset3d/credentials.ts
-import { chmodSync as chmodSync5, existsSync as existsSync11, lstatSync as lstatSync9, readFileSync as readFileSync14, statSync as statSync7, unlinkSync as unlinkSync4 } from "node:fs";
+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 isAbsolute5, resolve as resolve13 } from "node:path";
+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;
@@ -5715,22 +5907,22 @@ function validateKey(value) {
 }
 function defaultAwCredentialFile() {
   const configured = process.env.FORGEAX_ASSET3D_CREDENTIAL_FILE;
-  return resolve13(configured || resolve13(homedir4(), ".forgeax", "credentials", "asset3d-aw.json"));
+  return resolve14(configured || resolve14(homedir4(), ".forgeax", "credentials", "asset3d-aw.json"));
 }
 function readAwCredential(pathInput) {
-  const path = resolve13(pathInput);
-  if (!isAbsolute5(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 = lstatSync9(path);
+    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(readFileSync14(path, "utf8"));
+    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")
@@ -5792,13 +5984,13 @@ async function acquireAwKey(path) {
   return { key: await promptAwKey(), source: "prompt" };
 }
 function writeAwCredential(pathInput, keyInput) {
-  if (!isAbsolute5(pathInput))
+  if (!isAbsolute6(pathInput))
     throw new Error("asset3d_credential_path_invalid: absolute path required");
-  const path = resolve13(pathInput);
+  const path = resolve14(pathInput);
   const key = validateKey(keyInput);
   const parent = dirname11(path);
   ensurePrivateDir(parent);
-  const parentMetadata = lstatSync9(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");
@@ -5807,7 +5999,7 @@ function writeAwCredential(pathInput, keyInput) {
   const existed = existsSync11(path);
   if (existed)
     readAwCredential(path);
-  const previous = existed ? readFileSync14(path) : undefined;
+  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)}
 `;
@@ -5872,7 +6064,7 @@ async function runDormantAsset3dMcp() {
           result: {
             protocolVersion,
             capabilities: { tools: {} },
-            serverInfo: { name: "asset3d-search", version: "0.3.5" }
+            serverInfo: { name: "asset3d-search", version: RELEASE_IDENTITY.gameVersion }
           }
         };
       } else if (request2.method === "tools/list") {
@@ -5914,7 +6106,7 @@ function rewriteSearchTool(tool) {
   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.`,
+    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: {
@@ -5961,10 +6153,21 @@ function transformAsset3dSearchCall(projectRoot, request2) {
   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")) {
+  if (!Array.isArray(args.queries)) {
     throw new Error("asset3d_queries_invalid");
   }
-  const outputDir = asset3dSearchOutputDir(projectRoot, args.execution, args.queries);
+  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,
@@ -6080,20 +6283,27 @@ async function runAsset3dMcpProxy(projectRoot, launch) {
   };
   process.once("SIGINT", stopChild);
   process.once("SIGTERM", stopChild);
-  return await new Promise((resolve14, reject) => {
+  return await new Promise((resolve15, reject) => {
     child.once("error", reject);
-    child.once("close", (code, signal) => resolve14(code ?? (signal ? 1 : 0)));
+    child.once("close", (code, signal) => resolve15(code ?? (signal ? 1 : 0)));
   });
 }
 
 // src/asset3d/host-config.ts
-function inspectAsset3dHost(client, root) {
-  const launch = asset3dLaunchSpec("npx");
+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 = launch.args.find((arg) => arg.startsWith("@forgeax/game@"))?.slice("@forgeax/game@".length);
+  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);
@@ -6101,7 +6311,7 @@ function inspectAsset3dHost(client, root) {
   const differing = oldParts.findIndex((part, index) => part !== newParts[index]);
   if (differing < 0 || oldParts[differing] >= newParts[differing])
     return status;
-  const oldLaunch = { ...launch, args: launch.args.map((arg) => arg === `@forgeax/game@${current}` ? `@forgeax/game@${previous}` : arg) };
+  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" };
@@ -6109,7 +6319,7 @@ function inspectAsset3dHost(client, root) {
 function refreshAsset3dHost(client, root) {
   const status = inspectAsset3dHost(client, root);
   if (status.state === "outdated") {
-    const result = applyConfig(client, root, asset3dLaunchSpec("npx"), ASSET3D_SERVER_KEY);
+    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") {
@@ -6118,6 +6328,85 @@ function refreshAsset3dHost(client, root) {
   }
 }
 
+// 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
 
@@ -6184,23 +6473,23 @@ function requireProject() {
   return project.root;
 }
 function updateAgentsFile(root) {
-  const path = join11(root, "AGENTS.md");
-  const existing = existsSync12(path) ? readFileSync15(path, "utf8") : undefined;
+  const path = join12(root, "AGENTS.md");
+  const existing = existsSync12(path) ? readFileSync17(path, "utf8") : undefined;
   const content = upsertBlock(existing, ROUTING_TEXT);
   if (content === existing)
     return { path, changed: false };
-  writeFileSync11(path, content);
+  writeFileSync12(path, content);
   return { path, changed: true };
 }
 function removeAgentsBlock(root) {
-  const path = join11(root, "AGENTS.md");
+  const path = join12(root, "AGENTS.md");
   if (!existsSync12(path))
     return { path, changed: false };
-  const existing = readFileSync15(path, "utf8");
+  const existing = readFileSync17(path, "utf8");
   const content = removeBlock(existing);
   if (content === existing)
     return { path, changed: false };
-  writeFileSync11(path, content);
+  writeFileSync12(path, content);
   return { path, changed: true };
 }
 async function installCommand(args) {
@@ -6270,6 +6559,10 @@ async function initCommand(args) {
   reportMissingClients(selection.missing);
   const hosts = selection.selected;
   const devkit = installDevKit(root, hosts);
+  const removedMounts = pruneUnselectedEngineMounts(root, hosts);
+  if (removedMounts.length)
+    process.stdout.write(`Removed unused Engine-generated skill mounts: ${removedMounts.join(", ")}.
+`);
   process.stdout.write(`Bound Engine game ${slug} at ${selectedGame2}.
 `);
   process.stdout.write(`Engine ${release.version} (${release.commit}).
@@ -6300,7 +6593,7 @@ async function useCommand(args) {
     throw new Error(`game ${JSON.stringify(slug)} not found. Available: ${listGames(root).join(", ") || "(none)"}`);
   }
   if (listGames(root).length > 1) {
-    writeFileSync11(join11(root, ".forgeax", "active-game.json"), `${JSON.stringify({ version: 1, slug }, null, 2)}
+    writeFileSync12(join12(root, ".forgeax", "active-game.json"), `${JSON.stringify({ version: 1, slug }, null, 2)}
 `, "utf8");
   }
   process.stdout.write(`Active game: ${slug}
@@ -6402,7 +6695,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: ${join11(root, ".forgeax")}
+    process.stdout.write(`KEPT    your games and project metadata: ${join12(root, ".forgeax")}
 `);
   } else {
     process.stdout.write(`INFO  no ForgeaX project bound; only client configuration was touched.
@@ -6720,7 +7013,7 @@ 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 bridge = asset3dLaunchSpec("npx");
+      const localMode = selection.selected.some((id) => asset3dHostMode(findClient(id), projectRoot) === "local");
       for (const id of selection.selected) {
         const client = findClient(id);
         if (!client)
@@ -6743,7 +7036,7 @@ async function asset3dCommand(args) {
       const bundled = BUNDLED_ASSET3D_PROVIDERS[target];
       if (!bundled)
         throw new Error(`asset3d_provider_target_unreleased: ${target}`);
-      const providerCache = resolve14(homedir5(), ".forgeax", "providers", "asset3d-search", bundled.sha256);
+      const providerCache = resolve16(homedir5(), ".forgeax", "providers", "asset3d-search", bundled.sha256);
       let preparedCache = providerCache;
       if (!existsSync12(providerCache)) {
         const providerBundle = packagedAsset3dProvider(bundled.relativePath);
@@ -6769,14 +7062,14 @@ async function asset3dCommand(args) {
           awDepotName: library.library,
           awCredentialFile: credentialFile,
           clients,
-          gamePluginLaunch: launchSpec("npx"),
+          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, bridge, ASSET3D_SERVER_KEY);
+          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)
@@ -6825,7 +7118,7 @@ async function asset3dCommand(args) {
           else if (arg === "--aw-depot-name")
             awDepotName = parseAssetLibraryId(value);
           else if (arg === "--aw-credential-file")
-            awCredentialFile = resolve14(value);
+            awCredentialFile = resolve16(value);
           else
             clients = canonicalAsset3dClients(value);
           continue;
@@ -7029,7 +7322,7 @@ function parseMcpArgs(args) {
     } else
       throw new Error(`unknown MCP option: ${arg}`);
   }
-  return { transport, host, port, root: resolve15(root), requireAuth, allowedOrigins };
+  return { transport, host, port, root: resolve17(root), requireAuth, allowedOrigins };
 }
 async function runMcp(args) {
   const options = parseMcpArgs(args);