summer-engine 3.0.0 → 3.1.0

package/integrations/hermes/manifest-target.json

@@ -0,0 +1,3 @@
+{
+  "targets": []
+}

package/integrations/junie/README.md

@@ -0,0 +1,12 @@
+# Junie integration
+
+No manifest file is generated in this repo for Junie — `manifest-target.json`
+is intentionally empty. Support is delivered at install time by
+`summer setup junie` (aliases: `jetbrains-junie`), which writes:
+
+- MCP config: `~/.junie/mcp/mcp.json`; Windows `%USERPROFILE%/.junie/mcp/mcp.json` (user); `.junie/mcp/mcp.json` (project).
+  Shape: `mcpServers.summer-engine = { command, args }`.
+- Skills: none. Junie has no skills folder; put project guidance in .junie/guidelines.md. The MCP server ships summer_get_agent_playbook for in-chat guidance.
+- After: Restart the JetBrains IDE so Junie reloads its MCP config.
+
+Source of truth: `src/installer/agent-table.ts` (one row per agent).

package/integrations/junie/manifest-target.json

@@ -0,0 +1,3 @@
+{
+  "targets": []
+}

package/integrations/kilo-code/README.md

@@ -2,15 +2,11 @@
 
 No manifest file is generated in this repo for Kilo Code — `manifest-target.json`
 is intentionally empty. Support is delivered at install time by
-`summer setup kilo-code`, which writes:
+`summer setup kilo-code` (aliases: `kilo`, `kilocode`), which writes:
 
-- MCP config: Kilo Code's VS Code global storage
-  (`<VS Code user dir>/globalStorage/kilocode.kilo-code/settings/mcp_settings.json`,
-  user scope) or `./.kilocode/mcp.json` (project scope).
-- Skills: `summer setup kilo-code` installs the whole library in the same
-  scope as the MCP config (user by default), as rule files in
-  `~/.kilocode/rules/summer-<skill>.md` (user) or `./.kilocode/rules/`
-  (project). `summer skills install --agent kilo-code` on its own defaults
-  to project scope; pass `--scope user` to match a user-scope MCP config.
+- MCP config: `~/.config/kilo/kilo.json`; Windows `%APPDATA%/kilo/kilo.json` (user); `kilo.json` (project).
+  Shape: `mcp.summer-engine = { type: "local", command: [npx, ...], enabled: true }`.
+- Skills: `~/.kilo/skills` (user) or `.kilo/skills` (project) as `<skill>/SKILL.md`.
+- After: Restart Kilo (CLI or the VS Code extension) so it reloads kilo.json.
 
-Source of truth: `src/installer/agent-config.ts`, `src/cli/commands/skills.ts`.
+Source of truth: `src/installer/agent-table.ts` (one row per agent).

package/integrations/kimi-code/README.md

@@ -0,0 +1,12 @@
+# Kimi Code CLI integration
+
+No manifest file is generated in this repo for Kimi Code CLI — `manifest-target.json`
+is intentionally empty. Support is delivered at install time by
+`summer setup kimi-code` (aliases: `kimi`, `kimi-cli`, `kimicode`), which writes:
+
+- MCP config: `~/.kimi-code/mcp.json`; Windows `%USERPROFILE%/.kimi-code/mcp.json` (user); `.kimi-code/mcp.json` (project).
+  Shape: `mcpServers.summer-engine = { command, args }`.
+- Skills: `~/.kimi-code/skills` (user) or `.kimi-code/skills` (project) as `<skill>/SKILL.md`.
+- After: Restart Kimi Code CLI so it reconnects its MCP servers.
+
+Source of truth: `src/installer/agent-table.ts` (one row per agent).

package/integrations/kimi-code/manifest-target.json

@@ -0,0 +1,3 @@
+{
+  "targets": []
+}

package/integrations/kiro/README.md

@@ -0,0 +1,12 @@
+# Kiro integration
+
+No manifest file is generated in this repo for Kiro — `manifest-target.json`
+is intentionally empty. Support is delivered at install time by
+`summer setup kiro` (aliases: `kiro-ide`, `aws-kiro`), which writes:
+
+- MCP config: `~/.kiro/settings/mcp.json`; Windows `%USERPROFILE%/.kiro/settings/mcp.json` (user); `.kiro/settings/mcp.json` (project).
+  Shape: `mcpServers.summer-engine = { command, args }`.
+- Skills: `~/.kiro/skills` (user) or `.kiro/skills` (project) as `<skill>/SKILL.md`.
+- After: Kiro reloads MCP config on save; open the MCP Servers view to confirm summer-engine is connected.
+
+Source of truth: `src/installer/agent-table.ts` (one row per agent).

package/integrations/kiro/manifest-target.json

@@ -0,0 +1,3 @@
+{
+  "targets": []
+}

package/integrations/lm-studio/README.md

@@ -1,12 +1,12 @@
 # LM Studio integration
 
-No manifest file is generated in this repo for LM Studio —
-`manifest-target.json` is intentionally empty. Support is delivered at install
-time by `summer setup lm-studio`, which writes:
+No manifest file is generated in this repo for LM Studio — `manifest-target.json`
+is intentionally empty. Support is delivered at install time by
+`summer setup lm-studio` (aliases: `lmstudio`, `lm_studio`), which writes:
 
-- MCP config: `~/.lmstudio/mcp.json`. This file is app-global (user scope
-  only); project-scope requests are treated as user scope with a warning.
-- Skills: LM Studio has no rules or skills folder. The MCP server ships
-  `summer_get_agent_playbook`, so the model pulls Summer guidance in-chat.
+- MCP config: `~/.lmstudio/mcp.json`; Windows `%USERPROFILE%/.lmstudio/mcp.json` (user); user scope only (project requests fall back with a warning).
+  Shape: `mcpServers.summer-engine = { command, args }`.
+- Skills: none. LM Studio has no rules or skills folder. The MCP server ships summer_get_agent_playbook, so the model can pull Summer guidance in-chat.
+- After: Open LM Studio, toggle on the summer-engine MCP server in the Program tab, and raise the loaded model's context length to 32k or higher.
 
-Source of truth: `src/installer/agent-config.ts`, `src/installer/setup.ts`.
+Source of truth: `src/installer/agent-table.ts` (one row per agent).

package/integrations/mistral-vibe/README.md

@@ -0,0 +1,12 @@
+# Mistral Vibe integration
+
+No manifest file is generated in this repo for Mistral Vibe — `manifest-target.json`
+is intentionally empty. Support is delivered at install time by
+`summer setup mistral-vibe` (aliases: `vibe`, `mistral`), which writes:
+
+- MCP config: `~/.vibe/config.toml`; Windows `%USERPROFILE%/.vibe/config.toml` (user); `.vibe/config.toml` (project).
+  Shape: undefined.
+- Skills: `~/.vibe/skills` (user) or `.vibe/skills` (project) as `<skill>/SKILL.md`.
+- After: Restart Vibe so it reloads config.toml.
+
+Source of truth: `src/installer/agent-table.ts` (one row per agent).

package/integrations/mistral-vibe/manifest-target.json

@@ -0,0 +1,3 @@
+{
+  "targets": []
+}

package/integrations/opencode/README.md

@@ -1,15 +1,12 @@
 # OpenCode integration
 
-Nothing is generated for OpenCode today. OpenCode consumes the npm package as
-a JavaScript module (`.opencode/plugins/summer.js`, wired via the package's
-`main` field). The plugin's `config` hook appends `<package>/library/skills`
-to `skills.paths` (OpenCode's `<dir>/<name>/SKILL.md` layout) and its
-`experimental.chat.messages.transform` hook prepends the Summer orientation to
-the first user message once per session. `summer setup opencode` writes the
-MCP entry to `opencode.json` (`type: "local"`, array `command`) and installs
-skills as markdown under `agents/summer/`. `manifest-target.json` is
-intentionally empty. Install steps: `.opencode/INSTALL.md`.
+No manifest file is generated in this repo for OpenCode — `manifest-target.json`
+is intentionally empty. Support is delivered at install time by
+`summer setup opencode` (aliases: `open-code`), which writes:
 
-If OpenCode grows a declarative manifest, add its builder to
-`scripts/generate-registry/manifests.ts` and its target to
-`scripts/generate-registry/targets.ts` (mirrored here).
+- MCP config: `~/.config/opencode/opencode.json`; Windows `%APPDATA%/opencode/opencode.json` (user); `opencode.json` (project).
+  Shape: `mcp.summer-engine = { type: "local", command: [npx, ...], enabled: true }`.
+- Skills: `~/.config/opencode/skills` (user) or `.opencode/skills` (project) as `<skill>/SKILL.md`. OpenCode loads skills from this folder on the next session. Summer 3.0 and earlier wrote markdown under agents/summer; `--force` removes those.
+- After: Restart OpenCode so it reloads opencode.json.
+
+Source of truth: `src/installer/agent-table.ts` (one row per agent).

package/integrations/qoder/README.md

@@ -0,0 +1,12 @@
+# Qoder CLI integration
+
+No manifest file is generated in this repo for Qoder CLI — `manifest-target.json`
+is intentionally empty. Support is delivered at install time by
+`summer setup qoder` (aliases: `qoder-cli`), which writes:
+
+- MCP config: `~/.qoder/settings.json`; Windows `%USERPROFILE%/.qoder/settings.json` (user); `.mcp.json` (project).
+  Shape: `mcpServers.summer-engine = { command, args }`.
+- Skills: `~/.qoder/skills` (user) or `.qoder/skills` (project) as `<skill>/SKILL.md`.
+- After: Restart Qoder CLI so it reloads its MCP settings (the Qoder IDE manages servers in its UI).
+
+Source of truth: `src/installer/agent-table.ts` (one row per agent).

package/integrations/qoder/manifest-target.json

@@ -0,0 +1,3 @@
+{
+  "targets": []
+}

package/integrations/qwen-code/README.md

@@ -0,0 +1,12 @@
+# Qwen Code integration
+
+No manifest file is generated in this repo for Qwen Code — `manifest-target.json`
+is intentionally empty. Support is delivered at install time by
+`summer setup qwen-code` (aliases: `qwen`, `qwencode`), which writes:
+
+- MCP config: `~/.qwen/settings.json`; Windows `%USERPROFILE%/.qwen/settings.json` (user); `.qwen/settings.json` (project).
+  Shape: `mcpServers.summer-engine = { command, args }`.
+- Skills: `~/.qwen/skills` (user) or `.qwen/skills` (project) as `<skill>/SKILL.md`.
+- After: Restart Qwen Code or run /mcp in a new session.
+
+Source of truth: `src/installer/agent-table.ts` (one row per agent).

package/integrations/qwen-code/manifest-target.json

@@ -0,0 +1,3 @@
+{
+  "targets": []
+}

package/integrations/roo-code/README.md

@@ -1,13 +1,14 @@
 # Roo Code integration
 
+> **Legacy.** Roo Code shut down on 2026-05-15. The extension may still run, but it is no longer maintained; consider Cline or Kilo Code.
+
 No manifest file is generated in this repo for Roo Code — `manifest-target.json`
 is intentionally empty. Support is delivered at install time by
-`summer setup roo-code`, which writes:
+`summer setup roo-code` (aliases: `roo`, `roocode`), which writes:
 
-- MCP config: Roo Code's VS Code global storage (extension
-  `rooveterinaryinc.roo-cline`). User scope only — no project-scoped MCP config
-  today; project requests fall back to user scope with a warning.
-- Skills: `summer skills install --agent roo-code` writes rule files to Roo
-  Code's user rules directory (user scope) or `./.clinerules` (project scope).
+- MCP config: `~/Library/Application Support/Code/User/globalStorage/rooveterinaryinc.roo-cline/settings/cline_mcp_settings.json`; Linux `~/.config/Code/User/globalStorage/rooveterinaryinc.roo-cline/settings/cline_mcp_settings.json`; Windows `%APPDATA%/Code/User/globalStorage/rooveterinaryinc.roo-cline/settings/cline_mcp_settings.json` (user); user scope only (project requests fall back with a warning).
+  Shape: `mcpServers.summer-engine = { command, args }`.
+- Skills: `~/Documents/Roo/Rules` (user) or `.clinerules` (project) as rule files `summer-<skill>.md`.
+- After: Restart VS Code so Roo Code reloads its MCP config.
 
-Source of truth: `src/installer/agent-config.ts`, `src/cli/commands/skills.ts`.
+Source of truth: `src/installer/agent-table.ts` (one row per agent).

package/integrations/rovo-dev/README.md

@@ -0,0 +1,12 @@
+# Rovo Dev CLI integration
+
+No manifest file is generated in this repo for Rovo Dev CLI — `manifest-target.json`
+is intentionally empty. Support is delivered at install time by
+`summer setup rovo-dev` (aliases: `rovodev`, `rovo`, `atlassian-rovo-dev`), which writes:
+
+- MCP config: `~/.rovodev/mcp.json`; Windows `%USERPROFILE%/.rovodev/mcp.json` (user); user scope only (project requests fall back with a warning).
+  Shape: undefined.
+- Skills: `~/.rovodev/skills` (user) or `.rovodev/skills` (project) as `<skill>/SKILL.md`.
+- After: Restart Rovo Dev CLI so it reconnects its MCP servers.
+
+Source of truth: `src/installer/agent-table.ts` (one row per agent).

package/integrations/rovo-dev/manifest-target.json

@@ -0,0 +1,3 @@
+{
+  "targets": []
+}

package/integrations/trae/README.md

@@ -0,0 +1,12 @@
+# Trae integration
+
+No manifest file is generated in this repo for Trae — `manifest-target.json`
+is intentionally empty. Support is delivered at install time by
+`summer setup trae` (aliases: `trae-ide`, `bytedance-trae`), which writes:
+
+- MCP config: `.trae/mcp.json` (user); `.trae/mcp.json` (project).
+  Shape: `mcpServers.summer-engine = { command, args }`.
+- Skills: none. Trae documents no skills folder; the MCP server ships summer_get_agent_playbook for in-chat guidance.
+- After: Restart Trae and open the MCP settings; summer-engine should show as connected.
+
+Source of truth: `src/installer/agent-table.ts` (one row per agent).

package/integrations/trae/manifest-target.json

@@ -0,0 +1,3 @@
+{
+  "targets": []
+}

package/integrations/visual-studio/README.md

@@ -0,0 +1,12 @@
+# GitHub Copilot in Visual Studio integration
+
+No manifest file is generated in this repo for GitHub Copilot in Visual Studio — `manifest-target.json`
+is intentionally empty. Support is delivered at install time by
+`summer setup visual-studio` (aliases: `vs`, `vs2026`, `visual-studio-2026`, `visualstudio`), which writes:
+
+- MCP config: `~/.mcp.json`; Windows `%USERPROFILE%/.mcp.json` (user); `.mcp.json` (project).
+  Shape: `servers.summer-engine = { type: "stdio", command, args }`.
+- Skills: none. Visual Studio's Copilot has no skills folder yet; the MCP server ships summer_get_agent_playbook for in-chat guidance.
+- After: Restart Visual Studio, open Copilot Chat in Agent mode, and enable summer-engine in the tools picker.
+
+Source of truth: `src/installer/agent-table.ts` (one row per agent).

package/integrations/visual-studio/manifest-target.json

@@ -0,0 +1,3 @@
+{
+  "targets": []
+}

package/integrations/vscode-copilot/README.md

@@ -1,12 +1,12 @@
-# VS Code Copilot integration
+# GitHub Copilot in VS Code integration
 
-No manifest file is generated in this repo for VS Code Copilot —
-`manifest-target.json` is intentionally empty. Support is delivered at install
-time by `summer setup vscode-copilot`, which writes:
+No manifest file is generated in this repo for GitHub Copilot in VS Code — `manifest-target.json`
+is intentionally empty. Support is delivered at install time by
+`summer setup vscode-copilot` (aliases: `vscode`, `vs-code`, `vs-code-copilot`, `github-copilot-vscode`), which writes:
 
-- MCP config: VS Code's user-profile `mcp.json` (user scope) or
-  `./.vscode/mcp.json` (project scope), in VS Code's MCP config format.
-- Skills: `summer skills install --agent vscode-copilot` writes skill files to
-  `~/.copilot/skills/` (user scope) or `./.github/skills/` (project scope).
+- MCP config: `~/Library/Application Support/Code/User/mcp.json`; Linux `~/.config/Code/User/mcp.json`; Windows `%APPDATA%/Code/User/mcp.json` (user); `.vscode/mcp.json` (project).
+  Shape: `servers.summer-engine = { type: "stdio", command, args }`.
+- Skills: `~/.copilot/skills` (user) or `.github/skills` (project) as `<skill>/SKILL.md`.
+- After: Restart VS Code or run MCP: List Servers, then start summer-engine in Copilot Agent mode.
 
-Source of truth: `src/installer/agent-config.ts`, `src/cli/commands/skills.ts`.
+Source of truth: `src/installer/agent-table.ts` (one row per agent).

package/integrations/warp/README.md

@@ -0,0 +1,12 @@
+# Warp integration
+
+No manifest file is generated in this repo for Warp — `manifest-target.json`
+is intentionally empty. Support is delivered at install time by
+`summer setup warp` (aliases: `warp-terminal`), which writes:
+
+- MCP config: `~/.warp/.mcp.json`; Windows `%USERPROFILE%/.warp/.mcp.json` (user); `.warp/.mcp.json` (project).
+  Shape: `mcpServers.summer-engine = { command, args }`.
+- Skills: `~/.warp/skills` (user) or `.warp/skills` (project) as `<skill>/SKILL.md`.
+- After: Warp detects the file and spawns the server; check Settings > AI > MCP servers.
+
+Source of truth: `src/installer/agent-table.ts` (one row per agent).

package/integrations/warp/manifest-target.json

@@ -0,0 +1,3 @@
+{
+  "targets": []
+}

package/integrations/windsurf/README.md

@@ -1,13 +1,12 @@
-# Windsurf (Devin Desktop) integration
+# Devin Desktop (formerly Windsurf) integration
 
-No manifest file is generated in this repo for Windsurf — `manifest-target.json`
+No manifest file is generated in this repo for Devin Desktop (formerly Windsurf) — `manifest-target.json`
 is intentionally empty. Support is delivered at install time by
-`summer setup windsurf`, which writes:
+`summer setup windsurf` (aliases: `devin`, `devin-desktop`, `devindesktop`), which writes:
 
-- MCP config: `~/.codeium/windsurf/mcp_config.json` (user scope; project scope
-  writes `.windsurf/mcp_config.json` for teams that load workspace config —
-  Windsurf documents MCP configuration as user-scoped).
-- Skills: `summer skills install --agent windsurf` writes the `.windsurfrules`
-  rule file (`~/.windsurfrules` user scope, `./.windsurfrules` project scope).
+- MCP config: `~/.codeium/windsurf/mcp_config.json`; Windows `%USERPROFILE%/.codeium/windsurf/mcp_config.json` (user); user scope only (project requests fall back with a warning).
+  Shape: `mcpServers.summer-engine = { command, args }`.
+- Skills: `~/.codeium/windsurf/skills` (user) or `.windsurf/skills` (project) as `<skill>/SKILL.md`.
+- After: Restart Devin Desktop (formerly Windsurf) and refresh MCP servers from the agent settings. Devin's docs say mcp_config.json configures the Cascade agent; for the Devin agent add the server in the app's MCP settings with the same command.
 
-Source of truth: `src/installer/agent-config.ts`, `src/cli/commands/skills.ts`.
+Source of truth: `src/installer/agent-table.ts` (one row per agent).

package/integrations/zed/README.md

@@ -0,0 +1,12 @@
+# Zed integration
+
+No manifest file is generated in this repo for Zed — `manifest-target.json`
+is intentionally empty. Support is delivered at install time by
+`summer setup zed` (aliases: `zed-editor`), which writes:
+
+- MCP config: `~/.config/zed/settings.json`; Windows `%APPDATA%/zed/settings.json` (user); user scope only (project requests fall back with a warning).
+  Shape: `context_servers.summer-engine = { source: "custom", command, args, env }`.
+- Skills: `~/.agents/skills` (user) or `.agents/skills` (project) as `<skill>/SKILL.md`.
+- After: Zed reloads settings.json live; open the Agent panel and check summer-engine under MCP servers.
+
+Source of truth: `src/installer/agent-table.ts` (one row per agent).

package/integrations/zed/manifest-target.json

@@ -0,0 +1,3 @@
+{
+  "targets": []
+}

package/library/skills/README.md

@@ -0,0 +1,242 @@
+# Summer skills
+
+> 94 skills, grouped by their primary domain. **Generated** by `npm run generate:registry` from each skill's `resource.yaml`; `--check` fails when this file and the library disagree. Do not edit by hand.
+
+The folder is flat on purpose (`docs/design/DECISIONS.md`, D3): a skill usually belongs to several domains, so categories live in each skill's `facets.domains` and this index is rendered from them. The first domain listed is the primary one. `summer skills list --by-domain` prints the same grouping; `summer skills info <slug>` shows one skill.
+
+Status: **stable** unless marked; *preview* = not yet exercised in-engine by the Summer team; ~~deprecated~~ installs only by name. ★ = installed by `--recommended`.
+
+## Domains
+
+- [2d](#2d) (10)
+- [3d](#3d) (6)
+- [agent-workflow](#agent-workflow) (17)
+- [ai](#ai) (1)
+- [animation](#animation) (6)
+- [assets](#assets) (3)
+- [audio](#audio) (6)
+- [character-controller](#character-controller) (1)
+- [debug](#debug) (1)
+- [deployment](#deployment) (2)
+- [editor](#editor) (1)
+- [gameplay](#gameplay) (3)
+- [level-design](#level-design) (2)
+- [multiplayer](#multiplayer) (3)
+- [navigation](#navigation) (1)
+- [performance](#performance) (1)
+- [rendering](#rendering) (4)
+- [runtime](#runtime) (1)
+- [scenes](#scenes) (11)
+- [scripting](#scripting) (1)
+- [ui](#ui) (1)
+- [vfx](#vfx) (9)
+- [video](#video) (3)
+
+## 2d
+
+| skill | when to use | also |
+|---|---|---|
+| [character-portrait](./character-portrait/SKILL.md) ★ | Generate a single polished character bust for dialogue UI, character select, lore cards, or codex entries. One character, locked composition, VN-style. | assets |
+| [concept-art](./concept-art/SKILL.md) ★ | Explore art direction with 3-4 rough concept variants of a character, environment, or prop to pick a vibe before committing to a final asset. | assets |
+| [create-asset-sheet](./create-asset-sheet/SKILL.md) | Generate a pack of 2D game assets from one prompt — tile sheet, UI kit, character pack, or biome set — sliced, classified, and saved as one pack ArtAsset. | assets |
+| [instantiate-asset-pack](./instantiate-asset-pack/SKILL.md) | Import a whole create-asset-sheet pack into the scene: groups composites, sorts paint order, emits Sprite2D/Node2D/NinePatchRect ops to lay it out. | assets |
+| [pixel-art](./pixel-art/SKILL.md) ★ | Generate pixel-art assets — sprites, items, tiles, portraits — at a specific resolution with pixel-perfect grid, limited palette, retro feel. | assets |
+| [skybox-panorama](./skybox-panorama/SKILL.md) | Generate a 360-degree equirectangular sky panorama and wire it as a PanoramaSkyMaterial Sky resource on WorldEnvironment in a 3D scene. | assets |
+| [sprite-sheet](./sprite-sheet/SKILL.md) | Generate animated 2D character sprites laid out as a sprite sheet — walk cycle, attack, idle, death — wired into AnimatedSprite2D / SpriteFrames. | assets |
+| [tileable-texture](./tileable-texture/SKILL.md) | Generate a seamless tileable texture for walls, floors, or terrain — repeats cleanly on all four edges, wired as a StandardMaterial3D albedo. | assets |
+| [ui-graphics](./ui-graphics/SKILL.md) | Generate game-UI elements — icons, buttons, panels, frames, HUD widgets, badges — flat design, transparent background, wired via TextureRect/NinePatchRect. | assets |
+| [use-widget-asset](./use-widget-asset/SKILL.md) | Wire a widget slice from a create-asset-sheet pack (panel, button, slider, bar, toggle) into NinePatchRect, TextureProgressBar, or TextureRect via sliceMeta. | assets |
+
+## 3d
+
+| skill | when to use | also |
+|---|---|---|
+| [character-model](./character-model/SKILL.md) ★ | Generate a rigged humanoid — player, NPC, enemy, boss — via T-pose reference, user-gated preview, and Meshy auto-rig, wired as CharacterBody3D or Node3D. | assets |
+| [environment-kit](./environment-kit/SKILL.md) | Generate a modular environment kit — wall pieces, floor tiles, pillars, doors, arches, corners — snap-together meshes sharing one visual style. | assets |
+| [*fabricating-assets*](./fabricating-assets/SKILL.md) (preview) | Fabricate meshes with a bpy script in the user's own Blender (summer_fabricate_3d) — kits with exact dimensions, VFX meshes, post-processing generated models. | assets, scripting, agent-workflow |
+| [organic-model](./organic-model/SKILL.md) | Generate organic 3D shapes — trees, rocks, mushrooms, coral, plants, vines, crystals — where AI artifacts read as natural irregularity. | assets |
+| [prop-model](./prop-model/SKILL.md) ★ | Generate a single static 3D prop — sword, barrel, chest, lantern, throne, statue — one isolated object, no rigging, wired as a MeshInstance3D. | assets |
+| [vehicle-model](./vehicle-model/SKILL.md) | Generate a hard-surface vehicle — car, spaceship, mech, boat, tank — static mesh with optional detail-texture pass, wired as Vehicle3D or MeshInstance3D. | assets |
+
+## agent-workflow
+
+| skill | when to use | also |
+|---|---|---|
+| [brainstorming](./brainstorming/SKILL.md) ★ | Explore user intent, requirements, and design before implementation — must run before any creative work: features, components, mechanics, behavior. | game-design |
+| [debugging-game-feel](./debugging-game-feel/SKILL.md) | Debug features that work but feel wrong — floaty jumps, mushy combat, sluggish camera — subjective bugs living in tuning, timing, and feedback layers. | gameplay |
+| [diagnosing-perf-regressions](./diagnosing-perf-regressions/SKILL.md) | Find why frame rate, frame time, or load time got worse since a known-good state — regression hunting, not general performance tuning. | performance |
+| [dispatching-parallel-agents](./dispatching-parallel-agents/SKILL.md) | Work 2+ independent tasks in parallel when they share no state and have no sequential dependencies. | meta |
+| [gameskill](./gameskill/SKILL.md) | Capture what a game-dev session just learned as a reusable skill (project, user or Summer library) so the next session starts smarter. | meta |
+| [*godogen-visual-proof-game-generation*](./godogen-visual-proof-game-generation/SKILL.md) (preview) | Godogen-style game generation with a visual QC loop — capture frames from the running game, self-verify against the brief, bounded fix rounds, proof clip. | verification |
+| [headless-scripting](./headless-scripting/SKILL.md) ★ | Run a GDScript file against Summer Engine from the shell for operations no MCP tool exposes — navmesh baking, collision shapes, TileSets, re-imports. | headless |
+| [investigating-bugs](./investigating-bugs/SKILL.md) ★ | Systematic investigation of any bug, test failure, or unexpected behavior before proposing fixes. | debug |
+| [playtesting-a-feature](./playtesting-a-feature/SKILL.md) ★ | Before claiming a gameplay feature done: actually run the game and walk through the feature. Static diagnostics and type checks do not count. | verification |
+| [running-in-the-cloud](./running-in-the-cloud/SKILL.md) | Run Summer Engine on a Linux box with no display — install it, launch headless, know when xvfb + software GL are needed, authenticate without a browser. | project |
+| [skill-create](./skill-create/SKILL.md) | Bootstrap a new Summer library skill (library/skills/<slug>/ with resource.yaml and SKILL.md), frontmatter, and stub sections. | meta |
+| [skill-improve](./skill-improve/SKILL.md) | Upgrade an underperforming Summer skill — run it against a behavioral spec with and without changes via a parallel-eval harness; ship the winner. | meta |
+| [skill-test](./skill-test/SKILL.md) | Lint a Summer skill before commit, audit the whole library, or check a behavioral spec assertion — static structural rules plus behavioral specs. | meta |
+| [using-summer](./using-summer/SKILL.md) | Session bootstrap for Summer projects — establishes how to find and use Summer skills and the summer-engine MCP before any response. | meta |
+| [verification-before-completion](./verification-before-completion/SKILL.md) ★ | Run verification commands and confirm output before claiming work complete, fixed, or passing — evidence before assertions, always. | verification |
+| [writing-plans](./writing-plans/SKILL.md) | Turn a spec or requirements for a multi-step task into a written implementation plan before touching code. | meta |
+| [writing-skills](./writing-skills/SKILL.md) | Create, edit, and verify agent skills — format, structure, testing with subagents, and best practices. | meta |
+
+## ai
+
+| skill | when to use | also |
+|---|---|---|
+| [design-npc](./design-npc/SKILL.md) ★ | Design enemy/NPC/boss/companion behavior — perception, personality, intent, action state machine, telegraphs — outputs a GDScript stub plus node tree. | npc |
+
+## animation
+
+| skill | when to use | also |
+|---|---|---|
+| [animation-tree](./animation-tree/SKILL.md) | Design and wire AnimationTree state machines and blend trees so clips respond to gameplay — locomotion blends, attack interrupts, hit reactions. | 3d |
+| [character-animation-wiring](./character-animation-wiring/SKILL.md) | Wire a rigged, animated character end to end — inspect real clips and bones, locomotion state machine, method-track events, poses, blend shapes, root motion. | 3d |
+| [facial-and-lipsync](./facial-and-lipsync/SKILL.md) | Make a character's mouth move with a voice-over — phoneme extraction from audio, viseme blendshape mapping, and emotional facial expressions. | 3d |
+| [generate-motion](./generate-motion/SKILL.md) ★ | Attach an animation clip to a rigged character from the curated Meshy motion library — idle, walk, run, attack — wired via AnimationPlayer. | 3d |
+| [procedural-animation](./procedural-animation/SKILL.md) | Runtime bone modification on top of clips — head look-at, foot IK, hand-grabs-prop, additive lean, recoil. Code-and-modifier patterns, not generation. | 3d |
+| [retarget](./retarget/SKILL.md) | Apply existing animation clips from one rigged character to a different rigged character — same library, multiple models, no regeneration. | 3d |
+
+## assets
+
+| skill | when to use | also |
+|---|---|---|
+| [asset-strategy](./asset-strategy/SKILL.md) ★ | Route any 'I need a [thing]' asset request to the right specialist skill — disambiguates 2D / 3D / audio / video / VFX / animation pipelines. | pipeline |
+| [*lumera-single-image-scene-reconstruction*](./lumera-single-image-scene-reconstruction/SKILL.md) (preview) | Lumera-style single image to editable 3D scene — VLM-parsed object boxes and parametric lights, per-object meshes, HDR probe, .tscn assembly, refinement loop. | pipeline, 3d, scenes |
+| [*skintokens-auto-rigging*](./skintokens-auto-rigging/SKILL.md) (preview) | Offline auto-rigging with skin-tokens.cpp (GGML SkinTokens/TokenRig port) — skeleton and skin weights from a static GLB mesh on CPU/Vulkan, into Godot 4. | pipeline, 3d, animation |
+
+## audio
+
+| skill | when to use | also |
+|---|---|---|
+| [adaptive-music](./adaptive-music/SKILL.md) | Wire music stems to game state — combat/explore/boss/tension crossfades on a shared bus, paired with a state machine and AudioBus structure. | gameplay |
+| [ambient-bed](./ambient-bed/SKILL.md) | Generate a long looping location ambience — forest, dungeon, city, spaceship, cave — a looping AudioStreamPlayer on the Ambient bus with a seamless loop. | assets |
+| [audio-direction](./audio-direction/SKILL.md) ★ | Define the game's sonic identity — music style, instruments, SFX vocabulary, dynamic music plan — output as an audio bible at .summer/audio-bible.md. | game-design |
+| [music-track](./music-track/SKILL.md) ★ | Generate a looped or cinematic music track — loops authored at >=30s with a marked loop point, cinematic tracks at >=60s linear. | assets |
+| [sound-effect](./sound-effect/SKILL.md) ★ | Generate short SFX one-shots — footsteps, weapon swings, UI clicks, hit impacts — wired as AudioStreamPlayer/2D/3D that auto-frees on finished. | assets |
+| [voice-line](./voice-line/SKILL.md) ★ | Generate TTS voice lines — NPC barks, narrator, dialogue — with voice-id sourcing, a character-to-voice decision tree, and multi-line dialogue support. | assets |
+
+## character-controller
+
+| skill | when to use | also |
+|---|---|---|
+| [fps-controller](./fps-controller/SKILL.md) ★ | Production-quality first-person controller — WASD, mouse look, jump, coyote time, jump buffering, air control, and external-velocity handling. | gameplay |
+
+## debug
+
+| skill | when to use | also |
+|---|---|---|
+| [debug](./debug/SKILL.md) ★ | Disciplined bug/crash/error loop for Summer projects — script errors, console, debugger, hypothesis, fix, verify — before making code or scene changes. | verification |
+
+## deployment
+
+| skill | when to use | also |
+|---|---|---|
+| [export-and-ship](./export-and-ship/SKILL.md) ★ | Assess and prepare a game export: inventory installed templates and targets, validate release assets and config, produce supported builds after approval. | project |
+| [remote-deploy](./remote-deploy/SKILL.md) ★ | Run or test the game on a real device — phone, tablet, another computer — via the Remote Deploy button, runnable export presets, and on-device debugging. | project |
+
+## editor
+
+| skill | when to use | also |
+|---|---|---|
+| [*driving-the-editor-ui*](./driving-the-editor-ui/SKILL.md) (preview) | Drive the editor UI by name: invoke actions, clear blocking dialogs, switch the main screen, read a dock — and route scene work to the scene tools instead. | agent-workflow, verification |
+
+## gameplay
+
+| skill | when to use | also |
+|---|---|---|
+| [auto-fire-targeting](./auto-fire-targeting/SKILL.md) | Design or fix auto-fire weapon targeting (survivors, top-down ARPG, tower defense) — the pending-damage pattern that prevents over-commit and overkill. | game-design |
+| [*celeste-momentum-platforming*](./celeste-momentum-platforming/SKILL.md) (preview) | Celeste-style 2D precision platformer movement — momentum running, coyote time, variable jumps, dash, wall jump/slide, climb stamina, pixel corner correction. | character-controller, game-design |
+| [design-mechanic](./design-mechanic/SKILL.md) ★ | Design one game mechanic in detail — input, response, feedback, failure modes, depth, tunables — outputs a design doc, node-graph sketch, GDScript stub. | game-design |
+
+## level-design
+
+| skill | when to use | also |
+|---|---|---|
+| [design-level](./design-level/SKILL.md) ★ | Design a single level — layout, pacing, encounters, secrets, reward gating — outputs a level design doc and a node-tree skeleton for summer_create_scene. | game-design |
+| [scene-to-level](./scene-to-level/SKILL.md) | Go from a scene reference image or concept art to a playable scene — orchestrates concept, asset pack, terrain, composition, and scene assembly. | game-design |
+
+## multiplayer
+
+| skill | when to use | also |
+|---|---|---|
+| [host-authoritative-state](./host-authoritative-state/SKILL.md) ★ | Design the state layer of a multiplayer game — what the host owns, how clients request changes, and how the host validates and broadcasts. | game-design |
+| [peer-to-peer-multiplayer](./peer-to-peer-multiplayer/SKILL.md) ★ | Start a multiplayer game from scratch with peer-to-peer host authority — network architecture built top-down, before writing game logic. | project |
+| [setup-multiplayer](./setup-multiplayer/SKILL.md) ★ | Add multiplayer to an existing game — LAN/online co-op, PvP, lobbies — via MultiplayerAPI, MultiplayerSpawner, and MultiplayerSynchronizer. | scripting |
+
+## navigation
+
+| skill | when to use | also |
+|---|---|---|
+| [navigate-summer](./navigate-summer/SKILL.md) ★ | 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. | agent-workflow, meta |
+
+## performance
+
+| skill | when to use | also |
+|---|---|---|
+| [tune-performance](./tune-performance/SKILL.md) ★ | Profile a slow game via summer_get_diagnostics, identify rendering/physics/scripting hotspots, propose fixes with before/after metric expectations. | debug |
+
+## rendering
+
+| skill | when to use | also |
+|---|---|---|
+| [3d-lighting](./3d-lighting/SKILL.md) ★ | Set up 3D scene lighting — DirectionalLight3D vs Omni vs Spot, WorldEnvironment, sky, shadow tuning, ambient — per current Summer conventions. | lighting |
+| [art-direction](./art-direction/SKILL.md) ★ | Define the game's visual style — references, palette, mood, lighting plan, post-processing, do/don't list — output as an art bible at .summer/art-bible.md. | lighting |
+| [*psx-retro-rendering*](./psx-retro-rendering/SKILL.md) (preview) | Hardware-informed PlayStation 1 rendering in Godot 4 — low-res output, RGB5 and exact dither, affine textures, vertex snapping, blend modes, fog; limits named. | 3d |
+| [*realtime-wet-surfaces*](./realtime-wet-surfaces/SKILL.md) (preview) | Real-time wetness on existing Godot 4 materials without losing their values — value-copying wet shader, geometry-driven wet mask, instance-uniform wet amount. | vfx |
+
+## runtime
+
+| skill | when to use | also |
+|---|---|---|
+| [*agent-playtesting*](./agent-playtesting/SKILL.md) ★ (preview) | Playtest by driving the LIVE game — deterministic launch, frame-stamped probes before/after each action, exact frame steps, scripted or recorded input. | playtest, verification, agent-workflow |
+
+## scenes
+
+| skill | when to use | also |
+|---|---|---|
+| [brainstorm-game](./brainstorm-game/SKILL.md) ★ | Turn a vague idea into a buildable plan — genre, scope, core loop, mechanics, art direction — written as a 1-page brief to .summer/GameSoul.md. | project |
+| [browse-templates](./browse-templates/SKILL.md) ★ | List available Summer Engine project templates, present the choices, and create a project from the chosen one via summer create. | project |
+| [make-game](./make-game/SKILL.md) ★ | Orchestration spine for 'make me a game': brainstorm, plan, scaffold, mechanics, art, audio, polish, verify, ship — delegates to specialist skills. | project |
+| [new-project](./new-project/SKILL.md) ★ | Create a fresh blank Summer Engine project — asks one question (project name) and runs summer create empty. | project |
+| [play](./play/SKILL.md) ★ | Run the project in Summer Engine, wait briefly, then report what's happening — clean run, errors, or warnings. | project |
+| [scene-composition](./scene-composition/SKILL.md) ★ | Scene structure conventions — node hierarchy, when to extract sub-scenes, reusable prefab patterns, and instance-versus-add-node decisions. | project |
+| [*scene-hierarchy-design*](./scene-hierarchy-design/SKILL.md) (preview) | Structure Summer Engine scenes by access pattern — asset vs live hierarchies, wrapper nodes per operation, sub-scenes for reuse, path-agnostic logic. | project, agent-workflow |
+| [*scene-scripting*](./scene-scripting/SKILL.md) ★ (preview) | One GDScript in the live editor (summer_run_script) builds scenes, 2D levels, HUDs and gameplay wiring instead of CRUD chains; verify with diff + screenshot. | scripting, 2d, ui, agent-workflow |
+| [*spatial-placement*](./spatial-placement/SKILL.md) ★ (preview) | Place and verify 3D objects with Starcast evidence — inspect, place, starcast, correct, verify; floor, shelf, wall, alcove recipes and overlap repair. | 3d, world-building, level-design, verification |
+| [*verifying-scenes*](./verifying-scenes/SKILL.md) ★ (preview) | Prove scene work landed — snapshot before, diff + screenshot after (bookmarked viewpoint, labels), live runtime reads during playtests — then claim. | verification, agent-workflow |
+| [*world-building-3d*](./world-building-3d/SKILL.md) ★ (preview) | Compose, ground, space, and validate 3D scenes with Summer's four bounded spatial tools — exact paths, one geometric decision at a time, verified. | 3d, world-building, level-design, verification |
+
+## scripting
+
+| skill | when to use | also |
+|---|---|---|
+| [gdscript-patterns](./gdscript-patterns/SKILL.md) ★ | GDScript conventions — type hints, signals, exports, onready, lifecycle methods, get_node vs $NodePath, naming. | conventions |
+
+## ui
+
+| skill | when to use | also |
+|---|---|---|
+| [ui-basics](./ui-basics/SKILL.md) ★ | Build Summer Engine UI — HUDs, menus, health bars, dialogue boxes, Control trees — anchors, containers, responsive layout, theme vs inline styling. | ux |
+
+## vfx
+
+| skill | when to use | also |
+|---|---|---|
+| [game-feel](./game-feel/SKILL.md) ★ | Add juice: hit-flash, trauma-based camera shake, and audio ducking wired so one hit fires all three — for games that feel flat or lack impact. | gameplay |
+| [vfx-dissolve](./vfx-dissolve/SKILL.md) | Dissolve effect — a mesh disintegrating with a glowing burning edge, driven by a noise-threshold ShaderMaterial overriding the target's material. | rendering |
+| [vfx-fire](./vfx-fire/SKILL.md) ★ | Fire effect — animated flames built with a particle shader, GPUParticles3D, and a noise-based color ramp — torches, campfires, candles. | rendering |
+| [vfx-hit-spark](./vfx-hit-spark/SKILL.md) | Hit-spark effect — a one-shot burst of additive billboard particles oriented to a surface normal, fired on impact. | rendering |
+| [vfx-lightning](./vfx-lightning/SKILL.md) | Lightning bolt effect — procedural jagged path drawn via ImmediateMesh, glow shader, sparks at endpoints, screen shake. | rendering |
+| [vfx-magic-glow](./vfx-magic-glow/SKILL.md) | Magic-glow effect — a pulsing OmniLight3D plus drifting additive motes plus optional emission shader on the source mesh. | rendering |
+| [vfx-muzzle-flash](./vfx-muzzle-flash/SKILL.md) ★ | Muzzle-flash effect — a one-shot ~80 ms burst at a gun barrel built with a particle one-shot or a flashing quad with a star-burst shader. | rendering |
+| [vfx-smoke](./vfx-smoke/SKILL.md) | Smoke effect — a slow-rising column or puff of soft particles built with a noise + density falloff shader on a quad mesh, GPUParticles3D. | rendering |
+| [vfx-water-ripple](./vfx-water-ripple/SKILL.md) | Water-ripple effect — animated normal-distortion ripples on a water plane (or as a Decal) triggered by impacts. | rendering |
+
+## video
+
+| skill | when to use | also |
+|---|---|---|
+| [animated-loop](./animated-loop/SKILL.md) | Generate a short seamlessly-looping video clip — splash background, animated logo backdrop, idle title-screen footage — wired as a looping VideoStreamPlayer. | assets |
+| [cinematic-cutscene](./cinematic-cutscene/SKILL.md) ★ | Generate a non-interactive cutscene — reference-locked look, a 5-10s image-to-video shot, optional TTS dialogue — wired as a fading VideoStreamPlayer. | assets |
+| [trailer-shot](./trailer-shot/SKILL.md) | Generate marketing or trailer footage — slow-mo combat, establishing shots, hero beats, splash screens, pitch-deck B-roll — max punch in 5-10 seconds. | assets |