@genex-ai/cli-demo 0.66.0-dev.163 → 0.67.0-dev.167

package/README.md

@@ -22,6 +22,7 @@ genex character finalize <preview-id> --user-approved --approve-remesh 10000
 genex character animate <id> --action <action-id>  # add a same-rig Meshy action
 genex animations search "<intent>" --json           # search the committed Meshy catalog locally
 genex wait <id>            # attach to a --no-wait generation and print its URL(s) when done
+genex wait --all           # one status line per generation this project enqueued — never blocks, never bills
 genex controller <type>    # character|car|drone|touch|networked-physics → src/controllers/ (touch = the standalone mobile-input kit)
 genex controller character --character <id>  # install the Meshy-native adapter + manifest
 genex controller anims <sel…>  # download extra character animation clips (by tag or name) → public/assets/anims/

package/dist/index.js

@@ -2156,7 +2156,7 @@ var UNPICKED_AFTER_MS = 15 * 60 * 1e3;
 async function detectGenerationAudit(cwd = process.cwd()) {
   const ledger = await readLedger(cwd);
   const audited = ledger.filter((e) => WIRED_BY_URL.has(e.kind));
-  if (audited.length === 0) return { unwired: [], unpicked: [] };
+  if (audited.length === 0) return { unwired: [], unpicked: [], unresolved: [], deadWired: [] };
   let haystack = "";
   const read = async (file) => {
     try {
@@ -2189,14 +2189,21 @@ async function detectGenerationAudit(cwd = process.cwd()) {
     prompt
   });
   const now = Date.now();
+  const stale = (e) => e.status === "queued" && now - Date.parse(e.queuedAt) > UNPICKED_AFTER_MS;
   return {
     unwired: audited.filter((e) => e.status === "completed" && !haystack.includes(e.id)).map(ref),
-    // An id already referenced in the game was obviously picked up — a stale
-    // "queued" record (e.g. `genex wait` ran from another directory) must not
-    // nag about an asset that's wired in and working.
-    unpicked: audited.filter(
-      (e) => e.status === "queued" && !haystack.includes(e.id) && now - Date.parse(e.queuedAt) > UNPICKED_AFTER_MS
-    ).map(ref)
+    unpicked: audited.filter((e) => stale(e) && !haystack.includes(e.id)).map(ref),
+    // Wired in but never picked up: the deterministic URL let the agent wire
+    // the asset before it finished, so nobody ever learned whether it DID
+    // finish — a provider-side failure (credits, moderation) leaves a dead URL
+    // that renders as a silently missing asset. Kept separate from `unpicked`
+    // because the fix is a status check, not wiring.
+    unresolved: audited.filter((e) => stale(e) && haystack.includes(e.id)).map(ref),
+    // Known-failed AND still wired: the worst case, and it must keep firing
+    // AFTER the status check converges the ledger to "failed" (otherwise the
+    // audit self-erases the moment the agent runs the recommended command and
+    // the dead URL ships silently anyway).
+    deadWired: audited.filter((e) => e.status === "failed" && haystack.includes(e.id)).map(ref)
   };
 }
 async function detectFeatures(log, cwd = process.cwd()) {
@@ -2238,7 +2245,17 @@ function generationNudges(log, g) {
   const describe = (refs) => refs.map((r) => `${r.kind} ${r.id} ("${r.prompt.slice(0, 48)}")`).join("; ");
   if (g.unpicked.length) {
     log.warn(
-      `${g.unpicked.length} generation(s) enqueued 15+ minutes ago were never picked up: ${describe(g.unpicked)}. Run npx genex wait <id> on each \u2014 landed assets get wired in before the last push of a session, never parked for "later".`
+      `${g.unpicked.length} generation(s) enqueued 15+ minutes ago were never picked up: ${describe(g.unpicked)}. Run npx genex wait <id> on each (npx genex wait --all shows every status at once) \u2014 landed assets get wired in before the last push of a session, never parked for "later".`
+    );
+  }
+  if (g.unresolved.length) {
+    log.warn(
+      `${g.unresolved.length} generation(s) are wired into the game but were never picked up, so their real status is unknown: ${describe(g.unresolved)}. A generation that failed server-side (credits, moderation) leaves a dead URL \u2014 the asset just silently never appears. One call checks them all: npx genex wait --all.`
+    );
+  }
+  if (g.deadWired.length) {
+    log.warn(
+      `${g.deadWired.length} FAILED generation(s) are still wired into the game: ${describe(g.deadWired)}. Those URLs will never exist \u2014 each asset silently never appears. Replace the wiring or re-generate (that bills a new one), and tell the user what changed.`
     );
   }
   if (g.unwired.length) {
@@ -2273,6 +2290,43 @@ async function firstPreviewNudge(log, cwd = process.cwd()) {
     "  \u279C Draft page still the placeholder? Ship the first rough build now: npx genex preview \u2014 then keep building."
   );
 }
+async function exploreReuseNudge(log, meta, cwd = process.cwd()) {
+  if (!meta.exploreRanAt || meta.reuseNudgedAt) return;
+  if (await borrowEvidence(meta, cwd)) return;
+  log.warn(
+    "This project browsed the curated catalog (genex explore) but no borrowed catalog project is visible in the game. If the plan mapped systems to the catalog \u2014 grass, terrain, water, vehicles \u2014 land those borrows or cancel each in one plain line to the user: a planned borrow that silently becomes hand-rolled code is a scope cut. The genex-explore skill has the borrow steps."
+  );
+  meta.reuseNudgedAt = (/* @__PURE__ */ new Date()).toISOString();
+  try {
+    const onDisk = await readProject(cwd);
+    if (onDisk) {
+      onDisk.reuseNudgedAt = meta.reuseNudgedAt;
+      await writeProject(onDisk, cwd);
+    }
+  } catch {
+  }
+}
+async function borrowEvidence(meta, cwd) {
+  let host;
+  let ownPath;
+  try {
+    const own = new URL(meta.cloneUrl);
+    host = own.host;
+    ownPath = own.pathname;
+  } catch {
+    return true;
+  }
+  const gitConfig = await fs11.readFile(path12.join(cwd, ".git", "config"), "utf8").catch(() => "");
+  for (const m of gitConfig.matchAll(/url\s*=\s*(\S+)/g)) {
+    try {
+      const u = new URL(m[1]);
+      if (u.host === host && u.pathname !== ownPath) return true;
+    } catch {
+    }
+  }
+  const readme = await fs11.readFile(path12.join(cwd, "README.md"), "utf8").catch(() => "");
+  return readme.includes(host) || /\b(upstream|originally by|ported from|borrowed from)\b/i.test(readme);
+}
 
 // src/commands/publish.ts
 async function runPublish(opts) {
@@ -2309,8 +2363,10 @@ async function runPublish(opts) {
       process.exitCode = 1;
       return;
     }
-    meta.lastDeployAt = (/* @__PURE__ */ new Date()).toISOString();
-    await writeProject(meta);
+    const onDisk = await readProject();
+    const merged = { ...onDisk ?? meta, lastDeployAt: (/* @__PURE__ */ new Date()).toISOString() };
+    await writeProject(merged);
+    meta.lastDeployAt = merged.lastDeployAt;
   } else {
     log.info("Skipping build + deploy (--no-push).");
   }
@@ -2372,6 +2428,7 @@ async function runPreview(opts) {
   }
   const detections = await detectFeatures(log);
   advisoryNudges(log, detections);
+  await exploreReuseNudge(log, meta);
   const apiUrl = getApiUrl(meta.apiUrl);
   const ok = await deployGame(
     { projectId: meta.id, apiUrl, token },
@@ -2395,8 +2452,10 @@ async function runPreview(opts) {
   if (freshStatus && freshStatus !== meta.status) {
     meta.status = freshStatus;
   }
-  meta.lastDeployAt = (/* @__PURE__ */ new Date()).toISOString();
-  await writeProject(meta);
+  const onDisk = await readProject();
+  const merged = { ...onDisk ?? meta, status: meta.status, lastDeployAt: (/* @__PURE__ */ new Date()).toISOString() };
+  await writeProject(merged);
+  meta.lastDeployAt = merged.lastDeployAt;
   const published = meta.status === "published";
   log.plain("");
   if (published) {
@@ -3040,11 +3099,12 @@ function writeJson(value) {
 // src/commands/wait.ts
 var TERMINAL2 = /* @__PURE__ */ new Set(["completed", "failed"]);
 async function runWait(opts) {
+  if (opts.all) return runWaitAll(opts);
   const log = createLogger({ quiet: opts.quiet || opts.json });
   const id = opts.id?.trim();
   if (!id) {
     log.error(
-      `Missing generation id. Usage: ${c.cyan("genex wait <id>")} \u2014 the id printed when you enqueued with --no-wait.`
+      `Missing generation id. Usage: ${c.cyan("genex wait <id>")} \u2014 the id printed when you enqueued with --no-wait. For one status line per generation this project enqueued: ${c.cyan("genex wait --all")}.`
     );
     process.exitCode = 1;
     return;
@@ -3093,6 +3153,109 @@ async function runWait(opts) {
   }
   await awaitAndReport(apiUrl, token, id, kind, log, opts.open, opts.json);
 }
+async function runWaitAll(opts) {
+  const log = createLogger({ quiet: opts.quiet || opts.json });
+  const cwd = opts.cwd ?? process.cwd();
+  const ledger = await readLedger(cwd);
+  if (ledger.length === 0) {
+    log.plain(
+      "No generations recorded for this project yet \u2014 enqueue one (any genex model/image/\u2026 command) and its status shows up here."
+    );
+    return;
+  }
+  const token = opts.token ?? await readUserToken(opts.envPath);
+  if (!token) {
+    log.error("Not authorized. Run `genex init` first to sign in.");
+    process.exitCode = 1;
+    return;
+  }
+  const meta = await readProject(cwd);
+  const apiUrl = getApiUrl(opts.apiUrl ?? meta?.apiUrl);
+  const views = /* @__PURE__ */ new Map();
+  try {
+    const res = await apiFetch(`${apiUrl}/api/generations`, {
+      headers: { Authorization: `Bearer ${token}` }
+    });
+    if (res.status === 401) {
+      log.error("Unauthorized \u2014 your token may have expired. Re-run `genex init`.");
+      process.exitCode = 1;
+      return;
+    }
+    if (res.ok) {
+      const { generations } = await res.json();
+      for (const v of generations) views.set(v.id, v);
+    }
+  } catch {
+    log.dim("  (couldn't reach the API \u2014 showing the local ledger's last known state)");
+  }
+  for (const e of ledger) {
+    if (e.status !== "queued" || views.has(e.id)) continue;
+    try {
+      const res = await apiFetch(`${apiUrl}/api/generations/${e.id}`, {
+        headers: { Authorization: `Bearer ${token}` }
+      });
+      if (res.ok) {
+        const { generation } = await res.json();
+        views.set(e.id, generation);
+      }
+    } catch {
+    }
+  }
+  const rows = [];
+  for (const e of ledger) {
+    rows.push(await toRow(e, views.get(e.id), cwd));
+  }
+  if (opts.json) {
+    writeJson({ generations: rows });
+    return;
+  }
+  log.plain(c.bold("genex wait --all"));
+  log.plain("");
+  for (const r of rows) {
+    const mark = r.status === "done" ? c.green("\u2713") : r.status === "failed" ? c.red("\u2717") : c.yellow("\u2026");
+    const label = r.status === "running" && typeof r.progress === "number" ? `running ${r.progress}%` : r.status;
+    log.plain(`  ${mark} ${label.padEnd(12)} ${r.kind.padEnd(8)} ${r.id}  ${c.dim(`"${r.prompt.slice(0, 56)}"`)}`);
+    if (r.status === "failed" && r.error) log.plain(`      ${c.red(r.error)}`);
+  }
+  const count = (s) => rows.filter((r) => r.status === s).length;
+  log.plain("");
+  log.plain(
+    `  ${count("done")} done \xB7 ${count("running")} running \xB7 ${count("queued")} queued \xB7 ${count("failed")} failed`
+  );
+  if (count("failed") > 0) {
+    log.dim(
+      "  A failed generation never produces its URL \u2014 anything wired to it silently won't appear. Re-plan or re-generate (that bills a new one)."
+    );
+  }
+  if (count("running") + count("queued") > 0) {
+    log.dim(`  Attach to any single one with: ${c.cyan("npx genex wait <id>")}`);
+  }
+}
+async function toRow(e, v, cwd) {
+  const base = { id: e.id, kind: e.kind, prompt: e.prompt, queuedAt: e.queuedAt };
+  if (v) {
+    if (e.status === "queued" && TERMINAL2.has(v.status)) {
+      await recordTerminal(
+        e.id,
+        v.status,
+        v.files?.map((f) => f.url),
+        cwd
+      ).catch(() => {
+      });
+    }
+    switch (v.status) {
+      case "completed":
+        return { ...base, status: "done" };
+      case "failed":
+        return { ...base, status: "failed", error: v.error };
+      case "processing":
+        return { ...base, status: "running", progress: v.progress };
+      default:
+        return { ...base, status: "queued" };
+    }
+  }
+  return { ...base, status: e.status === "completed" ? "done" : e.status === "failed" ? "failed" : "queued" };
+}
 
 // src/commands/controller.ts
 import fs13 from "fs/promises";
@@ -13470,6 +13633,16 @@ async function runExplore(opts) {
   }
   const { items } = await res.json();
   const ranked = query ? rank(items, query).slice(0, 5) : [...items].sort((a, b) => b.playsCount - a.playsCount);
+  if (ranked.length > 0) {
+    try {
+      const meta = await readProject();
+      if (meta && !meta.exploreRanAt) {
+        meta.exploreRanAt = (/* @__PURE__ */ new Date()).toISOString();
+        await writeProject(meta);
+      }
+    } catch {
+    }
+  }
   if (opts.json) {
     console.log(JSON.stringify(ranked, null, 2));
     return;
@@ -14477,6 +14650,9 @@ ${c.bold("Usage")}
   genex wait <id>                    Attach to a generation enqueued with --no-wait and
                                      print its asset URL(s) when it finishes. Safe to
                                      re-run \u2014 it never creates a new generation.
+  genex wait --all                   One status line per generation this project has
+                                     enqueued (done/running/queued/failed) \u2014 a single
+                                     API refresh, never blocks, never bills.
   genex controller <type> [--force]  Install a bundled controller
                                      (character|car|drone|touch|networked-physics)
                                      into src/controllers (+ assets into public/assets).
@@ -14779,6 +14955,9 @@ function parseArgs(argv) {
       case "--json":
         parsed.options.json = true;
         break;
+      case "--all":
+        parsed.options.all = true;
+        break;
       default: {
         if (needsValue.has(arg)) {
           const value = argv[i++];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@genex-ai/cli-demo",
-  "version": "0.66.0-dev.163",
+  "version": "0.67.0-dev.167",
   "description": "Set up your project's agent workspace (.claude/.codex/.cursor in the game folder), authorize, create a game project, generate AI assets, and publish (genex CLI).",
   "type": "module",
   "bin": {

package/templates/skills/genex-explore/SKILL.md

@@ -30,6 +30,13 @@ while a proven grass system sits in the catalog wasted its minutes on a
 solved problem. If the catalog comes back empty on this stand, say so in one
 line and move on — the sweep costs one command either way.
 
+The clone/borrow lines bind at BUILD time too: each stays an open item until
+the borrow lands or you cancel it in one plain line to the user ("build
+fresh, because X" lines are already decided — nothing to re-announce). A
+"borrow the grass system" that quietly ships as hand-rolled cones never went
+through anyone's decision — it's a scope cut. (`genex preview` reminds you
+once if it sees a browsed catalog and zero visible borrows.)
+
 ## When to use again — before any hard system
 
 Later in the build, before hand-writing a hard visual/physics system the plan

package/templates/skills/genex-threejs-game-content/SKILL.md

@@ -25,6 +25,7 @@ line.** The template:
 ```
 CONTENT CONTRACT — <game>
 world:       <size class, as a number: one arena | a district (~500 m) | open world (km-class — $genex-threejs-open-world)>
+ground:      <the terrain as a DECISION: flat plane | rolling relief | heightfield; water: none | river/lake/sea>
 locations:   <N, named: village, crypt, bandit camp, watchtower, boss lair…>
 quests:      <N total — a main chain of M gated steps + side quests; each giver named>
 NPCs:        <N speaking (quest givers, merchants) + M flavor villagers>
@@ -58,6 +59,18 @@ Rules that make the contract real:
   of terrain, grass, water, vehicles, combat feel, buildings, dungeons exist
   there to clone or borrow with credits (`$genex-explore` has the steps). One
   reuse line per matched system; an empty catalog is a one-line note.
+- **The sweep binds at build time, not just plan time.** Every clone/borrow
+  line stays an open item until it is either landed or cancelled out loud:
+  when that system comes up for real work — in v0 or any upgrade round — load
+  `$genex-explore` and follow its borrow steps, or tell the user in one line
+  why you're now building it fresh after all. A planned borrow that silently
+  turns into hand-rolled primitives is a scope cut like any other. (A "build
+  fresh, because X" line was decided at plan time — no re-announcement.)
+- **The `ground:` line is a decision, not a default.** Flat is fine when
+  DECIDED — but the concept frame the user approved is a promise: if it shows
+  rolling hills or a shoreline and the game ships a flat plane, that visible
+  gap goes through one plain line to the user, exactly like any other cut
+  ($genex-threejs-open-world owns real relief when the answer is yes).
 
 ## Data-driven, or you won't finish in one session
 
@@ -192,3 +205,8 @@ owns the authority rules.
 - The contract posted, then quietly abandoned when the first slice previewed
   well — the slice is a milestone, not the destination.
 - Contract lines silently shrunk without a structured question to the user.
+- A reuse line from the sweep ("borrow the grass system from the catalog")
+  silently replaced by hand-rolled primitives — landed or cancelled out loud,
+  never quietly dropped.
+- The approved concept frame shows rolling hills or water; the game ships one
+  flat plane and nobody said so.

package/templates/skills/genex-threejs-skill-router/references/routing-map.md

@@ -39,6 +39,9 @@ Three.js release or branch, and do not blindly copy demo architecture.
    system in the plan (clone as base / borrow parts / build fresh because X);
    hand-building a system the catalog already proves is the waste this sweep
    exists to prevent. An empty catalog is a one-line note, not a blocker.
+   Clone/borrow lines bind at build time too: each is landed or cancelled out
+   loud when its system gets built — never silently swapped for hand-rolled
+   primitives (build-fresh lines are already decided).
 2. Wire player identity before any boot code: `$genex-threejs-embed-auth` is
    mandatory for every game (`initEmbed(...)` + the `waitForPlayer()` gate) —
    saves, leaderboards, and multiplayer auth all come from it.