summer-engine 3.8.0 → 4.2.0

package/library/skills/summer-match-results/SKILL.md

@@ -284,3 +284,20 @@ clients stay connected until they leave.
 - `summer-leaderboards` — ratings and `authority_v1` rating moves
 - `summer-world-saves` — persistent Worlds that outlive a match
 - `multiplayer-testing` — running bots through a whole match
+
+<!-- shell-commands: generated from the operation catalog by npm run generate:registry; do not edit by hand -->
+## From a shell
+
+No Summer MCP tools in this session? Run each one as a command; when `summer --version` is missing or below 4.0, use `npx -y summer-engine@latest` in place of `summer`. Fields are flags in kebab-case (`--scene-path res://main.tscn`) or one `--input '<json>'`, and `summer ops describe <op>` prints the exact input. The `summer-cli` skill has the rest.
+
+| In this skill | Command |
+|---|---|
+| `summer_get_diagnostics` | `summer engine get-diagnostics` |
+| `summer_get_script_errors` | `summer engine get-script-errors` |
+| `summer_play` | `summer engine play` |
+| `summer_project_setting` | `summer engine project-setting` |
+| `summer_read_file` | `summer engine read-file` |
+| `summer_replace_text` | `summer engine replace-text` |
+| `summer_stop` | `summer engine stop` |
+| `summer_write_file` | `summer engine write-file` |
+<!-- /shell-commands -->

package/library/skills/summer-matchmaking/SKILL.md

@@ -299,3 +299,20 @@ Test the accept prompt and rating-based grouping on a hosted staging build.
 - `summer-leaderboards` — ratings and leaderboards for rated queues
 - `summer-parties` — friends entering a queue together
 - `multiplayer-testing` — Local Play options and bots
+
+<!-- shell-commands: generated from the operation catalog by npm run generate:registry; do not edit by hand -->
+## From a shell
+
+No Summer MCP tools in this session? Run each one as a command; when `summer --version` is missing or below 4.0, use `npx -y summer-engine@latest` in place of `summer`. Fields are flags in kebab-case (`--scene-path res://main.tscn`) or one `--input '<json>'`, and `summer ops describe <op>` prints the exact input. The `summer-cli` skill has the rest.
+
+| In this skill | Command |
+|---|---|
+| `summer_get_diagnostics` | `summer engine get-diagnostics` |
+| `summer_get_script_errors` | `summer engine get-script-errors` |
+| `summer_play` | `summer engine play` |
+| `summer_project_setting` | `summer engine project-setting` |
+| `summer_read_file` | `summer engine read-file` |
+| `summer_replace_text` | `summer engine replace-text` |
+| `summer_stop` | `summer engine stop` |
+| `summer_write_file` | `summer engine write-file` |
+<!-- /shell-commands -->

package/library/skills/summer-parties/SKILL.md

@@ -251,3 +251,17 @@ summer_stop
 - `summer-friends`: friends list, profiles and messages
 - `multiplayer-project`: the client entry scene this extends
 - `multiplayer-testing`: Local Play, and what needs staging
+
+<!-- shell-commands: generated from the operation catalog by npm run generate:registry; do not edit by hand -->
+## From a shell
+
+No Summer MCP tools in this session? Run each one as a command; when `summer --version` is missing or below 4.0, use `npx -y summer-engine@latest` in place of `summer`. Fields are flags in kebab-case (`--scene-path res://main.tscn`) or one `--input '<json>'`, and `summer ops describe <op>` prints the exact input. The `summer-cli` skill has the rest.
+
+| In this skill | Command |
+|---|---|
+| `summer_get_diagnostics` | `summer engine get-diagnostics` |
+| `summer_get_script_errors` | `summer engine get-script-errors` |
+| `summer_play` | `summer engine play` |
+| `summer_project_setting` | `summer engine project-setting` |
+| `summer_stop` | `summer engine stop` |
+<!-- /shell-commands -->

package/library/skills/summer-player-data/SKILL.md

@@ -320,3 +320,17 @@ folder to start over.
 - `summer-world-saves` — saving a whole persistent World instead of one player
 - `multiplayer-testing` — bots and repeated Local Play runs
 - `summer-leaderboards` — scores other players can see
+
+<!-- shell-commands: generated from the operation catalog by npm run generate:registry; do not edit by hand -->
+## From a shell
+
+No Summer MCP tools in this session? Run each one as a command; when `summer --version` is missing or below 4.0, use `npx -y summer-engine@latest` in place of `summer`. Fields are flags in kebab-case (`--scene-path res://main.tscn`) or one `--input '<json>'`, and `summer ops describe <op>` prints the exact input. The `summer-cli` skill has the rest.
+
+| In this skill | Command |
+|---|---|
+| `summer_get_diagnostics` | `summer engine get-diagnostics` |
+| `summer_get_script_errors` | `summer engine get-script-errors` |
+| `summer_play` | `summer engine play` |
+| `summer_project_setting` | `summer engine project-setting` |
+| `summer_stop` | `summer engine stop` |
+<!-- /shell-commands -->

package/library/skills/summer-store/SKILL.md

@@ -42,7 +42,7 @@ proves nothing.
 | Local Play | `unavailable` | Works from a fixture: empty unless `.summer/test-users.json` lists item templates (step 5) |
 | Guests, older Summer apps | Readiness reports `unavailable` | Readiness reports `unavailable` |
 
-Items and offers are created in your game's Studio pages (`summer_open` target
+Items and offers are created in your game's Studio pages (`studio.open` target
 `game`). Code never creates items.
 
 This skill extends the Courtyard game from `multiplayer-project` and
@@ -269,3 +269,18 @@ Walk through every outcome:
 - `multiplayer-testing`: Local Play fixtures and personas
 - `summer-player-data`: saving a player's loadout between matches
 - `summer-analytics`: measuring the shop
+
+<!-- shell-commands: generated from the operation catalog by npm run generate:registry; do not edit by hand -->
+## From a shell
+
+No Summer MCP tools in this session? Run each one as a command; when `summer --version` is missing or below 4.0, use `npx -y summer-engine@latest` in place of `summer`. Fields are flags in kebab-case (`--scene-path res://main.tscn`) or one `--input '<json>'`, and `summer ops describe <op>` prints the exact input. The `summer-cli` skill has the rest.
+
+| In this skill | Command |
+|---|---|
+| `summer_get_diagnostics` | `summer engine get-diagnostics` |
+| `summer_get_script_errors` | `summer engine get-script-errors` |
+| `summer_play` | `summer engine play` |
+| `summer_project_setting` | `summer engine project-setting` |
+| `summer_stop` | `summer engine stop` |
+| `studio.open` | `summer studio open` |
+<!-- /shell-commands -->

package/library/skills/summer-world-chat/SKILL.md

@@ -193,3 +193,17 @@ Then test real chat on Summer staging with two accounts in one match.
 - `summer-friends`: direct messages with friends
 - `summer-parties`: party chat lives in the Summer app
 - `multiplayer-testing`: what Local Play can and can't test
+
+<!-- shell-commands: generated from the operation catalog by npm run generate:registry; do not edit by hand -->
+## From a shell
+
+No Summer MCP tools in this session? Run each one as a command; when `summer --version` is missing or below 4.0, use `npx -y summer-engine@latest` in place of `summer`. Fields are flags in kebab-case (`--scene-path res://main.tscn`) or one `--input '<json>'`, and `summer ops describe <op>` prints the exact input. The `summer-cli` skill has the rest.
+
+| In this skill | Command |
+|---|---|
+| `summer_get_diagnostics` | `summer engine get-diagnostics` |
+| `summer_get_script_errors` | `summer engine get-script-errors` |
+| `summer_play` | `summer engine play` |
+| `summer_project_setting` | `summer engine project-setting` |
+| `summer_stop` | `summer engine stop` |
+<!-- /shell-commands -->

package/library/skills/summer-world-saves/SKILL.md

@@ -282,3 +282,17 @@ Restoring after a real restart can only be proven hosted.
 - `multiplayer-state` — the shared document this skill saves
 - `multiplayer-project` — `world.json` and the authority scene
 - `multiplayer-testing` — Local Play runs and markers
+
+<!-- shell-commands: generated from the operation catalog by npm run generate:registry; do not edit by hand -->
+## From a shell
+
+No Summer MCP tools in this session? Run each one as a command; when `summer --version` is missing or below 4.0, use `npx -y summer-engine@latest` in place of `summer`. Fields are flags in kebab-case (`--scene-path res://main.tscn`) or one `--input '<json>'`, and `summer ops describe <op>` prints the exact input. The `summer-cli` skill has the rest.
+
+| In this skill | Command |
+|---|---|
+| `summer_get_diagnostics` | `summer engine get-diagnostics` |
+| `summer_get_script_errors` | `summer engine get-script-errors` |
+| `summer_play` | `summer engine play` |
+| `summer_project_setting` | `summer engine project-setting` |
+| `summer_stop` | `summer engine stop` |
+<!-- /shell-commands -->

package/library/skills/text-to-motion/SKILL.md

@@ -1,11 +1,11 @@
 ---
 name: text-to-motion
-description: "Custom 2-second animation clips from text prompts on any of the user's own rigged models — humanoids, animals, creatures, cartoon plants, props."
+description: "Make custom 2-second animation clips from text on the user's own rigged models: people, animals, props."
 license: MIT
 compatibility: [Cursor, Claude Code, Windsurf, Codex]
 category: animation
 user-invocable: false
-allowed-tools: Read summer_list_my_assets summer_generate_motion summer_check_job summer_get_asset summer_import_asset_by_id
+allowed-tools: Read summer_assets_search summer_assets_generate_motion summer_jobs_wait summer_assets_get summer_import_asset_by_id summer_call
 ---
 
 # Text to Motion
@@ -14,8 +14,8 @@ Summer-hosted text-to-motion turns a text prompt into a 2-second (60 frames) ske
 clip for the user's **own** rigged model. One model covers every skeleton with 5-70 bones:
 humanoids, animals, creatures, cartoon plants, turrets, props.
 
-The tool is `summer_generate_motion` with `backend: "text-to-motion"`. It returns a
-`jobId`; poll `summer_check_job`. The finished job's `result.assets` lists one `animation`
+The operation is `assets.generate_motion` with `backend: "text-to-motion"`. It answers at
+once with a job; `jobs.wait` follows it. The finished job's `result.assets` lists one `animation`
 asset per prompt x take (`id`, `fileUrl`, `animationName`, `prompt`, `take`); each is a GLB
 of the whole model carrying one animation named after its prompt.
 
@@ -37,28 +37,28 @@ doesn't have that move", any animation request for a non-humanoid rig.
 ## The order
 
 1. **Confirm the rig.** The asset must be the user's own `3d_model` GLB/FBX with one
-   skinned armature and 5-70 bones (`summer_list_my_assets` / `summer_get_asset`). If it
+   skinned armature and 5-70 bones (`assets.search({ scope: "mine", assetType: "3d_model" })` / `assets.get`). If it
    is unrigged or has odd bone names, read `rigging-for-text-motion.md` in this directory.
-2. **Agree the clip list and cost.** Each prompt x take is one billed clip. Show the list
-   and the estimated cost and wait for the user's OK before submitting.
+2. **Agree the clip list and cost.** Each prompt x take is one billed clip. Run the call
+   below with `dryRun: true` first: it checks the rig and returns `estimate.credits`. Show
+   the list and the credits and wait for the user's OK before submitting.
 3. **Submit once.** Up to 8 prompts per call, `takes` 1-4. For rooted characters pass
    `lockJoints` with the base bones:
 
    ```
-   summer_generate_motion(
+   assets.generate_motion({
      rigAssetId: "<id>",
      backend: "text-to-motion",
      prompts: ["nods happily", "waves hello with the right leaf"],
      lockJoints: ["Hips", "Spine"],   // rooted flower; omit for characters that move
-     cfgScale: 5,                     // default 3; 5 for clearer gestures on stylized rigs
-     wait: false
-   )
+     cfgScale: 5                      // default 3; 5 for clearer gestures on stylized rigs
+   })
    ```
 
    Pass a stable `idempotencyKey` if you might retry the same request. Prompt writing and
    every control: `prompts-and-controls.md` in this directory.
-4. **Poll to completion.** `summer_check_job(jobId)`. A job takes about 1-2 minutes. Do not
-   resubmit while it runs. (With the default `wait: true` the tool polls for you.)
+4. **Wait for the job.** `jobs.wait({ jobId: "<job.id>", timeoutSeconds: 50 })`, again until
+   `finished` is true. A job takes about 1-2 minutes. Do not resubmit while it runs.
 5. **Review, then import.** Import the chosen clip assets with
    `summer_import_asset_by_id(assetId, parent, scenePath)`. Offer to regenerate weak takes
    with a rephrased prompt or a higher `cfgScale`; keep the good ones.
@@ -74,26 +74,48 @@ doesn't have that move", any animation request for a non-humanoid rig.
 - **Report failures with their code.** Job failures starting `text_motion:` (no skinned
   armature, too many or too few joints, multiple armatures, unknown lock joint) are input
   problems and the charge is refunded. Fix the rig or the request; do not retry unchanged.
-- **`backend_unavailable` means text-to-motion is not enabled on this server yet.** Fall
+- **A `backend` without `text-to-motion` means it is not enabled on this server yet.** Fall
   back to `generate-motion` (meshy-library) for humanoid clips and say so; do not retry.
 - **Do not promise facial animation, finger detail or lip sync.** The model animates the
   skeleton only; blendshapes stay untouched (`facial-and-lipsync` covers faces).
 
 ## Request errors
 
-| Code | Meaning | Do |
+Refusals answer the one error shape: `error.code` with one `next` step, and
+`error.details.was` naming the reason below.
+
+| `code` / `details.was` | Meaning | Do |
 | --- | --- | --- |
-| `backend_unavailable` | Server flag off | Use `generate-motion`; do not retry |
-| `prompt_required` | No prompt | Pass `prompt` or `prompts` (1-8, each 1-300 chars) |
-| `invalid_takes` | `takes` outside 1-4 | Fix and resubmit |
-| `invalid_cfg_scale` | `cfgScale` outside 1.5-8 | Fix and resubmit |
-| `invalid_lock_joints` | Bone names wrong | Use bone names that exist in the rig |
-| `rig_asset_not_found` | Not the caller's asset | Find the user's own asset id |
-| `rig_asset_invalid` | Not a rigged GLB/FBX `3d_model` | Rig it first |
-| `insufficient_credits` (402) | Not enough credits | Fewer prompts/takes, or the user tops up |
+| `invalid_input` on `backend` | Text-to-motion is off on this server (`backend` lists only `meshy-library`) | Use `generate-motion`; do not retry |
+| `invalid_input` on `prompts` | No prompt | Pass `prompts` (1-8, each 1-300 chars) |
+| `invalid_input` / `invalid_takes` | `takes` outside 1-4 | Fix and resubmit |
+| `invalid_input` / `invalid_cfg_scale` | `cfgScale` outside 1.5-8 | Fix and resubmit |
+| `invalid_input` / `invalid_lock_joints` | Bone names wrong | Use bone names that exist in the rig |
+| `not_found` / `rig_asset_not_found` | Not the caller's asset | Find the user's own asset id |
+| `invalid_input` / `rig_asset_invalid` | Not a rigged GLB/FBX `3d_model` | Rig it first |
+| `no_credits` | Not enough credits | Fewer prompts/takes, or the person adds credits (`next` has the link) |
+
+## Without Summer Engine
+
+In a session without Summer Engine tools (the assets profile; the `summer-assets` skill has the whole loop), follow the order up to the review in step 5 and skip the import. Save the file where the person asked with `out` (the `summer-assets` skill says how), and tell them the path and format. Keep the good takes and name each file after its prompt.
 
 ## Do not stop early
 
 Done means the chosen clips are imported and playing on the model in the scene. For a
 playable character continue with `character-animation-wiring`; for state machines,
 `animation-tree`.
+
+<!-- shell-commands: generated from the operation catalog by npm run generate:registry; do not edit by hand -->
+## From a shell
+
+No Summer MCP tools in this session? Run each one as a command; when `summer --version` is missing or below 4.0, use `npx -y summer-engine@latest` in place of `summer`. Fields are flags in kebab-case (`--scene-path res://main.tscn`) or one `--input '<json>'`, and `summer ops describe <op>` prints the exact input. The `summer-cli` skill has the rest.
+
+| In this skill | Command |
+|---|---|
+| `assets.generate_3d` | `summer assets generate-3d` |
+| `assets.generate_motion`, `summer_assets_generate_motion` | `summer assets generate-motion` |
+| `assets.get`, `summer_assets_get` | `summer assets get` |
+| `assets.search`, `summer_assets_search` | `summer assets search` |
+| `summer_import_asset_by_id` | `summer engine import-asset-by-id` |
+| `jobs.wait`, `summer_jobs_wait` | `summer jobs wait` |
+<!-- /shell-commands -->

package/library/skills/text-to-motion/prompts-and-controls.md

@@ -11,19 +11,19 @@
 - Style words that map to motion work ("happily", "slowly", "tiredly"); story or
   appearance words do not.
 
-## Controls (`summer_generate_motion`, `backend: "text-to-motion"`)
+## Controls (`assets.generate_motion`, `backend: "text-to-motion"`)
 
 | Field | Default | Use |
 | --- | --- | --- |
-| `prompt` / `prompts` | - | One action, or 1-8 actions (each 1-300 chars); one clip each. Pass one of the two, not both |
+| `prompts` | - | 1-8 actions (each 1-300 chars); one clip each |
 | `takes` | 1 | 1-4; 2-3 when choosing a hero clip. Every take is billed |
 | `cfgScale` | 3 | 1.5-8; 5 for bigger, clearer gestures on stylized rigs; above 6 gets unstable |
 | `lockJoints` | none | Base bones of rooted characters (plants, turrets, statues), e.g. `["Hips","Spine"]` |
 | `idempotencyKey` | none | Stable key so a retried request is not billed twice |
-| `wait` | true | `false` returns the `jobId` at once; poll `summer_check_job` |
+| `dryRun` | false | `true` checks the rig and returns the `estimate` (credits) without making anything |
 
-Clip count = prompts x takes; each clip is billed. The queued response reports
-`clipCount` and `estimatedCost`.
+Clip count = prompts x takes; each clip is billed. The call answers with a job at once;
+`jobs.wait` follows it to the finished clips.
 
 ## Judging results
 

package/library/skills/text-to-motion/resource.yaml

@@ -1,7 +1,7 @@
 id: skill/text-to-motion
 kind: skill
 version: 1.0.0
-summary: "Custom 2-second animation clips from text prompts on any of the user's own rigged models — humanoids, animals, creatures, cartoon plants, props."
+summary: "Make custom 2-second animation clips from text on the user's own rigged models: people, animals, props."
 use_when:
   - a custom action the curated motion library lacks — nod, bow, shrug, wave with a specific arm, an emotional gesture
   - animating a non-humanoid rig — a talking flower, animal, creature, turret or prop

package/library/skills/text-to-motion/rigging-for-text-motion.md

@@ -43,8 +43,8 @@ clips; keep the package's canonical idle/walk/run/jump from `generate-motion`.
 
 ## Rigging an unrigged mesh
 
-- Humanoid: the Summer auto-rig (`character-model`, `summer_generate_3d` with
-  `options.rig: true`).
+- Humanoid: the Summer auto-rig (`character-model`, `assets.generate_3d` with
+  `rig: true`).
 - Other body plans: rig in the user's own Blender (`fabricating-assets`) or offline
   (`skintokens-auto-rigging`), using the human bone names above where the body plan allows
   (stem as spine, leaves as arms).

package/library/skills/tileable-texture/SKILL.md

@@ -1,11 +1,11 @@
 ---
 name: tileable-texture
-description: "Generate a seamless tileable texture for walls, floors, or terrain — repeats cleanly on all four edges, wired as a StandardMaterial3D albedo."
+description: "Generate a seamless tileable texture for walls, floors or terrain, wired as a StandardMaterial3D albedo."
 license: MIT
 compatibility: [Cursor, Claude Code, Windsurf, Codex]
 category: 2d-assets
 user-invocable: true
-allowed-tools: Read Grep Glob Write Edit summer_generate_image summer_search_assets summer_import_from_url summer_set_resource_property summer_add_node summer_set_prop summer_inspect_node
+allowed-tools: Read Grep Glob Write Edit summer_assets_generate_image summer_assets_search summer_import_from_url summer_set_resource_property summer_add_node summer_set_prop summer_inspect_node summer_call
 paths: ["assets/**", "art/textures/**", "materials/**"]
 ---
 
@@ -35,7 +35,7 @@ The hard part is "seamless." Most diffusion models violate edge continuity by de
 ### 1. Search for an existing texture
 
 ```
-summer_search_assets(query="<material> tileable", assetType="2d_image", source="all")
+assets.search({ query: "<material> tileable", assetType: "2d_image", scope: "all" })
 ```
 
 Texture libraries (AmbientCG, Polyhaven) often have free PBR sets that beat AI generation for realism. If the user wants photorealistic tiling, pause and suggest those.
@@ -59,16 +59,16 @@ The load-bearing phrases are:
 ### 3. Generate
 
 ```
-summer_generate_image(
-  prompt="weathered red brick wall, seamless tileable texture, top-down view, uniform lighting, no perspective, no shadows, no specific objects, square format, photographic detail. No vanishing point, no directional shadow, no vignette, no single standout feature, no scene context, no sky, no sun.",
-  model="nano-banana-2",
-  style="realistic"
-)
+assets.generate_image({
+  prompt: "weathered red brick wall, seamless tileable texture, top-down view, uniform lighting, no perspective, no shadows, no specific objects, square format, photographic detail. No vanishing point, no directional shadow, no vignette, no single standout feature, no scene context, no sky, no sun.",
+  model: "nano-banana-2",
+  style: "realistic"
+})
 ```
 
 Two things about the arguments:
 
-- **There is no `image_size` and no `negative_prompt`.** `summer_generate_image` takes only `prompt`, `model`, `style`, `referenceImageUrl`, `removeBackground` and `options`, and `options` only recognizes Nano Banana provider keys (`seed`, `outputFormat`, `safetyTolerance`, `syncMode`, `systemPrompt`, `limitGenerations`, `thinkingLevel`). Anything else is dropped without an error, so the call looks like it worked. Put the negations in the prompt text. Square is what you get regardless — MCP images come back at the server's 1:1 default, which is exactly what a tileable texture wants.
+- **There is no `image_size` and no `negative_prompt`.** `assets.generate_image` takes `prompt`, `model`, `style`, `aspectRatio`, `width`, `height`, `numImages`, `referenceImageUrl`, `removeBackground`, `seed` and `title`; a field it does not list does nothing, so the call looks like it worked. Put the negations in the prompt text. Leave `aspectRatio` at its `1:1` default, which is exactly what a tileable texture wants; for a larger tile, leave `model` out and pass `width` and `height`: a model that reaches the size is picked, or the answer names the models that can.
 - **`style: "realistic"` is a no-op.** Only `cartoon` and `anime` append anything to the prompt; `realistic` and `none` append nothing, and any other value is coerced to `none`. The photographic look has to come from the prompt (`photographic detail`). Switching to `"none"` for stylized work likewise changes nothing on its own — change the prompt.
 
 ### 4. Import to project
@@ -178,16 +178,20 @@ Then attach the same material with `uv1_scale` tuned to wall dimensions.
 - **User wants animated water / lava texture.** Generate a still tileable texture and use a `ShaderMaterial` with UV scrolling to animate. Don't try to generate frames.
 - **Visible seam after generation.** Run through GIMP `Filters → Map → Make Seamless` or open in Aseprite, set Tiled mode, paint over the seam manually. AI-generated tileables often need a 5-minute touch-up.
 
+## Without Summer Engine
+
+In a session without Summer Engine tools (the assets profile; the `summer-assets` skill has the whole loop), do steps 1-3 and the seam check in step 5 by eye on the image (tile it 2x2 in an image viewer); skip step 4 and step 6 (import, wiring onto geometry). Pass `out` with the person's folder so the PNG lands there (the `summer-assets` skill says how), and tell them to set the texture to repeat.
+
 ## Fallback (no MCP)
 
 Print the call:
 
 ```
-summer_generate_image(
-  prompt="<material> seamless tileable texture, top-down view, uniform lighting, no perspective, no shadows, no specific objects, square. No directional shadow, no single standout feature, no scene context.",
-  model="nano-banana-2",
-  style="realistic"
-)
+assets.generate_image({
+  prompt: "<material> seamless tileable texture, top-down view, uniform lighting, no perspective, no shadows, no specific objects, square. No directional shadow, no single standout feature, no scene context.",
+  model: "nano-banana-2",
+  style: "realistic"
+})
 ```
 
 Tell the user to run via the Summer dashboard, then `summer_import_from_url` to `res://art/textures/<name>.png`, set `Repeat: Enabled`, and tune `uv1_scale` to physical size.
@@ -208,4 +212,22 @@ After the texture is wired:
 - `asset-strategy` — meta-router and 3D pipeline.
 - `skybox-panorama` — sky/environment counterpart.
 - `scene-composition` — applying textures to CSG and MeshInstance3D.
-- `../../references/mcp-tools-reference/mcp-tools-reference.md` — `summer_generate_image` schema.
+- `summer_docs_read` id `reference/mcp-tools-reference` — how to call `assets.generate_image`.
+
+<!-- shell-commands: generated from the operation catalog by npm run generate:registry; do not edit by hand -->
+## From a shell
+
+No Summer MCP tools in this session? Run each one as a command; when `summer --version` is missing or below 4.0, use `npx -y summer-engine@latest` in place of `summer`. Fields are flags in kebab-case (`--scene-path res://main.tscn`) or one `--input '<json>'`, and `summer ops describe <op>` prints the exact input. The `summer-cli` skill has the rest.
+
+| In this skill | Command |
+|---|---|
+| `assets.generate_image`, `summer_assets_generate_image` | `summer assets generate-image` |
+| `summer_assets_search` | `summer assets search` |
+| `summer_docs_read` | `summer docs read` |
+| `summer_add_node` | `summer engine add-node` |
+| `summer_import_from_url` | `summer engine import-from-url` |
+| `summer_inspect_node` | `summer engine inspect-node` |
+| `summer_save_scene` | `summer engine save-scene` |
+| `summer_set_prop` | `summer engine set-prop` |
+| `summer_set_resource_property` | `summer engine set-resource-property` |
+<!-- /shell-commands -->

package/library/skills/tileable-texture/resource.yaml

@@ -1,7 +1,7 @@
 id: skill/tileable-texture
 kind: skill
 version: 1.0.4
-summary: Generate a seamless tileable texture for walls, floors, or terrain — repeats cleanly on all four edges, wired as a StandardMaterial3D albedo.
+summary: "Generate a seamless tileable texture for walls, floors or terrain, wired as a StandardMaterial3D albedo."
 use_when:
   - generating a seamless tileable texture for walls, floors, terrain, or ceilings — a square tile that repeats cleanly on all four edges
   - a wall, floor, or terrain material shows visible seams or repetition and needs a texture that tiles cleanly

package/library/skills/trailer-shot/SKILL.md

@@ -1,11 +1,11 @@
 ---
 name: trailer-shot
-description: "Generate marketing or trailer footage — slow-mo combat, establishing shots, hero beats, splash screens, pitch-deck B-roll — max punch in 5-10 seconds."
+description: "Generate trailer footage: slow-mo combat, establishing shots, hero beats, splash screens, 5-10 seconds."
 license: MIT
 compatibility: [Cursor, Claude Code, Windsurf, Codex]
 category: video
 user-invocable: true
-allowed-tools: Read Grep Glob Write Edit summer_generate_video summer_check_job summer_generate_image summer_search_assets summer_import_from_url summer_add_node summer_set_prop
+allowed-tools: Read Grep Glob Write Edit summer_assets_generate_video summer_jobs_wait summer_assets_generate_image summer_assets_search summer_import_from_url summer_add_node summer_set_prop summer_call
 paths: ["assets/video/**", "trailers/**", "marketing/**"]
 ---
 
@@ -55,25 +55,25 @@ State the archetype and composition out loud before generating: "I'll do a low-a
 For shots featuring a specific character, weapon, or environment, generate a reference still first and pass it as `imageUrl`. Without it, the boss in your trailer looks different from the boss in the game.
 
 ```
-summer_generate_image(
-  prompt="<subject>, <archetype-driven framing>, cinematic, dramatic lighting, film still, wide 16:9 framing",
-  model="nano-banana-2"
-)
+assets.generate_image({
+  prompt: "<subject>, <archetype-driven framing>, cinematic, dramatic lighting, film still, wide framing",
+  model: "nano-banana-2",
+  aspectRatio: "16:9"
+})
 ```
 
-`summer_generate_image` has no size or aspect argument — `options.image_size` is dropped without an error and every MCP image comes back at the server's 1:1 default. Ask for the framing in the prompt, or build the reference in the Summer dashboard (which exposes aspect ratio) and pass its URL. Since image-to-video inherits the reference's framing, a square reference gives you a square trailer shot.
+Set `aspectRatio` to the platform's framing (`16:9`, `9:16` for vertical social, `1:1` for square). Since image-to-video inherits the reference's framing, a square reference gives you a square trailer shot.
 
 For pure environment / abstract / VFX shots, you can skip this and prompt text-to-video directly — that also unlocks `aspectRatio`, `kling-turbo`, and `veo3`.
 
 ### 3. Pick the model
 
-The available models depend on whether you pass `imageUrl`. With a reference image (step 2) the call goes to the image-to-video route, which accepts only `ltx`, `kling`, and `minimax`; `kling-turbo` and `veo3` exist on the text-to-video route only, and pairing either with an `imageUrl` is a 400 `invalid_model`.
+The available models depend on whether you pass `imageUrl`. With a reference image (step 2) the call goes to the image-to-video route; `kling-turbo` and `veo3` exist on the text-to-video route only, and pairing either with an `imageUrl` is a 400 `invalid_model`.
 
 | Model | Text-to-video | Image-to-video | Speed | When |
 |---|---|---|---|---|
 | `kling` | yes | yes | 2-4 min | Default for trailer hero shots — best motion + composition |
 | `ltx` | yes | yes | ~30s | Cheapest. B-roll, throwaway tests, blocking the composition before committing |
-| `minimax` | yes | yes | 2-3 min | Anime / stylized trailer looks |
 | `kling-turbo` | yes | **no** | 1-2 min | Same look as kling, faster, slight quality dip — but you lose `imageUrl` |
 | `veo3` | yes | **no** | 3-5 min | Most expensive. Pitch deck for investors, the one shot that has to be perfect — but you lose `imageUrl` |
 
@@ -82,20 +82,20 @@ Default: **`ltx` first to block the composition, then `kling` for the final**. F
 ### 4. Generate the shot
 
 ```
-summer_generate_video(
-  prompt="<archetype framing>, <subject>, <action>, <camera move>, <lighting>, <film grain / lens / stylistic anchor>",
-  model="kling",
-  imageUrl="<optional reference URL from step 2>",
-  duration=5,
-  aspectRatio="16:9"
-)
+assets.generate_video({
+  prompt: "<archetype framing>, <subject>, <action>, <camera move>, <lighting>, <film grain / lens / stylistic anchor>",
+  model: "kling",
+  imageUrl: "<optional reference URL from step 2>",
+  duration: 5,
+  aspectRatio: "16:9"
+})
 ```
 
-`duration` accepts **only 5 or 10** — anything else is coerced to 5.
+On `ltx` and `kling`, `duration` is 5 or 10 — anything else renders 5. `dryRun: true` returns the shot's `estimate` (credits, balance, enough) without rendering.
 
-The call is **asynchronous**: it returns `{ success, queued: true, jobId, model, resolvedModel, estimatedCost, duration }` and **no URL**. Poll `summer_check_job(jobId="<jobId>")` until it reports `completed` before showing the user anything or claiming the shot is done.
+The call answers at once with `{ status: "running", job: { id } }` and **no URL**. Call `jobs.wait({ jobId: "<job.id>", timeoutSeconds: 50 })` until `finished` is true, before showing the user anything or claiming the shot is done.
 
-`aspectRatio` (`16:9`, `9:16`, `1:1`, ...) is applied on the **text-to-video path only**. The moment you pass `imageUrl` it is ignored and the clip inherits the reference image's framing — so vertical social needs a genuinely 9:16 reference, and square needs a square one. MCP image generation is square-only, so build non-square references in the Summer dashboard (which exposes aspect ratio) or crop them before use.
+`aspectRatio` (`16:9`, `9:16`, `1:1`, ...) is applied on the **text-to-video path only**. The moment you pass `imageUrl` it is ignored and the clip inherits the reference image's framing — so vertical social needs a genuinely 9:16 reference, and square needs a square one: generate the reference with that `aspectRatio`.
 
 ### 5. Review against trailer logic
 
@@ -150,7 +150,7 @@ Pattern: `<archetype framing> + <subject> + <action verb> + <camera move> + <lig
 | Vertical social hero | `kling` | `vertical close-up of a young witch raising hands, magical wind, hair flowing, candle-warm key, cinematic, framed for 9:16` | 5s |
 | Pitch-deck premium shot | `veo3` | `wide cinematic of a fleet of airships emerging through cloud cover at dawn, slow truck forward, golden god-rays, soaring orchestral cinematic` | 5s |
 | Cheap B-roll iteration | `ltx` | `mid shot of a knight walking through fog, slow truck backward, dawn light, cinematic` | 5s |
-| Anime style hero | `minimax` | `anime-style hero girl draws a katana in slow motion, sakura petals swirling, dramatic side-light, dynamic camera, Ghibli painterly` | 5s |
+| Anime style hero | `kling` | `anime-style hero girl draws a katana in slow motion, sakura petals swirling, dramatic side-light, dynamic camera, Ghibli painterly` | 5s |
 
 ### Bad prompts and why
 
@@ -169,7 +169,7 @@ Pattern: `<archetype framing> + <subject> + <action verb> + <camera move> + <lig
 - **Using `veo3` for B-roll.** Use `ltx` for blocking and B-roll; reserve `veo3` for the one shot that has to be perfect.
 - **Generating shots without composing the trailer first.** Make a 6-shot list before generating shot 1. Otherwise you'll generate shots that don't intercut.
 - **Assuming `aspectRatio="9:16"` reframed an image-to-video call.** It is ignored whenever `imageUrl` is set — the reference image decides the framing. Pillarboxed 16:9 on TikTok / Reels / Shorts reads as a desktop YouTube embed and gets demoted by the algorithm, so fix the reference, not the argument.
-- **Treating `summer_generate_video` as synchronous.** It returns `{ queued: true, jobId }` and no URL. Poll `summer_check_job` before handing the user a link.
+- **Treating `assets.generate_video` as finished.** It answers `{ status: "running", job }` and no URL. Wait with `jobs.wait` before handing the user a link.
 - **Forgetting that Studio doesn't cut video.** The user has to take the shots into an NLE. Tell them, don't pretend Studio can stitch.
 - **Asking for "the camera does X then Y then Z".** Pick one camera move per shot.
 
@@ -178,8 +178,12 @@ Pattern: `<archetype framing> + <subject> + <action verb> + <camera move> + <lig
 - **Steam capsule animated header (Steam asset).** Steam wants `.webm` at 616x353 or 1920x1080, ≤6s, 30fps, no audio, ≤4MB. Generate at 16:9, transcode in DaVinci, export `.webm` with VP9. The video model gives you the source; format conversion is on you.
 - **Pitch deck for investors.** One shot, `veo3`, money composition (low-angle hero or wide establishing).
 - **Vertical for TikTok / Shorts.** The reference image must genuinely be portrait — `aspectRatio` is ignored once `imageUrl` is set. Frame the subject in the upper-middle so titles can sit at the bottom.
-- **Subject is a UGC environment the player built.** Take a screenshot of the in-engine view, run it through `summer_generate_image` as `referenceImageUrl` to "upgrade" the look, then use that as the video reference. The model can stylize a screenshot; it can't invent the user's level.
-- **Logo splash with motion graphics.** Generate a static logo card in `summer_generate_image` (or use the user's existing logo PNG), then prompt video as `static composition of <logo>, only background particles drifting, cinematic, room for title text` — keep the foreground motionless.
+- **Subject is a UGC environment the player built.** Take a screenshot of the in-engine view, run it through `assets.generate_image` as `referenceImageUrl` to "upgrade" the look, then use that as the video reference. The model can stylize a screenshot; it can't invent the user's level.
+- **Logo splash with motion graphics.** Generate a static logo card with `assets.generate_image` (or use the user's existing logo PNG), then prompt video as `static composition of <logo>, only background particles drifting, cinematic, room for title text` — keep the foreground motionless.
+
+## Without Summer Engine
+
+In a session without Summer Engine tools (the assets profile; the `summer-assets` skill has the whole loop), do steps 1-5 and 7 and skip step 6 (import for archive). Save the file where the person asked with `out` (the `summer-assets` skill says how), and tell them the path and format. The MP4 goes straight into the person's video editor.
 
 ## Fallback (no MCP)
 
@@ -209,4 +213,22 @@ Once the shots are generated:
 - `music-track` — trailer score.
 - `sound-effect` — cut SFX (whooshes, impacts, stingers).
 - `concept-art` — generate the reference image axis when no asset exists yet.
-- `../../references/mcp-tools-reference/mcp-tools-reference.md` — `summer_generate_video` parameter schema and error codes.
+- `summer_docs_read` id `reference/mcp-tools-reference` — how to call `assets.generate_video`; `summer_search` returns its exact input.
+
+<!-- shell-commands: generated from the operation catalog by npm run generate:registry; do not edit by hand -->
+## From a shell
+
+No Summer MCP tools in this session? Run each one as a command; when `summer --version` is missing or below 4.0, use `npx -y summer-engine@latest` in place of `summer`. Fields are flags in kebab-case (`--scene-path res://main.tscn`) or one `--input '<json>'`, and `summer ops describe <op>` prints the exact input. The `summer-cli` skill has the rest.
+
+| In this skill | Command |
+|---|---|
+| `assets.generate_image`, `summer_assets_generate_image` | `summer assets generate-image` |
+| `assets.generate_video`, `summer_assets_generate_video` | `summer assets generate-video` |
+| `summer_assets_search` | `summer assets search` |
+| `summer_docs_read` | `summer docs read` |
+| `summer_add_node` | `summer engine add-node` |
+| `summer_import_from_url` | `summer engine import-from-url` |
+| `summer_set_prop` | `summer engine set-prop` |
+| `jobs.wait`, `summer_jobs_wait` | `summer jobs wait` |
+| `summer_search` | `summer ops search "<what you want>"` |
+<!-- /shell-commands -->

package/library/skills/trailer-shot/resource.yaml

@@ -1,7 +1,7 @@
 id: skill/trailer-shot
 kind: skill
 version: 1.0.4
-summary: Generate marketing or trailer footage — slow-mo combat, establishing shots, hero beats, splash screens, pitch-deck B-roll — max punch in 5-10 seconds.
+summary: "Generate trailer footage: slow-mo combat, establishing shots, hero beats, splash screens, 5-10 seconds."
 use_when:
   - generating marketing or trailer footage — slow-mo combat, dramatic establishing shots, hero beats, splash screens, pitch-deck B-roll
   - producing a store page, pitch deck, or social clip that shows the game at its most dramatic in seconds