summer-engine 2.8.2 → 3.1.0

package/{skills/scene-and-project → library/skills}/make-game/SKILL.md

@@ -25,7 +25,7 @@ This is the skill that runs end-to-end when a user says "make me a game." It doe
 
 - User has a specific narrow ask ("add jump", "fix this bug", "design the inventory") → use the specific skill, not this orchestrator.
 - User already has a working scaffold and wants to iterate → start at the relevant phase below, don't re-run the whole pipeline.
-- User says "I want to use a template" → run `summer:browse-templates` first; come back here only if they decide they want a custom build instead.
+- User says "I want to use a template" → run `browse-templates` first; come back here only if they decide they want a custom build instead.
 
 ## The Pipeline
 
@@ -50,7 +50,7 @@ Run the phases in order. Between every phase, **stop and confirm with the user b
 **Goal**: turn a vague idea into a 1-page brief.
 
 ```
-Skill: summer:brainstorm-game
+Skill: brainstorm-game
 ```
 
 That skill asks one question, scopes mechanics, picks an art direction, and writes `.summer/GameSoul.md`. Don't skip this. **The brief is what every later phase reads.**
@@ -106,18 +106,18 @@ Source: .summer/GameSoul.md (date)
 
 **Goal**: working project on disk, scene opens in the engine.
 
-If the user said "I want to use a template" earlier, this is just `summer:browse-templates`.
+If the user said "I want to use a template" earlier, this is just `browse-templates`.
 
 If from scratch:
 
 ```
-Skill: summer:new-project
+Skill: new-project
 ```
 
 That picks `empty` vs `3d-basic` based on the GameSoul brief. After the project is created and `summer run` succeeds:
 
 ```
-Skill: summer:scene-composition
+Skill: scene-composition
 ```
 
 To set up the canonical hierarchy for the genre. For 3D action games:
@@ -133,7 +133,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 `summer:debug` immediately — do NOT continue building on a broken base.
+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.
 
 **Checkpoint before continuing:**
 
@@ -147,20 +147,20 @@ For each mechanic in the plan, **in order**:
 
 1. **Design pass**:
    ```
-   Skill: summer:design-mechanic
+   Skill: design-mechanic
    ```
    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 `summer:scene-composition` if the structure is non-trivial.
-   - For movement-class mechanics, prefer the matching pre-built skill: `summer:fps-controller`, `summer:peer-to-peer-multiplayer`, etc.
-   - Write GDScript with `summer:gdscript-patterns` open.
+   - Add the nodes via `summer_add_node` / `summer_set_prop`. Use `scene-composition` if the structure is non-trivial.
+   - For movement-class mechanics, prefer the matching pre-built skill: `fps-controller`, `peer-to-peer-multiplayer`, etc.
+   - Write GDScript with `gdscript-patterns` open.
 
 3. **Verify**:
    ```
-   Skill: summer:play
+   Skill: play
    ```
-   Then `summer_get_diagnostics`. Clean? Move on. Errors? `summer:debug` until clean. **Do not stack mechanic 2 on top of a broken mechanic 1.**
+   Then `summer_get_diagnostics`. Clean? Move on. Errors? `debug` until clean. **Do not stack mechanic 2 on top of a broken mechanic 1.**
 
 4. **Checkpoint**:
 
@@ -173,18 +173,18 @@ Repeat until every mechanic in the plan is implemented OR the user calls cut.
 **Goal**: the game stops looking like a programmer art prototype.
 
 ```
-Skill: summer:art-direction
+Skill: art-direction
 ```
 
-That writes `.summer/art-bible.md` if it doesn't exist, then guides the lighting / material / palette pass. Use `summer:3d-lighting` for the actual scene work.
+That writes `.summer/art-bible.md` if it doesn't exist, then guides the lighting / material / palette pass. Use `3d-lighting` for the actual scene work.
 
 ```
-Skill: summer:audio-direction
+Skill: audio-direction
 ```
 
 Writes `.summer/audio-bible.md` and sets up the audio bus structure. Wires SFX hooks into the mechanics from Phase 4.
 
-Use `summer:asset-strategy` to decide whether to generate assets, search the library, or use primitives. **Public asset library search is free** — encourage it before generation, which costs credits.
+Use `asset-strategy` to decide whether to generate assets, search the library, or use primitives. **Public asset library search is free** — encourage it before generation, which costs credits.
 
 **Checkpoint before continuing:**
 
@@ -195,14 +195,14 @@ Use `summer:asset-strategy` to decide whether to generate assets, search the lib
 **Goal**: the game *feels* good. Hit-flash, screen shake, audio ducking, weight.
 
 ```
-Skill: summer:vfx
+Skill: game-feel
 ```
 
 Walks the canonical Summer Engine game-feel stack: hit flash, trauma camera
 shake, and audio ducking wired so a single hit fires all three.
 
 ```
-Skill: summer:tune-performance
+Skill: tune-performance
 ```
 
 Only if `summer_get_diagnostics` flags rendering or physics hotspots. Don't optimize prematurely.
@@ -211,18 +211,18 @@ Only if `summer_get_diagnostics` flags rendering or physics hotspots. Don't opti
 
 **Goal**: the full game runs end-to-end without errors, and the win condition can actually be reached.
 
-1. `summer:play` from main scene.
+1. `play` from main scene.
 2. Walk every mechanic from the plan.
 3. Hit the win condition (or lose condition).
 4. `summer_get_diagnostics` clean.
-5. `summer:debug` until clean if not.
+5. `debug` until clean if not.
 
 **Don't skip this even if every mechanic worked individually.** Integration bugs hide between mechanics.
 
 ## Phase 8: Ship
 
 ```
-Skill: summer:export-and-ship
+Skill: export-and-ship
 ```
 
 Pre-flight checklist (icon, store banners, build config) before producing release builds for the targets in the brief.
@@ -261,6 +261,6 @@ That's a real game. Not a half-finished prototype.
 
 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 (`summer:export-and-ship`) or iterate?"
+> "<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.

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

@@ -0,0 +1,35 @@
+id: skill/make-game
+kind: skill
+version: 1.0.3
+summary: "Orchestration spine for 'make me a game': brainstorm, plan, scaffold, mechanics, art, audio, polish, verify, ship — delegates to specialist skills."
+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
+facets:
+  lifecycle:
+    - build
+  domains:
+    - scenes
+    - project
+  modalities:
+    - project
+    - scenes
+compatibility:
+  engine: ">=4.6"
+related:
+  skills:
+    - skill/audio-direction
+    - skill/export-and-ship
+    - skill/design-mechanic
+    - skill/tune-performance
+    - skill/art-direction
+    - skill/brainstorm-game
+    - skill/new-project
+    - skill/play
+    - skill/scene-composition
+source: official
+license: MIT
+status: stable
+recommended: true
+aliases:
+  - skills/scene-and-project/make-game

package/library/skills/music-track/resource.yaml

@@ -0,0 +1,28 @@
+id: skill/music-track
+kind: skill
+version: 1.0.2
+summary: Generate a looped or cinematic music track — loops authored at >=30s with a marked loop point, cinematic tracks at >=60s linear.
+use_when:
+  - generating a looped or cinematic music track — main theme, boss music, title screen, exploration loop, combat track
+  - a game has no music yet or needs a new track for a level, a cutscene, or the credits
+facets:
+  lifecycle:
+    - build
+  domains:
+    - audio
+    - assets
+  modalities:
+    - audio
+    - assets
+compatibility:
+  engine: ">=4.6"
+related:
+  skills:
+    - skill/adaptive-music
+    - skill/audio-direction
+source: official
+license: MIT
+status: stable
+recommended: true
+aliases:
+  - skills/audio/music-track

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

@@ -0,0 +1,61 @@
+---
+name: navigate-summer
+description: Use when the user wants to SEE, CHECK, or DECIDE something — "show me my billing", "where do I change my plan", "open my games", "let me look at the scene", "open the MCP guide for Cursor". Decides whether to open a Summer web page or editor surface for the user or to act through the API, and lands exactly there with summer_open.
+license: MIT
+compatibility: [Cursor, Claude Code, Codex, Windsurf, Gemini, OpenCode, Factory, Copilot]
+category: _meta
+user-invocable: true
+allowed-tools: summer_open summer_get_project_context summer_is_running
+paths: ["**/project.godot", "**/*.tscn", "**/.summer/**"]
+---
+
+# navigate-summer — land the user exactly where they want to look
+
+## Overview
+
+Summer has two surfaces the user looks at: **summerengine.com** (Studio, games, billing, templates, guides, docs) and the **Summer Engine editor** (scenes, nodes, docks). `summer_open` — the same behavior as `summer open <target>` in a shell — takes an intent ("billing", "my games", "the scene I'm editing", "res://player.gd") and opens the exact page or panel, or prints the URL / engine op so you can hand it over. The **product map** reference (`../../references/product-map/product-map.md`) is the full table of destinations with their intent phrases, required context, and what the user will see.
+
+Rigid skill: follow the rules below exactly.
+
+## The one decision: open a surface, or act?
+
+| The user wants to… | Do |
+|---|---|
+| **see / check / decide** — plan and billing (money), their published games and releases, usage, pricing, the MCP setup guide for their agent, docs, the scene or node you just built ("show me") | **Open the surface** with `summer_open` |
+| **get a result** — add a node, set a property, import an asset, run the game, publish | **Act through Summer tools** (mutation tools, `summer_play`, `summer_creator_publish`); do not open the editor to do by hand what a tool does |
+| **both** ("add a camera and show me") | act first, then open the scene / select the node so the user sees the result |
+
+Never open a browser or switch the editor's tab as a side effect of building. Opening is a user-visible action — do it because the user asked to look, and say what will open before it opens.
+
+## How to call it
+
+1. **Resolve first when unsure.** `summer_open({ target: "change my plan", open: false })` returns the matched target, the URL (and `login_url` if login is required), or the engine op — nothing opens. If `action` is `ambiguous`, pick from `matches` and call again with the `id`.
+2. **Open.** `summer_open({ target: "billing" })` opens the browser at Studio → Billing. `summer_open({ target: "scene", params: { path: "res://levels/level_1.tscn" } })` opens the scene in the running editor. `summer_open({ target: "node", params: { node: "Player/Camera3D" } })` selects the node. `summer_open({ target: "res://player.gd" })` routes by extension.
+3. **Fill the slots the target declares.** `game` needs `params.gameId` (and an optional `section` such as `builds`, `releases`, `store-page`, `analytics`); `mcp-guide` takes `params.guide` as an agent name (`cursor`, `claude-code`, `codex`, `gemini`, …); `profile` takes `username`; `changelog` takes `version`.
+4. **List when you do not know the id.** `summer_open({})` returns every target with `surface`, `status`, and `requires`. In a shell: `summer open --list`.
+
+## Read the result honestly
+
+- `action: "opened"` — say what opened, in one line ("Opened Studio → Billing in your browser.").
+- `logged_in: false` with `login_url` — the login page opened with `returnUrl` set; tell the user the destination loads after sign-in.
+- `action: "engine_not_running"` — nothing opened. Tell the user to start Summer Engine (`summer run <project>`) or open the project in the desktop app, then offer to retry. Do not fall back to editing files.
+- `action: "unsupported"` (`failure_reason: engine_lacks_op`) — this Summer Engine build cannot open that surface (it predates the `Navigate` op, or does not advertise that id). Say so plainly, tell the user to update Summer Engine, and describe what to open by hand. Never claim it opened.
+- `action: "ambiguous"` — show the top matches by title and ask, or pick the obvious one and say which you picked.
+- `action: "not_found"` — the intent is not a Summer destination (or a `res://` path tried to escape the project). Do not invent a URL; the tool only opens summerengine.com and its subdomains.
+- `action: "open_failed"` — this machine could not launch a browser (headless, no display). Nothing opened; paste the `url` for the user.
+- `action: "blocked_origin"` — the configured gateway is not a Summer origin; nothing opened. Tell the user to check `gateway.url` / `SUMMER_GATEWAY_URL`.
+
+## When to hand over a link instead
+
+Use `open: false` (CLI: `--print`) and paste the `url` (or `login_url`) when the session has no browser (headless, remote, CI), when the user asked for a link, or when opening would interrupt what the user is doing. A link the user clicks is always acceptable; a browser window that appears unasked is not.
+
+## Editor targets
+
+The editor owns its own table of destinations (the `Navigate` op) and tells the tool which ids it can open. `summer_open({})` lists every editor id with `availability`: `available` (Navigate op), `legacy` (an older engine serving it through its original op), `unavailable` (update Summer Engine), `unknown` (engine not running). Ids: `scene` (default = the project's main scene), `main-scene`, `node`, `script` (with `line`), `file`, `files`, `scene-tree`, `inspector`, `import-dock`, `signals-dock`, `changes-dock`, `screen-2d/3d/script/game/assetlib`, `viewport-show/hide`, `assistant`, `project-settings`, `editor-settings`, `output`, `debugger`, `editor-window`. On a legacy engine, `script` opens without taking focus — mention it if the user does not see it.
+
+## Anti-patterns
+
+- Opening `billing` or `pricing` when the user asked about a **feature**, not money.
+- Opening the scene in the editor **before** the change landed ("show me" comes after the mutation and its screenshot).
+- Guessing a `gameId`. Open `my-games` and let the user pick, or read the id from a URL they gave you.
+- Describing a page you did not open. If `ok` is false, the user saw nothing.

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

@@ -0,0 +1,35 @@
+id: skill/navigate-summer
+kind: skill
+version: 1.0.0
+summary: When to open a Summer web page or editor surface FOR the user (billing, their games, the scene just built) versus acting through the API, using summer_open.
+use_when:
+  - the user asks to see, check, or decide something — "show me my billing", "where do I change my plan", "open my games", "let me look at the scene", "take me to the MCP guide for Cursor"
+  - deciding whether to open a surface for the user or to do the work through Summer tools
+  - handing the user a link (headless, remote, or the user prefers a link) instead of launching a browser
+do_not_use_when:
+  - the user wants a change made — add/set/remove nodes, publish, generate; use the build skills and mutation tools
+  - opening a project directory in the engine — `summer run <path>`
+facets:
+  lifecycle:
+    - build
+    - launch
+    - support
+  domains:
+    - navigation
+    - agent-workflow
+    - meta
+  modalities:
+    - docs
+compatibility:
+  engine: ">=4.6"
+related:
+  tools:
+    - tool/open
+  references:
+    - reference/product-map
+  skills:
+    - skill/using-summer
+source: official
+license: MIT
+status: stable
+recommended: true

package/{skills/scene-and-project → library/skills}/new-project/SKILL.md

@@ -23,8 +23,8 @@ When the user wants to start from a blank canvas — not a community template, n
 
 ## When NOT to use this skill
 
-- "Show me templates" / "use a template" → `summer:browse-templates`.
-- "Make me a game" with a defined idea → run `summer:brainstorm-game` first to scope, then come back here once the user knows what they want.
+- "Show me templates" / "use a template" → `browse-templates`.
+- "Make me a game" with a defined idea → run `brainstorm-game` first to scope, then come back here once the user knows what they want.
 - "I have an existing Godot project I want to import" → not this skill; have the user run `summer open <path>` directly.
 
 ## Steps
@@ -48,7 +48,7 @@ If you're not sure which fits, ask:
 
 > "Empty (just a root node) or 3d-basic (camera, light, and a floor — you can press play immediately)?"
 
-If the user has clearly invoked `summer:brainstorm-game` already and the brief calls for 3D, default to `3d-basic` and mention you did. If 2D, use `empty` (we don't ship a 2D-basic yet).
+If the user has clearly invoked `brainstorm-game` already and the brief calls for 3D, default to `3d-basic` and mention you did. If 2D, use `empty` (we don't ship a 2D-basic yet).
 
 ### 3. Create
 
@@ -74,12 +74,12 @@ Confirm the engine launched and the project loaded. If `summer run` fails, run `
 
 ### 5. Don't keep going automatically
 
-After scaffolding, **stop and let the user direct.** A common mistake: fire `summer:fps-controller` or `summer:design-mechanic` automatically because "now we make a game." Wait. The user might want to:
+After scaffolding, **stop and let the user direct.** A common mistake: fire `fps-controller` or `design-mechanic` automatically because "now we make a game." Wait. The user might want to:
 
-- Brainstorm what to build (`summer:brainstorm-game`)
-- Set the visual direction (`summer:art-direction`)
-- Jump straight into a known mechanic (`summer:design-mechanic`)
-- Build a specific controller (`summer:fps-controller`)
+- Brainstorm what to build (`brainstorm-game`)
+- Set the visual direction (`art-direction`)
+- Jump straight into a known mechanic (`design-mechanic`)
+- Build a specific controller (`fps-controller`)
 
 Ask: "Project is open. What do you want to build?"
 
@@ -89,8 +89,8 @@ Ask: "Project is open. What do you want to build?"
 |---|---|
 | Skip the name question and use `my-game` silently | The user has opinions about the directory name. Two seconds of asking saves a `mv` later. |
 | Use `summer create 3d-basic` for a 2D game | Wrong starting scene. Use `empty` and let the user/agent build the 2D root from there. |
-| Default to a community template | That's `summer:browse-templates`. This skill is specifically for "blank canvas." |
-| Continue into `summer:fps-controller` automatically | Most users want to brainstorm or set art direction first. Stop and ask. |
+| Default to a community template | That's `browse-templates`. This skill is specifically for "blank canvas." |
+| Continue into `fps-controller` automatically | Most users want to brainstorm or set art direction first. Stop and ask. |
 | Run this when the user is in an existing project | Check `summer status` or `summer_get_project_context` first. If a project is already open, the user probably wanted to modify it, not create a new one. |
 
 ## Edge cases

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

@@ -0,0 +1,28 @@
+id: skill/new-project
+kind: skill
+version: 1.0.4
+summary: Create a fresh blank Summer Engine project — asks one question (project name) and runs summer create empty.
+use_when:
+  - the user wants a fresh blank Summer Engine project — from scratch, blank canvas
+  - starting a Summer Engine project with no template, only a name, ready for an empty main scene
+do_not_use_when:
+  - starting from an existing template — use browse-templates
+facets:
+  lifecycle:
+    - build
+  domains:
+    - scenes
+    - project
+  modalities:
+    - project
+compatibility:
+  engine: ">=4.6"
+related:
+  skills:
+    - skill/make-game
+source: official
+license: MIT
+status: stable
+recommended: true
+aliases:
+  - skills/scene-and-project/new-project

package/{skills/3d-assets → library/skills}/organic-model/SKILL.md

@@ -29,11 +29,11 @@ Backing tool: `summer_generate_3d`. Default `hunyuan` is great here, but `trelli
 
 ## When NOT to use
 
-- Character (humanoid, even if "tree-person") → `summer:3d-assets/character-model` (rigging matters).
-- Vehicle, weapon, hard-surface object → `summer:3d-assets/prop-model` or `summer:3d-assets/vehicle-model`.
-- Tileable ground (grass field, sand) → `summer:asset-pipeline/asset-strategy` Pipeline 2 (textures, not meshes).
+- Character (humanoid, even if "tree-person") → `character-model` (rigging matters).
+- Vehicle, weapon, hard-surface object → `prop-model` or `vehicle-model`.
+- Tileable ground (grass field, sand) → `asset-strategy` Pipeline 2 (textures, not meshes).
 - Animated organic (Venus fly trap that opens, breathing pod) → generate static here, animate in-engine with bones or shape keys.
-- A single hero-tree centerpiece (Yggdrasil, the One Tree) — generate via `summer:3d-assets/prop-model` with higher polycount and detail attention.
+- A single hero-tree centerpiece (Yggdrasil, the One Tree) — generate via `prop-model` with higher polycount and detail attention.
 
 ## Polycount targets
 
@@ -137,7 +137,7 @@ A `.glb` cannot be assigned to `MeshInstance3D.mesh`. An imported `.glb` is a sc
 
 Every scene-mutating tool takes an explicit `scenePath`; node paths are relative to that scene's root (`./`).
 
-**Forest scatter (MultiMesh):** create a `MultiMeshInstance3D`, assign a `MultiMesh` resource referencing the tree mesh, set `instance_count` to e.g. 100, and populate `set_instance_transform()` from a script with random positions + rotations. See `summer:scene-composition` for the scatter pattern.
+**Forest scatter (MultiMesh):** create a `MultiMeshInstance3D`, assign a `MultiMesh` resource referencing the tree mesh, set `instance_count` to e.g. 100, and populate `set_instance_transform()` from a script with random positions + rotations. See `scene-composition` for the scatter pattern.
 
 ### 6. LOD and billboards
 
@@ -161,7 +161,7 @@ For a 200-tree forest, ~10 close trees are real meshes, 190 are billboards. Fram
 
 ## Edge cases
 
-- **Animated foliage (wind sway).** Generate static here, then add wind sway via a vertex shader on the material — `summer:vfx/shaders` (when available). No animation rig needed.
+- **Animated foliage (wind sway).** Generate static here, then add wind sway via a hand-written vertex displacement shader on the material. No animation rig needed.
 - **Underwater organics (kelp, anemones).** Same flow; expect Hunyuan to add a "ground attachment" base unless you say `floating, suspended in water`.
 - **Branching meshes (vines, roots) come back too thick.** Specify `thin tendril, fine branches`, or accept and scale Y down in the editor.
 - **Snow / ice / frozen variant.** Add `covered in snow, frosted, ice crystals` to the prompt — works well on trees and rocks. For temperature variants of the same scene, generate the variant rather than retexturing.
@@ -181,16 +181,16 @@ For totally free / offline alternatives: **Quaternius** (free stylized organics)
 After the organic models are scattered:
 
 > Forest scatter ready: 3 species at `res://assets/organic/`, 100 instances each via MultiMeshInstance3D in `./World/Forest`. Next:
-> - **Wind shader** (sway in breeze): `summer:vfx/shaders` when available, or hand-write a vertex displacement shader.
-> - **Ground texture** (grass beneath the trees): `summer:asset-pipeline/asset-strategy` Pipeline 2 for tileable ground.
-> - **Lighting / fog** (forest mood): `summer:3d-lighting` for ambient + directional sun + volumetric fog.
-> - **Ambient audio** (forest birds, leaves): `summer:audio/ambient-bed`.
-> - **Hero props** (a stump, a fallen log, a shrine): `summer:3d-assets/prop-model` for the hand-placed standouts.
+> - **Wind shader** (sway in breeze): hand-write a vertex displacement shader.
+> - **Ground texture** (grass beneath the trees): `asset-strategy` Pipeline 2 for tileable ground.
+> - **Lighting / fog** (forest mood): `3d-lighting` for ambient + directional sun + volumetric fog.
+> - **Ambient audio** (forest birds, leaves): `ambient-bed`.
+> - **Hero props** (a stump, a fallen log, a shrine): `prop-model` for the hand-placed standouts.
 
 ## See also
 
-- `summer:3d-assets/prop-model` — for hand-placed standout pieces.
-- `summer:3d-assets/environment-kit` — pair with this skill: kit pieces give the architecture, organic gives the natural softness.
-- `summer:asset-pipeline/asset-strategy` — meta-router; ground textures and skyboxes go to Pipeline 2 / panoramic gen.
-- `summer:scene-composition` — MultiMeshInstance3D scatter pattern.
-- `../../../references/mcp-tools-reference.md` — `summer_generate_3d` schema.
+- `prop-model` — for hand-placed standout pieces.
+- `environment-kit` — pair with this skill: kit pieces give the architecture, organic gives the natural softness.
+- `asset-strategy` — meta-router; ground textures and skyboxes go to Pipeline 2 / panoramic gen.
+- `scene-composition` — MultiMeshInstance3D scatter pattern.
+- `../../references/mcp-tools-reference/mcp-tools-reference.md` — `summer_generate_3d` schema.

package/library/skills/organic-model/resource.yaml

@@ -0,0 +1,32 @@
+id: skill/organic-model
+kind: skill
+version: 1.0.3
+summary: Generate organic 3D shapes — trees, rocks, mushrooms, coral, plants, vines, crystals — where AI artifacts read as natural irregularity.
+use_when:
+  - generating organic shapes — trees, rocks, mushrooms, coral, bushes, alien plants, vines, crystals, fruit, bones
+  - a level needs vegetation, rocks, or other natural shapes where irregularity reads as realism
+facets:
+  lifecycle:
+    - build
+  domains:
+    - 3d
+    - assets
+  modalities:
+    - 3d-models
+    - scenes
+compatibility:
+  engine: ">=4.6"
+related:
+  skills:
+    - skill/character-model
+    - skill/environment-kit
+    - skill/prop-model
+    - skill/vehicle-model
+    - skill/asset-strategy
+    - skill/ambient-bed
+source: official
+license: MIT
+status: stable
+recommended: false
+aliases:
+  - skills/3d-assets/organic-model

package/{skills/multiplayer-and-networking → library/skills}/peer-to-peer-multiplayer/SKILL.md

@@ -33,7 +33,7 @@ Ask the user before anything else:
 | Answer | Architecture |
 |---|---|
 | Friend-invite / small lobby (≤8 players) | **P2P with host authority.** This skill. |
-| Matchmaking + anti-cheat + scale | **Dedicated client-server.** Different skill (`/summer:client-server-multiplayer`). |
+| Matchmaking + anti-cheat + scale | **Dedicated client-server.** Different skill (`/host-authoritative-state`). |
 | MMO / persistent world | **Custom server.** Out of scope for this skill. |
 
 If P2P is right, continue. Otherwise, stop and route to the right skill.
@@ -348,7 +348,7 @@ func _interpolate_to_buffer() -> void:
 
 - **Single-player game with leaderboards.** No multiplayer needed.
 - **Async multiplayer** (turn-based via REST API). This skill assumes real-time.
-- **Dedicated server with anti-cheat.** Use `/summer:client-server-multiplayer` (when shipped).
+- **Dedicated server with anti-cheat.** Use `/host-authoritative-state`.
 - **Already-shipped game getting multiplayer retrofit.** Sorry — you're in for a refactor. This skill helps for the redesign but not the migration.
 
 ## Collaborative protocol

package/library/skills/peer-to-peer-multiplayer/resource.yaml

@@ -0,0 +1,28 @@
+id: skill/peer-to-peer-multiplayer
+kind: skill
+version: 1.0.4
+summary: Start a multiplayer game from scratch with peer-to-peer host authority — network architecture built top-down, before writing game logic.
+use_when:
+  - starting a multiplayer Summer game from scratch with peer-to-peer host authority, before writing game logic
+  - I want to play co-op or online with friends and the game doesn't exist yet
+facets:
+  lifecycle:
+    - build
+  domains:
+    - multiplayer
+    - project
+  modalities:
+    - scripts
+    - scenes
+compatibility:
+  engine: ">=4.6"
+related:
+  skills:
+    - skill/host-authoritative-state
+    - skill/setup-multiplayer
+source: official
+license: MIT
+status: stable
+recommended: true
+aliases:
+  - skills/multiplayer-and-networking/peer-to-peer-multiplayer

package/{skills/2d-assets → library/skills}/pixel-art/SKILL.md

@@ -33,9 +33,9 @@ and by downscaling to the target resolution after generation.
 
 ## When NOT to use
 
-- The user wants a high-resolution painterly portrait → `summer:2d-assets/character-portrait`.
-- The user wants animated frames (walk cycle, attack) → `summer:2d-assets/sprite-sheet` (pixel art is harder for sprite sheets — read that skill's caveats).
-- The user wants a tileable seamless texture (not pixel art) → `summer:2d-assets/tileable-texture`.
+- The user wants a high-resolution painterly portrait → `character-portrait`.
+- The user wants animated frames (walk cycle, attack) → `sprite-sheet` (pixel art is harder for sprite sheets — read that skill's caveats).
+- The user wants a tileable seamless texture (not pixel art) → `tileable-texture`.
 - The game is 3D / non-pixel — verify the user actually wants pixel before generating.
 
 ## Steps
@@ -140,7 +140,7 @@ Confirm `Filter: Nearest` is set in the import dock OR project-wide.
 | `8-bit sword` | "8-bit" is interpreted loosely. Returns a smooth render of a sword with vague pixel feel. Specify resolution + palette + "no AA" explicitly. |
 | `pixel art knight, photorealistic` | Conflicting directives. Model averages and gives you neither. |
 | `pixel art at 32x32` with no negations | Model adds soft edges and gradient shading. Always spell out "no anti-aliasing, no blur, no smooth gradients" in the prompt itself — there is no negative-prompt argument to fall back on. |
-| `pixel sprite walk cycle` | Walk cycles need consistent frames — single-prompt sprite sheets fail. Route to `summer:2d-assets/sprite-sheet`. |
+| `pixel sprite walk cycle` | Walk cycles need consistent frames — single-prompt sprite sheets fail. Route to `sprite-sheet`. |
 | `cute pixel art` | "Cute" without subject is undefined. Specify what. |
 
 ## Anti-patterns
@@ -150,13 +150,13 @@ Confirm `Filter: Nearest` is set in the import dock OR project-wide.
   Nearest on import or project-wide for pixel art.
 - **Reaching for `negative_prompt` or `image_size`.** Neither exists on this tool; both are dropped without an error, so the call looks like it worked and the output is off-style. Negations go in the prompt text; size is fixed.
 - **Inconsistent palette across the cast.** Pick a named palette (PICO-8, NES, custom hex list) and re-use across every asset in the project. Different palettes = the project doesn't read as one game.
-- **Generating walk-cycle frames as one image.** Sprite sheets via single-prompt are unreliable. Route to `summer:2d-assets/sprite-sheet`.
+- **Generating walk-cycle frames as one image.** Sprite sheets via single-prompt are unreliable. Route to `sprite-sheet`.
 
 ## Edge cases
 
-- **User wants animated pixel sprites.** Generate base sprite here, then per-frame variants via img2img with the base as `referenceImageUrl`. For more than 2-3 frames, route to `summer:2d-assets/sprite-sheet` (and read its caveats).
+- **User wants animated pixel sprites.** Generate base sprite here, then per-frame variants via img2img with the base as `referenceImageUrl`. For more than 2-3 frames, route to `sprite-sheet` (and read its caveats).
 - **User wants the entire game in pixel art.** Set `Project Settings → Rendering → Textures → Default Texture Filter: Nearest` once. Saves you from re-setting it on every import.
-- **User wants a high-res "pixel art" portrait that's not actually pixelated** (faux-pixel-aesthetic at full resolution). That's `summer:2d-assets/character-portrait` with a "pixel art aesthetic" prompt — not this skill.
+- **User wants a high-res "pixel art" portrait that's not actually pixelated** (faux-pixel-aesthetic at full resolution). That's `character-portrait` with a "pixel art aesthetic" prompt — not this skill.
 - **User specifies a palette like "Sweetie-16" or "Endesga-32" and the model ignores it.** Name the hex codes explicitly. Palette names alone are unreliable below the top 5-10 famous ones.
 - **Tilesets need to tile cleanly.** Pixel-art tile-edge cleanliness from raw generation is poor. Generate the tile grid, then manually fix edge seams in Aseprite. The AI gets you 80% there.
 
@@ -184,13 +184,13 @@ If MCP is offline entirely: open Aseprite or Piskel and hand-author the asset. F
 After the asset is wired:
 
 - **More assets in the same style** → re-invoke this skill, re-use the pixel anchor.
-- **Animation frames for the sprite** → `summer:2d-assets/sprite-sheet` with the base sprite as anchor.
+- **Animation frames for the sprite** → `sprite-sheet` with the base sprite as anchor.
 - **Pixel UI** → re-invoke with UI subjects (icons, button frames) at appropriate resolution.
-- **Tilemap setup** → `summer:scene-composition` for `TileMap` / `TileMapLayer` wiring.
+- **Tilemap setup** → `scene-composition` for `TileMap` / `TileMapLayer` wiring.
 
 ## See also
 
-- `summer:2d-assets/sprite-sheet` — animated pixel frames.
-- `summer:2d-assets/character-portrait` — high-res counterpart.
-- `summer:asset-pipeline/asset-strategy` — meta-router.
-- `../../../references/mcp-tools-reference.md` — `summer_generate_image` schema.
+- `sprite-sheet` — animated pixel frames.
+- `character-portrait` — high-res counterpart.
+- `asset-strategy` — meta-router.
+- `../../references/mcp-tools-reference/mcp-tools-reference.md` — `summer_generate_image` schema.

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

@@ -0,0 +1,31 @@
+id: skill/pixel-art
+kind: skill
+version: 1.0.4
+summary: Generate pixel-art assets — sprites, items, tiles, portraits — at a specific resolution with pixel-perfect grid, limited palette, retro feel.
+use_when:
+  - generating pixel-art assets — sprites, items, tiles, portraits — in a pixel style at a specific resolution (32x32, 64x64, 128x128)
+  - a retro or low-resolution 2D game needs sprites, tiles, or portraits on a fixed grid with a limited palette
+facets:
+  lifecycle:
+    - build
+  domains:
+    - 2d
+    - assets
+  modalities:
+    - images
+    - assets
+compatibility:
+  engine: ">=4.6"
+related:
+  skills:
+    - skill/character-portrait
+    - skill/sprite-sheet
+    - skill/tileable-texture
+    - skill/asset-strategy
+    - skill/create-asset-sheet
+source: official
+license: MIT
+status: stable
+recommended: true
+aliases:
+  - skills/2d-assets/pixel-art

package/library/skills/play/resource.yaml

@@ -0,0 +1,26 @@
+id: skill/play
+kind: skill
+version: 1.0.2
+summary: Run the project in Summer Engine, wait briefly, then report what's happening — clean run, errors, or warnings.
+use_when:
+  - the user says 'play', 'run it', 'test it', 'let me see it', or 'start the game'
+  - checking that the project still starts and runs cleanly right after a change
+facets:
+  lifecycle:
+    - build
+  domains:
+    - scenes
+    - project
+  modalities:
+    - project
+compatibility:
+  engine: ">=4.6"
+related:
+  skills:
+    - skill/debug
+source: official
+license: MIT
+status: stable
+recommended: true
+aliases:
+  - skills/scene-and-project/play