evomeme 0.1.9 → 0.1.10-beta.13

package/dist/skills/en-US/game-audio/SKILL.md

@@ -0,0 +1,121 @@
+---
+name: game-audio
+description: Connect hosted BGM / SFX to Phaser / Three.js runtime configuration, or generate new BGM via MCP when CDN tracks are not enough. Use when the game needs CDN/TOS audio URLs, configuration binding, loader integration, or AI-generated looping music.
+---
+
+# Game Audio
+
+## Overview
+
+Use this skill for game audio already hosted on a CDN or object storage, and for generating new looping BGM / optional vocal tracks via MCP when the catalog is not enough. Compose or obtain loadable audio URLs, then write them into `public/config.json` or the runtime loader.
+
+**SFX are not generated here.** Short sound effects still come from the CDN catalog (or a user-provided URL). Do not invent CDN paths; if an object key is missing and the user has not provided a URL, stop and ask.
+
+The BGM and SFX catalogs use `http://game-asset.evomeme.com/`. Compose each URL with the `bgm/` or `sfx/` prefix and the encoded filename from the corresponding reference. Choose verified tracks from the catalogs and confirm that audio URLs are accessible before adding them to the runtime.
+
+## When To Use This Skill
+
+- A design document, configuration file, or the user specifies the filename/key of a BGM or SFX track and a loadable URL is needed
+- Filling audio fields such as `bgm_main`, `audio_bgm_gameplay`, `audio_sfx_click`, `backgroundMusic`, `src`, `url`
+- The user explicitly says the audio comes from the company CDN, object storage, or a fixed hosted URL
+- Integrating game feedback sound effects such as click, pickup, collision, shooting, explosion, success/failure sounds
+- The user needs a **new** looping BGM or theme that is not in the CDN catalog (use MCP music generation below)
+
+---
+
+## Reading Order
+
+1. After reading this section, choose and **open the corresponding reference document** according to the task type; do not compose CDN URLs without reading the reference
+2. **BGM (looping background music)** from CDN: `references/bgm-cdn.md`
+3. **SFX (short triggered sound effects)**: `references/sfx-cdn.md`
+4. When both BGM and SFX are involved, read both references
+5. When generating a new track, follow **Generate BGM via MCP** below, then write the returned TOS URL into config using the same workflow as hosted URLs
+
+---
+
+## BGM Routing
+
+- Load the BGM reference document and extract the CDN root, path prefix, and track catalog from it
+- Used for looping background music, with configuration keys such as `bgm_main`, `audio_bgm_gameplay`, `audio_bgm_menu`, `backgroundMusic`
+- When a track is not in the catalog and the user wants a hosted key, do not invent a path; ask the user to confirm the object key before configuring it
+- When the user wants a **new** AI track instead of a catalog entry, use MCP generation (below)
+
+Recommended skill: `game-audio`; BGM reference `references/bgm-cdn.md`.
+
+## SFX Routing
+
+- Load `references/sfx-cdn.md` and extract the CDN root and filename rules
+- Used for short triggered sound effects, with configuration keys such as `audio_sfx_click`, `audio_sfx_pickup`, `audio_sfx_impact`, `audio_sfx_shoot`, `audio_sfx_explosion`, `audio_sfx_success`, `audio_sfx_fail`
+- High-frequency triggered sound effects (footsteps, dragging, continuous collisions) are handled through throttling or looping playback, not retriggered every frame
+
+Recommended skill: `game-audio`; SFX reference `references/sfx-cdn.md`.
+
+---
+
+## Generate BGM via MCP
+
+Use `evomeme_generate_game_music` when the game needs a new looping BGM or optional vocal track that is not in the CDN catalog.
+
+1. Pass the absolute workspace root as `workspace_dir`.
+2. On success the tool downloads audio under `<workspace_dir>/assets/music/` and returns a TOS URL.
+3. Write the TOS URL into config / loader the same way as a CDN URL. Runtime must not hardcode imports from `assets/music/`.
+
+Default is **instrumental** (`is_instrumental=true`), suitable for menu / combat / exploration loops.
+
+### Inputs
+
+| Parameter | Required | Description |
+| --- | --- | --- |
+| `prompt` | Yes | Style, mood, and scene |
+| `is_instrumental` | No | Default `true`. When instrumental, do not set `lyrics` or enable `lyrics_optimizer` |
+| `lyrics` | No | Lyrics for vocal tracks; structure tags such as `[Verse]` / `[Chorus]` are allowed |
+| `lyrics_optimizer` | No | For vocal tracks without lyrics, auto-write lyrics from the prompt |
+| `aigc_watermark` | No | Default `false` |
+| `music_model` | No | Only `music-3.0` |
+| `workspace_dir` | Yes (in practice) | Absolute workspace root |
+| `client_operation_id` | No | Local task ID: 1–140 letters, digits, underscores or hyphens; reuse it and the same parameters for recovery |
+
+Vocal track: set `is_instrumental=false`, and provide `lyrics` **or** `lyrics_optimizer=true`.
+
+### Outputs (text)
+
+- `job_id`, `tos_url` / `asset_url`, `local_path`, `mime_type`, `bytes`, `status`, `model`, `is_instrumental`
+- `client_operation_id`, `task_id`, `operation_id`, `asset_id`, `kind=audio` identify the local task, step and audio asset
+
+Prefer supplying and saving `client_operation_id` on the first call. Disconnecting does not cancel a running worker. After polling or download is interrupted, call again with the same ID, workspace and parameters to reuse the original task. Completed tasks return their saved result. A new ID starts a new generation; inspect the error before creating a replacement for `NEEDS_ATTENTION` (unknown submission outcome) or `FAILED`. With all processes stopped, recovery requires another call or starting the workspace task scheduler.
+
+---
+
+## Workflow
+
+1. Confirm the task type: hosted BGM, hosted SFX, generate BGM, or a mix
+2. For hosted audio: read the corresponding reference and extract the CDN root, required prefix, and filename rules; find the exact object key; compose the full URL using the listed root
+3. For generated BGM: call `evomeme_generate_game_music` with `workspace_dir`, then use the returned TOS URL
+4. Write the URL into the corresponding configuration key, manifest, or runtime loading code, preserving the project's existing audio architecture
+5. Verify control flags: BGM obeys `audio_music_enabled`, SFX obeys `audio_sfx_enabled`; in-game loops do not leak into the menu or results page
+
+### Writing 2D Project Configuration (`public/config.json`)
+
+```json
+"bgm_main":   { "value": "http://game-asset.evomeme.com/bgm/2048.mp3", "type": "audio", "label": "Background Music" },
+"sfx_click":  { "value": "http://game-asset.evomeme.com/sfx/%E7%82%B9%E5%87%BB.mp3", "type": "audio", "label": "Click Sound Effect" }
+```
+
+### Writing 3D Project Configuration
+
+Write according to the project's existing configuration structure; config key names follow the `audio_bgm_*` / `audio_sfx_*` naming convention.
+
+---
+
+## Guardrails
+
+- Do not invent filenames, CDN domains, directory prefixes, or percent-encoded fragments
+- Do not silently swap the root paths for BGM and SFX
+- Do not generate SFX with the music MCP tool; SFX stay on the CDN catalog or user-provided URLs
+- Runtime loaders use the hosted audio URL from the catalog or MCP result
+- When the object key is missing or the user has not provided a full URL (and generation was not requested), stop and require the user to provide it or update the reference; do not guess
+
+## References
+
+- BGM CDN catalog: `references/bgm-cdn.md`
+- SFX CDN catalog: `references/sfx-cdn.md`

package/dist/skills/en-US/game-audio/agents/openai.yaml

@@ -0,0 +1,4 @@
+interface:
+  display_name: "Game Audio"
+  short_description: "Wire hosted or MCP-generated BGM/SFX into game config and playback"
+  default_prompt: "Please use $game-audio to choose or generate suitable background music and sound effects for my game, and integrate them into the existing configuration and playback flow."

package/{skills → dist/skills/en-US}/game-audio/references/bgm-cdn.md

@@ -1,20 +1,16 @@
 # BGM CDN And URL Catalog
 
-This file is the authoritative source for hosted background-music routing. Read `../SKILL.md` first, then use this reference to compose final HTTPS URLs for tracks stored under the BGM bucket path.
+This file is the authoritative source for hosted background-music routing. Read `../SKILL.md` first, then use this reference to compose final audio URLs for tracks stored under the BGM bucket path.
 
-## CDN Roots
+## CDN Root
 
-Primary public CDN root:
+Production public CDN root:
 
 ```text
-https://vibe-writing-dev-public.tos-cn-beijing.volces.com/
+http://game-asset.evomeme.com/
 ```
 
-Secondary root that may be used only when the user explicitly provides a full URL or confirms that a track lives there:
-
-```text
-https://ppy-test.tos-cn-beijing.volces.com/
-```
+Use this root for every catalog entry.
 
 ## Required Prefix
 
@@ -47,7 +43,7 @@ bgm/
 
 ## Track Catalog
 
-Final URL = `https://vibe-writing-dev-public.tos-cn-beijing.volces.com/bgm/` + filename fragment below unless the user explicitly confirms the secondary CDN root.
+Final URL = `http://game-asset.evomeme.com/bgm/` + filename fragment below.
 
 | Object key | Filename fragment |
 | --- | --- |
@@ -84,7 +80,7 @@ Final URL = `https://vibe-writing-dev-public.tos-cn-beijing.volces.com/bgm/` + f
 | `吃分避障.mp3` | `%E5%90%83%E5%88%86%E9%81%BF%E9%9A%9C.mp3` |
 | `合成大西瓜1.mp3` | `%E5%90%88%E6%88%90%E5%A4%A7%E8%A5%BF%E7%93%9C1.mp3` |
 | `合成大西瓜2.mp3` | `%E5%90%88%E6%88%90%E5%A4%A7%E8%A5%BF%E7%93%9C2.mp3` |
-| `哈吉米南北绿豆.mp3` | `%E5%93%88%E5%9F%BA%E7%B1%B3%E5%8D%97%E5%8C%97%E7%BB%BF%E8%B1%86.mp3` |
+| `哈基米南北绿豆.mp3` | `%E5%93%88%E5%9F%BA%E7%B1%B3%E5%8D%97%E5%8C%97%E7%BB%BF%E8%B1%86.mp3` |
 | `场景模拟对话1.mp3` | `%E5%9C%BA%E6%99%AF%E6%A8%A1%E6%8B%9F%E5%AF%B9%E8%AF%9D1.mp3` |
 | `场景模拟对话2.mp3` | `%E5%9C%BA%E6%99%AF%E6%A8%A1%E6%8B%9F%E5%AF%B9%E8%AF%9D2.mp3` |
 | `塔防.mp3` | `%E5%A1%94%E9%98%B2.mp3` |

package/{skills → dist/skills/en-US}/game-audio/references/sfx-cdn.md

@@ -1,17 +1,19 @@
 # SFX CDN And URL Catalog
 
-This file is the authoritative source for hosted sound-effect routing. Read `../SKILL.md` first, then use this reference to compose final HTTPS URLs for short feedback audio stored under the SFX bucket path.
+This file is the authoritative source for hosted sound-effect routing. Read `../SKILL.md` first, then use this reference to compose final audio URLs for short feedback audio stored under the SFX bucket path.
 
 This catalog is for audio feedback only. Do not use it for canvas particles, trails, sparks, or other visual VFX implementations.
 
 ## CDN Root
 
-Public CDN root:
+Production public CDN root:
 
 ```text
-https://ppy-test.tos-cn-beijing.volces.com/
+http://game-asset.evomeme.com/
 ```
 
+Use this root for every catalog entry.
+
 ## Required Prefix
 
 All hosted gameplay and UI sound effects live under:
@@ -39,7 +41,7 @@ sfx/
 
 ## Sound Catalog
 
-Final URL = `https://ppy-test.tos-cn-beijing.volces.com/sfx/` + filename fragment below.
+Final URL = `http://game-asset.evomeme.com/sfx/` + filename fragment below.
 
 | Object key | Filename fragment |
 | --- | --- |

package/dist/skills/en-US/game-character-view-generator/SKILL.md

@@ -0,0 +1,110 @@
+---
+name: game-character-view-generator
+description: Generate character four-view or eight-direction sheets through MCP from an existing reference, reusing supplied four views or generating them automatically. Use to preserve appearance, clothing and style across views. Use their respective tools for ordinary image generation, cutout or animation.
+---
+
+# Character Four Views and Eight Directions
+
+## Choose the Capability
+
+| Tool | Action and generated output | When to use |
+| --- | --- | --- |
+| `evomeme_generate_four_view` (Character Four Views) | Generate one 3024×1296 sheet containing front, back, left-side and right-side views of the reference character; save it under `assets/`. | Complete a character design, inspect clothing and body surfaces, or prepare a reference for eight directions. |
+| `evomeme_generate_eight_direction` (Character Eight Directions) | Generate one 2048×2048 sheet in a 3×3 grid, containing eight gameplay orientations and a blank center, from a character reference and optional four views; save it under `assets/`. | Prepare appearances for a character that moves or turns in eight directions. |
+
+## What Four Views Mean
+
+Four views show the same character from four observation positions:
+
+| View | Observation position | Visible features |
+| --- | --- | --- |
+| Front | In front of the character, looking toward it | Face, chest and front of clothing. |
+| Back | Behind the character, looking toward it | Back of the head, body and clothing. |
+| Left side | On the character's own left | Left-side silhouette and equipment. |
+| Right side | On the character's own right | Right-side silhouette and equipment. |
+
+Left and right mean the **character's own sides**, not the sides of the image. Preserve design, proportions, clothing and style across views. These describe appearance, not four consecutive actions. The shared prompt requests these four views without specifying fixed cells or ordering; inspect the actual image before locating views. Output is one sheet, not four separate files.
+
+## What Eight Directions Mean
+
+An eight-direction sheet shows up, up-right, right, down-right, down, down-left, left and up-left. Directions use **game screen coordinates**: up is the top of the screen, down is the bottom, and left/right are its sides. They describe where the character faces, not where its cell is positioned.
+
+| Facing direction | Meaning |
+| --- | --- |
+| Down ↓ | Toward the bottom of the screen; mainly the character's front is visible. |
+| Down-right ↘ | Toward the lower right; front and side are visible. |
+| Down-left ↙ | Toward the lower left; front and the other side are visible. |
+| Right → | Toward the right edge; a side view. |
+| Left ← | Toward the left edge; the other side view. |
+| Up-right ↗ | Toward the upper right; back and side are visible. |
+| Up ↑ | Toward the top of the screen; mainly the character's back is visible. |
+| Up-left ↖ | Toward the upper left; back and the other side are visible. |
+
+The prompt shared with the canvas requests this 3×3 arrangement. **Cell position does not indicate facing direction**:
+
+| Left column | Middle column | Right column |
+| --- | --- | --- |
+| Down-right ↘ | Down ↓ | Down-left ↙ |
+| Right → | Blank | Left ← |
+| Up-right ↗ | Up ↑ | Up-left ↖ |
+
+Output is one directional sheet, not eight separate images or eight animation frames. Keep the same character, proportions and style in all cells. The reference and prompt determine the top-down or oblique viewing angle. The tool does not split the sheet; inspect generated directions and layout as needed.
+
+## Prepare References for Both Tools
+
+Before invoking either the four-view or eight-direction MCP tool, you MUST ensure the character reference and any supplied four-view sheet are under this workspace's `assets/`. Locate readable files for uploaded attachments, conversation images and images in other directories, then copy them into `assets/` or a subdirectory. Download accessible image URLs first. Verify the copied files exist and are readable. Use new filenames for conflicting names with different content to avoid overwriting assets. If the actual file cannot be obtained, explain the missing source and stop that call; do not invent paths or IDs.
+
+Reuse images already under this workspace's `assets/`, and reuse returned `asset_id` for generated images. An asset ID is the path relative to the workspace root: `D:/my-game/assets/references/hero.png` maps to `assets/references/hero.png`. Pass the character image ID as `character_reference_id`, a supplied four-view ID as `four_view_id`, and explicitly pass the same absolute workspace root as `workspace_dir`. Do not pass original attachment absolute paths or URLs in ID fields. This preserves provenance between workspace assets so the canvas can display dependency connections.
+
+## Four-View MCP
+
+| Parameter | Required | Description |
+| --- | --- | --- |
+| `character_reference_id` | Yes | One character reference image asset ID, not a remote URL or absolute path. |
+| `prompt` | No | Additional appearance, clothing, material, proportion and style requirements. |
+| `model` | No | `asset-max`, `asset-pro` or `asset-lite`; default `asset-max`. |
+| `background_color` | No | Background in `#RRGGBB` format; default `#ff00ff`. |
+| `transparent_background` | No | Default `false`; `true` requires `asset-max`. |
+| `workspace_dir` | No | Absolute current workspace root; pass it explicitly. |
+
+Size is fixed at `3024x1296`; do not pass `size`. The shared canvas image function constructs the four-view layout prompt. Focus additional instructions on character features to preserve, without requesting unrelated characters, animation frames or extra views.
+
+```json
+{
+  "character_reference_id": "assets/hero.png",
+  "prompt": "Preserve the reference character's silver armor, red cape, proportions and art style",
+  "model": "asset-max",
+  "transparent_background": true,
+  "workspace_dir": "D:/my-game"
+}
+```
+
+The tool waits for completion and saves one four-view sheet under workspace `assets/`. It returns text metadata including `asset_id`, `local_path`, `mime_type`, `job_id`, `asset_url`/`tos_url` and status, without image Base64. Record these values and inspect character consistency and complete views with an available IDE image viewer when needed.
+
+The tool does not automatically split, cut out or remove colors. Prefer a supported model and transparency setting when a transparent result is required. Process existing opaque output separately with `evomeme_cutout_game_image`, or `evomeme_color_key` if smart cutout is unavailable. On failure, read the specific error with `isError: true` and retain the reference. Do not blindly resubmit generation after an interrupted status query.
+
+## Eight-Direction MCP
+
+Eight-direction generation creates eight character orientations for gameplay, not an animation sequence. It shares the canvas image workflow and requires one `character_reference_id`. Model, background and workspace parameters match the four-view tool. Output is a fixed `2048x2048` sheet with a 3×3 layout; do not pass `size`. The tool does not automatically split it.
+
+Additional parameters:
+
+| Parameter | Required | Description |
+| --- | --- | --- |
+| `four_view_id` | No | Existing workspace four-view image asset ID; accepts `asset_id` returned by the four-view MCP tool. |
+| `auto_generate_four_view` | No | Default `true`: without supplied four views, generate four views and then eight directions, using two image generation requests. `false` uses the character reference directly. Ignored when `four_view_id` is supplied, preventing redundant four-view generation. |
+
+Prefer reusing existing four views. With only a character reference, invoke the eight-direction tool directly to inherit the default four-view workflow; there is no need to separately call the four-view MCP tool and then enable automatic generation.
+
+```json
+{
+  "character_reference_id": "assets/hero.png",
+  "four_view_id": "assets/four-view.png",
+  "prompt": "Preserve silver armor, red cape and character proportions across directions",
+  "model": "asset-max",
+  "transparent_background": true,
+  "workspace_dir": "D:/my-game"
+}
+```
+
+Results include the final eight-direction `asset_id`, `local_path` and URL, plus `four_view_source` (`provided`, `generated` or `character`). When four views are used, results also include `four_view_asset_id`, `four_view_local_path` and `four_view_asset_url`; automatic generation additionally returns `four_view_job_id`. Intermediate four views and the final sheet are saved under `assets/`, with task records shared by MCP and the canvas. If eight-direction generation fails after four views complete, the intermediate file remains. Check workspace task records or the canvas for its asset ID and supply it as `four_view_id` when continuing, avoiding redundant generation.

package/dist/skills/en-US/game-character-view-generator/agents/openai.yaml

@@ -0,0 +1,7 @@
+interface:
+  display_name: "Character Four Views and Eight Directions"
+  short_description: "Generate character four views or eight-direction sheets"
+  default_prompt: "Use $game-character-view-generator to generate character four views or eight-direction assets, reusing existing four views when available."
+
+policy:
+  allow_implicit_invocation: true

package/dist/skills/en-US/game-demo/SKILL.md

@@ -0,0 +1,103 @@
+---
+name: game-demo
+description: After the game engine and tech stack are clear, read the game design document and prioritize code safety and first-delivery success while building the file structure, code framework, and core systems for the minimal runnable Demo. Code and image generation proceed in parallel; all game image assets must use generated images, and SVG, line drawing, or large solid-color assets are prohibited. Use when creating a game Demo from scratch, turning a design document into the first playable version, or establishing the foundational project for later development.
+---
+
+# Game Demo
+
+## Goal
+
+Read the design document, implement the core gameplay as the minimal game Demo that can start, be played, end, and restart, and establish a clear engineering foundation for later development.
+
+This skill independently completes project setup. Its main outputs are actual project files and a runnable Demo that can continue to be improved. All game image assets are obtained through image generation and connected through a unified asset configuration or loading layer; the first batch of generated assets may be gradually replaced with higher-quality versions in later development.
+
+## Before Starting
+
+First clarify the game engine and tech stack used by the current project.
+
+For an existing project, read the package manifest, lock files, build configuration, entry files, and main dependencies to confirm. For a new project, have the developer confirm the technical choices.
+
+Confirm at least:
+
+- Game engine and version;
+- Programming language;
+- Rendering and UI approach;
+- Build tool and package manager;
+- Target platform, aspect ratio, and input method.
+
+Then read `/project.md` at the project root or the design document file specified by the developer to understand the core gameplay, Demo scope, game objects, controls, win/loss conditions, and the complete flow of one game session.
+
+## First-Delivery Principles
+
+The Demo's first delivery must target successful startup and a complete core loop. Implement only the minimum objects, systems, states, and interfaces needed for the gameplay to work, making every added part directly serve the core experience.
+
+Code safety has the highest priority. Architectural completeness, extensibility, visual presentation, feature count, and technical complexity all defer to the stability of the first delivery. Use mature, direct, and easy-to-debug implementation paths in the current tech stack, keep dependencies lean, keep module responsibilities clear, make state transitions explicit, and provide safety boundaries for loading failures and runtime exceptions.
+
+## Demo Production
+
+Produce the Demo as a complete task. After development begins, prioritize starting generation for the required image assets, and build the file structure, code framework, and core game systems at the same time. When image-generation tools can be called asynchronously, submit generation tasks and then continue code work so both advance in parallel.
+
+### Hard Requirements For Image Assets
+
+- The Demo must not contain any SVG assets, including SVG files, inline SVG, and `data:image/svg+xml`.
+- Do not use Canvas/Phaser/CSS lines, geometric outlines, or procedural drawing to impersonate game image assets such as characters, scenes, props, icons, or effects.
+- Do not use large solid-color blocks or solid-color backgrounds as formal game assets or visual placeholders.
+- All needed game image assets, including backgrounds, characters, enemies, props, terrain, decorations, icons, and visual effects, must be obtained through image generation and actually connected into the Demo.
+- Code development and image generation may proceed in parallel, but the required generated images must be connected before the first visual delivery. If assets are not finished, continue generating them or reduce the Demo asset scope; do not replace them with SVG, line drawing, or large solid-color placeholders.
+- Generated assets are first-version assets that can be iterated on; they can be gradually replaced later while keeping the asset interface stable, and development does not need to wait for final art quality.
+
+The Demo runs through the following minimal complete flow:
+
+```text
+Start -> Load -> Begin -> Play -> Success or Failure -> Results -> Restart
+```
+
+After the code build is complete, the core loop can run, and the generated images required for this round have been connected, start a static service and open the Demo page in the environment's browser for the developer to operate and accept directly. The first presentation must not contain SVG, line drawing, or large solid-color game assets.
+
+## Demo Construction
+
+### File Structure
+
+Create directories for the project entry, source code, configuration, game systems, entities, scenes, input, assets, UI, build output, and so on according to the game engine and tech stack. Give each directory and key file a clear responsibility.
+
+### Code Framework
+
+Set up foundational code for game startup, configuration loading, asset loading, state transitions, input mapping, game loop, render synchronization, UI communication, restart, and resource cleanup.
+
+Separate gameplay state, rendering presentation, input, and UI into clear modules, and connect them through explicit data, events, or interfaces.
+
+### Game Systems
+
+Build the systems actually needed by the core loop according to the design document, such as player control, enemies or obstacles, spawning, collision, damage, scoring, progress, time, win/loss, results, and pause.
+
+Select only the systems necessary for the current core loop, connecting them through parameterized content and a unified asset interface. All image assets use generated images and may be gradually replaced later through the same interface.
+
+## Acceptance
+
+The Demo is accepted in the developer's browser. The Agent does not perform automated gameplay testing, end-to-end testing, visual regression testing, or other Agent-side automated tests. After code finishes building and can run, the Agent is responsible for immediately starting a static service, opening the browser, and handing control to the developer; remaining images continue to be generated and connected after the presentation.
+
+Before delivering to the developer, confirm:
+
+- The project uses the confirmed game engine and tech stack;
+- The first delivery remains minimal and can build and start successfully;
+- File responsibilities and module boundaries are clear;
+- The core game loop can run completely;
+- Input, game state, rendering, and UI are correctly connected;
+- Success, failure, results, and restart can be repeated;
+- A new session restores the correct initial state;
+- The Demo does not contain SVG, line drawing, or large solid-color game assets or visual placeholders;
+- All game image assets required by the current Demo have been obtained through image generation, centrally managed, and actually connected;
+- The static service has been started, and the Demo page has been opened in the browser.
+
+## Output
+
+Actual project files and a runnable build are the main deliverables. After completion, briefly describe:
+
+- The game engine and tech stack used;
+- The main directories and code modules established;
+- The game systems built;
+- The centralized configuration, connection location, and later replacement method for generated image assets;
+- The generation and connection status of image assets;
+- The core game loop that has been run through;
+- The build and static-service commands executed;
+- The developer acceptance URL in the browser.

package/dist/skills/en-US/game-demo/agents/openai.yaml

@@ -0,0 +1,7 @@
+interface:
+  display_name: "Game Demo"
+  short_description: "Build a safe, minimal, runnable game demo, completing code and image assets in parallel"
+  default_prompt: "Please use $game-demo to build a runnable game demo from the design document, advance image generation and code construction in parallel, provide vector fallback images for all images, and open the webpage for my acceptance review as soon as the code can run."
+
+policy:
+  allow_implicit_invocation: true

package/dist/skills/en-US/game-image-layer-decomposer/SKILL.md

@@ -0,0 +1,99 @@
+---
+name: game-image-layer-decomposer
+description: Use evomeme_decompose_image_layers to separate one existing image into independently usable, compositable layer elements. Use when backgrounds, subjects, foregrounds or specified parts in scene, illustration, character or UI images need separate editing, replacement or game integration. Explains actual processing, output files and fields, transparency, stacking order, bounding boxes and occlusion completion. Not for grid cropping, background removal alone or animation generation.
+---
+
+# Image Layer Decomposition
+
+Separate the elements of one image into independent layers for later composition and editing. Inspect the source first, decide which elements to separate or group and identify their occlusion relationships, then call `evomeme_decompose_image_layers`.
+
+## What the tool actually does
+
+MCP and canvas reuse the `layer_decomposition=true` branch of the `generate_game_image` task. Shared `executeImageGeneration` calls the existing `decomposeImageLayers`. Multiple steps stay in shared task/image implementations, without MCP-to-MCP calls or chaining canvas feature entry points. Migration does not change image functions or built-in prompts.
+
+One call performs these steps:
+
+1. Read one reference image from the workspace, using existing reference URL resolution and upload when needed.
+2. Submit one AI layer decomposition request with fixed `asset-pro` and automatic size; it does not submit a separate generation for each layer.
+3. Wait for completion and sort the returned layers by ascending `z_index`.
+4. Download the layers into workspace `assets/`, preserve names, descriptions, stacking order and optional bounding boxes, register task outputs and return file metadata. Preserve the source image.
+
+The result is **N independent layer images**, where N depends on the model result. Successful results contain at least one layer, but two or more layers, an exact count or a separate layer for every requested part are not guaranteed. The layer capability is intended to produce transparent PNG elements; a background layer may be opaque, and `mime_type` identifies the actual file format. The current shared workflow downloads only the returned layer list, without downloading an additional basemap, packaging a PSD, or creating bones, animation, colliders or an engine scene.
+
+This is AI decomposition of image content and may redraw details. It does not guarantee pixel-exact reconstruction or recover the true content of areas that were occluded and never visible in the source.
+
+## When to use it
+
+| Need | Approach |
+| --- | --- |
+| Separate a scene into distant background, subjects and foreground decoration | Use this tool and specify the elements and front-to-back relationships of each layer. |
+| Edit or replace characters, buildings, trees or props independently | Describe which elements need separate layers and which should remain grouped, based on the actual editing task. |
+| Separate a character's weapon, body or decorations | Request part layers, then inspect joints and occluded areas. Rigging, pivots and motion remain separate work. |
+| Separate plates, borders and decorations from a flattened UI image | Specify the layout to preserve and check whether text or thin lines changed. For a new component kit, use the [UI component skill](../game-ui-generator/SKILL.md). |
+| Remove only the background while keeping one complete subject | Use cutout or color key through the [image generation and background processing skill](../game-asset-image-generator/SKILL.md). |
+| Cut fixed rows and columns or crop non-overlapping objects from an existing asset sheet | Use the appropriate cropping/splitting capability. Layer decomposition lets AI process the content; it is not pure cropping. |
+| Generate a new scrolling scene's background, midground and foreground | Use the [scrolling map skill](../game-scroll-generator/SKILL.md). This tool separates an existing image and does not repair seams automatically. |
+
+## Terminology
+
+- **Layer / layer element**: An image that can be shown, hidden, moved or replaced independently. A layer may contain one object or a group that should be edited together, such as an entire distant mountain range. Not every visual detail needs its own layer.
+- **Transparency / alpha channel**: Opacity stored alongside each pixel's color. Transparent regions reveal underlying layers; partial transparency can represent smoke, glass and soft edges. A painted checkerboard or white background is not actual transparency; inspect the file itself.
+- **Stacking order (`z_index`)**: Determines which image appears on top where images overlap. Draw in ascending numerical order so later layers cover earlier ones. It is not a file number, animation frame or physical 3D distance. Do not assume consecutive values or that 0 always means background.
+- **Bounding box (`bounding_box`)**: Describes an element's occupied region in a coordinate system. This interface passes through a service-provided object or array without normalizing field names, units, reference canvas or array ordering. Do not guess positions when absent or assume `[x,y,width,height]` when present; first confirm the actual structure and coordinate convention.
+- **Occlusion / completion**: A foreground object hides part of what lies behind it. Moving that foreground after decomposition exposes previously invisible areas. Requested AI completion synthesizes plausible new content rather than recovering information missing from the image, and needs review.
+- **Compositing / pivot**: Compositing overlays images using position, scale, transparency and order. A pivot is the reference point for later movement, rotation and scaling. This tool supplies images and layer metadata, without creating engine objects or setting pivots automatically.
+- **Parallax**: Moving layers representing different depths at different speeds to suggest distance. Decomposed layers can supply source artwork, but movement speed, screen coverage, edge extension and looping continuity require separate setup and checks.
+
+## Parameters and invocation
+
+| Parameter | Actual meaning |
+| --- | --- |
+| `id` | Required workspace asset ID of one existing image, such as `assets/scene.png`; accepts an `asset_id` returned by an earlier image tool. Not a public URL, absolute file path or Base64. |
+| `prompt` | Required nonempty description of decomposition targets, grouping, front-to-back relationships and content to preserve. |
+| `workspace_dir` | Optional absolute workspace root. Set it explicitly when possible; otherwise the MCP process working directory is used. |
+
+The source must exist inside that workspace's `assets/`. Import external files through the existing asset import workflow first, then use their actual asset IDs. There is one input image. No `reference_ids`, `model`, `size`, `count`, `rows`, `columns` or `transparent_background` parameters are accepted. Pro and automatic size are fixed internally; Max/Lite cannot be selected and an exact layer count cannot be enforced.
+
+Call `evomeme_decompose_image_layers`:
+
+```json
+{
+  "workspace_dir": "D:/my-game",
+  "id": "assets/forest-scene.png",
+  "prompt": "Separate this forest illustration into independently editable elements: group the sky and distant mountains as the background, place the cabin on its own layer, the character on its own layer, and group the closest plants as the foreground. Preserve the original style, palette, relative positions and proportions. Keep the background behind the character and cabin, with the plants in front. Outside each element should be transparent except on the background layer. Add no new objects, text or borders."
+}
+```
+
+## Writing the prompt
+
+Specify which elements belong on which layer rather than only asking to separate layers. These instructions describe generation goals and do not replace inspection of real outputs. Choose according to the task:
+
+- **Scene layers**: “Group sky and distant mountains together; give buildings and trees separate layers; group foreground grass together. Preserve original positions and sizes. Do not paint a checkerboard into transparent regions.”
+- **Part layers**: “Separate the character's body, held weapon and back cape into independent layers. Keep the body complete and preserve the pose and design. Do not duplicate parts or add decorations absent from the source. Check the hand/weapon and shoulder/cape connections.”
+- **Moving the foreground**: “Separate the foreground trees and plausibly complete the ground and sky behind them in the background layer, with continuous surrounding texture. Leave no ghost of the foreground trees in the background.” Explain on delivery that completed areas were inferred by AI.
+
+Avoid requesting many tiny fragments at once; group according to how the artwork will be used. There is no separate completion switch; describe completion goals in `prompt`. Do not modify built-in image prompts to express layer requirements.
+
+## Outputs and usage
+
+MCP returns text metadata with `images` represented as a JSON array. It does not embed image bytes or Base64:
+
+| Field | Meaning |
+| --- | --- |
+| `images` | All layers, sorted by ascending `z_index`. Each entry contains `id` / `asset_id`, `local_path`, `mime_type`, `asset_url`, `url`, `name`, `description`, `z_index` and optional `bounding_box`. Names and descriptions may be empty or fall back to a filename; inspect the actual image. |
+| Top-level `asset_id`, `local_path`, `mime_type`, `asset_url` | Summary of the first layer for generic file consumers. Not the source, complete layer set, additional basemap or recomposited preview. |
+| `source_id` | Input image asset ID. |
+| `model=asset-pro`, `size=auto` | Actual request settings; `auto` is not a concrete width and height. |
+| `operation_id`, `job_id`, `status` | Local operation ID, remote AI decomposition job ID and success status. All layers from one decomposition share one remote job ID. |
+
+No separate `base`, `layers`, PSD, positioning configuration file or engine prefab is returned; read `images`. Equal layer dimensions and automatic reconstruction of the source layout are not guaranteed. Layer dimensions, when successfully probed, are stored in task records and are not returned by this MCP tool.
+
+Delivery workflow:
+
+1. Open the source and each layer. Check missing or duplicated elements, incorrect grouping, redrawing and background ghosts, including transparency at edges and in translucent details. Create a file → element → stacking order list based on actual content.
+2. Inspect actual layer dimensions and placement. When layers retain matching canvas dimensions and original positions, overlay them at a shared origin and scale. If cropped or differently sized, confirm positioning data before assigning offsets; do not simply center all smaller images.
+3. Composite a preview in ascending `z_index` order and compare alignment and occlusion with the source. Do not infer semantic meaning solely from filenames or array indices.
+4. Import layers as independent sprites/textures in the game and set pivots, positions and draw order for their intended use. Configure motion separately for parallax or moving parts, checking newly exposed regions.
+5. Use each layer's `local_path` for local files and its `asset_url` for remote references. `url=/files/...` is a canvas local-service path, not a public address. Upload files again after local edits rather than reusing a URL for older content.
+
+On failure, inspect the error and task records first. Some layers may already have downloaded, but a failed call does not guarantee a complete output list. Check existing jobs and files before repeating a paid decomposition just to recover metadata.

package/dist/skills/en-US/game-image-layer-decomposer/agents/openai.yaml

@@ -0,0 +1,7 @@
+interface:
+  display_name: "Image Layer Decomposition"
+  short_description: "Separate image elements and explain layer composition"
+  default_prompt: "Use $game-image-layer-decomposer to separate this image into independently editable layer elements and explain their contents, files and stacking order."
+
+policy:
+  allow_implicit_invocation: true