Skills audit fixes: BOMs, mojibake, merge contradiction, retire jgengine-procedural, unify skill lists

.claude/skills/game/SKILL.md

@@ -1,16 +1,16 @@
----
+---
 name: game
-description: Alias — build a game to harvest engine gaps. Use harvest-game for a minimal probe or harvest-full-game for a full build. Invoke with a game name ("like <game>"), a genre, or nothing to have one picked.
+description: Alias — build a game to harvest engine gaps. Use harvest-game for a minimal probe or harvest-full-game for a full build. Invoke with a game name ("like <game>"), a genre, or nothing to have one picked.
 disable-model-invocation: true
 ---
 
-# game — alias
+# game — alias
 
 This skill is a thin redirect. Pick the real one by scope:
 
-- **`harvest-game`** — build a minimal playable slice to probe the engine surface for gaps. Use this for a quick harvest.
-- **`harvest-full-game`** — build the whole game from the compact `jgengine` intake and routed API domains. Use this when you want the deep gaps only a full build reaches.
+- **`harvest-game`** — build a minimal playable slice to probe the engine surface for gaps. Use this for a quick harvest.
+- **`harvest-full-game`** — build the whole game from the compact `jgengine` intake and routed API domains. Use this when you want the deep gaps only a full build reaches.
 
-Both run the same loop (research → build → track gaps → verify per `jgengine-verify` → file `[FEATURE]` issue(s) → push, PR, merge). Invoke the one that matches your scope; do not follow this file directly.
+Both run the same loop (research → build → track gaps → verify per `jgengine-verify` → file `[FEATURE]` issue(s) → push, PR, subscribe — never merge; the user merges). Invoke the one that matches your scope; do not follow this file directly.
 
 

.claude/skills/harvest-full-game/SKILL.md

@@ -1,28 +1,28 @@
----
+---
 name: harvest-full-game
 description: Run the full game loop end to end at full scope - research a game, build the WHOLE game from the jgengine intake and selectively routed API domains, track engine gaps, and file them as [FEATURE] issues.
 disable-model-invocation: true
 ---
 
 # The harvest-full-game loop
 
-Same harvest as `harvest-game` — build a game, harvest the engine gaps it exposes — but the deliverable is the **complete game**, not a minimal slice. Building the whole thing surfaces the deep gaps a slice never reaches: economy, progression, quests, multiplayer sync, content-scale generators. If you only want a quick probe, use `harvest-game` instead.
+Same harvest as `harvest-game` — build a game, harvest the engine gaps it exposes — but the deliverable is the **complete game**, not a minimal slice. Building the whole thing surfaces the deep gaps a slice never reaches: economy, progression, quests, multiplayer sync, content-scale generators. If you only want a quick probe, use `harvest-game` instead.
 
 Take the invocation argument and resolve a target game:
 
-- **A specific game named** → that's the target. Research it.
-- **A link (repo or game page)** → that's the target, and the link is its spec. Read it for mechanics, every signature system, camera, controls, and content breadth — it is a research source, never a port source. Build fresh from the engine surface; translating its code line-by-line faithfully recreates its workarounds and hides exactly the gaps this loop exists to expose. Even when the user explicitly asks for a 1:1 port of an open-source game, the same rule holds: copy its behavior and data (numbers, tables, layouts, palettes, formulas, feel) and, where the license allows, its assets — never its functions, custom renderers, or workaround systems; rebuild on engine seams, and file the gap when a seam is missing.
-- **A genre** → pick a well-known game in that genre whose full-scope mechanics stress engine areas no existing `Games/*` game already covers.
-- **Nothing / "find one"** → web-research currently popular or recently viral games and pick one the engine can't obviously do yet. Prefer games whose defining mechanic looks missing from the engine surface.
+- **A specific game named** → that's the target. Research it.
+- **A link (repo or game page)** → that's the target, and the link is its spec. Read it for mechanics, every signature system, camera, controls, and content breadth — it is a research source, never a port source. Build fresh from the engine surface; translating its code line-by-line faithfully recreates its workarounds and hides exactly the gaps this loop exists to expose. Even when the user explicitly asks for a 1:1 port of an open-source game, the same rule holds: copy its behavior and data (numbers, tables, layouts, palettes, formulas, feel) and, where the license allows, its assets — never its functions, custom renderers, or workaround systems; rebuild on engine seams, and file the gap when a seam is missing.
+- **A genre** → pick a well-known game in that genre whose full-scope mechanics stress engine areas no existing `Games/*` game already covers.
+- **Nothing / "find one"** → web-research currently popular or recently viral games and pick one the engine can't obviously do yet. Prefer games whose defining mechanic looks missing from the engine surface.
 
 Then run the whole loop in this session:
 
 1. **Research.** Learn the target well enough to fill `jgengine`'s short numbered intake: POV, world, core loop, interaction, combat, progression, players, UI, art direction, and an observable done scenario. Keep the game profile in working notes only.
-2. **Work on your session's branch**, per the root workflow — the PR comes later, when the game is real.
+2. **Work on your session's branch**, per the root workflow — the PR comes later, when the game is real.
 3. **Build the whole game** in `Games/<id>`. Fill the compact `jgengine` intake (the main skill is the foundation), read only the selected domain skills, then build straight through. Keep every system end-to-end, hit content breadth combinatorially, and dress the world. Build from documented engine surfaces, not copied game code.
-4. **Track gaps the moment you hit them** in your working notes — one raw engine problem per line, engine terms only, no game context, no solutions. The bar is not "the engine couldn't do it" — friction is a gap too: anything the game had to hand-roll that should be a natural engine primitive or one-liner. Tag each line `blocker` (no engine-surface route existed), `workaround` (a route existed but the game had to hand-roll something the engine should own), or `ergonomics` (it worked but took boilerplate a primitive would erase). A gap you hit while building outranks a gap you suspect from reading; note both, but only after genuinely attempting the engine-surface route. Note: `jgengine`'s "Engine gaps" section says to fix a truly-missing primitive directly in this repo — for a harvest run, prefer logging the gap over closing it inline unless the fix is small and unblocks the phase, so the [FEATURE] list stays the record of what a full build actually exposed.
-5. **Verify** per the intake's observable done scenario and the `jgengine-verify` skill: `bun run check-types`, `bun test packages Games` (including the co-located `<game>.world.test.ts` `summarizeEnvironment` assertions for every `environment()` world), then `bun run shoot <id> --mode ui` and `--mode play` as the final human glance — open the PNGs and actually look at them. A hung shot is never re-run in the foreground; the world test is what proves the scene resolved.
-6. **Session end.** File the gaps as `[FEATURE]` issue(s) on this repo — title `[FEATURE] <brief summary>`, body a numbered list of the raw engine problems, each carrying its `blocker` / `workaround` / `ergonomics` tag (nothing else, no game context, no solutions). Then ship per CLAUDE.md's ship rule: push, open the PR (GitHub MCP `create_pull_request`, ready for review), `subscribe_pr_activity`, confirm the PR's checks go green — never merge; the user merges on request.
+4. **Track gaps the moment you hit them** in your working notes — one raw engine problem per line, engine terms only, no game context, no solutions. The bar is not "the engine couldn't do it" — friction is a gap too: anything the game had to hand-roll that should be a natural engine primitive or one-liner. Tag each line `blocker` (no engine-surface route existed), `workaround` (a route existed but the game had to hand-roll something the engine should own), or `ergonomics` (it worked but took boilerplate a primitive would erase). A gap you hit while building outranks a gap you suspect from reading; note both, but only after genuinely attempting the engine-surface route. Note: `jgengine`'s "Engine gaps" section says to fix a truly-missing primitive directly in this repo — for a harvest run, prefer logging the gap over closing it inline unless the fix is small and unblocks the phase, so the [FEATURE] list stays the record of what a full build actually exposed.
+5. **Verify** per the intake's observable done scenario and the `jgengine-verify` skill: `bun run check-types`, `bun test packages Games` (including the co-located `<game>.world.test.ts` `summarizeEnvironment` assertions for every `environment()` world), then `bun run shoot <id> --mode ui` and `--mode play` as the final human glance — open the PNGs and actually look at them. A hung shot is never re-run in the foreground; the world test is what proves the scene resolved.
+6. **Session end.** File the gaps as `[FEATURE]` issue(s) on this repo — title `[FEATURE] <brief summary>`, body a numbered list of the raw engine problems, each carrying its `blocker` / `workaround` / `ergonomics` tag (nothing else, no game context, no solutions). Then ship per CLAUDE.md's ship rule: push, open the PR (GitHub MCP `create_pull_request`, ready for review), `subscribe_pr_activity`, confirm the PR's checks go green — never merge; the user merges on request.
 
 Because a full build may span sessions, hand off the numbered intake, completed work, and running gap list when needed. File issues only after the game is complete.
 

.claude/skills/harvest-game/SKILL.md

@@ -1,4 +1,4 @@
----
+---
 name: harvest-game
 description: Run the full game loop end to end - research a game, build a minimal version in Games/, track engine gaps as you hit them, and file them as [FEATURE] issue(s) at session end. Invoke with a game name ("like <game>"), a genre, a link (repo or game page), or nothing to have one picked.
 disable-model-invocation: true
@@ -8,19 +8,19 @@ disable-model-invocation: true
 
 Build a game, harvest the engine gaps it exposes. Take the invocation argument and resolve a target game:
 
-- **A specific game named** → that's the target. Research it.
-- **A link (repo or game page)** → that's the target, and the link is its spec. Read it for mechanics, systems, camera, controls, and content scope — it is a research source, never a port source. Build fresh from the engine surface; translating its code line-by-line faithfully recreates its workarounds and hides exactly the gaps this loop exists to expose. Even when the user explicitly asks for a 1:1 port of an open-source game, the same rule holds: copy its behavior and data (numbers, tables, layouts, palettes, formulas, feel) and, where the license allows, its assets — never its functions, custom renderers, or workaround systems; rebuild on engine seams, and file the gap when a seam is missing.
-- **A genre** → pick a well-known game in that genre whose core mechanics stress engine areas no existing `Games/*` game already covers.
-- **Nothing / "find one"** → web-research currently popular or recently viral games and pick one the engine can't obviously do yet. Prefer games whose defining mechanic looks missing from the engine surface.
+- **A specific game named** → that's the target. Research it.
+- **A link (repo or game page)** → that's the target, and the link is its spec. Read it for mechanics, systems, camera, controls, and content scope — it is a research source, never a port source. Build fresh from the engine surface; translating its code line-by-line faithfully recreates its workarounds and hides exactly the gaps this loop exists to expose. Even when the user explicitly asks for a 1:1 port of an open-source game, the same rule holds: copy its behavior and data (numbers, tables, layouts, palettes, formulas, feel) and, where the license allows, its assets — never its functions, custom renderers, or workaround systems; rebuild on engine seams, and file the gap when a seam is missing.
+- **A genre** → pick a well-known game in that genre whose core mechanics stress engine areas no existing `Games/*` game already covers.
+- **Nothing / "find one"** → web-research currently popular or recently viral games and pick one the engine can't obviously do yet. Prefer games whose defining mechanic looks missing from the engine surface.
 
 Then run the whole loop in this session:
 
-1. **Research.** Web-search the target's core loop, mechanics, camera, controls, win conditions, and HUD until you can describe a minimal playable slice. Keep the game profile in your working notes only — the game's name and genre must never appear in the filed issue or any committed text other than the game's own directory.
-2. **Work on your session's branch**, per the root workflow — the PR comes later, when the game is real.
-3. **Build** a minimal playable version in `Games/<id>` — core loop playable, not a full clone. Minimal never means graybox: the slice carries the target's *identity* — a named aesthetic with a committed palette (ground, sky, UI panel/ink/accent hex values), UI copy in the fantasy's own voice, and an initial camera framing that shows the game at its best — because presentation is where a whole class of engine gaps lives (sky/backdrop, time-of-day lighting, palette seams, camera pose) and none of them surface on a gray plane. Give the slice a timed observable acceptance up front ("run untouched at max speed for five minutes: what does a player actually see?") and judge the final screenshot against it. Wire it as the other `Games/*` do: a private workspace package `@games/<id>` with `./src` exports and no build, plus the standalone dev harness `check-game-shape` enforces (root `index.html` + `vite.config.ts`, `src/index.css` importing `./style.css`, a `"dev": "vite"` script). Games auto-register from `Games/*` in `apps/dev`'s registry and the jgengine.com Games dropdown — no registry entry, vite alias, or `@games` dependency to add by hand. Use the `jgengine` intake and its selectively routed API domains, not by copying other games.
-4. **Track gaps the moment you hit them** in your working notes — one raw engine problem per line, engine terms only, no game context, no solutions. The bar is not "the engine couldn't do it" — friction is a gap too: anything the game had to hand-roll that should be a natural engine primitive or one-liner. Tag each line `blocker` (no engine-surface route existed), `workaround` (a route existed but the game had to hand-roll something the engine should own), or `ergonomics` (it worked but took boilerplate a primitive would erase). A gap you hit while building outranks a gap you suspect from reading; note both, but only after genuinely attempting the engine-surface route.
-5. **Verify** per the `jgengine-verify` ladder — cheapest gate first, browser last: `bun run check-types`, then `bun test packages Games` including the co-located `<game>.world.test.ts` `summarizeEnvironment` assertions for every `environment()` world (this is the scene-correctness gate, not the screenshot), then `bun run shoot <id> --mode ui` and `--mode play` as the final human glance — open the PNGs and actually look at them. A hung shot is never re-run in the foreground; the world test is what proves the scene resolved.
-6. **Session end.** File the gaps as `[FEATURE]` issue(s) on this repo — title `[FEATURE] <brief summary>`, body a numbered list of the raw engine problems, each carrying its `blocker` / `workaround` / `ergonomics` tag (nothing else, no game context, no solutions). Then ship per CLAUDE.md's ship rule: push, open the PR (GitHub MCP `create_pull_request`, ready for review), `subscribe_pr_activity`, confirm the PR's checks go green — never merge; the user merges on request.
+1. **Research.** Web-search the target's core loop, mechanics, camera, controls, win conditions, and HUD until you can describe a minimal playable slice. Keep the game profile in your working notes only — the game's name and genre must never appear in the filed issue or any committed text other than the game's own directory.
+2. **Work on your session's branch**, per the root workflow — the PR comes later, when the game is real.
+3. **Build** a minimal playable version in `Games/<id>` — core loop playable, not a full clone. Minimal never means graybox: the slice carries the target's *identity* — a named aesthetic with a committed palette (ground, sky, UI panel/ink/accent hex values), UI copy in the fantasy's own voice, and an initial camera framing that shows the game at its best — because presentation is where a whole class of engine gaps lives (sky/backdrop, time-of-day lighting, palette seams, camera pose) and none of them surface on a gray plane. Give the slice a timed observable acceptance up front ("run untouched at max speed for five minutes: what does a player actually see?") and judge the final screenshot against it. Wire it as the other `Games/*` do: a private workspace package `@games/<id>` with `./src` exports and no build, plus the standalone dev harness `check-game-shape` enforces (root `index.html` + `vite.config.ts`, `src/index.css` importing `./style.css`, a `"dev": "vite"` script). Games auto-register from `Games/*` in `apps/dev`'s registry and the jgengine.com Games dropdown — no registry entry, vite alias, or `@games` dependency to add by hand. Use the `jgengine` intake and its selectively routed API domains, not by copying other games.
+4. **Track gaps the moment you hit them** in your working notes — one raw engine problem per line, engine terms only, no game context, no solutions. The bar is not "the engine couldn't do it" — friction is a gap too: anything the game had to hand-roll that should be a natural engine primitive or one-liner. Tag each line `blocker` (no engine-surface route existed), `workaround` (a route existed but the game had to hand-roll something the engine should own), or `ergonomics` (it worked but took boilerplate a primitive would erase). A gap you hit while building outranks a gap you suspect from reading; note both, but only after genuinely attempting the engine-surface route.
+5. **Verify** per the `jgengine-verify` ladder — cheapest gate first, browser last: `bun run check-types`, then `bun test packages Games` including the co-located `<game>.world.test.ts` `summarizeEnvironment` assertions for every `environment()` world (this is the scene-correctness gate, not the screenshot), then `bun run shoot <id> --mode ui` and `--mode play` as the final human glance — open the PNGs and actually look at them. A hung shot is never re-run in the foreground; the world test is what proves the scene resolved.
+6. **Session end.** File the gaps as `[FEATURE]` issue(s) on this repo — title `[FEATURE] <brief summary>`, body a numbered list of the raw engine problems, each carrying its `blocker` / `workaround` / `ergonomics` tag (nothing else, no game context, no solutions). Then ship per CLAUDE.md's ship rule: push, open the PR (GitHub MCP `create_pull_request`, ready for review), `subscribe_pr_activity`, confirm the PR's checks go green — never merge; the user merges on request.
 
 Finish by reporting: what was built and where, the issue link(s), and how many gaps were filed.