summer-engine 3.8.0 → 4.2.0

package/library/skills/agent-playtesting/resource.yaml

@@ -1,7 +1,7 @@
 id: skill/agent-playtesting
 kind: skill
 version: 1.0.0
-summary: Playtest by driving the LIVE game — deterministic launch, frame-stamped probes before/after each action, exact frame steps, scripted or recorded input.
+summary: "Playtest by driving the live game: deterministic launch, frame-stamped probes, scripted or recorded input."
 use_when:
   - proving a gameplay feature works by driving the running game frame by frame with the runtime tools (summer_game_probe, summer_game_input, summer_game_control, summer_runtime_set/call/spawn/animate)
   - a bug repro or an A/B needs a deterministic launch (seed, fixed frame rate, offscreen instance), a recorded input replay, or two instances side by side

package/library/skills/ai-characters-in-games/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: ai-characters-in-games
-description: "Safe AI characters in published games: no keys in the build, replies via Summer's player AI gateway, moderation, spend caps, offline brain and a report button."
+description: "Safe AI characters in published games: no keys in the build, Summer's player AI gateway, moderation, caps."
 license: MIT
 compatibility: [Cursor, Claude Code, Windsurf, Codex]
 category: ai-and-npcs
@@ -218,3 +218,18 @@ func _gateway() -> Object:
 - Retrying on `limit_exceeded` or `credits_exhausted`. The limit is the product working.
 - Putting a provider key in the project "until Summer is live". There is no bring-your-own-key path; keys in builds leak.
 - Letting the model decide rewards because "it only suggests". It will be talked into suggesting everything.
+
+<!-- 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_add_node` | `summer engine add-node` |
+| `summer_connect_signal` | `summer engine connect-signal` |
+| `summer_get_scene_tree` | `summer engine get-scene-tree` |
+| `summer_get_script_errors` | `summer engine get-script-errors` |
+| `summer_save_scene` | `summer engine save-scene` |
+| `summer_set_prop` | `summer engine set-prop` |
+<!-- /shell-commands -->

package/library/skills/ai-characters-in-games/resource.yaml

@@ -1,7 +1,7 @@
 id: skill/ai-characters-in-games
 kind: skill
 version: 0.3.0
-summary: "Safe AI characters in published games: no keys in the build, replies via Summer's player AI gateway, moderation, spend caps, offline brain and a report button."
+summary: "Safe AI characters in published games: no keys in the build, Summer's player AI gateway, moderation, caps."
 use_when:
   - a character, creature or object should answer free-form player text or speech in a published game (talking flowers, shopkeepers, companions)
   - about to put a model name, a provider SDK or a provider key into a game project

package/library/skills/ambient-bed/SKILL.md

@@ -1,11 +1,11 @@
 ---
 name: ambient-bed
-description: "Generate a long looping location ambience — forest, dungeon, city, spaceship, cave — a looping AudioStreamPlayer on the Ambient bus with a seamless loop."
+description: "Generate a long looping location ambience (forest, dungeon, city, cave) on the Ambient bus."
 license: MIT
 compatibility: [Cursor, Claude Code, Windsurf, Codex]
 category: audio
 user-invocable: true
-allowed-tools: Read Grep Glob Write Edit summer_generate_audio summer_search_assets summer_import_from_url summer_add_node summer_set_prop summer_inspect_node
+allowed-tools: Read Grep Glob Write Edit summer_assets_generate_audio summer_assets_search summer_import_from_url summer_add_node summer_set_prop summer_inspect_node summer_call
 paths: ["audio/ambient/**", "**/*.tscn", "**/*.import"]
 ---
 
@@ -15,7 +15,7 @@ paths: ["audio/ambient/**", "**/*.tscn", "**/*.import"]
 
 An ambient bed is the *air* of a place. Forest at dawn, dungeon corridor, spaceship hum, market street, ocean cave. It plays at low energy under everything else and is never melodic. Players rarely notice a bed, but they notice the silence when a level has none.
 
-This is **not** music. Use `summer_generate_audio({capability: 'sound_effects'})`, not `{capability: 'music'}`: the SFX model renders texture, the music model renders melody.
+This is **not** music. Use `assets.generate_audio({ capability: 'sound_effects' })`, not `{ capability: 'music' }`: the SFX model renders texture, the music model renders melody.
 
 Generated at 15–22 seconds (the SFX duration ceiling) and looped with a Summer
 Engine import loop point and optional crossfade.
@@ -101,17 +101,17 @@ If the user wants a busier bed (market, party), still prevent foreground events:
 ### 5. Generate at the duration ceiling
 
 ```
-summer_generate_audio(
+assets.generate_audio({
   capability: "sound_effects",
   modelId: "eleven_text_to_sound_v2",
   loop: true,
   text: "forest at dawn, gentle wind through leaves, distant bird calls every 6 seconds, soft creaking branches, no music, no human sound, 22s seamless loop",
   durationSeconds: 22
-)
-// Then: summer_import_from_url(url: "<fileUrl>", path: "res://audio/ambient/forest_dawn.wav")
+})
+// Then: summer_import_from_url(url: "<asset.fileUrl>", path: "res://audio/ambient/forest_dawn.wav")
 ```
 
-Name `modelId: "eleven_text_to_sound_v2"` with `loop: true`: it is the only sound-effect model that makes seamless loops, and without a `modelId` the person's default sound-effect model runs, which may not loop. `sound_effects` reads from **`text`**, not `prompt` — passing `prompt` is a 400 `text_required`. (`prompt` is the `music` capability's field.) The clip comes back as WAV, so a `.wav` target path is correct.
+Name `modelId: "eleven_text_to_sound_v2"` with `loop: true`: it is the only sound-effect model that makes seamless loops, and without a `modelId` the person's default sound-effect model runs, which may not loop. `sound_effects` reads from **`text`**, not `prompt` — without `text` the call is refused (`text_required`). (`prompt` is the `music` capability's field.) The clip comes back as WAV, so a `.wav` target path is correct.
 
 22s is the SFX ceiling. Always generate at the ceiling for ambient — longer cycle means less recognized repetition.
 
@@ -196,11 +196,16 @@ This eliminates the click and adds variation through phase-overlap (the loop ove
 For most beds, non-positional is correct (the player is *in* the place; the bed isn't an emitter):
 
 ```
-summer_add_node(scenePath="res://levels/level_01.tscn", parent="./Level", type="AudioStreamPlayer", name="AmbientBed")
-summer_set_prop(scenePath="res://levels/level_01.tscn", path="./Level/AmbientBed", key="stream", value="res://audio/ambient/forest_dawn.wav")
-summer_set_prop(scenePath="res://levels/level_01.tscn", path="./Level/AmbientBed", key="bus", value="Ambient")
-summer_set_prop(scenePath="res://levels/level_01.tscn", path="./Level/AmbientBed", key="volume_db", value=-12.0)
-summer_set_prop(scenePath="res://levels/level_01.tscn", path="./Level/AmbientBed", key="autoplay", value=true)
+summer_run_script(scenePath="res://levels/level_01.tscn", source="""
+func run(ctx):
+    ctx.add_node("AudioStreamPlayer", "AmbientBed", ctx.find("Level"), {
+        "stream": load("res://audio/ambient/forest_dawn.wav"),
+        "bus": "Ambient",
+        "volume_db": -12.0,
+        "autoplay": true,
+    })
+    ctx.save_scene()
+""")
 ```
 
 Or attach the script in step 7 to a Node, set its `stream` to the imported audio, and skip the `AudioStreamPlayer` node — the script provides its own.
@@ -249,7 +254,7 @@ Boss arena:         vast stone arena, low ominous drone, distant rumble,
 
 ## Anti-patterns
 
-- **Using `summer_generate_audio({capability: 'music'})` for an ambient bed.** Music model adds melody. You don't want melody.
+- **Using `assets.generate_audio({ capability: 'music' })` for an ambient bed.** Music model adds melody. You don't want melody.
 - **Foreground events in the bed.** A wolf howl, an explosion, a clear word — these promote themselves and the bed becomes annoying.
 - **Bed louder than `-10 dB` on its bus.** Beds belong under everything; default is `-12 dB` to `-15 dB`.
 - **No loop point set.** The clip plays once and silence follows.
@@ -265,6 +270,10 @@ Boss arena:         vast stone arena, low ominous drone, distant rumble,
 - **Need positional bed (a campfire crackle).** Use `AudioStreamPlayer3D` with `max_distance` matching the campfire's reasonable hearing radius (4–8m typical).
 - **Multi-room transitions.** Use Areas; on player enter, fade in destination bed and fade out source bed over 1.5s.
 
+## 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 stop when the bed exists. Skip steps 6-9: the loop point, the crossfade script and the `AudioStreamPlayer` are Summer Engine work. Save the file where the person asked with `out` (the `summer-assets` skill says how), and tell them the path and format. Tell the person it is a long bed made to loop: their engine either loops it with a short crossfade or plays two copies that overlap.
+
 ## Fallback (no MCP)
 
 Print the SFX prompt and the import dock settings. User runs via the Summer dashboard and imports manually.
@@ -282,3 +291,19 @@ Print the SFX prompt and the import dock settings. User runs via the Summer dash
 - `sound-effect` — short event SFX layered over the bed
 - `music-track` — melodic music layered over the bed
 - `adaptive-music` — state-driven crossfades use the same pattern
+
+<!-- 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_audio`, `summer_assets_generate_audio` | `summer assets generate-audio` |
+| `summer_assets_search` | `summer assets search` |
+| `summer_add_node` | `summer engine add-node` |
+| `summer_import_from_url` | `summer engine import-from-url` |
+| `summer_inspect_node` | `summer engine inspect-node` |
+| `summer_run_script` | `summer engine run-script` |
+| `summer_set_prop` | `summer engine set-prop` |
+<!-- /shell-commands -->

package/library/skills/ambient-bed/resource.yaml

@@ -1,7 +1,7 @@
 id: skill/ambient-bed
 kind: skill
 version: 1.0.3
-summary: Generate a long looping location ambience — forest, dungeon, city, spaceship, cave — a looping AudioStreamPlayer on the Ambient bus with a seamless loop.
+summary: "Generate a long looping location ambience (forest, dungeon, city, cave) on the Ambient bus."
 use_when:
   - generating a long looping location ambience — forest at dawn, dungeon air, city street, spaceship hum, cave drip — non-melodic and low-energy
   - a location feels silent and needs a continuous soundscape beneath the score and effects

package/library/skills/animated-loop/SKILL.md

@@ -1,11 +1,11 @@
 ---
 name: animated-loop
-description: "Generate a short seamlessly-looping video clip — splash background, animated logo backdrop, idle title-screen footage — wired as a looping VideoStreamPlayer."
+description: "Generate a short seamless video loop: splash background, animated logo backdrop, idle title screen."
 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/**", "menus/**", "ui/**"]
 ---
 
@@ -13,7 +13,7 @@ paths: ["assets/video/**", "menus/**", "ui/**"]
 
 A loop is the only video format that has to *not have* a beginning or end. The viewer sees it on the title screen for 30 seconds; if the seam between loop iterations is visible, the whole thing reads as broken. This skill exists to force the constraints that make seams invisible: take the shortest duration available, keep the motion ambient (no narrative, no big camera moves), use the fast model (`ltx`), and prompt for a composition where the first and last frames are functionally identical.
 
-**Duration is not a dial here.** `summer_generate_video` accepts only `duration=5` or `duration=10`; the server coerces every other value to 5. So "drop to 3s to hide the seam" is not an option — 5s is the floor, and the seam has to be won in the prompt and the reference frame instead.
+**Duration is not a dial here.** On `ltx` and `kling`, `assets.generate_video` renders only `duration: 5` or `duration: 10`; every other value renders 5. So "drop to 3s to hide the seam" is not an option — 5s is the floor, and the seam has to be won in the prompt and the reference frame instead.
 
 If the user wants a 5s punchy marketing shot, that's `trailer-shot`. If they want a 10s narrative cutscene, that's `cinematic-cutscene`. This skill is the one for video that has to *disappear* — atmosphere behind a logo, mood behind a menu, ambience behind a splash card.
 
@@ -46,13 +46,12 @@ If the user wants narrative motion (a character walking, a door opening), this i
 
 For loops, `ltx` is almost always right. It takes ~30s, and short ambient motion is what it handles best. The premium models cost more credits and do not loop better.
 
-This skill always passes `imageUrl` (step 3), which puts every call on the image-to-video route — and that route accepts only `ltx`, `kling`, and `minimax`. `kling-turbo` and `veo3` are text-to-video only; pairing either with an `imageUrl` is a 400 `invalid_model`, not a silent downgrade.
+This skill always passes `imageUrl` (step 3), which puts every call on the image-to-video route. `kling-turbo` and `veo3` are text-to-video only; pairing either with an `imageUrl` is a 400 `invalid_model`, not a silent downgrade.
 
 | Model | i2v? | Speed | When |
 |---|---|---|---|
 | `ltx` | yes | ~30s | Default. Use this. |
 | `kling` | yes | 2-4 min | Only if the loop is the centerpiece of a premium splash and quality is visibly lacking on `ltx` |
-| `minimax` | yes | 2-3 min | Stylized / anime aesthetic loops |
 | `kling-turbo` | **no** | 1-2 min | Not reachable from this skill — text-to-video only |
 | `veo3` | **no** | 3-5 min | Not reachable from this skill, and pointless for ambient loops anyway |
 
@@ -61,15 +60,16 @@ This skill always passes `imageUrl` (step 3), which puts every call on the image
 The reference still doubles as the *target* loop frame. Generate it deliberately — the video model's first and last frames will gravitate toward the reference, which is exactly what you want for a closing seam.
 
 ```
-summer_generate_image(
-  prompt="<subject>, ambient atmospheric scene, cinematic lighting, painterly, wide 16:9 framing, balanced composition with no clear focal action",
-  model="nano-banana-2"
-)
+assets.generate_image({
+  prompt: "<subject>, ambient atmospheric scene, cinematic lighting, painterly, wide framing, balanced composition with no clear focal action",
+  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 generate the reference in the Summer dashboard (which exposes aspect ratio) and pass its URL.
+Set `aspectRatio` to the screen the loop fills (`16:9`, or `9:16` for a vertical mobile splash).
 
-On the image-to-video route `aspectRatio` is **not applied at all** — the clip inherits the reference image's framing. So a vertical mobile splash needs a 9:16 reference image, and setting `aspectRatio="9:16"` on the video call does nothing.
+On the image-to-video route `aspectRatio` is **not applied at all** — the clip inherits the reference image's framing. So a vertical mobile splash needs a 9:16 reference image, and setting `aspectRatio: "9:16"` on the video call does nothing.
 
 ### 4. Prompt for loopable motion only
 
@@ -80,20 +80,20 @@ Loopable verbs: `drift`, `flicker`, `swirl`, `shimmer`, `sway`, `pulse`, `glow`,
 Non-loopable verbs (avoid): `walks`, `enters`, `appears`, `emerges`, `transforms`, `attacks`, `falls down`, `opens`, `closes`.
 
 ```
-summer_generate_video(
-  prompt="<subject from reference>, <ambient loopable motion>, slow continuous, looping, seamless, cinematic",
-  model="ltx",
-  imageUrl="<reference URL from step 3>",
-  duration=5,
-  options={ negative_prompt: "sudden movement, character action, narrative event, fade to black" }
-)
+assets.generate_video({
+  prompt: "<subject from reference>, <ambient loopable motion>, slow continuous, looping, seamless, cinematic",
+  model: "ltx",
+  imageUrl: "<reference URL from step 3>",
+  duration: 5,
+  negativePrompt: "sudden movement, character action, narrative event, fade to black"
+})
 ```
 
-The phrase **"looping, seamless"** in the prompt biases the model toward stable first/last frames. `options.negative_prompt` is one of the few provider keys that does pass through on the video route (`prompt`, `image_url`, `num_frames`, `duration`, `resolution`, and `model` are stripped; everything else is forwarded), so the negative prompt does rule out narrative drift here — unlike on `summer_generate_image`, where no such argument exists.
+The phrase **"looping, seamless"** in the prompt biases the model toward stable first/last frames, and `negativePrompt` rules out narrative drift. Images have no negative prompt: put negations in the image prompt text.
 
 `aspectRatio` is omitted deliberately: it is applied on the text-to-video path only, and this call passes `imageUrl`.
 
-The call returns `{ success, queued: true, jobId, ... }` and **no URL** — video generation is asynchronous. Poll `summer_check_job(jobId="<jobId>")` until it reports `completed`, and only then treat the clip as existing.
+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; only a `done` job's `result` holds the clip.
 
 ### 5. Inspect the seam
 
@@ -125,19 +125,24 @@ ffmpeg -i title_screen_bg.mp4 -c:v libtheora -q:v 8 -an title_screen_bg.ogv
 summer_import_from_url(url="<hosted .ogv url>", path="res://assets/video/loops/title_screen_bg.ogv")
 ```
 
-Then wire it. Every scene-mutating tool takes an explicit `scenePath`, and `summer_set_prop`'s property argument is named `key`, not `property`:
+Then wire it in one script. `scenePath` is the exact scene to change:
 
 ```
-summer_add_node(scenePath="res://ui/title_screen.tscn", parent=".", type="VideoStreamPlayer", name="BackgroundLoop")
-summer_set_prop(scenePath="res://ui/title_screen.tscn", path="./BackgroundLoop", key="stream", value="res://assets/video/loops/title_screen_bg.ogv")
-summer_set_prop(scenePath="res://ui/title_screen.tscn", path="./BackgroundLoop", key="autoplay", value=true)
-summer_set_prop(scenePath="res://ui/title_screen.tscn", path="./BackgroundLoop", key="loop", value=true)
-summer_set_prop(scenePath="res://ui/title_screen.tscn", path="./BackgroundLoop", key="expand", value=true)
-summer_set_prop(scenePath="res://ui/title_screen.tscn", path="./BackgroundLoop", key="anchors_preset", value=15)
-summer_save_scene(scenePath="res://ui/title_screen.tscn")
+summer_run_script(scenePath="res://ui/title_screen.tscn", source="""
+func run(ctx):
+    var loop_player = ctx.add_node("VideoStreamPlayer", "BackgroundLoop", null, {
+        "stream": load("res://assets/video/loops/title_screen_bg.ogv"),
+        "autoplay": true,
+        "loop": true,
+        "expand": true,
+    })
+    loop_player.set_anchors_and_offsets_preset(Control.PRESET_FULL_RECT)   # the loop fills the menu
+    ctx.get_scene_root().move_child(loop_player, 0)   # drawn first: the menu draws on top
+    ctx.save_scene()
+""")
 ```
 
-Anchors preset 15 is "full rect" — the loop fills the menu. Place the logo and menu buttons as children *above* the `VideoStreamPlayer` in the tree (Controls draw in tree order; later siblings render on top).
+Controls draw in tree order and later siblings render on top, so the logo and menu buttons come after the `VideoStreamPlayer` in the tree.
 
 ### 7. Mute the audio track
 
@@ -161,7 +166,7 @@ Pattern: `<subject> + <ambient loopable motion> + <constant lighting> + "looping
 | Logo backdrop — magic runes | `ltx` | `dark surface with glowing blue runes pulsing softly in slow rhythm, faint shimmer, no narrative motion, looping, seamless` | 5s |
 | Menu — underwater | `ltx` | `underwater scene with caustic light dancing on a sandy floor, slow drifting bubbles, gentle current sway on kelp, looping, seamless` | 5s |
 | Pause screen — slow rain | `ltx` | `window pane with continuous gentle rain drops, blurred warm interior glow behind, looping, seamless, ambient` | 5s |
-| Title — anime sky | `minimax` | `anime style cumulus clouds drifting slowly across a pastel sunset sky, soft, painterly, looping, seamless, Ghibli` | 5s |
+| Title — anime sky | `ltx` | `anime style cumulus clouds drifting slowly across a pastel sunset sky, soft, painterly, looping, seamless, Ghibli` | 5s |
 | Premium splash centerpiece | `kling` | `dragon silhouette breathing in profile against a vast sunset sky, only the chest rising and falling and clouds drifting, looping, seamless` | 5s |
 
 ### Bad prompts and why
@@ -177,7 +182,7 @@ Pattern: `<subject> + <ambient loopable motion> + <constant lighting> + "looping
 ## Anti-patterns
 
 - **Asking the model for a 10s loop.** Past ~6s, identity drifts and the seam shows. `duration=5` is both the floor and the right answer; 10 is the only other value the API accepts.
-- **Treating `summer_generate_video` as synchronous.** It returns `{ queued: true, jobId }` and no URL. Poll `summer_check_job` before claiming a clip exists.
+- **Treating `assets.generate_video` as finished.** It answers `{ status: "running", job }` and no URL. Wait with `jobs.wait` before claiming a clip exists.
 - **Using `kling` for a loop.** `ltx` is almost always right; short ambient motion is what it does best.
 - **Prompting narrative motion.** "Hero draws sword" doesn't loop. Use ambient verbs.
 - **Forgetting `loop=true` on the `VideoStreamPlayer`.** The clip will play once and freeze on the last frame.
@@ -193,6 +198,10 @@ Pattern: `<subject> + <ambient loopable motion> + <constant lighting> + "looping
 - **Loop is behind translucent UI.** Generate with extra contrast headroom — the model tends toward mid-grey, and translucent UI on mid-grey reads muddy. Push for `high contrast cinematic` in the prompt.
 - **Loop seam still visible after 3 regens.** Set up two `VideoStreamPlayer` siblings and crossfade between them with a `Tween` on a 0.5s overlap. Costs an extra GPU decode but hides the seam.
 
+## 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 stop when the seam passes. Skip steps 6-7 (the `VideoStreamPlayer` and its audio). Save the file where the person asked with `out` (the `summer-assets` skill says how), and tell them the path and format. The file is MP4; tell the person to play it looped and muted.
+
 ## Fallback (no MCP)
 
 If the MCP server isn't running, route the user to the Summer dashboard:
@@ -221,4 +230,23 @@ Once the loop is wired:
 - `music-track` — score the menu.
 - `ui-graphics` — logo, menu buttons, HUD that sits over the loop.
 - `concept-art` — produce the reference still that anchors the loop.
-- `../../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 |
+|---|---|
+| `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_run_script` | `summer engine run-script` |
+| `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/animated-loop/resource.yaml

@@ -1,7 +1,7 @@
 id: skill/animated-loop
 kind: skill
 version: 1.0.4
-summary: Generate a short seamlessly-looping video clip — splash background, animated logo backdrop, idle title-screen footage — wired as a looping VideoStreamPlayer.
+summary: "Generate a short seamless video loop: splash background, animated logo backdrop, idle title screen."
 use_when:
   - generating a short looping video clip — splash screen background, animated logo backdrop, idle title-screen footage, looping environment ambience
   - an idle backdrop behind the UI needs subtle motion without a real-time animated scene

package/library/skills/animation-tree/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: animation-tree
-description: "Design and wire AnimationTree state machines and blend trees so clips respond to gameplay — locomotion blends, attack interrupts, hit reactions."
+description: "Wire AnimationTree state machines and blend trees: locomotion blends, attack interrupts, hit reactions."
 license: MIT
 compatibility: [Cursor, Claude Code, Windsurf, Codex]
 category: animation
@@ -299,3 +299,29 @@ the same `.tres`; it is slower but discoverable.
 - `character-animation-wiring` — the end-to-end rigged-GLB path: inspect real clip/bone names, `ctx.anim_state_machine`, method tracks, root motion, playtest verification.
 - `generate-motion` — produce the clips this tree references.
 - `retarget` — share one tree across many characters.
+
+<!-- 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_add_node` | `summer engine add-node` |
+| `summer_connect_signal` | `summer engine connect-signal` |
+| `summer_get_diagnostics` | `summer engine get-diagnostics` |
+| `summer_get_project_context` | `summer engine get-project-context` |
+| `summer_get_scene_tree` | `summer engine get-scene-tree` |
+| `summer_get_script_errors` | `summer engine get-script-errors` |
+| `summer_inspect_node` | `summer engine inspect-node` |
+| `summer_inspect_resource` | `summer engine inspect-resource` |
+| `summer_instantiate_scene` | `summer engine instantiate-scene` |
+| `summer_play` | `summer engine play` |
+| `summer_remove_node` | `summer engine remove-node` |
+| `summer_replace_node` | `summer engine replace-node` |
+| `summer_run_script` | `summer engine run-script` |
+| `summer_save_scene` | `summer engine save-scene` |
+| `summer_set_prop` | `summer engine set-prop` |
+| `summer_set_resource_property` | `summer engine set-resource-property` |
+| `summer_stop` | `summer engine stop` |
+<!-- /shell-commands -->

package/library/skills/animation-tree/resource.yaml

@@ -1,7 +1,7 @@
 id: skill/animation-tree
 kind: skill
 version: 1.0.1
-summary: Design and wire AnimationTree state machines and blend trees so clips respond to gameplay — locomotion blends, attack interrupts, hit reactions.
+summary: "Wire AnimationTree state machines and blend trees: locomotion blends, attack interrupts, hit reactions."
 use_when:
   - the character has clips that must play in response to gameplay — idle/walk/run blends, attacks that interrupt locomotion, hit reactions
   - a character keeps T-posing

package/library/skills/art-direction/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: art-direction
-description: "Define the game's visual style — references, palette, mood, lighting plan, post-processing, do/don't list — output as an art bible at .summer/art-bible.md."
+description: "Define the game's visual style (palette, mood, lighting, post) as an art bible in .summer/art-bible.md."
 license: MIT
 compatibility: [Cursor, Claude Code, Windsurf, Codex]
 category: rendering-and-lighting
@@ -185,7 +185,7 @@ If a `WorldEnvironment` node is in the main scene, set its environment defaults
 
 ```
 summer_inspect_node(path="./World/WorldEnvironment")
-summer_set_prop(path="./World/WorldEnvironment/...", key="...", value="...")
+summer_set_prop(scenePath="res://main.tscn", path="./World/WorldEnvironment/...", key="...", value="...")
 ```
 
 Ask before each:
@@ -247,7 +247,7 @@ End with:
 > - `/audio-direction` to define the sonic identity that pairs with this look.
 > - `/game-feel` to design particle / hit-feedback styles within the palette.
 > - Open the project's `WorldEnvironment` node and dial in the lighting plan.
-> - Or generate first-pass concept assets via `summer_generate_image` using the palette + mood as the prompt prefix.
+> - Or generate first-pass concept assets via `assets.generate_image` using the palette + mood as the prompt prefix.
 
 ## Common mistakes
 
@@ -277,3 +277,17 @@ No template — this is a workflow that produces the bible the rest of the proje
 - `brainstorm-game` — produces the brief that anchors the bible
 - `audio-direction` — the sonic counterpart
 - `3d-lighting` — implements the lighting plan and the environment's glow, tonemap and SSAO settings
+
+<!-- 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_get_project_context` | `summer engine get-project-context` |
+| `summer_inspect_node` | `summer engine inspect-node` |
+| `summer_project_setting` | `summer engine project-setting` |
+| `summer_set_prop` | `summer engine set-prop` |
+<!-- /shell-commands -->

package/library/skills/art-direction/resource.yaml

@@ -1,7 +1,7 @@
 id: skill/art-direction
 kind: skill
 version: 1.0.2
-summary: Define the game's visual style — references, palette, mood, lighting plan, post-processing, do/don't list — output as an art bible at .summer/art-bible.md.
+summary: "Define the game's visual style (palette, mood, lighting, post) as an art bible in .summer/art-bible.md."
 use_when:
   - defining the visual style of the game — references, palette, mood, lighting plan, post-processing
   - make it look like PS1, retro, low-poly, pixel art, cel-shaded, or a horror aesthetic

package/library/skills/asset-strategy/SKILL.md

@@ -1,11 +1,11 @@
 ---
 name: asset-strategy
-description: "Route any 'I need a [thing]' asset request to the right specialist skill — disambiguates 2D / 3D / audio / video / VFX / animation pipelines."
+description: "Route any 'I need a [thing]' asset request to the right skill: 2D, 3D, audio, video, VFX or animation."
 license: MIT
 compatibility: [Cursor, Claude Code, Windsurf, Codex]
 category: asset-pipeline
 user-invocable: false
-allowed-tools: Read Grep Skill summer_search_assets summer_list_my_assets summer_get_asset summer_import_asset_by_id
+allowed-tools: Read Grep Skill summer_assets_search summer_assets_get summer_import_asset_by_id summer_call
 ---
 
 # Asset Strategy — Meta-Router for Asset Creation
@@ -114,22 +114,69 @@ VFX is **code, not generative** — recipes are shader + GDScript + node setup,
 | Magic glow / aura | `vfx-magic-glow` |
 | Camera shake / hit-stop | `game-feel` |
 
+## How the specialists call Summer
+
+The specialists name Summer's asset work by operation. A call written `area.action({...})` is one operation: use the tool `summer_area_action` when your client lists it, else `summer_call({ op: "area.action", input: {...} })`. `summer_search` finds any operation and its exact input.
+
+- **Find and read:** `assets.search({ query, scope })` (`scope`: `library` (default), `mine` for their own, `all`), then `assets.get({ assetId })` for the file, `downloadUrl` and `viewerUrl`. Reuse before generating.
+- **Generate:** `assets.generate_image`, `assets.generate_3d`, `assets.generate_audio`, `assets.generate_video`, `assets.generate_motion`, `assets.generate_sfx_choices` (then `assets.choices` for the person's picks). They spend the person's credits; `dryRun: true` returns the estimate (`credits`, `balance`, `enough`) and makes nothing.
+- **Wait:** 3D, video and animation answer at once with a job; `jobs.wait({ jobId, timeoutSeconds: 50 })` until `finished`, and the finished job's `result` holds the asset ids.
+- **Save on this machine:** with the local Summer MCP or the CLI, `out` (a folder or a file path) on a generate call, `jobs.wait` or `assets.get` saves the file there, and the answer adds `localPath`.
+- **Edit their assets:** `assets.remove_background`, `assets.slice_sheet`, `assets.update` (title, description, tags, private or team), `assets.make_public` (lists one for everyone in Summer's asset store), `assets.delete` (deletes for good; asks the person unless they let their agent delete, and then nothing is deleted until they confirm).
+- **Permissions:** The person decides once what their agent may do: publishing (including `assets.make_public`), spending and building run at once by default, and deleting for good asks. An operation whose group they have not granted answers `needs_approval` with a link: give the link to the person, then `jobs.wait` on the `apr:` job.
+- **Upload an image from disk:** `assets.upload_begin`, then `assets.upload_complete`.
+- **One-shot makers:** `makers.<tool>` (for example `makers.npc_voice`, `makers.trailer_forge`); `summer_search` lists them.
+
 ## When NOT to use this skill
 
 - The user already named the specific skill — go straight there.
 - The user is debugging or running the game — route to `debug` or `play`.
-- The asset is an existing Summer asset ID — call `summer_get_asset`, then `summer_import_asset_by_id`.
+- The asset is an existing Summer asset ID — call `assets.get({ assetId })`, then `summer_import_asset_by_id`.
 - The asset is being imported from a non-Summer URL (`.glb` / `.wav` from Sketchfab, Quaternius, AmbientCG) — call `summer_import_from_url` directly.
 - The user wants to plan the whole game's asset list — `brainstorm-game` first, then this router on each item.
 
 ## Anti-patterns
 
-- **Generating yourself instead of dispatching.** This file holds zero prompt patterns by design. If you're writing a `summer_generate_image` call from here, stop and invoke the specialist.
+- **Generating yourself instead of dispatching.** This file holds zero prompt patterns by design. If you're writing an `assets.generate_image` call from here, stop and invoke the specialist.
 - **Skipping the disambiguation question.** Sends users to the wrong specialist and burns a paid generation. The verbatim phrasing in Step 2 is required.
 - **Routing concept-art to character-portrait** (or the reverse). Different goals: concept-art produces 4 divergent variants for art direction; character-portrait produces 1 polished bust for dialogue UI.
 - **Inventing skill names.** Only dispatch to skills listed above. If nothing fits, ask the user to clarify.
 - **Routing rigged-humanoid requests to `prop-model`.** Anything that needs animation always goes to `character-model`.
 
+## Without Summer Engine
+
+In a session without Summer Engine tools (the assets profile; the `summer-assets` skill has the whole loop), the routing tables still pick the skill. Leave out every step that imports (`summer_import_asset_by_id`, `summer_import_from_url`): deliver the file with `out` instead (the `summer-assets` skill says how).
+
 ## Fallback (no MCP)
 
 The router still works without MCP — classification is text-only. It hands off to the specialist, which surfaces its own no-MCP fallback (typically: run the same generation in the Summer dashboard, then `summer_import_from_url` once MCP is back).
+
+<!-- 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.choices` | `summer assets choices` |
+| `assets.delete` | `summer assets delete` |
+| `assets.generate_3d` | `summer assets generate-3d` |
+| `assets.generate_audio` | `summer assets generate-audio` |
+| `assets.generate_image` | `summer assets generate-image` |
+| `assets.generate_motion` | `summer assets generate-motion` |
+| `assets.generate_sfx_choices` | `summer assets generate-sfx-choices` |
+| `assets.generate_video` | `summer assets generate-video` |
+| `assets.get`, `summer_assets_get` | `summer assets get` |
+| `assets.remove_background` | `summer assets remove-background` |
+| `assets.search`, `summer_assets_search` | `summer assets search` |
+| `assets.slice_sheet` | `summer assets slice-sheet` |
+| `assets.update` | `summer assets update` |
+| `assets.upload_begin` | `summer assets upload-begin` |
+| `assets.upload_complete` | `summer assets upload-complete` |
+| `summer_import_asset_by_id` | `summer engine import-asset-by-id` |
+| `summer_import_from_url` | `summer engine import-from-url` |
+| `jobs.wait` | `summer jobs wait` |
+| `makers.npc_voice` | `summer makers npc-voice` |
+| `makers.trailer_forge` | `summer makers trailer-forge` |
+| `summer_search` | `summer ops search "<what you want>"` |
+<!-- /shell-commands -->

package/library/skills/asset-strategy/resource.yaml

@@ -1,7 +1,7 @@
 id: skill/asset-strategy
 kind: skill
 version: 1.0.3
-summary: Route any 'I need a [thing]' asset request to the right specialist skill — disambiguates 2D / 3D / audio / video / VFX / animation pipelines.
+summary: "Route any 'I need a [thing]' asset request to the right skill: 2D, 3D, audio, video, VFX or animation."
 use_when:
   - planning asset creation, picking an asset pipeline, or routing an 'I need a [thing]' request to the right specialist skill
   - '"I need a sword / a forest / a boss theme / an explosion" and it is unclear which pipeline (2D, 3D, audio, video, VFX, animation) fits'
@@ -20,6 +20,7 @@ compatibility:
   engine: ">=4.6"
 related:
   skills:
+    - skill/summer-assets
     - skill/character-portrait
     - skill/concept-art
     - skill/pixel-art