summer-engine 4.0.0 → 4.2.0

package/library/skills/save-load/SKILL.md

@@ -154,3 +154,18 @@ Set `get_tree().set_auto_accept_quit(false)` so you control the quit.
   instead: a `RunVerification` probe (see `playtesting-a-feature`) that calls
   `save_game()`, changes a value, calls `load_game()`, and `report()`s the
   restored value.
+
+<!-- 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_project_setting` | `summer engine project-setting` |
+| `summer_read_file` | `summer engine read-file` |
+| `summer_replace_text` | `summer engine replace-text` |
+| `summer_write_file` | `summer engine write-file` |
+<!-- /shell-commands -->

package/library/skills/scene-composition/SKILL.md

@@ -165,3 +165,20 @@ Don't skip the player mask update. If you only move foliage to layer 9 without a
 ## Collaborative protocol
 
 This skill creates and mutates scene files. Always ask before applying: "May I create `res://scenes/player.tscn` and instantiate it under `./World`?".
+
+<!-- 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_create_scene` | `summer engine create-scene` |
+| `summer_get_scene_tree` | `summer engine get-scene-tree` |
+| `summer_import_from_url` | `summer engine import-from-url` |
+| `summer_instantiate_scene` | `summer engine instantiate-scene` |
+| `summer_open_scene` | `summer engine open-scene` |
+| `summer_save_scene` | `summer engine save-scene` |
+| `summer_set_prop` | `summer engine set-prop` |
+<!-- /shell-commands -->

package/library/skills/scene-hierarchy-design/SKILL.md

@@ -100,3 +100,27 @@ Follow the canonical scene loop from the Summer MCP reference: route → orient
 3. Deleting a wrapper parent (`summer_remove_node`) removes exactly its subtree — the recursive-despawn feature works.
 4. No script references a path deeper than one or two segments; group/signal/NodePath used instead.
 5. `summer_get_script_errors` and (if played) `summer_get_debugger_errors` are clean; `summer_screenshot` matches the intended layout.
+
+<!-- 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 |
+|---|---|
+| `docs.plan` | `summer docs plan` |
+| `summer_add_node` | `summer engine add-node` |
+| `summer_connect_signal` | `summer engine connect-signal` |
+| `summer_create_scene` | `summer engine create-scene` |
+| `summer_get_debugger_errors` | `summer engine get-debugger-errors` |
+| `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_instantiate_scene` | `summer engine instantiate-scene` |
+| `summer_play` | `summer engine play` |
+| `summer_remove_node` | `summer engine remove-node` |
+| `summer_save_scene` | `summer engine save-scene` |
+| `summer_screenshot` | `summer engine screenshot` |
+| `summer_stop` | `summer engine stop` |
+| `summer_get_agent_playbook` | `summer tool get-agent-playbook` |
+<!-- /shell-commands -->

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

@@ -192,3 +192,33 @@ If `summer_run_script` answers `engine_lacks_op`, the engine build predates RunS
 - `character-animation-wiring` — the animation tier end to end.
 - `gdscript-patterns` — idioms for the scripts `attach_script` writes.
 - `verification-before-completion` — proving the result 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 |
+|---|---|
+| `assets.slice_sheet` | `summer assets slice-sheet` |
+| `summer_api_docs` | `summer docs engine-api` |
+| `summer_docs_read` | `summer docs read` |
+| `summer_add_node` | `summer engine add-node` |
+| `summer_batch` | `summer engine batch` |
+| `summer_connect_signal` | `summer engine connect-signal` |
+| `summer_get_project_context` | `summer engine get-project-context` |
+| `summer_get_runtime_tree` | `summer engine get-runtime-tree` |
+| `summer_get_script_errors` | `summer engine get-script-errors` |
+| `summer_input_map_bind` | `summer engine input-map-bind` |
+| `summer_instantiate_scene` | `summer engine instantiate-scene` |
+| `summer_play` | `summer engine play` |
+| `summer_project_setting` | `summer engine project-setting` |
+| `summer_run_editor_script` | `summer engine run-editor-script` |
+| `summer_run_script` | `summer engine run-script` |
+| `summer_screenshot` | `summer engine screenshot` |
+| `summer_set_prop` | `summer engine set-prop` |
+| `summer_snapshot_diff` | `summer engine snapshot-diff` |
+| `summer_stop` | `summer engine stop` |
+| `summer_world_snapshot` | `summer engine world-snapshot` |
+| `summer_write_file` | `summer engine write-file` |
+<!-- /shell-commands -->

package/library/skills/scene-to-level/SKILL.md

@@ -125,3 +125,25 @@ Expect about 30 minutes for the asset packs (in parallel) and another 15 for sce
 - **Auto-tiling terrain.** The pipeline node exists in the decision tree but the leaf skill that implements it is not built.
 - **Animation orchestration.** Per-character `sprite-sheet` is invoked manually; no auto-pairing of characters with their animation pipelines yet.
 - **Gameplay code.** Player movement, interactions, win conditions — those are level-design + gameplay-mechanics skills, not this one.
+
+<!-- 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_search` | `summer assets search` |
+| `summer_add_node` | `summer engine add-node` |
+| `summer_create_scene` | `summer engine create-scene` |
+| `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_import_from_url` | `summer engine import-from-url` |
+| `summer_inspect_node` | `summer engine inspect-node` |
+| `summer_open_scene` | `summer engine open-scene` |
+| `summer_play` | `summer engine play` |
+| `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/skill-test/SKILL.md

@@ -84,3 +84,13 @@ This skill is **read-only**. It never writes. No "May I" needed.
 - the template registry: `library/templates/<id>/resource.yaml` (see `library/templates/README.md`)
 - `tests/runner.md`
 - `evals/skills/specs/` — per-skill behavioral specs
+
+<!-- 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/skybox-panorama/SKILL.md

@@ -205,3 +205,23 @@ After the sky is wired:
 - `scene-composition` — WorldEnvironment placement and configuration.
 - `asset-strategy` — meta-router.
 - `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_play` | `summer engine play` |
+| `summer_save_scene` | `summer engine save-scene` |
+| `summer_set_prop` | `summer engine set-prop` |
+| `summer_set_resource_property` | `summer engine set-resource-property` |
+| `summer_write_file` | `summer engine write-file` |
+<!-- /shell-commands -->

package/library/skills/sound-effect/SKILL.md

@@ -176,3 +176,26 @@ Print the prompt, the length and the target path (`res://audio/sfx/<name>.wav`),
 - `music-track` — music
 - `voice-line` — speech
 - `summer_docs_read` id `reference/mcp-tools-reference`
+
+<!-- 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` | `summer assets choices` |
+| `assets.generate_audio`, `summer_assets_generate_audio` | `summer assets generate-audio` |
+| `assets.generate_sfx_choices`, `summer_assets_generate_sfx_choices` | `summer assets generate-sfx-choices` |
+| `assets.get` | `summer assets get` |
+| `assets.search`, `summer_assets_search` | `summer assets search` |
+| `summer_docs_read` | `summer docs read` |
+| `summer_add_node` | `summer engine add-node` |
+| `summer_get_scene_tree` | `summer engine get-scene-tree` |
+| `summer_import_asset_by_id` | `summer engine import-asset-by-id` |
+| `summer_import_from_url` | `summer engine import-from-url` |
+| `summer_inspect_node` | `summer engine inspect-node` |
+| `summer_instantiate_scene` | `summer engine instantiate-scene` |
+| `summer_run_script` | `summer engine run-script` |
+| `summer_set_prop` | `summer engine set-prop` |
+<!-- /shell-commands -->

package/library/skills/spatial-placement/SKILL.md

@@ -208,3 +208,33 @@ anchors, pass their names instead.
 - A piece seated flush against a single-sided wall can read `open` in the
   wall's direction while `contacts` lists the wall: Starcast's one ray per
   direction starts at the touching face. Read `contacts` too.
+
+<!-- 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_align_distribute_3d` | `summer engine align-distribute-3d` |
+| `summer_attach_to_surface` | `summer engine attach-to-surface` |
+| `summer_batch` | `summer engine batch` |
+| `summer_connect_ports` | `summer engine connect-ports` |
+| `summer_get_scene_tree` | `summer engine get-scene-tree` |
+| `summer_inspect_asset` | `summer engine inspect-asset` |
+| `summer_inspect_node` | `summer engine inspect-node` |
+| `summer_instantiate_scene` | `summer engine instantiate-scene` |
+| `summer_measure` | `summer engine measure` |
+| `summer_open_scene` | `summer engine open-scene` |
+| `summer_place_adjacent` | `summer engine place-adjacent` |
+| `summer_raycast` | `summer engine raycast` |
+| `summer_repeat_along` | `summer engine repeat-along` |
+| `summer_run_script` | `summer engine run-script` |
+| `summer_screenshot` | `summer engine screenshot` |
+| `summer_set_prop` | `summer engine set-prop` |
+| `summer_snap_to_surface` | `summer engine snap-to-surface` |
+| `summer_snapshot_diff` | `summer engine snapshot-diff` |
+| `summer_starcast` | `summer engine starcast` |
+| `summer_test_placement` | `summer engine test-placement` |
+| `summer_world_snapshot` | `summer engine world-snapshot` |
+<!-- /shell-commands -->

package/library/skills/sprite-sheet/SKILL.md

@@ -247,3 +247,26 @@ After the animation is wired:
 - `generate-motion` — 3D-skeletal counterpart.
 - `sound-effect` — frame-synced SFX.
 - `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` |
+| `assets.get` | `summer assets get` |
+| `summer_assets_search` | `summer assets search` |
+| `assets.slice_sheet`, `summer_assets_slice_sheet` | `summer assets slice-sheet` |
+| `summer_docs_read` | `summer docs read` |
+| `docs.workflows` | `summer docs workflows` |
+| `summer_add_node` | `summer engine add-node` |
+| `summer_import_asset_by_id` | `summer engine import-asset-by-id` |
+| `summer_import_from_url` | `summer engine import-from-url` |
+| `summer_import_from_url_batch` | `summer engine import-from-url-batch` |
+| `summer_save_scene` | `summer engine save-scene` |
+| `summer_set_prop` | `summer engine set-prop` |
+| `summer_set_resource_property` | `summer engine set-resource-property` |
+| `summer_write_file` | `summer engine write-file` |
+<!-- /shell-commands -->

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

@@ -21,3 +21,14 @@ Its current text lives on the hosted Summer Engine MCP, the same text the Studio
 Screenshots: `summer_capture_gameplay` takes them offscreen. Get past the title screen with the game's own flags in `args` or with `steps`, e.g. `{"args":["--autostart"],"steps":[{"wait":3000},{"shot":true},{"key":"Space"},{"wait":800},{"shot":true}]}`.
 
 The one rule to keep even before you load it: Key art, covers and icons carry no text: the stores draw the title over them. Screenshots are real play.
+
+<!-- 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_capture_gameplay` | `summer engine capture-gameplay` |
+<!-- /shell-commands -->

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

@@ -19,3 +19,13 @@ Its current text lives on the hosted Summer Engine MCP, the same text the Studio
 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: Never invent features, modes, player counts, awards or prices.
+
+<!-- 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/summer-analytics/SKILL.md

@@ -147,3 +147,18 @@ Every failure is final: none of them asks you to capture again.
 - `multiplayer` — where the client and the authority run
 - `multiplayer-state` — the authority's Command handlers, where most events happen
 - `summer-match-results` — results and ratings, which Summer records itself
+
+<!-- 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 |
+|---|---|
+| `analytics.summary` | `summer analytics summary` |
+| `summer_get_diagnostics` | `summer engine get-diagnostics` |
+| `summer_get_script_errors` | `summer engine get-script-errors` |
+| `summer_play` | `summer engine play` |
+| `summer_stop` | `summer engine stop` |
+| `studio.open` | `summer studio open` |
+<!-- /shell-commands -->

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

@@ -166,3 +166,32 @@ critical are the person's to press.
 The app is published; `apps.screenshot` shows it with real data in light, dark and at
 390 px with no errors; its states (loading, empty, error) work; and the person knows what it
 does and where its data goes.
+
+<!-- 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 |
+|---|---|
+| `apps.call`, `summer_apps_call` | `summer apps call` |
+| `apps.create`, `summer_apps_create` | `summer apps create` |
+| `apps.dock` | `summer apps dock` |
+| `apps.events`, `summer_apps_events` | `summer apps events` |
+| `apps.get`, `summer_apps_get` | `summer apps get` |
+| `apps.guide`, `summer_apps_guide` | `summer apps guide` |
+| `summer_apps_list` | `summer apps list` |
+| `apps.page`, `summer_apps_page` | `summer apps page` |
+| `apps.publish`, `summer_apps_publish` | `summer apps publish` |
+| `apps.read_data`, `summer_apps_read_data` | `summer apps read-data` |
+| `apps.report_gap`, `summer_apps_report_gap` | `summer apps report-gap` |
+| `apps.screenshot`, `summer_apps_screenshot` | `summer apps screenshot` |
+| `apps.tools`, `summer_apps_tools` | `summer apps tools` |
+| `apps.update`, `summer_apps_update` | `summer apps update` |
+| `apps.use_page`, `summer_apps_use_page` | `summer apps use-page` |
+| `apps.write_data`, `summer_apps_write_data` | `summer apps write-data` |
+| `assets.generate_sfx_choices` | `summer assets generate-sfx-choices` |
+| `docs.feedback` | `summer docs feedback` |
+| `jobs.wait` | `summer jobs wait` |
+| `summer_search` | `summer ops search "<what you want>"` |
+<!-- /shell-commands -->

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

@@ -1,6 +1,6 @@
 ---
 name: summer-assets
-description: "Make game assets with Summer without Summer Engine: find, generate and download 3D models, images, audio and video for any engine or web app."
+description: "Make game assets with Summer, no Summer Engine: find, generate and download 3D models, images, audio and video for any engine or app."
 license: MIT
 compatibility: [Cursor, Claude Code, Codex, Windsurf, Gemini, OpenCode, Factory, Copilot]
 category: _meta
@@ -54,3 +54,33 @@ Each asset is a normal file in the person's Summer library: GLB for 3D models, P
 | Generating the same asset again to get the file | `assets.get` with `out` on the asset you already have |
 | Telling the person the asset looks right without a preview | Say what you received, or that no preview came back |
 | The person wants a whole game, not assets | Say that this needs Summer Engine and the full setup: `npx -y summer-engine@latest setup <agent> --yes` |
+
+<!-- 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.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` |
+| `assets.search` | `summer assets search` |
+| `assets.slice_sheet` | `summer assets slice-sheet` |
+| `summer_docs_read` | `summer docs read` |
+| `summer_docs_search` | `summer docs search` |
+| `summer_add_node` | `summer engine add-node` |
+| `summer_get_project_context` | `summer engine get-project-context` |
+| `summer_import_asset_by_id` | `summer engine import-asset-by-id` |
+| `summer_play` | `summer engine play` |
+| `summer_screenshot` | `summer engine screenshot` |
+| `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/summer-assets/resource.yaml

@@ -1,7 +1,7 @@
 id: skill/summer-assets
 kind: skill
-version: 1.0.0
-summary: "Make game assets with Summer without Summer Engine: find, generate and download 3D models, images, audio and video for any engine or web app."
+version: 1.0.1
+summary: "Make game assets with Summer, no Summer Engine: find, generate and download 3D models, images, audio and video for any engine or app."
 use_when:
   - starting a session that has the Summer assets profile (generation tools, no engine tools)
   - the person wants assets for their own engine or web app, not a game built in Summer Engine

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

@@ -0,0 +1,133 @@
+---
+name: summer-cli
+description: "Summer as shell commands, no MCP: sign in, find and run operations, follow jobs, save files, drive the engine."
+license: MIT
+compatibility: [Cursor, Claude Code, Codex, Windsurf, Gemini, OpenCode, Factory, Copilot]
+category: _meta
+allowed-tools: Bash Read
+---
+
+# Summer from the shell
+
+Use this skill when the session has no `summer_*` MCP tools (Summer was set up with `summer setup <agent> --cli`), or when a script or CI job runs Summer. Every Summer capability is an operation named `area.action`, and every operation is one command: `summer <area> <action>`. The commands run the same code as the MCP tools and give the same answers.
+
+First run `summer --version`. If the shell does not find `summer`, or the version is below 4.0 (an old global install, which has no `summer <area> <action>` commands), put `npx -y summer-engine@latest` in place of `summer`, with the same arguments. In Windows PowerShell, write `npx.cmd`.
+
+## The five commands in a game project
+
+<!-- project-commands: the AGENTS.md that summer create and summer setup write copies this list -->
+1. `summer run .` opens the project in Summer Engine. An agent's run stays in the background.
+2. `summer engine get-project-context` (MCP: `summer_get_project_context`) reads the project, its main scene and the engine version. Run it first.
+3. `summer engine play`, then `summer engine get-diagnostics` (MCP: `summer_play`, `summer_get_diagnostics`), runs the game and reads its errors. `summer engine stop` (`summer_stop`) ends it.
+4. `summer engine screenshot` (MCP: `summer_screenshot`) saves an image of the editor or the running game. Open its `localPath` to look.
+5. `summer ops search "<what you want>"` (MCP: `summer_search`) finds any other operation. Run it as `summer <area> <action>` (MCP: `summer_call`), with `--dry-run` first for a change.
+<!-- /project-commands -->
+
+## 1. Sign in once
+
+```bash
+summer login     # opens the browser: the Summer account, then the store and cloud operations
+summer whoami    # who is signed in, and their credits
+```
+
+Cloud operations (generation, the asset library, the store, publishing, analytics) need the sign-in. Engine commands do not. Run `summer login` in the foreground, once. Tell the person that their browser opens, and wait for them.
+
+## 2. Find the operation
+
+```bash
+summer ops search "make a sound effect"       # the best matches: name, effect, title
+summer ops describe assets.generate_audio     # the exact input: fields, types, which are required
+```
+
+Describe the job in plain words. `--area assets` keeps one area. Without a sign-in, search and describe still find every operation: a cloud one shows `(needs sign-in)` and runs after `summer login`.
+
+For a guide instead of an operation, search the library: `summer docs search --query "<the task>"`, then `summer docs read --id <id>`. Both work offline. Then follow the skill it names.
+
+Each Summer skill ends with a **From a shell** table: the command for each MCP tool and operation the skill names. A skill that says `summer_play` or `assets.generate_image` means `summer engine play` or `summer assets generate-image`.
+
+## 3. Run it
+
+```bash
+summer assets generate-image --dry-run --prompt "a cozy pixel-art tavern" --aspect-ratio 16:9
+summer engine set-prop --scene-path res://main.tscn --path Player --key position --value "Vector3(0, 1, 0)"
+summer store status --game-id <id> --json
+```
+
+- Actions and fields are kebab-case: `aspectRatio` is `--aspect-ratio`, `look_at` is `--look-at`.
+- `--<field>` alone sets a boolean field to true; `--no-<field>` sets it to false. Repeat a flag to give a list.
+- Objects, and anything hard to quote, go in `--input '<json>'`. A flag wins over the same key in `--input`.
+- `--dry-run` checks the input and changes nothing. For a spend it shows the estimate in credits. Put it right after the action: after `summer setup <agent> --cli --allow-rules --yes` (run that only when the person asks for it), Claude Code and Codex run it without asking (and the reads). Before each generation or other spend: dry-run it, tell the person what you will make, and wait for a yes.
+- `--idempotency-key <key>` makes a retry safe: Summer runs a change once per key.
+- `--json` prints only the answer: `{"ok":true,"status":"done","result":{...}}`. The exit code is 0 for every `ok` answer and 1 for an error.
+
+## 4. Long jobs
+
+3D, video, animation, builds and uploads answer `Started: job <id>` with the command that follows the job.
+
+```bash
+summer assets generate-3d --prompt "a wooden barrel" --wait          # runs, then follows the job to the end
+summer jobs wait --job-id <id> --timeout-seconds 50                  # run it again until finished is true
+```
+
+Do not run the same change again to get its result. Wait on the job.
+
+## 5. Approvals
+
+A publish or another live change can answer `Needs approval` with a link. Give the person that link: nothing changes until they approve. Follow it with `summer jobs wait --job-id <id>` (or `--wait` on the call) until it ends: `done`, `declined`, `expired` or `stale`. Never approve for the person.
+
+## 6. Files
+
+- `--out <folder or file>` on a generate command, on `summer jobs wait` or on `summer assets get` saves the file there. In a Godot project, `res://` paths work. The answer adds `localPath`.
+- Without `--out`, a generation run inside a game project saves into its asset folder: Godot `assets/`, Unity `Assets/Summer`, Unreal `Content/Summer`, three.js `public/assets`. Outside a project, give `--out`.
+- `summer assets get --asset-id <id>` saves only with `--out`.
+- A save never overwrites a file. Tell the person the `localPath`.
+
+## 7. The engine
+
+Engine commands (`summer engine …`) drive the Summer Engine app on this machine. The app must run with the project open.
+
+```bash
+summer status                                              # is the engine up, and the sign-in
+summer run ./my-game                                       # opens the project; for an agent, in the background
+summer engine get-project-context                          # first call: project, main scene, engine version
+summer engine get-scene-tree --scene-path res://main.tscn --depth 2
+summer engine screenshot                                   # the answer's localPath is an image: open it to look
+```
+
+- Values are engine value strings, not JSON: `"Vector3(0, 10, 0)"`, `"Color(1, 0.5, 0, 1)"`. A resource is its class name: `"BoxMesh"`.
+- Name the scene in every change: `--scene-path res://<scene>.tscn`.
+- 3 or more scene edits are one script, not a chain of commands. Write a `func run(ctx):` that ends with `ctx.save_scene()` to a file, then run `summer engine run-script --scene-path res://main.tscn --source "$(cat build.gd)"`. The `scene-scripting` skill has the script API.
+- With more than one editor open, set `SUMMER_ENGINE_PROJECT` to the project folder so the command picks the right one.
+- `summer tool <slug> --args '<json>'` runs an engine tool by its 3.x name too. `summer tool --list` lists them.
+
+## Without Summer Engine
+
+Everything except section 7 works without the app: the sign-in, the library, generation, assets and files, the store and analytics. Skip the `summer engine …` commands; there they answer `engine_not_running`. For assets for another engine or a web app, follow the `summer-assets` skill and stop at the file.
+
+## 8. Errors
+
+An error prints `Error (<code>): <message>` and one `Next:` step, and exits 1. Do the next step. Retry only when the table says so.
+
+| Code | Do this |
+|---|---|
+| `not_signed_in` | Run the command in `Next` (`summer login`), then the same command again. |
+| `engine_not_running` | Open the project in Summer Engine, or `summer run <project-path>`. Then run it again. |
+| `engine_lacks_op` | This engine build is too old for the command. Use the fallback the message names, or ask the person to update Summer Engine. |
+| `invalid_input` | `summer ops describe <op>`, fix the flags, run it again. |
+| `no_credits` | Give the person the link in `Next`. Do not run it again until they say they added credits. |
+| `forbidden` | Summer refused this account. The person checks it in Summer Studio. |
+| `not_found` | Check the id (the area's `list` command), or find the right operation with `summer ops search`. |
+| `rate_limited`, `unavailable` | Nothing ran. Wait a minute and run it again. If it repeats, tell the person the message. |
+| `outcome_unknown` | The change may have run. Run it again only with the same `--idempotency-key`, or check first. |
+| `in_progress` | The same change is still running. Wait, then follow its job or run it again with the same `--idempotency-key`. |
+| `idempotency_conflict` | That key was used for a different input. A new change needs a new key. |
+| `conflict` | The state changed, or a job or approval ended without running (declined, expired, stale or cancelled). Check the current state; start again only if the person wants it. |
+| `over_limit` | A plan limit or cap was reached. Give the person the message and the link in `Next`. Do not retry. |
+| `unsupported` | Summer cannot do this yet, or not here. Tell the person the message. Do not retry. |
+| `internal` | Summer failed on its side. Run it once more; if it fails again, tell the person the message. |
+
+## Done means
+
+- You ran each command and read its answer. Do not report an answer you did not get.
+- Every spend had a dry run and a yes from the person first.
+- Every file you made is saved, and you told the person its `localPath`.

package/library/skills/summer-cli/resource.yaml

@@ -0,0 +1,31 @@
+id: skill/summer-cli
+kind: skill
+version: 1.0.1
+summary: "Summer as shell commands, no MCP: sign in, find and run operations, follow jobs, save files, drive the engine."
+use_when:
+  - the session has no summer_* MCP tools, or Summer was set up with summer setup <agent> --cli
+  - running a Summer operation, a generation or an engine change from a shell, a script or CI
+  - a skill names an MCP tool or an operation and you need the summer command that runs it
+do_not_use_when:
+  - the session lists Summer's MCP tools; call them directly (the using-summer skill)
+facets:
+  lifecycle:
+    - build
+  domains:
+    - agent-workflow
+    - assets
+    - tools
+  modalities:
+    - docs
+related:
+  tools:
+    - tool/search-library
+    - tool/read-library
+  skills:
+    - skill/using-summer
+    - skill/summer-assets
+    - skill/scene-scripting
+source: official
+license: MIT
+status: preview
+recommended: true

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

@@ -224,3 +224,17 @@ and revoke access in the Summer app, and watch `access_changed`.
 - `summer-world-chat`: chat inside a match
 - `multiplayer-publish`: `summer.build.json` and publishing a Build
 - `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-leaderboards/SKILL.md

@@ -229,3 +229,19 @@ on them.
 - `summer-match-results` — concluding matches, which moves ratings
 - `summer-matchmaking` — declaring rated queues and teams
 - `summer-player-data` — saving per-player progress that isn't a ranking
+
+<!-- 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_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-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 -->