summer-engine 3.8.0 → 4.2.0

package/library/skills/generate-motion/SKILL.md

@@ -1,11 +1,11 @@
 ---
 name: generate-motion
-description: "Attach an animation clip to a rigged character from the curated Meshy motion library — idle, walk, run, attack — wired via AnimationPlayer."
+description: "Attach a library animation clip (idle, walk, run, attack) to a rigged character via AnimationPlayer."
 license: MIT
 compatibility: [Cursor, Claude Code, Windsurf, Codex]
 category: animation
 user-invocable: false
-allowed-tools: Read Grep summer_search_assets summer_list_my_assets summer_get_asset summer_get_asset_download_url summer_generate_motion summer_inspect_resource summer_get_scene_tree summer_add_node summer_set_prop summer_set_resource_property summer_save_scene
+allowed-tools: Read Grep summer_assets_search summer_assets_get summer_assets_generate_motion summer_inspect_resource summer_get_scene_tree summer_add_node summer_set_prop summer_set_resource_property summer_save_scene summer_jobs_wait summer_call
 paths: ["**/*.tscn", "**/*.tres", "**/*.gd"]
 ---
 
@@ -13,7 +13,7 @@ paths: ["**/*.tscn", "**/*.tres", "**/*.gd"]
 
 Picks a clip from a **curated mocap library** by name and wires it onto a Meshy-rigged humanoid. Fast (~30s), and it looks good because it is real mocap. The five short aliases that always work are `idle`, `walk`, `run`, `jump`, `attack`; anything else must be an exact library name — see the Reference card before you invent one.
 
-The target must be a **Meshy-rigged humanoid** — a `rigAssetId` from a prior `summer_generate_3d({ kind: "image-to-3d", imageUrl: "...", options: { rig: true } })` call. The result job includes `rigAssetId`. If the user points at a non-rigged mesh, stop and route to `asset-strategy` (or directly call `summer_generate_3d` with `options.rig: true`) before generating motion.
+The target must be a **Meshy-rigged humanoid** — a `rigAssetId` from a prior `assets.generate_3d({ kind: "image-to-3d", imageUrl: "...", rig: true })` call. The finished job's `result` includes `rigAssetId`. If the user points at a non-rigged mesh, stop and route to `asset-strategy` (or directly call `assets.generate_3d` with `rig: true`) before generating motion.
 
 > **Custom or non-humanoid motion** (e.g. "drops to one knee, draws bow", a
 > nodding flower, a creature) goes to the `text-to-motion` skill
@@ -32,7 +32,7 @@ The target must be a **Meshy-rigged humanoid** — a `rigAssetId` from a prior `
 - The user wants to apply an *existing* animation to a *new* model — use `retarget` instead. Don't regenerate.
 - The user wants state-machine wiring (idle → walk → run blend) — generate the clips here, then hand off to `animation-tree`.
 - The user wants facial / lipsync animation — that's `facial-and-lipsync`.
-- The mesh isn't rigged. Rig first; never call `summer_generate_motion` on a static `.glb`.
+- The mesh isn't rigged. Rig first; never call `assets.generate_motion` on a static `.glb`.
 - The user wants procedural look-at, IK, foot placement — that's `procedural-animation`.
 - The user described a **custom signature move** that isn't on the curated list — use `text-to-motion`; if the server answers `backend_unavailable`, use the manual-authoring fallback below.
 
@@ -41,31 +41,36 @@ The target must be a **Meshy-rigged humanoid** — a `rigAssetId` from a prior `
 ### 1. Verify the target is a rigged humanoid
 
 ```
-summer_search_assets(query="<character name>", assetType="3d_model", source="my_assets")
+assets.search({ query: "<character name>", assetType: "3d_model", scope: "mine" })
 ```
 
-The result must include `rigAssetId: <id>` on a Meshy rig. If it shows `rigAssetId: null`, the model isn't rigged — stop, propose `summer_generate_3d({ kind: "image-to-3d", imageUrl: "...", options: { rig: true } })` first (the result includes `rigAssetId`), or route to `asset-strategy`.
+The rigged model's `assetId` is its `rigAssetId` (the id the rig job's result named `rigAssetId`). Search results do not say whether a model is rigged: the dry run in step 2 checks it, and a model that is not rigged is refused there with `invalid_input` on `rigAssetId`. Then stop, propose `assets.generate_3d({ kind: "image-to-3d", imageUrl: "...", rig: true })` first (the finished job's result includes `rigAssetId`), or route to `asset-strategy`.
 
 ### 2. Confirm with the user before spending
 
 > I'm about to generate a "run" animation on `goblin_rigged` via meshy-library — about 30s, and it uses credits. OK?
 
-### 3. Call the tool
+`dryRun: true` on the call below returns the credits (`estimate`) and checks the rig is the person's and rigged; clips the rig already has cost nothing, so the estimate is the most it can cost.
+
+### 3. Call the operation
 
 ```
-summer_generate_motion(
+assets.generate_motion({
   rigAssetId: "<id>",
   backend: "meshy-library",   // curated library (default)
-  motionName: "run"           // exact name from the curated list — see Reference card
-)
+  motionNames: ["run"]        // exact names from the curated list — see Reference card
+})
+jobs.wait({ jobId: "<job.id>", timeoutSeconds: 50 })   // again until finished
 ```
 
-With the default `wait: true` the tool polls to completion and returns the job
-result with `animationAssetId` in it. Don't assume any other field is present —
-resolve the asset to get stable file/download metadata:
+`assets.generate_motion` answers at once with a job; `jobs.wait` follows it until
+`finished` is true, and the finished job's `result` has `animationAssetId` in it.
+When the rig already has every clip asked for, the answer is `done` at once with
+`reused` (nothing new was made or charged). Don't assume any other field is
+present — resolve the asset to get stable file/download metadata:
 
 ```
-summer_get_asset(assetId="<animationAssetId>")
+assets.get({ assetId: "<animationAssetId>" })
 ```
 
 ### 4. Attach to the character's AnimationPlayer
@@ -97,7 +102,7 @@ If the character will use multiple clips, leave the AnimationPlayer in place —
 
 ## Reference card
 
-### Curated motion library — what `motionName` actually accepts
+### Curated motion library — what `motionNames` actually accepts
 
 There are **five** short canonical aliases, and only five:
 
@@ -113,7 +118,7 @@ nothing like a tidy snake_case scheme — real names look like `Walking_Woman`,
 Plausible-looking names that do **not** resolve, verified against the resolver:
 `attack_sword`, `hit_react`, `death`, `sprint`, `block`, `dodge_left`,
 `crouch_idle`, `walk_back`, `run_strafe_left`, `jump_land`, `idle_combat`,
-`wave`, `dance`, `sit_idle`. They return `null` and the call errors. For a sword
+`wave`, `dance`, `sit_idle`. They resolve to nothing and the call errors. For a sword
 attack, use `attack`.
 
 So: if the user asks for something outside the five aliases, do not guess a
@@ -122,17 +127,17 @@ have actually seen, or route to the manual-authoring fallback.
 
 ### Pitfalls
 
-- **Invented `motionName` strings fail.** `"run_fast"`, `"attack_sword"`, `"death"` all resolve to nothing and the call errors. Name resolution is exact — five aliases, or a real library name / display name / numeric id. Do not extrapolate a naming scheme.
+- **Invented `motionNames` entries fail.** `"run_fast"`, `"attack_sword"`, `"death"` all resolve to nothing and the call errors. Name resolution is exact — five aliases, or a real library name / display name / numeric id. Do not extrapolate a naming scheme.
 - **Locomotion clips have a forward bias.** Meshy's `run` translates the root forward by ~5m. Either the code drives movement (then the baked root translation causes a lunge-and-snap every loop — strip it) or the clip does via `root_motion_track` + `get_root_motion_position()` — never both. The full root-motion setup and its playtest verification live in `character-animation-wiring`.
 - **Rig pose mismatch.** If your rig was rigged with a non-T-pose reference image, the limbs may bend wrong. Re-rig from a T-pose mannequin (see `asset-strategy`) before re-generating.
-- **Rig still preparing.** New rigs need ~3 minutes after the rig job completes before the animation library is ready. The MCP route returns 425 "animations_preparing" if you call too early. Wait and retry.
+- **Rig still preparing.** New rigs need ~3 minutes after the rig job completes before the animation library is ready. Called too early, `assets.generate_motion` answers `in_progress` with `retry: "after"` and `details.retryAfterSeconds` (about 180). Wait and retry.
 
 ## Anti-patterns
 
-- Calling `summer_generate_motion` on a `.glb` that wasn't rigged — wastes a generation; the API errors but only after 30s.
-- Generating the same clip twice because you forgot to save the `animationAssetId` from the first call. Search the asset library first: `summer_search_assets(query: "goblin run", assetType: "animation", source: "my_assets")`.
+- Calling `assets.generate_motion` on a `.glb` that wasn't rigged — the call is refused; a dry run says so first.
+- Generating the same clip twice because you forgot to save the `animationAssetId` from the first call. Search the asset library first: `assets.search({ query: "goblin run", assetType: "animation", scope: "mine" })`.
 - Wiring clips into an AnimationTree inside this skill. That's the next skill's job. Generate, attach, hand off.
-- Asking the model to invent a `motionName` that isn't on the list. Quote from the list verbatim, or fall back to manual authoring.
+- Asking the model to invent a motion name that isn't on the list. Quote from the list verbatim, or fall back to manual authoring.
 
 ## Edge cases
 
@@ -145,6 +150,10 @@ have actually seen, or route to the manual-authoring fallback.
 - **Character is < 1m tall (child / dwarf).** Library clips assume a ~1.8m humanoid. Apply the clip; the proportions retarget but stride length looks long. Either accept it or tune `playback_speed` on the AnimationPlayer track.
 - **Character has wings / tail.** The library ignores the extra bones — they sag. Hand-author additive overlays for the extra bones, or accept the visual hit.
 
+## 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 skip step 4 (the `AnimationPlayer`). Save the clip where the person asked with `out` on `jobs.wait` (the `summer-assets` skill says how), and tell them the path and format.
+
 ## Fallback (no MCP)
 
 The user can upload to Meshy directly at meshy.ai, generate through the
@@ -163,3 +172,24 @@ Engine.
 - `asset-strategy` — how to get a Meshy-rigged character in the first place.
 - `animation-tree` — wire the generated clips into a state machine.
 - `retarget` — re-use one library across many characters without regenerating.
+
+<!-- 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` |
+| `summer_assets_get` | `summer assets get` |
+| `assets.search`, `summer_assets_search` | `summer assets search` |
+| `summer_add_node` | `summer engine add-node` |
+| `summer_get_scene_tree` | `summer engine get-scene-tree` |
+| `summer_inspect_node` | `summer engine inspect-node` |
+| `summer_inspect_resource` | `summer engine inspect-resource` |
+| `summer_save_scene` | `summer engine save-scene` |
+| `summer_set_prop` | `summer engine set-prop` |
+| `summer_set_resource_property` | `summer engine set-resource-property` |
+| `jobs.wait`, `summer_jobs_wait` | `summer jobs wait` |
+<!-- /shell-commands -->

package/library/skills/generate-motion/resource.yaml

@@ -1,7 +1,7 @@
 id: skill/generate-motion
 kind: skill
 version: 1.0.4
-summary: Attach an animation clip to a rigged character from the curated Meshy motion library — idle, walk, run, attack — wired via AnimationPlayer.
+summary: "Attach a library animation clip (idle, walk, run, attack) to a rigged character via AnimationPlayer."
 use_when:
   - the user needs an animation clip on a rigged character — idle/walk/run/attack from the curated Meshy library
   - a rigged character has no idle, walk, run, or attack animation yet

package/library/skills/godogen-visual-proof-game-generation/SKILL.md

@@ -157,7 +157,7 @@ Rules that make it work:
 
 ## Asset Generation
 
-Godogen calls external image, video and image-to-3D providers with their own API keys, then cuts animated sprites from generated video (frame extraction, loop detection, background removal, imagemagick for resize and crop). In Summer, route asset work through `asset-strategy` and the Summer generation tools (`summer_generate_image`, `summer_generate_3d`, `summer_generate_video`) instead of wiring provider keys into the project.
+Godogen calls external image, video and image-to-3D providers with their own API keys, then cuts animated sprites from generated video (frame extraction, loop detection, background removal, imagemagick for resize and crop). In Summer, route asset work through `asset-strategy` and the Summer generation operations (`assets.generate_image`, `assets.generate_3d`, `assets.generate_video`) instead of wiring provider keys into the project.
 
 ## Implementation Steps
 
@@ -203,3 +203,20 @@ Not yet verified in Summer Engine. To validate an implementation:
 ## Confidence
 
 `extracted`. The architecture (thin runtime, manifest, engine guide, asset-gen), proof over claims, self-verification from captured frames, the dropped verifier model, the C# rationale, the capture tooling and the two involvement modes come from Godogen's public README, CHANGELOG and setup notes. The `ProofCapture` script, the QC-loop JSON protocol and the Summer mapping are adaptations; Godogen's internal prompt and guide files are not public.
+
+<!-- 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_image` | `summer assets generate-image` |
+| `assets.generate_video` | `summer assets generate-video` |
+| `summer_game_probe` | `summer engine game-probe` |
+| `summer_get_diagnostics` | `summer engine get-diagnostics` |
+| `summer_get_script_errors` | `summer engine get-script-errors` |
+| `summer_play` | `summer engine play` |
+| `summer_screenshot` | `summer engine screenshot` |
+<!-- /shell-commands -->

package/library/skills/godogen-visual-proof-game-generation/resource.yaml

@@ -30,3 +30,4 @@ source: official
 license: MIT
 status: preview
 recommended: false
+bundled: false

package/library/skills/grow-analytics/SKILL.md

@@ -1,11 +1,11 @@
 ---
 name: grow-analytics
-description: "Read and analyse a creator's Summer Grow numbers: store page views, launches, play sessions, play time; compare windows, flag drops."
+description: "Read a creator's Summer Grow numbers (page views, launches, sessions, play time), compare windows."
 license: MIT
 compatibility: [Cursor, Claude Code, Windsurf, Codex]
 category: deployment
 user-invocable: true
-allowed-tools: summer_read_library
+allowed-tools: summer_docs_read
 ---
 
 # /grow-analytics — grow analytics
@@ -14,8 +14,18 @@ This skill covers how to read a creator's Summer Grow numbers (store page views,
 
 Its current text lives on the hosted Summer Engine MCP, the same text the Studio agent reads, so it changes with the store and is never stale here. Load it before you act:
 
-1. `summer_read_library` with id `skill/grow-analytics` returns the current text when this machine has a store sign-in (`summer login --store`).
+1. `summer_docs_read` with id `skill/grow-analytics` returns the current text when this machine is signed in (`summer login`).
 2. A host that shows MCP prompts or resources has it as the `grow-analytics` prompt and the resource `summer://skills/grow-analytics`.
 3. Without a store sign-in: https://docs.summerengine.com/llms.txt lists every docs page; fetch any page as .md.
 
 The one rule to keep even before you load it: Report what the numbers show; do not guess causes the data cannot support.
+
+<!-- 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_docs_read` | `summer docs read` |
+<!-- /shell-commands -->

package/library/skills/grow-analytics/resource.yaml

@@ -1,7 +1,7 @@
 id: skill/grow-analytics
 kind: skill
 version: 1.0.0
-summary: "Read and analyse a creator's Summer Grow numbers: store page views, launches, play sessions, play time; compare windows, flag drops."
+summary: "Read a creator's Summer Grow numbers (page views, launches, sessions, play time), compare windows."
 use_when:
   - "the user asks how their game is doing on Summer Games: views, launches, players, play time"
   - "reading summer_grow_overview or summer_grow_analytics and turning the numbers into one next step"

package/library/skills/headless-scripting/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: headless-scripting
-description: "Run a GDScript file against Summer Engine from the shell for operations no MCP tool exposes — navmesh baking, collision shapes, TileSets, re-imports."
+description: "Run a GDScript file against Summer Engine from the shell for what no MCP tool does: navmesh, TileSets."
 ---
 
 # Headless Scripting
@@ -412,3 +412,16 @@ Keep scripts in the project (`res://` is required for `-s`), but name them so th
 - `playtesting-a-feature` — the verify instance, probes, and proving gameplay behaviour.
 - `export-and-ship` — the full release pipeline this skill's export example is one step of.
 - `verification-before-completion` — checking the artifact before claiming done.
+
+<!-- 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_project_context` | `summer engine get-project-context` |
+| `summer_import_from_url` | `summer engine import-from-url` |
+| `summer_run_script` | `summer engine run-script` |
+| `summer_write_file` | `summer engine write-file` |
+<!-- /shell-commands -->

package/library/skills/headless-scripting/resource.yaml

@@ -1,7 +1,7 @@
 id: skill/headless-scripting
 kind: skill
 version: 1.1.3
-summary: Run a GDScript file against Summer Engine from the shell for operations no MCP tool exposes — navmesh baking, collision shapes, TileSets, re-imports.
+summary: "Run a GDScript file against Summer Engine from the shell for what no MCP tool does: navmesh, TileSets."
 use_when:
   - a Summer project needs an operation no MCP tool exposes — baking a navmesh, generating collision shapes, authoring an Animation, building a TileSet, re-importing assets
   - a plan involves 'run it headless and screenshot it' (which does not work — this skill explains why)

package/library/skills/in-game-purchases/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: in-game-purchases
-description: "Sell items for Sparks in a game shop via the Summer purchase sheet: checkout, results, not enough Sparks, inventory unlocks, authority grants, store policy."
+description: "Sell items for Sparks via the Summer purchase sheet: checkout, not enough Sparks, unlocks, grants."
 license: MIT
 compatibility: [Cursor, Claude Code, Windsurf, Codex]
 category: gameplay
@@ -257,3 +257,14 @@ Sparks in the Summer app.
 
 - multiplayer-state
 - ui-basics
+
+<!-- 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_scene_tree` | `summer engine get-scene-tree` |
+| `summer_get_script_errors` | `summer engine get-script-errors` |
+<!-- /shell-commands -->

package/library/skills/in-game-purchases/resource.yaml

@@ -1,7 +1,7 @@
 id: skill/in-game-purchases
 kind: skill
 version: 1.0.0
-summary: "Sell items for Sparks in a game shop via the Summer purchase sheet: checkout, results, not enough Sparks, inventory unlocks, authority grants, store policy."
+summary: "Sell items for Sparks via the Summer purchase sheet: checkout, not enough Sparks, unlocks, grants."
 use_when:
   - "adding a shop, buy button or paid item to a Summer game and wiring request_checkout"
   - "the player does not have enough Sparks (checkout rejected with insufficient_funds) and the game should tell them how to buy more Sparks"

package/library/skills/instantiate-asset-pack/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: instantiate-asset-pack
-description: "Import a whole create-asset-sheet pack into the scene: groups composites, sorts paint order, emits Sprite2D/Node2D/NinePatchRect ops to lay it out."
+description: "Lay out a whole create-asset-sheet pack in the scene: composites, paint order, Sprite2D and NinePatch."
 license: MIT
 compatibility: [Cursor, Claude Code, Windsurf, Codex]
 category: 2d-assets
@@ -228,7 +228,7 @@ Pack has a composite parent `settings_panel` (filtered out) plus three children:
 
 After this, hand `panel_bg` and `apply_button` to `use-widget-asset` to set `patch_margin_*` from their `widget.frameMargins`.
 
-Note the ops format: `position` is the **engine variant string** `"Vector2(0, 0)"`, not a JSON object. `z_index` is a bare integer. This is the format Summer Engine expects — see `../../references/mcp-tools-reference/mcp-tools-reference.md`.
+Note the ops format: `position` is the **engine variant string** `"Vector2(0, 0)"`, not a JSON object. `z_index` is a bare integer. This is the format Summer Engine expects — see `summer_docs_read` id `reference/mcp-tools-reference`.
 
 ## Failure modes
 
@@ -245,3 +245,20 @@ Note the ops format: `position` is the **engine variant string** `"Vector2(0, 0)
 - `create-asset-sheet` — production side; how the pack was made.
 - `use-widget-asset` — wiring an individual widget slice (NinePatchRect, TextureProgressBar geometry).
 - `asset-strategy` — broader find-or-generate -> import -> apply flow.
+
+<!-- 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_docs_read` | `summer docs read` |
+| `summer_add_node` | `summer engine add-node` |
+| `summer_batch` | `summer engine batch` |
+| `summer_get_scene_tree` | `summer engine get-scene-tree` |
+| `summer_import_from_url` | `summer engine import-from-url` |
+| `summer_inspect_node` | `summer engine inspect-node` |
+| `summer_set_prop` | `summer engine set-prop` |
+| `summer_set_resource_property` | `summer engine set-resource-property` |
+<!-- /shell-commands -->

package/library/skills/instantiate-asset-pack/resource.yaml

@@ -1,7 +1,7 @@
 id: skill/instantiate-asset-pack
 kind: skill
 version: 1.0.3
-summary: "Import a whole create-asset-sheet pack into the scene: groups composites, sorts paint order, emits Sprite2D/Node2D/NinePatchRect ops to lay it out."
+summary: "Lay out a whole create-asset-sheet pack in the scene: composites, paint order, Sprite2D and NinePatch."
 use_when:
   - importing or spawning an entire asset pack (multi-slice ArtAsset from create-asset-sheet) into the current scene
   - laying out a generated tile sheet, UI kit, or biome pack as placed Sprite2D and NinePatchRect nodes in one pass

package/library/skills/lumera-single-image-scene-reconstruction/resource.yaml

@@ -32,3 +32,4 @@ source: official
 license: MIT
 status: preview
 recommended: false
+bundled: false

package/library/skills/make-game/SKILL.md

@@ -1,11 +1,11 @@
 ---
 name: make-game
-description: "Orchestration spine for 'make me a game': brainstorm, plan, scaffold, mechanics, art, audio, polish, verify, ship — delegates to specialist skills."
+description: "Orchestrate 'make me a game': brainstorm, plan, scaffold, mechanics, art, audio, polish, verify, ship."
 license: MIT
 compatibility: [Cursor, Claude Code, Codex, Windsurf, Gemini, OpenCode]
 category: scene-and-project
 user-invocable: true
-allowed-tools: Read Edit Write Bash Skill summer_get_project_context summer_get_scene_tree summer_create_scene summer_add_node summer_set_prop summer_save_scene summer_play summer_stop summer_get_diagnostics summer_get_script_errors
+allowed-tools: Read Edit Write Bash Skill summer_get_project_context summer_get_scene_tree summer_create_scene summer_run_script summer_add_node summer_set_prop summer_save_scene summer_play summer_stop summer_get_diagnostics summer_get_script_errors
 paths: [".summer/**", "project.godot", "**/*.gd", "**/*.tscn"]
 ---
 
@@ -162,7 +162,7 @@ World (Node3D)
 └── GameManager (Node)  # autoload-style, holds win/lose state
 ```
 
-Save the scene. Run `summer_play` once to verify the empty scaffold opens cleanly. If it crashes, run `debug` immediately — do NOT continue building on a broken base.
+Build that hierarchy in one `summer_run_script` with the scene's `scenePath` (see `scene-scripting`), not node by node, and end the script with `ctx.save_scene()`. Run `summer_play` once to verify the empty scaffold opens cleanly. If it crashes, run `debug` immediately — do NOT continue building on a broken base.
 
 **Checkpoint before continuing:**
 
@@ -181,7 +181,7 @@ For each mechanic in the plan, **in order**:
    Outputs the mechanic spec: input, response, feedback, failure modes, depth, tunables, GDScript stub.
 
 2. **Implement**:
-   - Add the nodes via `summer_add_node` / `summer_set_prop`. Use `scene-composition` if the structure is non-trivial.
+   - Add the nodes: 3 or more scene edits are one `summer_run_script` with `scenePath` (snapshot, script, diff, screenshot); a single tweak is one `summer_set_prop`. Use `scene-composition` if the structure is non-trivial.
    - For movement-class mechanics, prefer the matching pre-built skill: `character-movement`, `fps-controller`, `multiplayer-movement`, etc. Follow the genre playbook's build order when one applies.
    - Write GDScript with `gdscript-patterns` open.
 
@@ -303,3 +303,32 @@ When all phases are done:
 > "<Game name> is in. <N> mechanics, <playable from main scene to win condition>. <Brief summary of the build>. Want me to package a build (`export-and-ship`) or iterate?"
 
 That's the handoff back to the user.
+
+<!-- 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.search` | `summer assets search` |
+| `summer_docs_read` | `summer docs read` |
+| `summer_add_node` | `summer engine add-node` |
+| `summer_batch` | `summer engine batch` |
+| `summer_create_scene` | `summer engine create-scene` |
+| `summer_export_game` | `summer engine export-game` |
+| `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_import_asset` | `summer engine import-asset` |
+| `summer_import_asset_by_id` | `summer engine import-asset-by-id` |
+| `summer_play` | `summer engine play` |
+| `summer_replace_text` | `summer engine replace-text` |
+| `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` |
+| `summer_write_file` | `summer engine write-file` |
+<!-- /shell-commands -->

package/library/skills/make-game/references/2d-platformer.md

@@ -2,7 +2,7 @@
 
 Side-scrolling platformer blueprint: architecture, the level, and the core loop.
 Movement itself lives in the `character-movement` skill (base controller) and its
-`../../character-movement/references/platformer-feel.md` (coyote time, jump buffer, variable height) - do
+platformer-feel reference (`summer_docs_read` id `skill/character-movement/references/platformer-feel.md`: coyote time, jump buffer, variable height) - do
 not rewrite it here; wire it in. For Celeste-grade precision movement (dash, wall
 jump, climb) use `celeste-momentum-platforming` instead.
 

package/library/skills/make-game/references/3d-fps.md

@@ -135,7 +135,7 @@ for free.
 ## Level scene
 
 The real level comes from real assets, not primitives: route the need through
-the `asset-strategy` skill (`summer_search_assets`, then `summer_import_asset` /
+the `asset-strategy` skill (`assets.search`, then `summer_import_asset` /
 `summer_import_asset_by_id`), import a ready location or kit that fits, and build
 gameplay inside it; weapons and props should share its style. A PlaneMesh ground
 is only the walk-test blockout and for pieces no asset covers — never the

package/library/skills/make-game/references/3d-horror.md

@@ -116,7 +116,7 @@ resist cranking them.
 ## Level building (library first, primitives last)
 
 The level comes from real assets: route it through the `asset-strategy` skill
-(`summer_search_assets`, then `summer_import_asset` / `summer_import_asset_by_id`)
+(`assets.search`, then `summer_import_asset` / `summer_import_asset_by_id`)
 and look for a ready horror location (an abandoned house, a haunted forest, a
 modular horror-house kit) plus period props, keeping one coherent style. Import
 the location that fits and build gameplay inside it. Do NOT grey-box a level a

package/library/skills/make-game/references/3d-third-person.md

@@ -128,7 +128,7 @@ global transform and zeroes `rotation.z`.
 If the visual is a Summer humanoid package, do not use the generic setup below.
 Instantiate its `character.tscn` under `CharacterRotationRoot`, preserve the package's
 normalized `-Z` forward axis, then install the `character-movement` skill's
-`../../character-movement/references/default-third-person-controller.gd` unchanged for the standard
+default third-person controller (`summer_docs_read` id `skill/character-movement/references/default-third-person-controller.gd`) unchanged for the standard
 playable controller (that skill has the byte-exact install steps and the
 verification probe). Do not hand-write an equivalent controller. Never rebuild package clips
 into a second AnimationTree.
@@ -163,7 +163,7 @@ and set `loop_mode = Animation.LOOP_LINEAR` on those at runtime.
 
 ## Level assembly
 
-Check for real assets first (`asset-strategy`: `summer_search_assets`, then
+Check for real assets first (`asset-strategy`: `assets.search`, then
 `summer_import_asset`): a ready location or kit beats CSG. Keep CSG for the
 first-motion blockout, invisible glue (death planes, triggers) and pieces no
 asset covers — do not ship a grey-box level when a real one is available.

package/library/skills/make-game/resource.yaml

@@ -1,7 +1,7 @@
 id: skill/make-game
 kind: skill
 version: 1.1.0
-summary: "Orchestration spine for 'make me a game': brainstorm, plan, scaffold, mechanics, art, audio, polish, verify, ship — delegates to specialist skills."
+summary: "Orchestrate 'make me a game': brainstorm, plan, scaffold, mechanics, art, audio, polish, verify, ship."
 use_when:
   - the user says 'make me a game', 'build me a game', 'I want to make a [genre] game', or 'let's build something' — running the full game-dev pipeline
   - the user wants a complete playable game end to end, from brainstorm through shipping

package/library/skills/multiplayer/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: multiplayer
-description: "Start here for Summer multiplayer: how the authority, clients, Worlds and Sessions fit, and which skill comes next."
+description: "Start here for Summer multiplayer: how authority, clients, Worlds and Sessions fit, and what comes next."
 license: MIT
 compatibility: [Cursor, Claude Code, Windsurf, Codex]
 category: multiplayer-and-networking
@@ -150,3 +150,15 @@ Check what exists: `summer.build.json`, `world.json`, `network/`,
 - **The game already uses `@rpc` or `MultiplayerSynchronizer`:** tell the user
   it needs moving to Summer's networking. Then follow `multiplayer-project`
   and port one system at a time: movement first, then state.
+
+<!-- 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_scene_tree` | `summer engine get-scene-tree` |
+| `summer_get_script_errors` | `summer engine get-script-errors` |
+| `summer_project_setting` | `summer engine project-setting` |
+<!-- /shell-commands -->

package/library/skills/multiplayer/resource.yaml

@@ -1,7 +1,7 @@
 id: skill/multiplayer
 kind: skill
 version: 1.0.0
-summary: "Start here for Summer multiplayer: how the authority, clients, Worlds and Sessions fit, and which skill comes next."
+summary: "Start here for Summer multiplayer: how authority, clients, Worlds and Sessions fit, and what comes next."
 use_when:
   - "the user wants multiplayer, co-op, PvP, online play over the internet, or to play with friends in a Summer game"
   - "the user asks for peer-to-peer, a player-hosted server, host migration, join-by-IP or a lobby"

package/library/skills/multiplayer-movement/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: multiplayer-movement
-description: "Client-side movement in Summer multiplayer: owners move instantly, others glide, the authority checks each pose."
+description: "Movement in Summer multiplayer: owners move instantly, others glide, the authority checks each pose."
 license: MIT
 compatibility: [Cursor, Claude Code, Windsurf, Codex]
 category: multiplayer-and-networking
@@ -508,3 +508,21 @@ client never sees the jump.
 
 `multiplayer-state`: scores, doors, private inventories, and actions the
 authority checks against these poses.
+
+<!-- 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_scene_tree` | `summer engine get-scene-tree` |
+| `summer_get_script_errors` | `summer engine get-script-errors` |
+| `summer_inspect_node` | `summer engine inspect-node` |
+| `summer_play` | `summer engine play` |
+| `summer_project_setting` | `summer engine project-setting` |
+| `summer_read_file` | `summer engine read-file` |
+| `summer_stop` | `summer engine stop` |
+| `summer_write_file` | `summer engine write-file` |
+<!-- /shell-commands -->

package/library/skills/multiplayer-movement/resource.yaml

@@ -1,7 +1,7 @@
 id: skill/multiplayer-movement
 kind: skill
 version: 1.0.0
-summary: "Client-side movement in Summer multiplayer: owners move instantly, others glide, the authority checks each pose."
+summary: "Movement in Summer multiplayer: owners move instantly, others glide, the authority checks each pose."
 use_when:
   - "moving players in a Summer multiplayer game: each player's own character, other players drawn smoothly"
   - "remote players stutter, jitter, teleport or rubberband in a Summer multiplayer game"

package/library/skills/multiplayer-project/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: multiplayer-project
-description: "Set up a Summer multiplayer project: both entry scenes, World and queue files, joining, and a first Local Play run."
+description: "Set up a Summer multiplayer project: entry scenes, World and queue files, joining, a first Local Play."
 license: MIT
 compatibility: [Cursor, Claude Code, Windsurf, Codex]
 category: multiplayer-and-networking
@@ -535,3 +535,20 @@ warning yourself.
 
 `multiplayer-movement`: each player moves their own character, and everyone
 else sees it move smoothly.
+
+<!-- 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_scene_tree` | `summer engine get-scene-tree` |
+| `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_stop` | `summer engine stop` |
+| `summer_write_file` | `summer engine write-file` |
+<!-- /shell-commands -->

package/library/skills/multiplayer-project/resource.yaml

@@ -1,7 +1,7 @@
 id: skill/multiplayer-project
 kind: skill
 version: 1.0.0
-summary: "Set up a Summer multiplayer project: both entry scenes, World and queue files, joining, and a first Local Play run."
+summary: "Set up a Summer multiplayer project: entry scenes, World and queue files, joining, a first Local Play."
 use_when:
   - "making a Summer game playable online or co-op: the first multiplayer setup"
   - "adding multiplayer to a Summer game: the client and authority scenes, summer.build.json, world.json and joining a queue"