@genex-ai/cli-demo 1.29.1-dev.634 → 1.30.0-dev.636

package/dist/index.js

@@ -659,8 +659,8 @@ async function runAuth(opts) {
 }
 
 // src/commands/remix.ts
-import fs17 from "fs/promises";
-import path16 from "path";
+import fs18 from "fs/promises";
+import path17 from "path";
 import crypto4 from "crypto";
 import { spawn as spawn4 } from "child_process";
 
@@ -2798,9 +2798,63 @@ function auditGenerationPlan(input) {
 
 // src/lib/deploy.ts
 import crypto2 from "crypto";
-import fs16 from "fs/promises";
+import fs17 from "fs/promises";
 import os5 from "os";
-import path15 from "path";
+import path16 from "path";
+
+// src/lib/source-size.ts
+import fs14 from "fs/promises";
+import path14 from "path";
+var FALLBACK_SOURCE_LIMITS = {
+  maxTotalBytes: 2 * 1024 * 1024 * 1024,
+  maxFiles: 5e3
+};
+function isOversized(p, limits) {
+  return p.bytes >= limits.maxTotalBytes || p.files >= limits.maxFiles;
+}
+function formatBytes2(n) {
+  if (n >= 1024 ** 3) return `${(n / 1024 ** 3).toFixed(1)} GB`;
+  if (n >= 1024 ** 2) return `${Math.round(n / 1024 ** 2)} MB`;
+  if (n >= 1024) return `${Math.round(n / 1024)} KB`;
+  return `${n} B`;
+}
+function groupByDir(entries, limit = 5) {
+  const acc = /* @__PURE__ */ new Map();
+  for (const [file, bytes] of entries) {
+    const dirParts = file.split("/").slice(0, -1).slice(0, 2);
+    const dir = dirParts.length > 0 ? dirParts.join("/") : "(root)";
+    const row = acc.get(dir) ?? { dir, files: 0, bytes: 0 };
+    row.files += 1;
+    row.bytes += bytes;
+    acc.set(dir, row);
+  }
+  return [...acc.values()].sort((a, b) => b.bytes - a.bytes).slice(0, limit);
+}
+function oversizedLines(p, limits) {
+  return [
+    `This is ${formatBytes2(p.bytes)} across ${p.files} files, past the ${formatBytes2(limits.maxTotalBytes)} / ${limits.maxFiles} file limit on this account.`,
+    "Heaviest directories:",
+    ...p.top.map((d) => `  ${formatBytes2(d.bytes).padStart(8)}  ${String(d.files).padStart(6)} files  ${d.dir}`),
+    "Screenshots, traces and reports made while building are not part of the game \u2014",
+    "put them in .genex/scratch/ (already ignored), or add the folders above to .gitignore.",
+    "If this really is the game, ask an admin to raise the source limit on your account."
+  ];
+}
+async function measurePayload(cwd, staged) {
+  const entries = [];
+  let bytes = 0;
+  for (const file of staged) {
+    let size = 0;
+    try {
+      size = (await fs14.stat(path14.join(cwd, file))).size;
+    } catch {
+      size = 0;
+    }
+    bytes += size;
+    entries.push([file, size]);
+  }
+  return { files: staged.length, bytes, top: groupByDir(entries) };
+}
 
 // ../../packages/mobile-scan/src/image-dims.ts
 function u32be(b, o) {
@@ -3064,12 +3118,12 @@ function tierFor(estVramMb) {
 }
 
 // src/commands/ui.ts
-import fs15 from "fs/promises";
-import path14 from "path";
+import fs16 from "fs/promises";
+import path15 from "path";
 import { PNG as PNG2 } from "pngjs";
 
 // src/lib/png-tools.ts
-import fs14 from "fs/promises";
+import fs15 from "fs/promises";
 import { PNG } from "pngjs";
 var ALPHA_TRANSPARENT_MAX = 16;
 var isHttpUrl = (s) => /^https?:\/\//i.test(s);
@@ -3080,12 +3134,12 @@ async function loadPng(input) {
     if (!res.ok) throw new Error(`Couldn't fetch ${input} (HTTP ${res.status}).`);
     buf = Buffer.from(await res.arrayBuffer());
   } else {
-    buf = await fs14.readFile(input);
+    buf = await fs15.readFile(input);
   }
   return PNG.sync.read(buf);
 }
 async function writePng(file, png) {
-  await fs14.writeFile(file, PNG.sync.write(png));
+  await fs15.writeFile(file, PNG.sync.write(png));
 }
 function cropPng(image, box) {
   const out = new PNG({ width: box.w, height: box.h });
@@ -3385,7 +3439,7 @@ async function uiExtract(opts, log) {
   const dilatePx = opts.dilate ?? 0;
   const sheet = await loadPng(input);
   const { width: W, height: H, data } = sheet;
-  await fs15.mkdir(outDir, { recursive: true });
+  await fs16.mkdir(outDir, { recursive: true });
   log.plain(c.bold("genex ui extract"));
   log.dim(`  ${input} (${W}x${H}) \u2192 ${outDir}, ${names.length} names`);
   let hasTransparency = false;
@@ -3614,7 +3668,7 @@ async function uiExtract(opts, log) {
         rimPixels: speckle.sampled
       });
     }
-    const outPath = path14.join(outDir, `${name}.png`);
+    const outPath = path15.join(outDir, `${name}.png`);
     await writePng(outPath, out);
     const sidecar = {
       name,
@@ -3633,7 +3687,7 @@ async function uiExtract(opts, log) {
       defringed
     };
     const { name: _n, out: _o, ...sidecarBody } = sidecar;
-    await fs15.writeFile(
+    await fs16.writeFile(
       outPath.replace(/\.png$/i, "") + ".bbox.json",
       JSON.stringify(sidecarBody, null, 2)
     );
@@ -3642,8 +3696,8 @@ async function uiExtract(opts, log) {
       `${name}.png  ${cropW}x${cropH} (ar ${sidecar.aspectRatio}) at sheet ${padX0},${padY0}`
     );
   }
-  const debugPath = path14.join(outDir, "extract-debug.json");
-  await fs15.writeFile(
+  const debugPath = path15.join(outDir, "extract-debug.json");
+  await fs16.writeFile(
     debugPath,
     JSON.stringify(
       {
@@ -4105,7 +4159,7 @@ async function uiMasks(opts, log) {
   const registrationTolerance = opts.registrationTolerance ?? 0.04;
   const edgeFlushMax = opts.edgeFlushMax ?? 0.04;
   const loosened = registrationTolerance > 0.04 || edgeFlushMax > 0.04 || minCoverage < 0.01 || maxCoverage > 0.85;
-  await fs15.mkdir(outDir, { recursive: true });
+  await fs16.mkdir(outDir, { recursive: true });
   log.plain(c.bold("genex ui masks"));
   log.dim(`  ${input} (${image.width}x${image.height}), ${pairs.length} pair(s) \u2192 ${outDir}`);
   const sheetComponents = detectSheetComponents(image, opts.minPixels ?? 2e3);
@@ -4158,11 +4212,11 @@ async function uiMasks(opts, log) {
       });
     }
     const overlay = makeOverlay(clean2, converted.png);
-    const framePath = path14.join(outDir, `${pair.name}-frame.png`);
-    const maskPath = path14.join(outDir, `${pair.name}-mask.png`);
-    const annotatedPath = path14.join(outDir, `${pair.name}-annotated-source.png`);
-    const overlayPath = path14.join(outDir, `${pair.name}-overlay.png`);
-    const metaPath = path14.join(outDir, `${pair.name}.annotated-progress.json`);
+    const framePath = path15.join(outDir, `${pair.name}-frame.png`);
+    const maskPath = path15.join(outDir, `${pair.name}-mask.png`);
+    const annotatedPath = path15.join(outDir, `${pair.name}-annotated-source.png`);
+    const overlayPath = path15.join(outDir, `${pair.name}-overlay.png`);
+    const metaPath = path15.join(outDir, `${pair.name}.annotated-progress.json`);
     await writePng(framePath, clean2);
     await writePng(maskPath, converted.png);
     await writePng(annotatedPath, annotated);
@@ -4209,7 +4263,7 @@ async function uiMasks(opts, log) {
       },
       overlay: overlayPath
     };
-    await fs15.writeFile(metaPath, `${JSON.stringify(meta, null, 2)}
+    await fs16.writeFile(metaPath, `${JSON.stringify(meta, null, 2)}
 `);
     results.push(meta);
     const fb = converted.bbox;
@@ -4225,8 +4279,8 @@ async function uiMasks(opts, log) {
       );
     }
   }
-  const indexPath = path14.join(outDir, "annotated-progress.json");
-  await fs15.writeFile(indexPath, `${JSON.stringify({ input, loosened, pairs: results }, null, 2)}
+  const indexPath = path15.join(outDir, "annotated-progress.json");
+  await fs16.writeFile(indexPath, `${JSON.stringify({ input, loosened, pairs: results }, null, 2)}
 `);
   log.plain("");
   log.success(`Wrote ${pairs.length} frame+mask pair(s) \u2192 ${outDir} (index: ${indexPath}).`);
@@ -4352,7 +4406,7 @@ async function uiTextColor(opts, log) {
   };
   process.stdout.write(`${JSON.stringify(result, null, 2)}
 `);
-  if (opts.out) await fs15.writeFile(opts.out, `${JSON.stringify(result, null, 2)}
+  if (opts.out) await fs16.writeFile(opts.out, `${JSON.stringify(result, null, 2)}
 `);
   if (opts.cropPath) log.dim(`  crop \u2192 ${opts.cropPath}`);
 }
@@ -4384,7 +4438,7 @@ async function uiTrim(opts, log) {
   const sidecar = computeBBoxes(trimmed);
   const speckleAllowed = !!(speckle && speckle.ratio > SPECKLE_MAX_RATIO);
   const sidecarPath = outPath.replace(/\.png$/i, "") + ".bbox.json";
-  await fs15.writeFile(
+  await fs16.writeFile(
     sidecarPath,
     JSON.stringify(speckleAllowed ? { ...sidecar, speckleAllowed: true } : sidecar, null, 2)
   );
@@ -4491,7 +4545,7 @@ async function uiPlate(opts, log) {
     fail("No interior found \u2014 the image is fully transparent (or erode ate everything). Check --in / lower --erode.");
   }
   await writePng(outPath, out);
-  const name = path14.basename(outPath);
+  const name = path15.basename(outPath);
   log.plain(c.bold("genex ui plate"));
   log.success(`${outPath}  ${W}x${H}, interior ${(count / (W * H) * 100).toFixed(1)}% (erode ${erode}px)`);
   log.dim("  Wire it as the plate's silhouette (same box as the frame <img>, plate UNDER the art):");
@@ -4656,13 +4710,13 @@ async function walkFiles(dir) {
   const out = [];
   let entries;
   try {
-    entries = await fs15.readdir(dir, { withFileTypes: true });
+    entries = await fs16.readdir(dir, { withFileTypes: true });
   } catch {
     return out;
   }
   for (const entry of entries) {
     if (entry.name === "node_modules" || entry.name.startsWith(".")) continue;
-    const p = path14.join(dir, entry.name);
+    const p = path15.join(dir, entry.name);
     if (entry.isDirectory()) out.push(...await walkFiles(p));
     else out.push(p);
   }
@@ -4671,7 +4725,7 @@ async function walkFiles(dir) {
 async function collectUiAuditFindings(assetDir, srcDir, cwd = process.cwd()) {
   const viewportFindings = [];
   try {
-    const indexHtml = await fs15.readFile(path14.join(cwd, "index.html"), "utf8");
+    const indexHtml = await fs16.readFile(path15.join(cwd, "index.html"), "utf8");
     if (!/<meta[^>]+name=["']viewport["']/i.test(indexHtml)) {
       viewportFindings.push({
         kind: "viewport-meta",
@@ -4685,28 +4739,28 @@ async function collectUiAuditFindings(assetDir, srcDir, cwd = process.cwd()) {
     }
   } catch {
   }
-  const absAssets = path14.resolve(cwd, assetDir);
+  const absAssets = path15.resolve(cwd, assetDir);
   try {
-    if (!(await fs15.stat(absAssets)).isDirectory()) {
+    if (!(await fs16.stat(absAssets)).isDirectory()) {
       return viewportFindings.length > 0 ? viewportFindings : null;
     }
   } catch {
     return viewportFindings.length > 0 ? viewportFindings : null;
   }
-  const srcFiles = (await walkFiles(path14.resolve(cwd, srcDir))).filter(
-    (p) => AUDIT_SRC_EXTS.has(path14.extname(p).toLowerCase())
+  const srcFiles = (await walkFiles(path15.resolve(cwd, srcDir))).filter(
+    (p) => AUDIT_SRC_EXTS.has(path15.extname(p).toLowerCase())
   );
   try {
-    for (const name of await fs15.readdir(cwd)) {
-      const ext = path14.extname(name).toLowerCase();
-      if (ext === ".html" || ext === ".css") srcFiles.push(path14.join(cwd, name));
+    for (const name of await fs16.readdir(cwd)) {
+      const ext = path15.extname(name).toLowerCase();
+      if (ext === ".html" || ext === ".css") srcFiles.push(path15.join(cwd, name));
     }
   } catch {
   }
   const sources = [];
   for (const p of srcFiles) {
     try {
-      sources.push({ rel: path14.relative(cwd, p), text: await fs15.readFile(p, "utf8") });
+      sources.push({ rel: path15.relative(cwd, p), text: await fs16.readFile(p, "utf8") });
     } catch {
     }
   }
@@ -4716,11 +4770,11 @@ async function collectUiAuditFindings(assetDir, srcDir, cwd = process.cwd()) {
   const metaByName = /* @__PURE__ */ new Map();
   const bboxByPng = /* @__PURE__ */ new Map();
   for (const p of assetFiles) {
-    const base = path14.basename(p);
+    const base = path15.basename(p);
     const metaMatch = /^(.+)\.annotated-progress\.json$/.exec(base);
     if (metaMatch) {
       try {
-        const meta = JSON.parse(await fs15.readFile(p, "utf8"));
+        const meta = JSON.parse(await fs16.readFile(p, "utf8"));
         metaByName.set(metaMatch[1], {
           cleanCrop: meta.clean?.crop ?? null,
           loosened: meta.loosened === true
@@ -4731,7 +4785,7 @@ async function collectUiAuditFindings(assetDir, srcDir, cwd = process.cwd()) {
     }
     if (base.endsWith(".bbox.json")) {
       try {
-        const sidecar = JSON.parse(await fs15.readFile(p, "utf8"));
+        const sidecar = JSON.parse(await fs16.readFile(p, "utf8"));
         if (sidecar.sheetBBox) bboxByPng.set(base.replace(/\.bbox\.json$/, ".png"), sidecar.sheetBBox);
       } catch {
       }
@@ -4740,7 +4794,7 @@ async function collectUiAuditFindings(assetDir, srcDir, cwd = process.cwd()) {
   for (const [name, meta] of metaByName) {
     if (!meta.cleanCrop || !referenced(`${name}-mask.png`)) continue;
     for (const p of assetFiles) {
-      const base = path14.basename(p);
+      const base = path15.basename(p);
       if (!base.toLowerCase().endsWith(".png")) continue;
       if (base !== `${name}.png` && !base.startsWith(`${name}-`)) continue;
       if (/-mask\.png$|-frame\.png$|-overlay\.png$|-annotated-source\.png$/.test(base)) continue;
@@ -4764,7 +4818,7 @@ async function collectUiAuditFindings(assetDir, srcDir, cwd = process.cwd()) {
   }
   const pngByBase = /* @__PURE__ */ new Map();
   for (const p of assetFiles) {
-    const base = path14.basename(p);
+    const base = path15.basename(p);
     if (base.toLowerCase().endsWith(".png")) pngByBase.set(base, p);
   }
   for (const [maskBase, maskPath] of pngByBase) {
@@ -4777,8 +4831,8 @@ async function collectUiAuditFindings(assetDir, srcDir, cwd = process.cwd()) {
       let frame;
       let mask;
       try {
-        frame = PNG2.sync.read(await fs15.readFile(framePath));
-        mask = PNG2.sync.read(await fs15.readFile(maskPath));
+        frame = PNG2.sync.read(await fs16.readFile(framePath));
+        mask = PNG2.sync.read(await fs16.readFile(maskPath));
       } catch {
         continue;
       }
@@ -4797,7 +4851,7 @@ async function collectUiAuditFindings(assetDir, srcDir, cwd = process.cwd()) {
     if (!referenced(base)) continue;
     let png;
     try {
-      png = PNG2.sync.read(await fs15.readFile(p));
+      png = PNG2.sync.read(await fs16.readFile(p));
     } catch {
       continue;
     }
@@ -4817,7 +4871,7 @@ async function collectUiAuditFindings(assetDir, srcDir, cwd = process.cwd()) {
   }
   const maskReported = /* @__PURE__ */ new Set();
   for (const p of assetFiles) {
-    const m = /^(.+)\.annotated-progress\.json$/.exec(path14.basename(p));
+    const m = /^(.+)\.annotated-progress\.json$/.exec(path15.basename(p));
     if (!m) continue;
     const maskBase = `${m[1]}-mask.png`;
     if (!referenced(maskBase)) {
@@ -4829,14 +4883,14 @@ async function collectUiAuditFindings(assetDir, srcDir, cwd = process.cwd()) {
     }
   }
   for (const p of assetFiles) {
-    const base = path14.basename(p);
+    const base = path15.basename(p);
     if (!base.toLowerCase().endsWith(".png")) continue;
     if (/-annotated-source\.png$|-overlay\.png$/.test(base)) continue;
     if (maskReported.has(base)) continue;
     if (!referenced(base)) {
       findings.push({
         kind: "unwired-sprite",
-        message: `${path14.relative(cwd, p)} is on disk but never referenced in ${srcDir}/index.html/CSS \u2014 wire it, or record the one-line reason it was cut. (Computed-string references are invisible here \u2014 check.)`
+        message: `${path15.relative(cwd, p)} is on disk but never referenced in ${srcDir}/index.html/CSS \u2014 wire it, or record the one-line reason it was cut. (Computed-string references are invisible here \u2014 check.)`
       });
     }
   }
@@ -4951,7 +5005,7 @@ async function printUiAuditPreflight(log) {
 }
 async function printPipelineStatePreflight(log, cwd = process.cwd()) {
   try {
-    const design = await fs16.readFile(path15.join(cwd, "DESIGN.md"), "utf8").catch(() => "");
+    const design = await fs17.readFile(path16.join(cwd, "DESIGN.md"), "utf8").catch(() => "");
     const warnings = [];
     if (design.length > 0 && !/##\s*build plan & status/i.test(design)) {
       warnings.push(
@@ -4959,7 +5013,7 @@ async function printPipelineStatePreflight(log, cwd = process.cwd()) {
       );
     }
     if (!/player character:/i.test(design)) {
-      const hasCharacter = await fs16.access(path15.join(cwd, "public", "assets", "meshy-character.json")).then(() => true, () => false);
+      const hasCharacter = await fs17.access(path16.join(cwd, "public", "assets", "meshy-character.json")).then(() => true, () => false);
       if (!hasCharacter && await loadsPlayerBody(cwd)) {
         warnings.push(
           `Player character is the stock avatar \u2014 no generated character is wired. The game's own generated character is the player's body wherever a human body appears on screen, first-person included (genex-ai-character). Generate it, or record "Player character: VRM \u2014 <reason>" in DESIGN.md (no human body in this game / out of credits / player declined).`
@@ -4976,12 +5030,12 @@ async function printPipelineStatePreflight(log, cwd = process.cwd()) {
 async function loadsPlayerBody(cwd) {
   const BODY_LOADERS = /\bloadPlayerCharacter\s*\(|\bloadVrm(?:Clone)?\s*\(/;
   try {
-    const entries = await fs16.readdir(path15.join(cwd, "src"), { recursive: true });
+    const entries = await fs17.readdir(path16.join(cwd, "src"), { recursive: true });
     for (const rel of entries) {
       if (rel.includes("node_modules")) continue;
-      if (rel.split(path15.sep)[0] === "controllers" || rel.startsWith("controllers/")) continue;
+      if (rel.split(path16.sep)[0] === "controllers" || rel.startsWith("controllers/")) continue;
       if (!/\.(ts|tsx|js|jsx)$/.test(rel)) continue;
-      const text = await fs16.readFile(path15.join(cwd, "src", rel), "utf8").catch(() => "");
+      const text = await fs17.readFile(path16.join(cwd, "src", rel), "utf8").catch(() => "");
       if (BODY_LOADERS.test(text)) return true;
     }
   } catch {
@@ -5018,9 +5072,9 @@ async function deployGame(ctx, opts, log) {
     }
     log.success("Built.");
   }
-  const distDir = path15.join(cwd, "dist");
+  const distDir = path16.join(cwd, "dist");
   const siteDir = await isDir(distDir) ? distDir : cwd;
-  const rel = path15.relative(cwd, siteDir) || ".";
+  const rel = path16.relative(cwd, siteDir) || ".";
   if (siteDir === cwd) await writeGitignore(cwd, log);
   const files = await collectFiles(siteDir);
   if (files.length === 0) {
@@ -5111,7 +5165,7 @@ async function deployGame(ctx, opts, log) {
 }
 async function hasBuildScript(cwd) {
   try {
-    const pkg = JSON.parse(await fs16.readFile(path15.join(cwd, "package.json"), "utf8"));
+    const pkg = JSON.parse(await fs17.readFile(path16.join(cwd, "package.json"), "utf8"));
     return Boolean(pkg.scripts?.build);
   } catch {
     return false;
@@ -5120,12 +5174,12 @@ async function hasBuildScript(cwd) {
 async function collectFiles(root) {
   const out = [];
   const walk2 = async (dir, prefix) => {
-    for (const e of await fs16.readdir(dir, { withFileTypes: true })) {
+    for (const e of await fs17.readdir(dir, { withFileTypes: true })) {
       const relPath = prefix ? `${prefix}/${e.name}` : e.name;
       if (e.isDirectory()) {
-        if (!EXCLUDE_DIRS.has(e.name)) await walk2(path15.join(dir, e.name), relPath);
+        if (!EXCLUDE_DIRS.has(e.name)) await walk2(path16.join(dir, e.name), relPath);
       } else if (e.isFile() && !isSecretEnvFile(e.name)) {
-        out.push({ relPath, bytes: await fs16.readFile(path15.join(dir, e.name)) });
+        out.push({ relPath, bytes: await fs17.readFile(path16.join(dir, e.name)) });
       }
     }
   };
@@ -5362,23 +5416,43 @@ async function pushSource(cwd, ctx, log, branch = "main", expectStagingCommit, o
   if (target === "stale") return "stale";
   if (!target) return false;
   const ref = target.managed ? branch : "main";
-  if (await pushWorktree(cwd, target.pushUrl, target.managed, log, ref, onCommit)) return true;
+  const first = await pushWorktree(
+    cwd,
+    target.pushUrl,
+    target.managed,
+    log,
+    ref,
+    onCommit,
+    false,
+    target.sourceLimits
+  );
+  if (first === true) return true;
+  if (first === "oversize") return false;
   if (!target.managed) return false;
   log.info("Retrying the source push\u2026");
   await new Promise((r) => setTimeout(r, 2e3));
   const fresh = await fetchPushUrl(ctx, log, expectStagingCommit);
   if (fresh === "stale") return "stale";
   if (!fresh) return false;
-  return pushWorktree(cwd, fresh.pushUrl, fresh.managed, log, ref, onCommit);
+  return await pushWorktree(
+    cwd,
+    fresh.pushUrl,
+    fresh.managed,
+    log,
+    ref,
+    onCommit,
+    false,
+    fresh.sourceLimits
+  ) === true;
 }
 var WORKSPACE_SOURCE_REF = "workspace";
-async function pushWorktree(cwd, pushUrl, managed, log, branch = "main", onCommit) {
+async function pushWorktree(cwd, pushUrl, managed, log, branch = "main", onCommit, skipSizeCheck = false, limits) {
   const EMPTY_TREE = "4b825dc642cb6eb9a060e54bf8d69288fbee4904";
   const failed = () => {
     log.error("Couldn't save your game's source \u2014 please try again.");
-    return false;
+    return "failed";
   };
-  const gitDir = await fs16.mkdtemp(path15.join(os5.tmpdir(), "genex-source-"));
+  const gitDir = await fs17.mkdtemp(path16.join(os5.tmpdir(), "genex-source-"));
   const base = { GIT_DIR: gitDir };
   if (urlHasEmbeddedCredentials(pushUrl)) {
     base.GIT_CONFIG_COUNT = "1";
@@ -5393,8 +5467,8 @@ async function pushWorktree(cwd, pushUrl, managed, log, branch = "main", onCommi
   };
   try {
     if ((await run("git", ["init", "-q"], base)).code !== 0) return failed();
-    await fs16.writeFile(path15.join(gitDir, "info", "exclude"), excludeFile());
-    const env = { ...base, GIT_WORK_TREE: cwd, GIT_INDEX_FILE: path15.join(gitDir, "index-source") };
+    await fs17.writeFile(path16.join(gitDir, "info", "exclude"), excludeFile());
+    const env = { ...base, GIT_WORK_TREE: cwd, GIT_INDEX_FILE: path16.join(gitDir, "index-source") };
     let lfs = (await run("git", ["lfs", "version"], base)).code !== 0 ? false : true;
     if (!lfs) {
       log.step("Installing git-lfs (keeps large binary assets out of the source push)\u2026");
@@ -5418,17 +5492,31 @@ async function pushWorktree(cwd, pushUrl, managed, log, branch = "main", onCommi
       for (const [key, value] of filters) await run("git", ["config", key, value], base);
     }
     await run("git", ["add", "-A"], env);
-    const tree = (await run("git", ["ls-files"], env)).out.trim() ? (await run("git", ["write-tree"], env)).out.trim() : "";
+    const staged = (await run("git", ["ls-files", "-z"], env)).out.split("\0").filter(Boolean);
+    if (staged.length === 0) {
+      log.error("Nothing to publish \u2014 the project has no files.");
+      return "failed";
+    }
+    const payload = await measurePayload(cwd, staged);
+    log.dim(`Source: ${payload.files} files, ${formatBytes2(payload.bytes)}.`);
+    const ceiling = limits ?? FALLBACK_SOURCE_LIMITS;
+    if (!skipSizeCheck && isOversized(payload, ceiling)) {
+      const [head, ...rest] = oversizedLines(payload, ceiling);
+      log.error(head ?? "Source too large.");
+      for (const line of rest) log.dim(`  ${line}`);
+      return "oversize";
+    }
+    const tree = (await run("git", ["write-tree"], env)).out.trim();
     if (!tree || tree === EMPTY_TREE) {
       log.error("Nothing to publish \u2014 the project has no files.");
-      return false;
+      return "failed";
     }
     const commit = (await run("git", ["commit-tree", tree, "-m", "source"], { ...base, ...ident })).out.trim();
     if (commit) onCommit?.(commit);
     await run("git", ["update-ref", "refs/heads/main", commit], base);
     if (lfs && (await run("git", ["lfs", "push", "--all", pushUrl, "main"], base)).code !== 0) {
       log.error("Couldn't upload your game's binary assets to the source store.");
-      return false;
+      return "failed";
     }
     const push = await run(
       "git",
@@ -5440,13 +5528,13 @@ async function pushWorktree(cwd, pushUrl, managed, log, branch = "main", onCommi
       log.error(
         "Couldn't push to your repo. Check that you have push access (SSH key or git credentials) and that the repo exists."
       );
-      return false;
+      return "failed";
     }
     return failed();
   } catch {
     return failed();
   } finally {
-    await fs16.rm(gitDir, { recursive: true, force: true }).catch(() => {
+    await fs17.rm(gitDir, { recursive: true, force: true }).catch(() => {
     });
   }
 }
@@ -5496,11 +5584,18 @@ async function fetchPushUrl(ctx, log, expectStagingCommit) {
     log.error("The API didn't return a push URL.");
     return null;
   }
-  return { pushUrl: data.pushUrl, managed: data.managed !== false, sourceRef: data.sourceRef ?? null };
+  const l = data.sourceLimits;
+  const sourceLimits = typeof l?.maxTotalBytes === "number" && typeof l?.maxFiles === "number" ? { maxTotalBytes: l.maxTotalBytes, maxFiles: l.maxFiles } : void 0;
+  return {
+    pushUrl: data.pushUrl,
+    managed: data.managed !== false,
+    sourceRef: data.sourceRef ?? null,
+    sourceLimits
+  };
 }
 async function isDir(p) {
   try {
-    return (await fs16.stat(p)).isDirectory();
+    return (await fs17.stat(p)).isDirectory();
   } catch {
     return false;
   }
@@ -5712,28 +5807,28 @@ function loggerFor(opts) {
 }
 async function readState(directory) {
   try {
-    const marker = path16.join(directory, ".genex", "remix-operation.json");
-    if ((await fs17.lstat(marker)).isSymbolicLink()) return null;
-    const value = JSON.parse(await fs17.readFile(marker, "utf8"));
+    const marker = path17.join(directory, ".genex", "remix-operation.json");
+    if ((await fs18.lstat(marker)).isSymbolicLink()) return null;
+    const value = JSON.parse(await fs18.readFile(marker, "utf8"));
     return value.schema === 1 && value.directory === directory && typeof value.operationId === "string" && /^[a-zA-Z0-9_-]{8,128}$/.test(value.operationId) && value.source && /^[a-f0-9]{40}$/.test(value.source.sourceCommitSha) ? value : null;
   } catch {
     return null;
   }
 }
 async function saveState(state) {
-  const dir = path16.join(state.directory, ".genex");
-  await fs17.mkdir(dir, { recursive: true, mode: 448 });
-  const temp = path16.join(dir, "remix-operation.next.json");
-  await fs17.writeFile(temp, JSON.stringify(state, null, 2) + "\n", { mode: 384 });
-  await fs17.rename(temp, path16.join(dir, "remix-operation.json"));
+  const dir = path17.join(state.directory, ".genex");
+  await fs18.mkdir(dir, { recursive: true, mode: 448 });
+  const temp = path17.join(dir, "remix-operation.next.json");
+  await fs18.writeFile(temp, JSON.stringify(state, null, 2) + "\n", { mode: 384 });
+  await fs18.rename(temp, path17.join(dir, "remix-operation.json"));
 }
 async function checkDestination(directory) {
   try {
-    const stat = await fs17.lstat(directory);
+    const stat = await fs18.lstat(directory);
     if (!stat.isDirectory() || stat.isSymbolicLink()) throw new RemixError("destination_occupied", "The destination is not a fresh directory. Choose a new folder.");
-    const entries = await fs17.readdir(directory);
+    const entries = await fs18.readdir(directory);
     if (!entries.length) return null;
-    const genex = await fs17.lstat(path16.join(directory, ".genex")).catch(() => null);
+    const genex = await fs18.lstat(path17.join(directory, ".genex")).catch(() => null);
     const state = genex?.isDirectory() && !genex.isSymbolicLink() ? await readState(directory) : null;
     if (state) return state;
     throw new RemixError("destination_occupied", "The destination already contains files. Choose a fresh folder; remix never clears an existing project.");
@@ -5744,7 +5839,7 @@ async function checkDestination(directory) {
 }
 async function assertReferenceParents(cwd) {
   for (const rel of [".genex", ".genex/refs"]) {
-    const stat = await fs17.lstat(path16.join(cwd, rel)).catch((err) => {
+    const stat = await fs18.lstat(path17.join(cwd, rel)).catch((err) => {
       if (err.code === "ENOENT") return null;
       throw err;
     });
@@ -5752,41 +5847,41 @@ async function assertReferenceParents(cwd) {
   }
 }
 async function archiveSourceInstructions(directory) {
-  const archive = path16.join(directory, ".genex", "source-instructions");
+  const archive = path17.join(directory, ".genex", "source-instructions");
   const rootArtifacts = /* @__PURE__ */ new Set([".claude", ".codex", ".cursor", ".agents", ".mcp.json", ".cursorrules", "DESIGN.md"]);
   const instructionNames = /* @__PURE__ */ new Set(["AGENTS.md", "CLAUDE.md", "GEMINI.md"]);
   const visit = async (dir) => {
-    for (const entry of await fs17.readdir(dir, { withFileTypes: true })) {
+    for (const entry of await fs18.readdir(dir, { withFileTypes: true })) {
       if (entry.name === ".genex" || entry.name === ".git" || entry.name === "node_modules") continue;
-      const from = path16.join(dir, entry.name), rel = path16.relative(directory, from);
+      const from = path17.join(dir, entry.name), rel = path17.relative(directory, from);
       if (instructionNames.has(entry.name) || dir === directory && rootArtifacts.has(entry.name)) {
-        const to = path16.join(archive, rel);
-        await fs17.mkdir(path16.dirname(to), { recursive: true });
-        if (await fs17.lstat(to).catch(() => null)) throw new RemixError("destination_changed", `Source instructions at ${rel} changed during preparation; both copies were retained.`);
-        await fs17.rename(from, to);
+        const to = path17.join(archive, rel);
+        await fs18.mkdir(path17.dirname(to), { recursive: true });
+        if (await fs18.lstat(to).catch(() => null)) throw new RemixError("destination_changed", `Source instructions at ${rel} changed during preparation; both copies were retained.`);
+        await fs18.rename(from, to);
       } else if (entry.isDirectory()) await visit(from);
     }
   };
   await visit(directory);
 }
 async function acquireLock(directory) {
-  const lock = path16.join(directory, ".genex", "remix.lock");
+  const lock = path17.join(directory, ".genex", "remix.lock");
   for (let attempt = 0; attempt < 2; attempt++) {
     try {
-      const handle = await fs17.open(lock, "wx", 384);
+      const handle = await fs18.open(lock, "wx", 384);
       await handle.writeFile(String(process.pid));
       await handle.close();
-      return () => fs17.unlink(lock).catch(() => {
+      return () => fs18.unlink(lock).catch(() => {
       });
     } catch (err) {
       if (err.code !== "EEXIST") throw err;
-      const pid = Number(await fs17.readFile(lock, "utf8").catch(() => ""));
+      const pid = Number(await fs18.readFile(lock, "utf8").catch(() => ""));
       if (!Number.isInteger(pid) || pid <= 0) throw new RemixError("remix_in_progress", "Another remix owns this destination. Retry after it finishes.");
       try {
         process.kill(pid, 0);
       } catch (probe) {
         if (probe.code === "ESRCH") {
-          await fs17.unlink(lock);
+          await fs18.unlink(lock);
           continue;
         }
       }
@@ -5872,13 +5967,13 @@ function pinRemixDependencies(pkg, version) {
   return warnings;
 }
 async function installRemixDependencies(cwd, pm, version, log, runner = childRun) {
-  const pkgPath = path16.join(cwd, "package.json");
-  const pkg = JSON.parse(await fs17.readFile(pkgPath, "utf8"));
+  const pkgPath = path17.join(cwd, "package.json");
+  const pkg = JSON.parse(await fs18.readFile(pkgPath, "utf8"));
   const warnings = pinRemixDependencies(pkg, version);
-  await fs17.writeFile(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
+  await fs18.writeFile(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
   log.step(`Restoring dependencies with ${pm}; pinning ${CLI_PACKAGE}@${version} (${CLI_CHANNEL}).`);
   const args = pm === "npm" ? ["install", "--workspaces=false", "--no-audit", "--no-fund"] : pm === "pnpm" ? ["install", "--ignore-workspace", "--no-frozen-lockfile"] : ["install"];
-  if (pm === "yarn") await fs17.writeFile(path16.join(cwd, "yarn.lock"), "", { flag: "wx" }).catch((err) => {
+  if (pm === "yarn") await fs18.writeFile(path17.join(cwd, "yarn.lock"), "", { flag: "wx" }).catch((err) => {
     if (err.code !== "EEXIST") throw err;
   });
   await runner(cwd, pm, args);
@@ -5912,27 +6007,27 @@ function rebindRemixConfig(content, slug) {
 async function configureIdentity(state, log) {
   const cwd = state.directory, meta = state.project;
   await writeProject(meta, cwd);
-  const configFile = path16.join(cwd, "src", "genex.config.ts");
-  const config = await fs17.readFile(configFile, "utf8").catch((err) => {
+  const configFile = path17.join(cwd, "src", "genex.config.ts");
+  const config = await fs18.readFile(configFile, "utf8").catch((err) => {
     if (err.code === "ENOENT") return null;
     throw err;
   });
-  if (config !== null) await fs17.writeFile(configFile, rebindRemixConfig(config, meta.slug));
+  if (config !== null) await fs18.writeFile(configFile, rebindRemixConfig(config, meta.slug));
   await writeGameConfigFiles(meta, log, cwd);
   await writeGitignore(cwd, log);
   await installRemixProfile(cwd, state.apiUrl, log);
-  const manifestFile = path16.join(cwd, "package.json");
-  const manifest = JSON.parse(await fs17.readFile(manifestFile, "utf8"));
+  const manifestFile = path17.join(cwd, "package.json");
+  const manifest = JSON.parse(await fs18.readFile(manifestFile, "utf8"));
   manifest.genex.remixSource = { projectId: state.source.projectId, slug: state.source.slug, sourceCommitSha: state.source.sourceCommitSha, version: state.source.version, versionCertainty: state.source.versionCertainty };
-  await fs17.writeFile(manifestFile, JSON.stringify(manifest, null, 2) + "\n");
+  await fs18.writeFile(manifestFile, JSON.stringify(manifest, null, 2) + "\n");
   const possible = [];
   const quoted = new RegExp(`(["'\`])(?:${state.source.slug.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}|${state.source.projectId.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")})\\1`);
   const scan = async (dir) => {
-    for (const entry of await fs17.readdir(dir, { withFileTypes: true })) {
+    for (const entry of await fs18.readdir(dir, { withFileTypes: true })) {
       if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
-      const file = path16.join(dir, entry.name);
+      const file = path17.join(dir, entry.name);
       if (entry.isDirectory()) await scan(file);
-      else if (entry.isFile() && /\.(?:[cm]?[jt]sx?|html)$/.test(entry.name) && (await fs17.stat(file)).size < 1024 * 1024 && quoted.test(await fs17.readFile(file, "utf8"))) possible.push(path16.relative(cwd, file));
+      else if (entry.isFile() && /\.(?:[cm]?[jt]sx?|html)$/.test(entry.name) && (await fs18.stat(file)).size < 1024 * 1024 && quoted.test(await fs18.readFile(file, "utf8"))) possible.push(path17.relative(cwd, file));
     }
   };
   await scan(cwd);
@@ -5957,7 +6052,7 @@ async function runRemix(opts, deps = {}) {
     const apiUrl = getApiUrl(opts.apiUrl), dashboardUrl = new URL(getAuthUrl(opts.authUrl)).origin;
     if (opts.sourceOnly && !opts.destination) await assertReferenceParents(originalCwd);
     const selected = parseRemixSource(opts.remixSource, apiUrl, dashboardUrl);
-    let directory = opts.destination ? path16.resolve(originalCwd, opts.destination) : !opts.sourceOnly ? path16.resolve(originalCwd, `${selected.slug}-remix`) : void 0;
+    let directory = opts.destination ? path17.resolve(originalCwd, opts.destination) : !opts.sourceOnly ? path17.resolve(originalCwd, `${selected.slug}-remix`) : void 0;
     if (directory) state = await checkDestination(directory);
     resumed = state !== null;
     if (state && (state.apiUrl !== apiUrl || state.sourceOnly !== Boolean(opts.sourceOnly) || ![state.requestedSlug, state.source.slug].includes(selected.slug) || opts.operationId && state.operationId !== opts.operationId || opts.name && state.name !== opts.name || selected.version && selected.version !== state.source.version)) throw new RemixError("operation_mismatch", "This folder belongs to a different remix operation. Resume with its original source/options or choose a fresh folder.");
@@ -5975,7 +6070,7 @@ async function runRemix(opts, deps = {}) {
       log.step(`Resolving source for ${selected.slug}\u2026`);
       const body = await responseJson(await request(`${apiUrl}/api/projects/${encodeURIComponent(selected.slug)}/source?${query}`, { headers, redirect: "error" }));
       validateSource(body, Boolean(opts.sourceOnly));
-      directory ??= path16.resolve(originalCwd, ".genex", "refs", `${body.source.slug}-${body.source.sourceCommitSha.slice(0, 12)}`);
+      directory ??= path17.resolve(originalCwd, ".genex", "refs", `${body.source.slug}-${body.source.sourceCommitSha.slice(0, 12)}`);
       const existing = await checkDestination(directory);
       if (existing) {
         if (!existing.sourceOnly || !opts.sourceOnly || existing.apiUrl !== apiUrl || existing.source.sourceCommitSha !== body.source.sourceCommitSha || existing.source.projectId !== body.source.projectId) throw new RemixError("destination_occupied", "This reference destination already belongs to another operation. Choose a fresh folder.");
@@ -5983,21 +6078,21 @@ async function runRemix(opts, deps = {}) {
         resumed = true;
       } else {
         state = { schema: 1, operationId: opts.operationId ?? crypto4.randomUUID(), directory, apiUrl, dashboardUrl, requestedSlug: selected.slug, source: body.source, sourceToken: body.sourceToken, sourceOnly: Boolean(opts.sourceOnly), cliVersion: getCliVersion(), name: opts.name?.trim() || `${body.source.title.slice(0, 74)} remix`, stage: "download", warnings: [...body.source.warnings] };
-        await fs17.mkdir(directory, { recursive: true });
-        if ((await fs17.readdir(directory)).length) throw new RemixError("destination_occupied", "The destination changed during setup. Choose a fresh folder.");
-        await fs17.mkdir(path16.join(directory, ".genex"), { mode: 448 });
+        await fs18.mkdir(directory, { recursive: true });
+        if ((await fs18.readdir(directory)).length) throw new RemixError("destination_occupied", "The destination changed during setup. Choose a fresh folder.");
+        await fs18.mkdir(path17.join(directory, ".genex"), { mode: 448 });
         await saveState(state);
       }
     }
     unlock = await acquireLock(state.directory);
     state = await readState(state.directory) ?? state;
     if (resumed && state.stage === "download") await renewSource(state, request, headers);
-    const staging = path16.join(state.directory, ".genex", "remix-stage");
+    const staging = path17.join(state.directory, ".genex", "remix-stage");
     if (state.stage === "download") {
-      await fs17.rm(staging, { recursive: true, force: true });
-      await fs17.mkdir(staging, { recursive: true });
-      const archive = path16.join(staging, "source.zip"), sourceDir = path16.join(staging, "source");
-      await fs17.mkdir(sourceDir);
+      await fs18.rm(staging, { recursive: true, force: true });
+      await fs18.mkdir(staging, { recursive: true });
+      const archive = path17.join(staging, "source.zip"), sourceDir = path17.join(staging, "source");
+      await fs18.mkdir(sourceDir);
       const archiveUrl = new URL(state.source.archiveUrl, state.apiUrl);
       if (archiveUrl.origin !== new URL(state.apiUrl).origin || !archiveUrl.pathname.startsWith("/api/projects/")) throw new RemixError("invalid_source_response", "Source archive must be served by the selected Genex API.");
       log.step(`Downloading ${state.source.slug} at ${state.source.sourceCommitSha.slice(0, 12)}\u2026`);
@@ -6012,26 +6107,26 @@ async function runRemix(opts, deps = {}) {
       if (!state.sourceOnly) {
         let pkg;
         try {
-          pkg = JSON.parse(await fs17.readFile(path16.join(sourceDir, "package.json"), "utf8"));
+          pkg = JSON.parse(await fs18.readFile(path17.join(sourceDir, "package.json"), "utf8"));
         } catch (error) {
-          const staticEntry = await fs17.stat(path16.join(sourceDir, "index.html")).catch(() => null);
+          const staticEntry = await fs18.stat(path17.join(sourceDir, "index.html")).catch(() => null);
           if (error.code !== "ENOENT" || !staticEntry?.isFile()) throw new RemixError("source_unavailable", "Source has neither a readable package.json nor a static index.html. Use --source-only to inspect it.");
           pkg = { name: manifestName(state.directory), private: true };
-          await fs17.writeFile(path16.join(sourceDir, "package.json"), JSON.stringify(pkg, null, 2) + "\n");
+          await fs18.writeFile(path17.join(sourceDir, "package.json"), JSON.stringify(pkg, null, 2) + "\n");
           state.warnings.push("This static game had no package.json; added a minimal private manifest for the local CLI. Its source and index.html remain unchanged.");
         }
         if (!pkg || typeof pkg !== "object" || Array.isArray(pkg)) throw new RemixError("source_unavailable", "Source package.json is not a project manifest.");
       }
-      state.transferEntries = await fs17.readdir(sourceDir);
+      state.transferEntries = await fs18.readdir(sourceDir);
       state.stage = "transfer";
       await saveState(state);
     }
     if (state.stage === "transfer") {
       for (const entry of state.transferEntries ?? []) {
-        const from = path16.join(staging, "source", entry), to = path16.join(state.directory, entry);
-        if (await fs17.lstat(from).catch(() => null)) {
-          if (await fs17.lstat(to).catch(() => null)) throw new RemixError("destination_changed", `A file appeared at ${entry} during source preparation. It was left untouched.`);
-          await fs17.rename(from, to);
+        const from = path17.join(staging, "source", entry), to = path17.join(state.directory, entry);
+        if (await fs18.lstat(from).catch(() => null)) {
+          if (await fs18.lstat(to).catch(() => null)) throw new RemixError("destination_changed", `A file appeared at ${entry} during source preparation. It was left untouched.`);
+          await fs18.rename(from, to);
         }
       }
       if (!state.sourceOnly) {
@@ -6040,7 +6135,7 @@ async function runRemix(opts, deps = {}) {
       }
       state.stage = state.sourceOnly ? "prepared" : "configure";
       await saveState(state);
-      await fs17.rm(staging, { recursive: true, force: true });
+      await fs18.rm(staging, { recursive: true, force: true });
     }
     process.chdir(state.directory);
     if (state.stage === "configure") {
@@ -6111,8 +6206,8 @@ async function runRemix(opts, deps = {}) {
 }
 
 // src/commands/init.ts
-import fs18 from "fs/promises";
-import path17 from "path";
+import fs19 from "fs/promises";
+import path18 from "path";
 
 // src/lib/printed.ts
 var printed = /* @__PURE__ */ new WeakSet();
@@ -6153,7 +6248,7 @@ var TOOLING_ENTRIES = /* @__PURE__ */ new Set([
 ]);
 async function listPreexistingEntries(dir) {
   try {
-    return (await fs18.readdir(dir)).filter((name) => !TOOLING_ENTRIES.has(name)).sort();
+    return (await fs19.readdir(dir)).filter((name) => !TOOLING_ENTRIES.has(name)).sort();
   } catch {
     return [];
   }
@@ -6220,8 +6315,8 @@ async function runInit(opts) {
   let totalNew = 0;
   let totalUpdated = 0;
   for (const t of targets) {
-    const src = t.full ? templatesDir : path17.join(templatesDir, "skills");
-    const dest = t.full ? t.baseDir : path17.join(t.baseDir, "skills");
+    const src = t.full ? templatesDir : path18.join(templatesDir, "skills");
+    const dest = t.full ? t.baseDir : path18.join(t.baseDir, "skills");
     const family = remixing ? skillFamilyFilter("remix") : converting ? skillFamilyFilter("tools", { hosted: true }) : skillFamilyFilter("game");
     if (remixing) await pruneRemixWorkflow(t.baseDir);
     const { copied, updated } = await copyTemplates(src, dest, {
@@ -6229,8 +6324,8 @@ async function runInit(opts) {
       exclude: ["controllers", "motion", "asset-viewer", "blender-service"],
       filter: t.full ? family : (rel) => family(`skills/${rel}`)
     });
-    await pruneRemovedSkills(path17.join(t.baseDir, "skills"), log);
-    await writeSkillsMarker(path17.join(t.baseDir, "skills"));
+    await pruneRemovedSkills(path18.join(t.baseDir, "skills"), log);
+    await writeSkillsMarker(path18.join(t.baseDir, "skills"));
     const added = copied.length - updated.length;
     totalNew += added;
     totalUpdated += updated.length;
@@ -6287,7 +6382,7 @@ async function runInit(opts) {
     if (email) log.plain(`  signed in as ${c.cyan(email)}`);
   };
   await echoIdentity();
-  const projectName = opts.name?.trim() || path17.basename(process.cwd());
+  const projectName = opts.name?.trim() || path18.basename(process.cwd());
   const create = (bearer) => createDraftProject({
     apiUrl,
     token: bearer,
@@ -6338,7 +6433,7 @@ async function runInit(opts) {
     if (await writeToolsContract(process.cwd(), { hosted: true })) {
       log.dim("  wrote the Genex Tools publishing rules into AGENTS.md (managed block)");
     }
-    await ensureEnvVar(path17.join(process.cwd(), ".env"), "VITE_GENEX_SLUG", meta.slug, log);
+    await ensureEnvVar(path18.join(process.cwd(), ".env"), "VITE_GENEX_SLUG", meta.slug, log);
     await reportCliEvent(apiUrl, token, "tools_converted");
   }
   if (!remixing) warnPreexisting(log, preexisting);
@@ -6365,9 +6460,9 @@ async function runInit(opts) {
 }
 
 // src/commands/link.ts
-import fs19 from "fs/promises";
+import fs20 from "fs/promises";
 import os6 from "os";
-import path18 from "path";
+import path19 from "path";
 async function runLink(opts) {
   const log = createLogger({ quiet: opts.quiet });
   log.plain(c.bold("genex link"));
@@ -6448,7 +6543,7 @@ async function runLink(opts) {
 }
 async function isEmptyDir(cwd) {
   try {
-    const entries = await fs19.readdir(cwd);
+    const entries = await fs20.readdir(cwd);
     return entries.every((e) => e === ".git" || e === ".genex" || e === ".DS_Store");
   } catch {
     return false;
@@ -6462,13 +6557,13 @@ async function downloadSource(apiUrl, token, project, log) {
     return false;
   }
   log.step(`Downloading the ${grant.sourceRef === "preview" ? "draft" : "published"} source\u2026`);
-  const staging = await fs19.mkdtemp(path18.join(os6.tmpdir(), "genex-link-"));
-  const fresh = path18.join(staging, "source");
+  const staging = await fs20.mkdtemp(path19.join(os6.tmpdir(), "genex-link-"));
+  const fresh = path19.join(staging, "source");
   try {
     if (!await cloneSource(grant, fresh, log)) return false;
-    await fs19.rm(path18.join(fresh, ".git"), { recursive: true, force: true });
-    for (const entry of await fs19.readdir(fresh)) {
-      await fs19.cp(path18.join(fresh, entry), path18.join(process.cwd(), entry), {
+    await fs20.rm(path19.join(fresh, ".git"), { recursive: true, force: true });
+    for (const entry of await fs20.readdir(fresh)) {
+      await fs20.cp(path19.join(fresh, entry), path19.join(process.cwd(), entry), {
         recursive: true,
         force: true
       });
@@ -6476,28 +6571,28 @@ async function downloadSource(apiUrl, token, project, log) {
     log.success("Downloaded.");
     return true;
   } finally {
-    await fs19.rm(staging, { recursive: true, force: true }).catch(() => {
+    await fs20.rm(staging, { recursive: true, force: true }).catch(() => {
     });
   }
 }
 async function ensureSlugEnv(slug, log, cwd = process.cwd()) {
-  const file = path18.join(cwd, ".env");
+  const file = path19.join(cwd, ".env");
   let content;
   try {
-    content = await fs19.readFile(file, "utf8");
+    content = await fs20.readFile(file, "utf8");
   } catch {
     return;
   }
   const re = /^(\s*VITE_GENEX_SLUG=)(.*)$/m;
   const m = content.match(re);
   if (!m) {
-    await fs19.appendFile(file, `${content.endsWith("\n") ? "" : "\n"}VITE_GENEX_SLUG=${slug}
+    await fs20.appendFile(file, `${content.endsWith("\n") ? "" : "\n"}VITE_GENEX_SLUG=${slug}
 `);
     log.dim(`  added VITE_GENEX_SLUG=${slug} to .env`);
     return;
   }
   if (m[2].trim() === slug) return;
-  await fs19.writeFile(file, content.replace(re, `$1${slug}`));
+  await fs20.writeFile(file, content.replace(re, `$1${slug}`));
   log.dim(`  updated .env: VITE_GENEX_SLUG=${slug} (was ${m[2].trim()})`);
 }
 async function fetchOwnProject(apiUrl, token, slug, log) {
@@ -6551,8 +6646,8 @@ async function listOwnSlugs(apiUrl, token, log) {
 }
 
 // src/commands/pull.ts
-import fs20 from "fs/promises";
-import path19 from "path";
+import fs21 from "fs/promises";
+import path20 from "path";
 import os7 from "os";
 function isMachineLocal(entry) {
   if (entry === ".genex" || entry === "node_modules" || entry === ".git") return true;
@@ -6612,23 +6707,23 @@ async function runPull(opts) {
     process.exitCode = 1;
     return;
   }
-  const staging = await fs20.mkdtemp(path19.join(os7.tmpdir(), "genex-pull-"));
-  const fresh = path19.join(staging, "source");
+  const staging = await fs21.mkdtemp(path20.join(os7.tmpdir(), "genex-pull-"));
+  const fresh = path20.join(staging, "source");
   try {
     if (!await cloneSource(grant, fresh, log)) {
       process.exitCode = 1;
       return;
     }
-    await fs20.rm(path19.join(fresh, ".git"), { recursive: true, force: true });
+    await fs21.rm(path20.join(fresh, ".git"), { recursive: true, force: true });
     const kept = await keepReplaced(cwd, log);
     await replaceTree(cwd, fresh);
     if (kept) {
       log.plain("");
-      log.info(`What was here is kept at ${c.cyan(path19.relative(cwd, kept) || kept)}`);
+      log.info(`What was here is kept at ${c.cyan(path20.relative(cwd, kept) || kept)}`);
       log.dim("  Nothing was thrown away \u2014 re-apply from there, or delete it when you are done.");
     }
   } finally {
-    await fs20.rm(staging, { recursive: true, force: true }).catch(() => {
+    await fs21.rm(staging, { recursive: true, force: true }).catch(() => {
     });
   }
   if (await hasRemixProfile(cwd)) await installRemixProfile(cwd, apiUrl, log);
@@ -6648,13 +6743,13 @@ async function runPull(opts) {
 }
 async function keepReplaced(cwd, log) {
   const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-  const dest = path19.join(cwd, ".genex", `replaced-${stamp}`);
+  const dest = path20.join(cwd, ".genex", `replaced-${stamp}`);
   try {
-    const entries = (await fs20.readdir(cwd)).filter((e) => !isMachineLocal(e));
+    const entries = (await fs21.readdir(cwd)).filter((e) => !isMachineLocal(e));
     if (entries.length === 0) return null;
-    await fs20.mkdir(dest, { recursive: true });
+    await fs21.mkdir(dest, { recursive: true });
     for (const entry of entries) {
-      await fs20.cp(path19.join(cwd, entry), path19.join(dest, entry), { recursive: true });
+      await fs21.cp(path20.join(cwd, entry), path20.join(dest, entry), { recursive: true });
     }
     return dest;
   } catch (err) {
@@ -6664,19 +6759,19 @@ async function keepReplaced(cwd, log) {
   }
 }
 async function replaceTree(dest, src) {
-  for (const entry of await fs20.readdir(dest)) {
+  for (const entry of await fs21.readdir(dest)) {
     if (isMachineLocal(entry)) continue;
-    await fs20.rm(path19.join(dest, entry), { recursive: true, force: true });
+    await fs21.rm(path20.join(dest, entry), { recursive: true, force: true });
   }
-  for (const entry of await fs20.readdir(src)) {
+  for (const entry of await fs21.readdir(src)) {
     if (isMachineLocal(entry)) continue;
-    await fs20.cp(path19.join(src, entry), path19.join(dest, entry), { recursive: true });
+    await fs21.cp(path20.join(src, entry), path20.join(dest, entry), { recursive: true });
   }
 }
 
 // src/commands/rename.ts
-import fs21 from "fs/promises";
-import path20 from "path";
+import fs22 from "fs/promises";
+import path21 from "path";
 async function runRename(opts) {
   const log = createLogger({ quiet: opts.quiet });
   log.plain(c.bold("genex rename"));
@@ -6764,23 +6859,23 @@ async function runRename(opts) {
   log.info("Run `genex preview` (or `publish`) to rebuild \u2014 the new slug is baked into the bundle.");
 }
 async function rewriteSlugEnv(from, to, log, cwd = process.cwd()) {
-  const file = path20.join(cwd, ".env");
+  const file = path21.join(cwd, ".env");
   let content;
   try {
-    content = await fs21.readFile(file, "utf8");
+    content = await fs22.readFile(file, "utf8");
   } catch {
     return;
   }
   const re = /^(\s*VITE_GENEX_SLUG=)(.*)$/m;
   if (!re.test(content)) return;
-  await fs21.writeFile(file, content.replace(re, `$1${to}`));
+  await fs22.writeFile(file, content.replace(re, `$1${to}`));
   log.dim(`  .env: VITE_GENEX_SLUG=${to} (was ${from})`);
 }
 async function rewriteBakedSlug(from, to, log, cwd = process.cwd()) {
-  const file = path20.join(cwd, "src", "genex.config.ts");
+  const file = path21.join(cwd, "src", "genex.config.ts");
   let content;
   try {
-    content = await fs21.readFile(file, "utf8");
+    content = await fs22.readFile(file, "utf8");
   } catch {
     return;
   }
@@ -6790,7 +6885,7 @@ async function rewriteBakedSlug(from, to, log, cwd = process.cwd()) {
     log.warn(`  src/genex.config.ts has no "${from}" literal \u2014 check its slug by hand.`);
     return;
   }
-  await fs21.writeFile(file, content.replace(quoted, `"${to}"`));
+  await fs22.writeFile(file, content.replace(quoted, `"${to}"`));
   log.dim(`  src/genex.config.ts: baked slug -> ${to}`);
 }
 
@@ -6969,7 +7064,7 @@ async function runMakeRemixable(opts) {
     return;
   }
   log.step("Copying your game's source to the public repo\u2026");
-  if (!await pushWorktree(process.cwd(), data.pushUrl, true, log)) {
+  if (await pushWorktree(process.cwd(), data.pushUrl, true, log) !== true) {
     process.exitCode = 1;
     return;
   }
@@ -7614,7 +7709,16 @@ async function runSave(opts) {
     process.exitCode = 1;
     return;
   }
-  if (!await pushWorktree(process.cwd(), data.pushUrl, true, log, WORKSPACE_SOURCE_REF)) {
+  const saved = await pushWorktree(
+    process.cwd(),
+    data.pushUrl,
+    true,
+    log,
+    WORKSPACE_SOURCE_REF,
+    void 0,
+    true
+  );
+  if (saved !== true) {
     process.exitCode = 1;
     return;
   }
@@ -7775,8 +7879,8 @@ async function runRollback(opts) {
 }
 
 // src/commands/generate.ts
-import fs22 from "fs/promises";
-import path21 from "path";
+import fs23 from "fs/promises";
+import path22 from "path";
 import { PNG as PNG4 } from "pngjs";
 
 // src/lib/glass.ts
@@ -8080,7 +8184,7 @@ var isRemoteRef = (value) => /^(https?:\/\/|data:)/i.test(value);
 async function inlineLocalImage(filePath, flag) {
   let bytes;
   try {
-    bytes = await fs22.readFile(filePath);
+    bytes = await fs23.readFile(filePath);
   } catch {
     return { ok: false, error: `Couldn't read the ${flag} file at ${filePath}.` };
   }
@@ -8090,7 +8194,7 @@ async function inlineLocalImage(filePath, flag) {
       error: `${flag} file is ${(bytes.length / 1048576).toFixed(1)} MB \u2014 over the ~4 MB inline limit. Downscale/compress it first, or pass an asset URL instead.`
     };
   }
-  const mime = IMAGE_MIME_BY_EXT[path21.extname(filePath).toLowerCase()] ?? "image/png";
+  const mime = IMAGE_MIME_BY_EXT[path22.extname(filePath).toLowerCase()] ?? "image/png";
   return { ok: true, dataUri: `data:${mime};base64,${bytes.toString("base64")}` };
 }
 var SKYBOX_ENVIRONMENT_SUFFIX = ". The image contains ONLY sky: cloud, atmosphere, light, weather and distant haze at the horizon. Every structure, object, plant and ground surface is outside the frame.";
@@ -8276,7 +8380,7 @@ async function runGenerate(kind, opts) {
   let typedPrompt = opts.prompt?.trim();
   if (!typedPrompt && kind === "model" && opts.imageUrl) {
     const ref = opts.imageUrl.startsWith("data:") ? "local image" : opts.imageUrl;
-    typedPrompt = `from image: ${path21.basename(ref).slice(0, 120)}`;
+    typedPrompt = `from image: ${path22.basename(ref).slice(0, 120)}`;
   }
   if (kind === "model" && opts.texture !== void 0 && !MODEL_TEXTURE_TIERS.includes(opts.texture)) {
     log.error(`--texture ${opts.texture} is a character texture size. \`genex model\` takes a texture TIER: ${MODEL_TEXTURE_TIERS.join("|")} (default detailed).`);
@@ -8325,7 +8429,7 @@ async function runGenerate(kind, opts) {
       return;
     }
     try {
-      const bytes = await fs22.readFile(opts.inpaintUrl);
+      const bytes = await fs23.readFile(opts.inpaintUrl);
       opts = { ...opts, inpaintUrl: `data:image/png;base64,${bytes.toString("base64")}` };
     } catch {
       log.error(`Couldn't read the --inpaint mask at ${opts.inpaintUrl}.`);
@@ -8519,7 +8623,7 @@ async function reportGlassTerminal(view, outDir, log, json) {
     return;
   }
   await recordTerminal(view.id, "completed", files.map((f) => f.url));
-  await fs22.mkdir(outDir, { recursive: true });
+  await fs23.mkdir(outDir, { recursive: true });
   const solved = [];
   for (let i = 0; i < files.length; i++) {
     const f = files[i];
@@ -8551,8 +8655,8 @@ async function reportGlassTerminal(view, outDir, log, json) {
       });
       continue;
     }
-    const outPath = path21.join(outDir, `glass-${i + 1}.png`);
-    await fs22.writeFile(outPath, PNG4.sync.write(r.png));
+    const outPath = path22.join(outDir, `glass-${i + 1}.png`);
+    await fs23.writeFile(outPath, PNG4.sync.write(r.png));
     solved.push({
       path: outPath,
       url: f.url,
@@ -9070,8 +9174,8 @@ function writeJson(value) {
 }
 
 // src/commands/model-sub.ts
-import fs23 from "fs/promises";
-import path22 from "path";
+import fs24 from "fs/promises";
+import path23 from "path";
 var MODEL_SUBCOMMANDS = ["segment", "rig", "animate", "import"];
 function apiErrorMessage(data, fallback) {
   if (typeof data !== "object" || data === null) return fallback;
@@ -9086,29 +9190,29 @@ async function importModelFile(args) {
   const { log } = args;
   const filePath = args.filePath.trim();
   if (!/\.glb$/i.test(filePath)) {
-    log.error(`\`import\` takes a .glb file (binary glTF 2.0). Export ${path22.basename(filePath) || "the model"} as GLB first \u2014 Blender: File \u2192 Export \u2192 glTF 2.0, format "glTF Binary".`);
+    log.error(`\`import\` takes a .glb file (binary glTF 2.0). Export ${path23.basename(filePath) || "the model"} as GLB first \u2014 Blender: File \u2192 Export \u2192 glTF 2.0, format "glTF Binary".`);
     return null;
   }
   let bytes;
   try {
-    bytes = await fs23.readFile(filePath);
+    bytes = await fs24.readFile(filePath);
   } catch {
     log.error(`Couldn't read ${filePath}.`);
     return null;
   }
   if (bytes.byteLength > MODEL_IMPORT_MAX_BYTES) {
-    log.error(`${path22.basename(filePath)} is ${(bytes.byteLength / 1e6).toFixed(1)} MB; imports are capped at ${MODEL_IMPORT_MAX_BYTES / 1024 / 1024} MB. Shrink its textures (they are usually the bulk) and try again.`);
+    log.error(`${path23.basename(filePath)} is ${(bytes.byteLength / 1e6).toFixed(1)} MB; imports are capped at ${MODEL_IMPORT_MAX_BYTES / 1024 / 1024} MB. Shrink its textures (they are usually the bulk) and try again.`);
     return null;
   }
   if (bytes.byteLength < 12 || bytes.readUInt32LE(0) !== GLB_MAGIC) {
-    log.error(`${path22.basename(filePath)} is not a GLB (no glTF magic). A .gltf + .bin pair must be exported as one binary .glb.`);
+    log.error(`${path23.basename(filePath)} is not a GLB (no glTF magic). A .gltf + .bin pair must be exported as one binary .glb.`);
     return null;
   }
   const headers = { "Content-Type": "application/json", Authorization: `Bearer ${args.token}` };
   const minted = await apiFetch(`${args.apiUrl}/api/generations/import`, {
     method: "POST",
     headers,
-    body: JSON.stringify({ filename: path22.basename(filePath), bytes: bytes.byteLength, contentType: "model/gltf-binary" })
+    body: JSON.stringify({ filename: path23.basename(filePath), bytes: bytes.byteLength, contentType: "model/gltf-binary" })
   });
   if (printedStructuredError(minted)) return null;
   if (!minted.ok) {
@@ -9117,7 +9221,7 @@ async function importModelFile(args) {
     return null;
   }
   const { id, uploadUrl, url } = await minted.json();
-  log.dim(`  uploading ${path22.basename(filePath)} (${(bytes.byteLength / 1e6).toFixed(1)} MB)\u2026`);
+  log.dim(`  uploading ${path23.basename(filePath)} (${(bytes.byteLength / 1e6).toFixed(1)} MB)\u2026`);
   const put = await fetch(uploadUrl, {
     method: "PUT",
     headers: { "Content-Type": "model/gltf-binary", "Content-Length": String(bytes.byteLength) },
@@ -9265,7 +9369,7 @@ async function runModelAnimate(opts) {
 }
 
 // src/commands/wait.ts
-import path23 from "path";
+import path24 from "path";
 var TERMINAL2 = /* @__PURE__ */ new Set(["completed", "failed"]);
 async function runWait(opts) {
   if (opts.all) return runWaitAll(opts);
@@ -9396,7 +9500,7 @@ async function runWaitAll(opts) {
       if (v?.status !== "completed" || !v.files?.length) continue;
       const local = localDeliveryFor("tools", opts, e.prompt || e.kind);
       if (!local) continue;
-      const outDir = path23.join(path23.relative(process.cwd(), cwd) || ".", local.outDir);
+      const outDir = path24.join(path24.relative(process.cwd(), cwd) || ".", local.outDir);
       const target = { kind: e.kind, prompt: local.prompt, id: e.id, outDir };
       const missing = await undeliveredFiles(v.files, target);
       if (missing.length === 0) continue;
@@ -9491,8 +9595,8 @@ async function toRow(e, v, cwd) {
 }
 
 // src/commands/controller.ts
-import fs25 from "fs/promises";
-import path25 from "path";
+import fs26 from "fs/promises";
+import path26 from "path";
 
 // ../../packages/meshy-animation-catalog/src/index.ts
 import { createHash } from "crypto";
@@ -18622,9 +18726,9 @@ function searchMeshyAnimations(query, options = {}) {
 }
 
 // src/lib/anims.ts
-import fs24 from "fs/promises";
-import path24 from "path";
-var ANIMS_DEST = path24.join("public", "assets", "anims");
+import fs25 from "fs/promises";
+import path25 from "path";
+var ANIMS_DEST = path25.join("public", "assets", "anims");
 var HIDDEN_TAG = "reference";
 async function runAnims(opts) {
   const log = createLogger({ quiet: opts.quiet });
@@ -18640,7 +18744,7 @@ async function runAnims(opts) {
     printCatalog(log, manifest, selectors);
     return;
   }
-  const controllerMarker = path24.join(root, "src", "controllers", "character");
+  const controllerMarker = path25.join(root, "src", "controllers", "character");
   if (!await exists3(controllerMarker)) {
     log.error(
       `No character controller in this game (missing ${c.cyan("src/controllers/character/")}).`
@@ -18649,11 +18753,11 @@ async function runAnims(opts) {
     process.exitCode = 1;
     return;
   }
-  const destDir = path24.join(root, ANIMS_DEST);
-  const gameManifestPath = path24.join(destDir, "manifest.json");
+  const destDir = path25.join(root, ANIMS_DEST);
+  const gameManifestPath = path25.join(destDir, "manifest.json");
   if (opts.reset) {
-    await fs24.rm(destDir, { recursive: true, force: true });
-    log.step(`Cleared ${c.cyan(ANIMS_DEST + path24.sep)} (--reset)`);
+    await fs25.rm(destDir, { recursive: true, force: true });
+    log.step(`Cleared ${c.cyan(ANIMS_DEST + path25.sep)} (--reset)`);
   }
   if (selectors.length === 0) {
     const installed = await readGameManifest(gameManifestPath);
@@ -18691,35 +18795,35 @@ async function runAnims(opts) {
     }
   }
   const wanted = [...byName.values()].sort((a, b) => a.name.localeCompare(b.name));
-  const cacheDir = path24.join(
+  const cacheDir = path25.join(
     opts.cacheDir ?? getAnimsCacheDir(),
     `${manifest.library}-v${manifest.version}`
   );
-  await fs24.mkdir(cacheDir, { recursive: true });
-  await fs24.mkdir(destDir, { recursive: true });
+  await fs25.mkdir(cacheDir, { recursive: true });
+  await fs25.mkdir(destDir, { recursive: true });
   const base = getAnimsBase(opts.animsBase);
   let installedCount = 0;
   let presentCount = 0;
   let addedBytes = 0;
   const failures = [];
   for (const entry of wanted) {
-    const dest = path24.join(destDir, entry.file);
+    const dest = path25.join(destDir, entry.file);
     if (await hasSize(dest, entry.bytes)) {
       presentCount++;
       continue;
     }
     try {
-      const cached = path24.join(cacheDir, entry.file);
+      const cached = path25.join(cacheDir, entry.file);
       if (!await hasSize(cached, entry.bytes)) {
         const res = await fetch(base + entry.file);
         if (!res.ok) throw new Error(`HTTP ${res.status}`);
         const buf = Buffer.from(await res.arrayBuffer());
-        await fs24.writeFile(cached, buf);
+        await fs25.writeFile(cached, buf);
       }
-      await fs24.copyFile(cached, dest);
+      await fs25.copyFile(cached, dest);
       installedCount++;
       addedBytes += entry.bytes;
-      log.dim(`  ${path24.join(ANIMS_DEST, entry.file)} (${formatMb(entry.bytes)})`);
+      log.dim(`  ${path25.join(ANIMS_DEST, entry.file)} (${formatMb(entry.bytes)})`);
     } catch (err) {
       failures.push(`${entry.name} (${err instanceof Error ? err.message : String(err)})`);
     }
@@ -18735,13 +18839,13 @@ async function runAnims(opts) {
     version: manifest.version,
     clips: [...union].sort((a, b) => a.localeCompare(b))
   };
-  await fs24.writeFile(gameManifestPath, JSON.stringify(gameManifest, null, 2) + "\n");
+  await fs25.writeFile(gameManifestPath, JSON.stringify(gameManifest, null, 2) + "\n");
   log.plain("");
   const parts = [`${installedCount} clip${installedCount === 1 ? "" : "s"} installed`];
   if (presentCount > 0) parts.push(`${presentCount} already present`);
   if (bundledSkips > 0) parts.push(`${bundledSkips} already bundled in animation-library.glb`);
   log.success(
-    `${parts.join(", ")} \u2192 ${c.cyan(ANIMS_DEST + path24.sep)}${addedBytes > 0 ? ` (+${formatMb(addedBytes)})` : ""}`
+    `${parts.join(", ")} \u2192 ${c.cyan(ANIMS_DEST + path25.sep)}${addedBytes > 0 ? ` (+${formatMb(addedBytes)})` : ""}`
   );
   for (const [selector, entries] of resolved) {
     const names = entries.filter((e) => !coreNames.has(e.name)).map((e) => e.name);
@@ -18773,8 +18877,8 @@ async function loadManifest(baseOverride) {
     }
   } catch {
   }
-  const snapshotPath = path24.join(getTemplatesDir(), "controllers", "assets", "anims-manifest.json");
-  const manifest = JSON.parse(await fs24.readFile(snapshotPath, "utf8"));
+  const snapshotPath = path25.join(getTemplatesDir(), "controllers", "assets", "anims-manifest.json");
+  const manifest = JSON.parse(await fs25.readFile(snapshotPath, "utf8"));
   return { manifest, source: "snapshot" };
 }
 function resolveSelectors(manifest, selectors) {
@@ -18892,21 +18996,21 @@ function printCatalog(log, manifest, selectors) {
 }
 async function readGameManifest(file) {
   try {
-    return JSON.parse(await fs24.readFile(file, "utf8"));
+    return JSON.parse(await fs25.readFile(file, "utf8"));
   } catch {
     return null;
   }
 }
 async function hasSize(file, bytes) {
   try {
-    return (await fs24.stat(file)).size === bytes;
+    return (await fs25.stat(file)).size === bytes;
   } catch {
     return false;
   }
 }
 async function exists3(p) {
   try {
-    await fs24.access(p);
+    await fs25.access(p);
     return true;
   } catch {
     return false;
@@ -19107,8 +19211,8 @@ var CONTROLLER_FILE_SETS = {
     ]
   }
 };
-var CODE_DEST = path25.join("src", "controllers");
-var ASSETS_DEST = path25.join("public", "assets");
+var CODE_DEST = path26.join("src", "controllers");
+var ASSETS_DEST = path26.join("public", "assets");
 async function runController(opts) {
   const log = createLogger({ quiet: opts.quiet });
   if (opts.kind?.trim() === "anims") {
@@ -19125,31 +19229,31 @@ async function runController(opts) {
     process.exitCode = 1;
     return;
   }
-  const srcDir = path25.join(getTemplatesDir(), "controllers");
+  const srcDir = path26.join(getTemplatesDir(), "controllers");
   const root = opts.cwd ?? process.cwd();
   const set = CONTROLLER_FILE_SETS[kind];
   log.plain(c.bold(`genex controller ${kind}`));
   log.plain("");
-  log.step(`Installing the ${kind} controller into ${c.cyan(CODE_DEST + path25.sep)}`);
+  log.step(`Installing the ${kind} controller into ${c.cyan(CODE_DEST + path26.sep)}`);
   const plan = [
-    ...set.code.map((rel) => ({ from: rel, rel: path25.join(CODE_DEST, rel) })),
+    ...set.code.map((rel) => ({ from: rel, rel: path26.join(CODE_DEST, rel) })),
     ...set.assets.map((rel) => ({
       from: rel,
-      rel: path25.join(ASSETS_DEST, path25.basename(rel))
+      rel: path26.join(ASSETS_DEST, path26.basename(rel))
     }))
   ];
   let copied = 0;
   let skipped = 0;
   try {
     for (const file of plan) {
-      const dest = path25.join(root, file.rel);
+      const dest = path26.join(root, file.rel);
       if (!opts.force && await exists4(dest)) {
         skipped++;
         log.dim(`  skipped ${file.rel} (exists \u2014 use --force to overwrite)`);
         continue;
       }
-      await fs25.mkdir(path25.dirname(dest), { recursive: true });
-      await fs25.copyFile(path25.join(srcDir, file.from), dest);
+      await fs26.mkdir(path26.dirname(dest), { recursive: true });
+      await fs26.copyFile(path26.join(srcDir, file.from), dest);
       copied++;
       log.dim(`  ${file.rel}`);
     }
@@ -19202,7 +19306,7 @@ async function runController(opts) {
   for (const line of set.sketch) {
     log.dim(`       ${line}`);
   }
-  if (kind === "character" && !await exists4(path25.join(root, ASSETS_DEST, "meshy-character.json"))) {
+  if (kind === "character" && !await exists4(path26.join(root, ASSETS_DEST, "meshy-character.json"))) {
     log.plain("");
     log.plain(
       `  ${stepOffset + 3}. This game has no generated character yet \u2014 ${c.cyan(
@@ -19234,9 +19338,9 @@ async function installMeshyCharacterManifest(args) {
     throw new Error("The API returned an invalid Meshy character manifest.");
   }
   assertCompleteMeshyControllerPack(manifest);
-  const destination = path25.join(args.root, ASSETS_DEST, "meshy-character.json");
-  await fs25.mkdir(path25.dirname(destination), { recursive: true });
-  await fs25.writeFile(
+  const destination = path26.join(args.root, ASSETS_DEST, "meshy-character.json");
+  await fs26.mkdir(path26.dirname(destination), { recursive: true });
+  await fs26.writeFile(
     destination,
     `${JSON.stringify(manifest, null, 2)}
 `
@@ -19381,14 +19485,14 @@ function assertCompleteMeshyControllerPack(manifest) {
 }
 async function installFallbackAvatar(args) {
   const { root, srcDir, log } = args;
-  const dest = path25.join(root, ASSETS_DEST, "avatar.vrm");
-  await fs25.mkdir(path25.dirname(dest), { recursive: true });
-  await fs25.copyFile(path25.join(srcDir, "assets", "default-avatar.vrm"), dest);
+  const dest = path26.join(root, ASSETS_DEST, "avatar.vrm");
+  await fs26.mkdir(path26.dirname(dest), { recursive: true });
+  await fs26.copyFile(path26.join(srcDir, "assets", "default-avatar.vrm"), dest);
   log.dim("  public/assets/avatar.vrm (fallback avatar \u2014 bundled CC0 default)");
 }
 async function exists4(p) {
   try {
-    await fs25.access(p);
+    await fs26.access(p);
     return true;
   } catch {
     return false;
@@ -19396,8 +19500,8 @@ async function exists4(p) {
 }
 
 // src/commands/character.ts
-import fs26 from "fs/promises";
-import path26 from "path";
+import fs27 from "fs/promises";
+import path27 from "path";
 function exactAnimation(selector) {
   const trimmed = selector.trim();
   if (/^-?\d+$/.test(trimmed)) return animationById(Number(trimmed));
@@ -19477,7 +19581,7 @@ function showAmbiguity(selector, candidates, log, json = false) {
   }
   process.exitCode = 1;
 }
-var INSTALLED_MANIFEST = path26.join("public", "assets", "meshy-character.json");
+var INSTALLED_MANIFEST = path27.join("public", "assets", "meshy-character.json");
 async function resolveAdoptTarget(selector) {
   const trimmed = selector?.trim();
   if (trimmed && !trimmed.endsWith(".json")) {
@@ -19486,7 +19590,7 @@ async function resolveAdoptTarget(selector) {
   const file = trimmed ?? INSTALLED_MANIFEST;
   let raw;
   try {
-    raw = await fs26.readFile(file, "utf8");
+    raw = await fs27.readFile(file, "utf8");
   } catch {
     return {
       ok: false,
@@ -19607,7 +19711,7 @@ async function runCharacterImport(opts) {
     opts,
     ctx,
     kind: "character",
-    prompt: `Import ${path26.basename(filePath)} as a rigged character`,
+    prompt: `Import ${path27.basename(filePath)} as a rigged character`,
     createPath: "/api/characters/import",
     body,
     quote: price,
@@ -20087,22 +20191,22 @@ async function context2(opts) {
   const project = await readProject();
   return { token, apiUrl: getApiUrl(opts.apiUrl ?? project?.apiUrl) };
 }
-async function readVideo(path32, log) {
+async function readVideo(path33, log) {
   let bytes;
   try {
-    bytes = await readFile(path32);
+    bytes = await readFile(path33);
   } catch {
-    log.error(`Can't read ${path32}.`);
+    log.error(`Can't read ${path33}.`);
     return null;
   }
   if (bytes.byteLength > MAX_VIDEO_BYTES) {
-    log.error(`${basename(path32)} is ${(bytes.byteLength / 1e6).toFixed(0)} MB \u2014 the limit is ${MAX_VIDEO_BYTES / 1e6} MB.`);
+    log.error(`${basename(path33)} is ${(bytes.byteLength / 1e6).toFixed(0)} MB \u2014 the limit is ${MAX_VIDEO_BYTES / 1e6} MB.`);
     return null;
   }
   return bytes;
 }
-async function uploadVideo(apiUrl, token, characterId, path32, bytes, log) {
-  const contentType = /\.mov$/i.test(path32) ? "video/quicktime" : "video/mp4";
+async function uploadVideo(apiUrl, token, characterId, path33, bytes, log) {
+  const contentType = /\.mov$/i.test(path33) ? "video/quicktime" : "video/mp4";
   const minted = await apiFetch(
     `${apiUrl}/api/characters/${encodeURIComponent(characterId)}/motions/video-url`,
     {
@@ -20117,7 +20221,7 @@ async function uploadVideo(apiUrl, token, characterId, path32, bytes, log) {
     return null;
   }
   const { uploadUrl, videoUrl } = await minted.json();
-  log.dim(`  uploading ${basename(path32)} (${(bytes.byteLength / 1e6).toFixed(1)} MB)\u2026`);
+  log.dim(`  uploading ${basename(path33)} (${(bytes.byteLength / 1e6).toFixed(1)} MB)\u2026`);
   const put = await fetch(uploadUrl, {
     method: "PUT",
     headers: { "Content-Type": contentType, "Content-Length": String(bytes.byteLength) },
@@ -20433,8 +20537,8 @@ function rank(items, query) {
 }
 
 // src/commands/motion.ts
-import fs27 from "fs/promises";
-import path27 from "path";
+import fs28 from "fs/promises";
+import path28 from "path";
 
 // src/lib/motion/npz.ts
 import zlib from "zlib";
@@ -21685,7 +21789,7 @@ async function motionGen(opts, log) {
   }
   if (opts.constraintsPath !== void 0) {
     try {
-      const raw = await fs27.readFile(opts.constraintsPath, "utf8");
+      const raw = await fs28.readFile(opts.constraintsPath, "utf8");
       generationOptions.constraints = JSON.parse(raw);
     } catch {
       log.error(`Couldn't read the --constraints JSON at ${opts.constraintsPath}.`);
@@ -21709,10 +21813,10 @@ async function motionGen(opts, log) {
 async function expandTakes(selectors) {
   const out = [];
   for (const sel of selectors) {
-    const st = await fs27.stat(sel).catch(() => null);
+    const st = await fs28.stat(sel).catch(() => null);
     if (st?.isDirectory()) {
-      const names = await fs27.readdir(sel);
-      for (const n of names.sort()) if (n.endsWith(".npz")) out.push(path27.join(sel, n));
+      const names = await fs28.readdir(sel);
+      for (const n of names.sort()) if (n.endsWith(".npz")) out.push(path28.join(sel, n));
     } else if (st?.isFile()) {
       out.push(sel);
     } else {
@@ -21747,7 +21851,7 @@ async function motionVerify(opts, log) {
   let gates = DEFAULT_GATES;
   if (opts.gatesPath) {
     try {
-      gates = mergeGates(DEFAULT_GATES, JSON.parse(await fs27.readFile(opts.gatesPath, "utf8")));
+      gates = mergeGates(DEFAULT_GATES, JSON.parse(await fs28.readFile(opts.gatesPath, "utf8")));
     } catch {
       log.error(`Couldn't read the --gates JSON at ${opts.gatesPath}.`);
       process.exitCode = 1;
@@ -21769,9 +21873,9 @@ async function motionVerify(opts, log) {
   }
   const reports = [];
   for (const file of files) {
-    const stem = path27.basename(file).replace(/\.npz$/, "");
+    const stem = path28.basename(file).replace(/\.npz$/, "");
     try {
-      reports.push(analyzeTake(stem, await fs27.readFile(file), gates));
+      reports.push(analyzeTake(stem, await fs28.readFile(file), gates));
     } catch (err) {
       reports.push({
         take: stem,
@@ -21809,7 +21913,7 @@ async function motionCompile(opts, log) {
   let cfg = DEFAULT_MOTION_CONFIG;
   if (opts.configPath) {
     try {
-      const patch = JSON.parse(await fs27.readFile(opts.configPath, "utf8"));
+      const patch = JSON.parse(await fs28.readFile(opts.configPath, "utf8"));
       cfg = { ...DEFAULT_MOTION_CONFIG, ...patch, idleLoop: { ...DEFAULT_MOTION_CONFIG.idleLoop, ...patch.idleLoop } };
     } catch {
       log.error(`Couldn't read the --config JSON at ${opts.configPath}.`);
@@ -21827,16 +21931,16 @@ async function motionCompile(opts, log) {
   }
   const inputs = [];
   for (const file of files) {
-    const stem = path27.basename(file).replace(/\.npz$/, "");
+    const stem = path28.basename(file).replace(/\.npz$/, "");
     try {
-      inputs.push({ stem, take: loadTake(await fs27.readFile(file)) });
+      inputs.push({ stem, take: loadTake(await fs28.readFile(file)) });
     } catch (err) {
       log.error(`${stem}: ${err instanceof Error ? err.message : String(err)}`);
       process.exitCode = 1;
       return;
     }
   }
-  const setName = opts.set ?? path27.basename(opts.out).replace(/\.json$/, "");
+  const setName = opts.set ?? path28.basename(opts.out).replace(/\.json$/, "");
   let result;
   try {
     result = compileSet(inputs, setName, cfg);
@@ -21851,9 +21955,9 @@ async function motionCompile(opts, log) {
     process.exitCode = 1;
     return;
   }
-  await fs27.mkdir(path27.dirname(path27.resolve(opts.out)), { recursive: true });
+  await fs28.mkdir(path28.dirname(path28.resolve(opts.out)), { recursive: true });
   const json = JSON.stringify(result.data);
-  await fs27.writeFile(opts.out, json);
+  await fs28.writeFile(opts.out, json);
   if (opts.json) {
     writeJson({ out: opts.out, set: setName, tracks: Object.keys(result.data.gaits), bytes: json.length });
     return;
@@ -21871,9 +21975,9 @@ var MOTION_RUNTIME_FILES = [
 var MOTION_PRESETS = {
   rifle: ["sets/rifle.json", "sets/jumps.json"]
 };
-var MOTION_DEST = path27.join("src", "motion");
+var MOTION_DEST = path28.join("src", "motion");
 async function motionInstall(opts, log) {
-  const srcDir = path27.join(getTemplatesDir(), "motion");
+  const srcDir = path28.join(getTemplatesDir(), "motion");
   const root = opts.cwd ?? process.cwd();
   const preset = opts.set;
   if (preset !== void 0 && !MOTION_PRESETS[preset]) {
@@ -21884,21 +21988,21 @@ async function motionInstall(opts, log) {
   const files = [...MOTION_RUNTIME_FILES, ...preset ? MOTION_PRESETS[preset] : []];
   log.plain(c.bold(`genex motion install${preset ? ` --set ${preset}` : ""}`));
   log.plain("");
-  log.step(`Vendoring the motion runtime into ${c.cyan(MOTION_DEST + path27.sep)}`);
+  log.step(`Vendoring the motion runtime into ${c.cyan(MOTION_DEST + path28.sep)}`);
   let copied = 0, skipped = 0;
   try {
     for (const rel of files) {
-      const dest = path27.join(root, MOTION_DEST, rel);
-      const exists5 = await fs27.access(dest).then(() => true, () => false);
+      const dest = path28.join(root, MOTION_DEST, rel);
+      const exists5 = await fs28.access(dest).then(() => true, () => false);
       if (!opts.force && exists5) {
         skipped++;
-        log.dim(`  skipped ${path27.join(MOTION_DEST, rel)} (exists \u2014 use --force to overwrite)`);
+        log.dim(`  skipped ${path28.join(MOTION_DEST, rel)} (exists \u2014 use --force to overwrite)`);
         continue;
       }
-      await fs27.mkdir(path27.dirname(dest), { recursive: true });
-      await fs27.copyFile(path27.join(srcDir, rel), dest);
+      await fs28.mkdir(path28.dirname(dest), { recursive: true });
+      await fs28.copyFile(path28.join(srcDir, rel), dest);
       copied++;
-      log.dim(`  ${path27.join(MOTION_DEST, rel)}`);
+      log.dim(`  ${path28.join(MOTION_DEST, rel)}`);
     }
   } catch (err) {
     log.error(`Copy failed: ${String(err)}`);
@@ -21939,7 +22043,7 @@ async function motionConstraints(opts, log) {
   }
   const doc = directionConstraint(dir, speed, duration);
   const out = opts.out ?? "constraints.json";
-  await fs27.writeFile(out, JSON.stringify(doc));
+  await fs28.writeFile(out, JSON.stringify(doc));
   if (opts.json) {
     writeJson({ out, dir: dirName, speed, duration, waypoints: doc[0].frame_indices.length });
     return;
@@ -21976,14 +22080,14 @@ async function runMotion(opts) {
 }
 
 // src/commands/blender.ts
-import fs28 from "fs/promises";
-import path28 from "path";
+import fs29 from "fs/promises";
+import path29 from "path";
 var SUBS2 = ["demo", "exec", "snap", "scene", "import", "export", "reset", "mcp", "serve", "seat", "release"];
 var DEFAULT_OUT_DIR = "assets/blender";
 async function writeB64(dir, name, b64) {
-  await fs28.mkdir(dir, { recursive: true });
-  const p = path28.join(dir, name);
-  await fs28.writeFile(p, Buffer.from(b64, "base64"));
+  await fs29.mkdir(dir, { recursive: true });
+  const p = path29.join(dir, name);
+  await fs29.writeFile(p, Buffer.from(b64, "base64"));
   return p;
 }
 function reportScene(log, s) {
@@ -22067,7 +22171,7 @@ async function runBlender(opts) {
     log.plain(rest.join("\n"));
     return 1;
   }
-  const outDir = path28.resolve(opts.outDir ?? DEFAULT_OUT_DIR);
+  const outDir = path29.resolve(opts.outDir ?? DEFAULT_OUT_DIR);
   const mode = opts.mode;
   if (mode !== void 0 && !isRenderMode(mode)) {
     log.error(`Unknown --mode ${mode}. Use one of: ${RENDER_MODES.join(", ")}.`);
@@ -22107,14 +22211,14 @@ async function runBlender(opts) {
       return 0;
     }
     case "export": {
-      const target = opts.out ?? path28.join(outDir, "scene.glb");
+      const target = opts.out ?? path29.join(outDir, "scene.glb");
       const r = await blenderCall(base, "/export", { path: "/tmp/genex-export.glb" });
       if (!r.glbBase64) {
         log.error(`/export answered with no GLB bytes${r.uploaded ? " (it was uploaded, not inlined)" : ""}`);
         return 1;
       }
-      await fs28.mkdir(path28.dirname(target), { recursive: true });
-      await fs28.writeFile(target, Buffer.from(r.glbBase64, "base64"));
+      await fs29.mkdir(path29.dirname(target), { recursive: true });
+      await fs29.writeFile(target, Buffer.from(r.glbBase64, "base64"));
       log.success(`Exported ${r.bytes ?? 0} bytes`);
       log.plain(`  ${c.cyan(target)}`);
       return 0;
@@ -22147,12 +22251,12 @@ async function runBlender(opts) {
           return 1;
         }
         try {
-          script = await fs28.readFile(opts.input, "utf8");
+          script = await fs29.readFile(opts.input, "utf8");
         } catch {
           log.error(`Can't read ${opts.input}`);
           return 1;
         }
-        label = path28.basename(opts.input);
+        label = path29.basename(opts.input);
       }
       const r = await blenderCall(base, "/exec", { script, ...mode ? { mode } : {}, sheet: { formats: SHEET_FORMATS } });
       if (r.stdout?.trim()) log.plain(r.stdout.trimEnd());
@@ -22271,9 +22375,9 @@ print(f"castle: {n} objects")
 `;
 
 // src/commands/asset-new.ts
-import fs29 from "fs";
+import fs30 from "fs";
 import fsp from "fs/promises";
-import path29 from "path";
+import path30 from "path";
 import { pathToFileURL } from "url";
 var EXTRA_FILES = [
   "genex-asset.example.json",
@@ -22367,7 +22471,7 @@ Every milestone ends with \`npm run verify\`, then \`npx genex preview --no-buil
 }
 async function runAssetNew(options) {
   const log = createLogger();
-  const cwd = options.dir ? path29.resolve(options.dir) : process.cwd();
+  const cwd = options.dir ? path30.resolve(options.dir) : process.cwd();
   const slug = options.assetSlug;
   if (!slug) {
     log.error('Usage: genex asset new <slug> [--title "<Name>"] [--dims WxDxH] [--tri-band LOW-HIGH] [--holder "<your name>"] [--out <dir>]');
@@ -22377,14 +22481,14 @@ async function runAssetNew(options) {
     log.error(`The slug must be kebab-case (letters, digits, dashes), got: ${slug}`);
     return 1;
   }
-  const templateDir = path29.join(getTemplatesDir(), "asset-viewer");
-  if (!fs29.existsSync(templateDir)) {
+  const templateDir = path30.join(getTemplatesDir(), "asset-viewer");
+  if (!fs30.existsSync(templateDir)) {
     log.error(`Vendored asset-viewer template not found at ${templateDir} \u2014 reinstall the CLI.`);
     return 1;
   }
-  const manifestTools = await import(pathToFileURL(path29.join(templateDir, "tools", "emit-manifest.mjs")).href);
+  const manifestTools = await import(pathToFileURL(path30.join(templateDir, "tools", "emit-manifest.mjs")).href);
   const { SHARED_FILES, PARITY_FILENAME, hashSharedFiles, pascalCase } = manifestTools;
-  const lockPath = path29.join(templateDir, "shared-files.sha256.json");
+  const lockPath = path30.join(templateDir, "shared-files.sha256.json");
   const lock = JSON.parse(await fsp.readFile(lockPath, "utf8"));
   const actual = hashSharedFiles(templateDir);
   const drifted = SHARED_FILES.filter((rel) => lock.files[rel] !== actual[rel]);
@@ -22397,8 +22501,8 @@ async function runAssetNew(options) {
   const triBand = parseBand(options.triBand ?? "500-8000");
   const holder = options.holder?.trim() || HOLDER_PLACEHOLDER;
   const year = (/* @__PURE__ */ new Date()).getUTCFullYear();
-  const outDir = path29.resolve(cwd, options.out ?? slug);
-  if (fs29.existsSync(outDir) && fs29.readdirSync(outDir).length > 0 && !options.force) {
+  const outDir = path30.resolve(cwd, options.out ?? slug);
+  if (fs30.existsSync(outDir) && fs30.readdirSync(outDir).length > 0 && !options.force) {
     log.error(`${outDir} already holds files. Nothing was touched \u2014 pass --force to write into it anyway.`);
     return 1;
   }
@@ -22426,24 +22530,24 @@ async function runAssetNew(options) {
   };
   await fsp.mkdir(outDir, { recursive: true });
   for (const rel of [...SHARED_FILES, ...EXTRA_FILES]) {
-    const to = path29.join(outDir, rel);
-    await fsp.mkdir(path29.dirname(to), { recursive: true });
-    await fsp.copyFile(path29.join(templateDir, rel), to);
+    const to = path30.join(outDir, rel);
+    await fsp.mkdir(path30.dirname(to), { recursive: true });
+    await fsp.copyFile(path30.join(templateDir, rel), to);
   }
-  const pkg = fillTemplate(await fsp.readFile(path29.join(templateDir, "package.json"), "utf8"), {
+  const pkg = fillTemplate(await fsp.readFile(path30.join(templateDir, "package.json"), "utf8"), {
     slug,
     name,
     version
   });
-  await fsp.writeFile(path29.join(outDir, "package.json"), pkg, "utf8");
-  await fsp.writeFile(path29.join(outDir, "asset.config.json"), JSON.stringify(config, null, 2) + "\n", "utf8");
-  await fsp.writeFile(path29.join(outDir, ".gitignore"), GITIGNORE, "utf8");
+  await fsp.writeFile(path30.join(outDir, "package.json"), pkg, "utf8");
+  await fsp.writeFile(path30.join(outDir, "asset.config.json"), JSON.stringify(config, null, 2) + "\n", "utf8");
+  await fsp.writeFile(path30.join(outDir, ".gitignore"), GITIGNORE, "utf8");
   await fsp.writeFile(
-    path29.join(outDir, "DESIGN.md"),
+    path30.join(outDir, "DESIGN.md"),
     designDoc({ name, slug, sizeMeters, triBand, holder }),
     "utf8"
   );
-  const placeholder = await fsp.readFile(path29.join(templateDir, "src", "asset", "PLACEHOLDER.ts"), "utf8");
+  const placeholder = await fsp.readFile(path30.join(templateDir, "src", "asset", "PLACEHOLDER.ts"), "utf8");
   const seeded = seedAssetSource(placeholder, {
     slug,
     name,
@@ -22454,8 +22558,8 @@ async function runAssetNew(options) {
     pascalCase
   });
   const assetFilename = `${slug.replace(/-([a-z0-9])/g, (_, ch) => ch.toUpperCase())}.ts`;
-  await fsp.mkdir(path29.join(outDir, "src", "asset"), { recursive: true });
-  await fsp.writeFile(path29.join(outDir, "src", "asset", assetFilename), seeded, "utf8");
+  await fsp.mkdir(path30.join(outDir, "src", "asset"), { recursive: true });
+  await fsp.writeFile(path30.join(outDir, "src", "asset", assetFilename), seeded, "utf8");
   const copied = hashSharedFiles(outDir);
   const mismatched = SHARED_FILES.filter((rel) => copied[rel] !== lock.files[rel]);
   if (mismatched.length) {
@@ -22463,7 +22567,7 @@ async function runAssetNew(options) {
     return 1;
   }
   await fsp.writeFile(
-    path29.join(outDir, PARITY_FILENAME),
+    path30.join(outDir, PARITY_FILENAME),
     JSON.stringify(
       {
         note: "Recorded by `genex asset new`. Gate G13 recomputes these; do not hand-edit the viewer.",
@@ -22507,10 +22611,10 @@ async function runAssetNew(options) {
 }
 
 // src/commands/tools.ts
-import path31 from "path";
+import path32 from "path";
 
 // src/commands/doctor.ts
-import path30 from "path";
+import path31 from "path";
 var LANE_ORDER = [
   "model",
   "image",
@@ -22791,7 +22895,7 @@ async function fetchLegalStatus(apiUrl, token) {
 }
 async function firstSkillsMarker() {
   for (const target of resolveAgentTargets()) {
-    const marker = await readSkillsMarker(path30.join(target.baseDir, "skills"));
+    const marker = await readSkillsMarker(path31.join(target.baseDir, "skills"));
     if (marker) return marker;
   }
   return null;
@@ -22842,8 +22946,8 @@ async function runTools(opts) {
   let totalNew = 0;
   let totalUpdated = 0;
   for (const t of targets) {
-    const dest = path31.join(t.baseDir, "skills");
-    const { copied, updated } = await copyTemplates(path31.join(templatesDir, "skills"), dest, {
+    const dest = path32.join(t.baseDir, "skills");
+    const { copied, updated } = await copyTemplates(path32.join(templatesDir, "skills"), dest, {
       filter: (rel) => skillFamilyFilter("tools")(`skills/${rel}`)
     });
     await pruneRemovedSkills(dest, log);