summer-engine 2.3.0 → 2.5.0

package/.claude-plugin/marketplace.json

@@ -7,7 +7,7 @@
     {
       "name": "summer",
       "source": "./",
-      "version": "2.3.0",
+      "version": "2.5.0",
       "description": "Superpowers for AI game dev. 60 auto-trigger skills under summer: namespace, MCP bridge to the local Summer Engine, session-start + pre-commit hooks.",
       "author": { "name": "Summer Engine", "email": "founders@summerengine.com" },
       "category": "game-development",

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/claude-code-plugin-manifest.json",
   "name": "summer",
-  "version": "2.3.0",
+  "version": "2.5.0",
   "description": "Superpowers for AI game dev. 60 auto-trigger skills + lifecycle hooks + MCP bridge to the local Summer Engine — the AI-native game engine.",
   "author": {
     "name": "Summer Engine",
@@ -26,10 +26,20 @@
     "performance"
   ],
   "skills": [
-    "./skills/_meta/using-summer/",
-    "./skills/_meta/skill-create/",
-    "./skills/_meta/skill-improve/",
-    "./skills/_meta/skill-test/",
+    "./skills/workflow/using-summer/",
+    "./skills/workflow/skill-create/",
+    "./skills/workflow/skill-improve/",
+    "./skills/workflow/skill-test/",
+    "./skills/workflow/gameskill/",
+    "./skills/workflow/brainstorming/",
+    "./skills/workflow/investigating-bugs/",
+    "./skills/workflow/verification-before-completion/",
+    "./skills/workflow/writing-plans/",
+    "./skills/workflow/dispatching-parallel-agents/",
+    "./skills/workflow/writing-skills/",
+    "./skills/workflow/playtesting-a-feature/",
+    "./skills/workflow/debugging-game-feel/",
+    "./skills/workflow/diagnosing-perf-regressions/",
     "./skills/scene-and-project/brainstorm-game/",
     "./skills/scene-and-project/new-project/",
     "./skills/scene-and-project/browse-templates/",
@@ -38,7 +48,9 @@
     "./skills/scene-and-project/make-game/",
     "./skills/debugging/debug/",
     "./skills/gameplay-mechanics/design-mechanic/",
+    "./skills/gameplay-mechanics/auto-fire-targeting/",
     "./skills/level-design/design-level/",
+    "./skills/level-design/scene-to-level/",
     "./skills/rendering-and-lighting/art-direction/",
     "./skills/rendering-and-lighting/3d-lighting/",
     "./skills/audio/audio-direction/",
@@ -60,6 +72,9 @@
     "./skills/2d-assets/tileable-texture/",
     "./skills/2d-assets/sprite-sheet/",
     "./skills/2d-assets/skybox-panorama/",
+    "./skills/2d-assets/create-asset-sheet/",
+    "./skills/2d-assets/instantiate-asset-pack/",
+    "./skills/2d-assets/use-widget-asset/",
     "./skills/3d-assets/prop-model/",
     "./skills/3d-assets/character-model/",
     "./skills/3d-assets/environment-kit/",

package/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "summer",
-  "version": "2.3.0",
+  "version": "2.5.0",
   "description": "Superpowers for AI game dev. 60 auto-trigger skills, MCP bridge to the local Summer Engine, lifecycle hooks. Build games by talking.",
   "author": {
     "name": "Summer Engine",
@@ -15,10 +15,20 @@
     "workflow", "level-design", "vfx", "multiplayer"
   ],
   "skills": [
-    "./skills/_meta/using-summer/",
-    "./skills/_meta/skill-create/",
-    "./skills/_meta/skill-improve/",
-    "./skills/_meta/skill-test/",
+    "./skills/workflow/using-summer/",
+    "./skills/workflow/skill-create/",
+    "./skills/workflow/skill-improve/",
+    "./skills/workflow/skill-test/",
+    "./skills/workflow/gameskill/",
+    "./skills/workflow/brainstorming/",
+    "./skills/workflow/investigating-bugs/",
+    "./skills/workflow/verification-before-completion/",
+    "./skills/workflow/writing-plans/",
+    "./skills/workflow/dispatching-parallel-agents/",
+    "./skills/workflow/writing-skills/",
+    "./skills/workflow/playtesting-a-feature/",
+    "./skills/workflow/debugging-game-feel/",
+    "./skills/workflow/diagnosing-perf-regressions/",
     "./skills/scene-and-project/brainstorm-game/",
     "./skills/scene-and-project/new-project/",
     "./skills/scene-and-project/browse-templates/",

package/.cursor-plugin/plugin.json

@@ -2,7 +2,7 @@
   "$schema": "https://cursor.com/schemas/cursor-plugin/plugin.json",
   "name": "summer",
   "displayName": "Summer",
-  "version": "2.3.0",
+  "version": "2.5.0",
   "description": "Superpowers for AI game dev. 60 auto-trigger skills + lifecycle hooks + MCP bridge to the local Summer Engine — the AI-native game engine.",
   "author": { "name": "Summer Engine", "email": "founders@summerengine.com" },
   "publisher": "summer-engine",
@@ -17,10 +17,20 @@
   ],
   "tags": ["game-dev", "ai", "godot", "creative", "design"],
   "skills": [
-    "./skills/_meta/using-summer/",
-    "./skills/_meta/skill-create/",
-    "./skills/_meta/skill-improve/",
-    "./skills/_meta/skill-test/",
+    "./skills/workflow/using-summer/",
+    "./skills/workflow/skill-create/",
+    "./skills/workflow/skill-improve/",
+    "./skills/workflow/skill-test/",
+    "./skills/workflow/gameskill/",
+    "./skills/workflow/brainstorming/",
+    "./skills/workflow/investigating-bugs/",
+    "./skills/workflow/verification-before-completion/",
+    "./skills/workflow/writing-plans/",
+    "./skills/workflow/dispatching-parallel-agents/",
+    "./skills/workflow/writing-skills/",
+    "./skills/workflow/playtesting-a-feature/",
+    "./skills/workflow/debugging-game-feel/",
+    "./skills/workflow/diagnosing-perf-regressions/",
     "./skills/scene-and-project/brainstorm-game/",
     "./skills/scene-and-project/new-project/",
     "./skills/scene-and-project/browse-templates/",

package/.factory-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "summer",
-  "description": "Superpowers for AI game dev. 24 auto-trigger skills + lifecycle hooks + MCP bridge to the local Summer Engine — the AI-native game engine.",
-  "version": "2.0.1",
+  "description": "Superpowers for AI game dev. 60 auto-trigger skills + lifecycle hooks + MCP bridge to the local Summer Engine — the AI-native game engine.",
+  "version": "2.5.0",
   "author": {
     "name": "Summer Engine",
     "email": "founders@summerengine.com",

package/.opencode/INSTALL.md

@@ -63,7 +63,7 @@ The model should auto-invoke the `summer:fps-controller` skill before writing an
 |---|---|
 | No orientation banner appears | Verify `plugin` array in `opencode.json` and that `summer-engine` is installed in `node_modules/`. |
 | MCP tools return "not connected" | Run `summer run` to launch the engine. The MCP server lazy-connects on the first tool call. |
-| `summer` command not found | `npm install -g summer-engine` for the global CLI. |
+| `summer` command not found | Use `npx -y summer-engine@latest <command>` or install the CLI globally only if you want a persistent `summer` command. |
 | Skills don't auto-trigger | The using-summer skill loads on first user message; if that message is empty (e.g. a startup probe), they'll trigger on the second. |
 
 ## Uninstall

package/CHANGELOG.md

@@ -2,13 +2,34 @@
 
 All notable changes to summer-engine will be documented here. Following [Keep a Changelog](https://keepachangelog.com/en/1.1.0/) and [Semantic Versioning](https://semver.org/).
 
+## [2.5.0] — 2026-05-27 — "Project Memory"
+
+Note: `2.1.0` through `2.4.0` were internal package/plugin snapshots in the engine repo. npm `latest` was still `2.3.0` before this release, so `2.5.0` is the public catch-up release for the memory, setup, and MCP reliability work.
+
+### Added
+- `summer memory` — read-only CLI view of `.summer` project memory, with `--json`, `show <file>`, and `path` subcommands.
+- `projectMemory` in `summer_get_project_context` — lightweight summary of `.summer` canonical files and structured memory for agents.
+- `.summer/memory/` convention for locked project facts such as voice IDs, world canon, provider bindings, and cross-session decisions.
+- Project-memory checks in `summer status` and `summer doctor`.
+- First-class `summer setup github-copilot` and `summer setup vscode-copilot` targets for Copilot CLI and GitHub Copilot in VS Code.
+- Copy-paste setup prompt docs: users can paste "Install Summer Engine and let's make a game." into their AI environment instead of starting with npm commands.
+
+### Changed
+- `/summer:voice-line` now writes locked cast assignments to `.summer/memory/casting/voices.md`, while still reading legacy `.summer/voice-cast.md`.
+- Agent playbook and `using-summer` now require agents to read relevant project memory before creative/audio/dialogue/level/character work.
+- CLI and docs now link directly to the public source repo: `https://github.com/SummerEngine/summer`.
+
+### Fixed
+- MCP project context now falls back to engine health fields for project path, project name, and current scene.
+- Mutating MCP tools now surface failure terminal states and no-results failure envelopes instead of masking them as success.
+
 ## [2.0.0] — 2026-05-09 — "Superpowers"
 
 The plugin rebrand. Summer is now positioned as superpowers for AI game dev — installable in Claude Code, Codex (CLI + App), Cursor, Factory Droid, Gemini CLI, OpenCode, GitHub Copilot CLI, and Windsurf with one canonical command per harness.
 
 ### Added
 - **`summer:using-summer`** meta-skill — establishes workflow priority, red-flag list, and skill-invocation discipline. Auto-loads on session start. Modeled on `superpowers:using-superpowers`.
-- **`summer:debug`** skill — the missing flagship skill. Disciplined script-errors → console → debugger → hypothesize → propose → fix → verify loop. Honors all 4 cases in `_tests/specs/debug.md`.
+- **`summer:debug`** skill — the missing flagship skill. Disciplined script-errors → console → debugger → hypothesize → propose → fix → verify loop. Honors all 4 cases in `tests/specs/debug.md`.
 - **Manifest validator** (`src/lib/plugin-manifests.test.ts`) — vitest test that walks every plugin manifest and verifies each referenced skill resolves to a real `SKILL.md` on disk. Also enforces the "Use when…" auto-trigger pattern in every skill's description.
 - **`AGENTS.md`** + **`GEMINI.md`** at repo root — context primer for harnesses that read AGENTS-style files (Codex, Factory) and the Gemini extension.
 - **`.opencode/INSTALL.md`** — explicit OpenCode setup guide.
@@ -36,10 +57,10 @@ The plugin rebrand. Summer is now positioned as superpowers for AI game dev —
 
 ### Fixed
 - `summer_input_map_bind` syntax aligned across `fps-controller` SKILL.md and its behavioral test spec.
-- `_meta/skill-test` static linter relaxed to allow forward-reference `See also` links to other SKILL.md files (warn instead of fail).
+- `workflow/skill-test` static linter relaxed to allow forward-reference `See also` links to other SKILL.md files (warn instead of fail).
 
 ### Added
-- `_shared/summer-folder.md` — canonical `.summer/` folder convention (documents files written by `/summer:brainstorm-game`, `/summer:art-direction`, etc.).
+- `references/summer-folder.md` — canonical `.summer/` folder convention (documents files written by `/summer:brainstorm-game`, `/summer:art-direction`, etc.).
 - `CHANGELOG.md` — retroactive v1.0.0 → v1.3.1 history.
 
 ## [1.3.1] — 2026-05-05
@@ -64,9 +85,9 @@ The plugin rebrand. Summer is now positioned as superpowers for AI game dev —
 
 ### Added
 - 20-category skill library scaffold with descriptive folder names (`character-controllers`, `gameplay-mechanics`, `scripting-patterns`, etc.).
-- `_shared/` directory with 5 canonical references (godot-version, mcp-tools-reference, collaborative-protocol, template-registry, gd-style).
-- `_meta/` directory with 3 meta-skills (skill-test linter, skill-create bootstrap, skill-improve eval harness).
-- `_tests/specs/` directory with per-skill behavioral test specs (fps-controller as canonical format).
+- `references/` directory with 5 canonical references (godot-version, mcp-tools-reference, collaborative-protocol, template-registry, gd-style).
+- `workflow/` directory with 3 meta-skills (skill-test linter, skill-create bootstrap, skill-improve eval harness).
+- `tests/specs/` directory with per-skill behavioral test specs (fps-controller as canonical format).
 - `catalog.yaml` — 85-skill roadmap with HAVE / NEXT / LATER status.
 
 ### Changed

package/CLAUDE.md

@@ -1,5 +1,5 @@
 # Summer — Claude context
 
-This file primes Claude Code on Summer when it loads from this repo. The full agent workflow lives in `skills/_meta/using-summer/SKILL.md`; activate that skill on every fresh session.
+This file primes Claude Code on Summer when it loads from this repo. The full agent workflow lives in `skills/workflow/using-summer/SKILL.md`; activate that skill on every fresh session.
 
-@./skills/_meta/using-summer/SKILL.md
+@./skills/workflow/using-summer/SKILL.md

package/GEMINI.md

@@ -51,6 +51,5 @@ Tools return "Summer Engine is not running." Tell the user to run `summer run` (
 
 If skills aren't loading or the MCP server fails:
 
-- `npm install -g summer-engine` — global CLI.
-- `summer setup gemini --yes` — writes the right MCP config.
-- `summer doctor` — reports auth, engine, port, skill state.
+- `npx -y summer-engine@latest setup gemini --yes --force` — writes the right MCP config.
+- `npx -y summer-engine@latest doctor` — reports auth, engine, port, project memory, and skill state.

package/README.md

@@ -2,7 +2,11 @@
 
 Build real 2D and 3D games through conversation. No coding required. Export to Steam, desktop, mobile, and web. Built on the Godot team's work, customized and honed so AI agents and humans can collaborate on great games.
 
-**Summer** is the open-source plugin that connects your AI coding agent to Summer Engine. MIT licensed. Works in Claude Code, Cursor, Codex, Gemini CLI, OpenCode, Cline, Roo Code, Factory Droid, GitHub Copilot CLI, and Windsurf.
+**Summer** is the open-source plugin that connects your AI coding agent to Summer Engine. MIT licensed. First-class setup works in Claude Code, Cursor, Codex, Windsurf, Cline, Roo Code, Gemini CLI, GitHub Copilot CLI, GitHub Copilot in VS Code, and OpenCode. Factory Droid uses the plugin marketplace path.
+
+- **Source:** [github.com/SummerEngine/summer](https://github.com/SummerEngine/summer)
+- **Docs:** [summerengine.com/docs](https://summerengine.com/docs)
+- **MCP setup:** [summerengine.com/mcp](https://summerengine.com/mcp)
 
 It just works. Open your agent, say *"let's make an FPS in Summer Engine,"* and it does.
 
@@ -10,7 +14,7 @@ It just works. Open your agent, say *"let's make an FPS in Summer Engine,"* and
 
 ## Get started — one prompt
 
-Open Claude Code (or Cursor / Codex / Windsurf / etc.) and paste:
+Open your AI agent (Claude Code, Cursor, Codex, Copilot, Windsurf, etc.) and paste:
 
 > Install Summer Engine and let's make a game.
 
@@ -29,7 +33,7 @@ At that point the agent has the skills, the MCP server, and your engine running.
 
 ## AGENTS READING THIS — the install playbook
 
-You are an AI coding agent (Claude Code, Cursor, Codex, Windsurf). The user told you to install Summer Engine. **Run this playbook via your shell** — Bash on macOS/Linux or PowerShell on Windows; `npx -y` is shell-agnostic and works identically in both. Detection first, then only install what's missing — never double-install.
+You are an AI coding agent. The user told you to install Summer Engine. **Run this playbook via your shell** — Bash on macOS/Linux or PowerShell on Windows; `npx -y` is shell-agnostic and works identically in both. Detection first, then only install what's missing — never double-install.
 
 ### Step −1 — Verify Node.js is on PATH
 
@@ -53,12 +57,15 @@ Parse the JSON output. Top-level `ok: true` means everything is installed and yo
 {
   "ok": true | false,
   "checks": [
-    { "id": "node-version",   "status": "ok" | "warning" | "fail", ... },
-    { "id": "cli-version",    "status": "ok" | "warning" | "fail", ... },
-    { "id": "login",          "status": "ok" | "warning" | "fail", ... },
-    { "id": "engine-install", "status": "ok" | "warning" | "fail", ... },
-    { "id": "local-api",      "status": "ok" | "warning" | "fail", ... },
-    { "id": "mcp-server",     "status": "ok" | "warning" | "fail", ... }
+    { "id": "node-version",        "status": "ok" | "warning" | "fail", ... },
+    { "id": "cli-version",         "status": "ok" | "warning" | "fail", ... },
+    { "id": "cli-version-current", "status": "ok" | "warning" | "fail", ... },
+    { "id": "skills-version-stale","status": "ok" | "warning" | "fail", ... },
+    { "id": "login",               "status": "ok" | "warning" | "fail", ... },
+    { "id": "engine-install",      "status": "ok" | "warning" | "fail", ... },
+    { "id": "local-api",           "status": "ok" | "warning" | "fail", ... },
+    { "id": "project-memory",      "status": "ok" | "warning" | "fail", ... },
+    { "id": "mcp-server",          "status": "ok" | "warning" | "fail", ... }
   ]
 }
 ```
@@ -67,21 +74,23 @@ Parse the JSON output. Top-level `ok: true` means everything is installed and yo
 |---|---|---|
 | `node-version` | continue | (Step −1 already covered this) |
 | `cli-version` | (always ok via npx) | — |
+| `cli-version-current` | continue | run `npx clear-npx-cache && npx -y summer-engine@latest doctor --json` (forces a fresh resolve) |
+| `skills-version-stale` | skip Step 1 | run Step 1 with `--force` |
 | `engine-install` | skip Step 2 | run Step 2 |
 | `login` | skip Step 3 | run Step 3 |
 | `local-api` | skip Step 5b wait-loop | run wait-loop after `summer run` |
+| `project-memory` | continue | if a project is open, run `summer:brainstorm-game` before building |
 | `mcp-server` | skip Step 1 | run Step 1 |
-| (skills installed) | skip Step 1 | run Step 1 |
 
-(There's no doctor check for "skills installed" yet — run Step 1 unconditionally on first install. It's idempotent.)
+**On version drift:** if either `cli-version-current` or `skills-version-stale` returns `warning` or `fail`, you should refresh before proceeding. Tell the user once: "There's a newer Summer (X.Y.Z → A.B.C); updating before we start." Then run the recommended action from `details.recommendedAction` and re-run doctor. Don't ask the user to choose — they paste 'install' and want the latest.
 
 ### Step 1 — Install user-level skills (idempotent, fast)
 
 ```bash
-npx -y summer-engine@latest setup claude-code --yes
+npx -y summer-engine@latest setup claude-code --yes --force
 ```
 
-Replace `claude-code` with the user's actual agent: `codex`, `cursor`, `windsurf`, `cline`, `roo-code`, `gemini`, or `opencode`. (Factory Droid and Copilot CLI use different install paths — see [`docs/`](docs/) per harness.) This writes 60 skill files to `~/.claude/skills/<name>/SKILL.md` (or the agent's equivalent user-skill directory) AND writes the MCP server config so the agent can talk to the engine.
+Replace `claude-code` with the user's actual agent: `codex`, `cursor`, `windsurf`, `cline`, `roo-code`, `gemini`, `github-copilot`, `vscode-copilot`, or `opencode`. Use `github-copilot` for Copilot CLI and `vscode-copilot` for GitHub Copilot Chat/Agent in VS Code. Factory Droid still uses the plugin marketplace path in the install section below. This writes 60 skill files to `~/.claude/skills/<name>/SKILL.md` (or the agent's equivalent user-skill directory) AND writes the MCP server config so the agent can talk to the engine. The `--force` flag wipes any stale skill content first, so re-runs always end up with the latest copy.
 
 **First-install detection:** if `~/.claude/skills/` didn't exist before this command, Claude Code wasn't watching it and won't auto-detect the new files this session. Tell the user **once**: "Skills installed — restart your agent so they load." On subsequent installs (directory already existed), skills auto-detect mid-session and no restart is needed. **You can detect first-install vs upgrade by checking if `~/.claude/skills/` existed before Step 1; record the result before running setup.**
 
@@ -151,6 +160,8 @@ Once `local-api` is `ok`, MCP tools are safe to call.
 
 Now you have skills + MCP. **Don't jump into `summer create` content from a vague prompt** — invoke the `summer:brainstorm-game` skill via the `Skill` tool first. It scopes mechanics, art direction, and the V1 cut list, and writes the result to `.summer/GameSoul.md`. Every other Summer skill reads from that file.
 
+Project memory lives in `.summer/` as readable Markdown. Use `.summer/memory/` for locked facts that should not drift across sessions, such as character voice IDs, world canon, and provider bindings. Users can inspect it with `summer memory`; agents should read relevant memory surfaced by `summer_get_project_context` before changing creative/audio/dialogue/level/character work.
+
 Only skip brainstorm if the user explicitly said "skip brainstorm" or "just build the X already." After brainstorm, the appropriate build skills (`fps-controller`, `design-mechanic`, `design-level`, `make-game`, etc.) auto-trigger from natural language.
 
 ### Anti-patterns (do NOT do these)
@@ -169,9 +180,9 @@ Only skip brainstorm if the user explicitly said "skip brainstorm" or "just buil
 - **Don't loop `summer login` if it times out at 120s.** Re-run it once and tell the user to be quicker; loop forever and the user is stuck.
 - **Don't jump straight into `summer create` from a vague prompt.** Invoke `summer:brainstorm-game` first (Step 6). The build skills assume `.summer/GameSoul.md` exists.
 
-**Using a different agent?** Replace `claude-code` with any supported agent in Step 1: `codex`, `cursor`, `windsurf`, `cline`, `roo-code`, `gemini`, or `opencode`. Skill targets vary per agent (Cursor uses `.cursor/rules/`, Windsurf uses `.windsurfrules`, Cline + Roo use `.clinerules/`, OpenCode uses agent definitions, etc.). The CLI handles the difference. After install, **Cline and Roo Code users should restart VS Code** so the extension reloads its MCP config. **Gemini users** may need to run `gemini extensions enable summer-engine` after the first install. **Factory Droid and Copilot CLI** still have their own install paths — see [`docs/`](docs/).
+**Using a different agent?** Replace `claude-code` with any supported agent in Step 1: `codex`, `cursor`, `windsurf`, `cline`, `roo-code`, `gemini`, `github-copilot`, `vscode-copilot`, or `opencode`. Skill targets vary per agent (Cursor uses `.cursor/rules/`, Windsurf uses `.windsurfrules`, Cline + Roo use `.clinerules/`, Copilot uses `~/.copilot/skills` or `.github/skills`, OpenCode uses agent definitions, etc.). The CLI handles the difference. After install, **Cline and Roo Code users should restart VS Code** so the extension reloads its MCP config. **Gemini users** may need to run `gemini extensions enable summer-engine` after the first install. **VS Code Copilot users** should start the `summer-engine` MCP server from Agent mode if VS Code does not autostart it. **Factory Droid** still has its own plugin path below.
 
-**Power-user note:** if the user specifically wants `summer` on their `PATH` for everyday terminal use (outside the AI agent), they can run `npm install -g summer-engine` themselves later. The agent flow doesn't need it.
+**Power-user note:** if the user specifically wants `summer` on their `PATH` for everyday terminal use outside the AI agent, a global npm install is still possible. The agent flow doesn't need it.
 
 ---
 
@@ -184,7 +195,7 @@ If you specifically prefer the official Claude Code plugin marketplace UI, you c
 /plugin install summer@summer-engine
 ```
 
-This is functionally equivalent to `summer setup claude-code --yes` for the skill install. You'll still need `summer install` and `summer login` to get the engine running. The agent-driven path above is faster and idempotent; this exists for users who want everything in the plugin TUI.
+This is functionally equivalent to `npx -y summer-engine@latest setup claude-code --yes` for the skill install. You'll still need `npx -y summer-engine@latest install` and `npx -y summer-engine@latest login` to get the engine running. The agent-driven path above is faster and idempotent; this exists for users who want everything in the plugin TUI.
 
 ---
 
@@ -192,9 +203,9 @@ This is functionally equivalent to `summer setup claude-code --yes` for the skil
 
 You installed one product. It has three parts. You don't have to think about them — Summer wires them up — but here's what each does:
 
-- **Summer Engine** — the game engine app. Where you see, play, and debug your game. Installed by `summer install`. Proprietary, free to use.
-- **Summer plugin** — what Claude Code (or your agent) uses to know what game-dev skills to apply and which tools to call. Installed via `/plugin install`. MIT, open source.
-- **Summer CLI** — the terminal command (`summer ...`) that installs the engine, scaffolds projects, runs them, signs you in. Installed via `npm install -g summer-engine`. MIT, open source.
+- **Summer Engine** — the game engine app. Where you see, play, and debug your game. Installed by the agent via `npx -y summer-engine@latest install`. Proprietary, free to use.
+- **Summer plugin** — what Claude Code (or your agent) uses to know what game-dev skills to apply and which tools to call. Installed by `summer setup` or the marketplace path. MIT, open source.
+- **Summer CLI** — the terminal command layer that installs the engine, scaffolds projects, runs them, signs you in, and starts MCP. Usually invoked through `npx -y summer-engine@latest ...`, so no global install is needed. MIT, open source.
 
 The plugin gives the agent the skills. The CLI gives it hands to install and launch the engine. The engine is where the game actually lives.
 
@@ -206,9 +217,9 @@ We tell you before we touch your disk.
 
 | What | Size | When | Source |
 |---|---|---|---|
-| `summer-engine` npm package (CLI + plugin source) | ~3 MB | `npm install -g summer-engine` | [npmjs.com/package/summer-engine](https://www.npmjs.com/package/summer-engine) |
-| Summer Engine app | ~1 GB (engine + bundled Git/runtime tools) | `summer install` | Summer's signed releases |
-| Auth token | ~1 KB | `summer login` | Browser → `~/.summer/auth-token` |
+| `summer-engine` npm package (CLI + plugin source) | ~3 MB | first `npx -y summer-engine@latest ...` call | [npmjs.com/package/summer-engine](https://www.npmjs.com/package/summer-engine) |
+| Summer Engine app | ~1 GB (engine + bundled Git/runtime tools) | `npx -y summer-engine@latest install` | Summer's signed releases |
+| Auth token | ~1 KB | `npx -y summer-engine@latest login` | Browser → `~/.summer/auth-token` |
 | Skill files | < 50 KB | bundled in the npm package | no extra network call |
 | Generated assets (3D / image / audio / video) | varies | only on explicit `summer_generate_*` calls | Summer Engine Studio |
 | URL imports | varies | only on explicit `summer_import_from_url` calls | the URL you provide |
@@ -299,7 +310,7 @@ Twenty-four skills replace "agent flailing through tutorials" with measurable cr
 
 C# is supported by the engine. A `summer:csharp-patterns` skill is on the roadmap; for now write C# from Godot 4.5 docs.
 
-Full catalog with HAVE / NEXT / LATER status: [`skills/catalog.yaml`](./skills/catalog.yaml).
+Full list of shipping skills: the `skills:` array in [`.claude-plugin/plugin.json`](./.claude-plugin/plugin.json).
 
 ## Philosophy
 
@@ -380,10 +391,19 @@ Drops a Summer extension manifest at `~/.gemini/extensions/summer-engine/`. If t
 ### GitHub Copilot CLI
 
 ```bash
-copilot plugin marketplace add SummerEngine/summer
-copilot plugin install summer@summer-engine
+npx -y summer-engine@latest setup github-copilot --yes
+```
+
+Writes MCP config to `~/.copilot/mcp-config.json` and skills to `~/.copilot/skills/`. In an active Copilot CLI session, run `/mcp reload` and `/skills reload`; otherwise restart Copilot CLI.
+
+### GitHub Copilot in VS Code
+
+```bash
+npx -y summer-engine@latest setup vscode-copilot --yes
 ```
 
+Writes MCP config to VS Code's user `mcp.json` and skills to `~/.copilot/skills/`. Restart VS Code or run **MCP: List Servers**, then use Copilot Agent mode.
+
 ### OpenCode
 
 ```bash
@@ -395,9 +415,8 @@ Writes the MCP server entry into `opencode.json` (`~/.config/opencode/opencode.j
 ### Windsurf and others
 
 ```bash
-npm install -g summer-engine
-summer setup <agent> --yes
-summer doctor
+npx -y summer-engine@latest setup <agent> --yes --force
+npx -y summer-engine@latest doctor
 ```
 
 ---
@@ -410,7 +429,9 @@ summer doctor
 | `summer login` | Browser-based sign-in. |
 | `summer logout` | Clear auth tokens. |
 | `summer status` | Engine state, port, auth. |
-| `summer doctor` | Diagnose Node, login, engine, MCP. |
+| `summer doctor` | Diagnose Node, login, engine, project memory, MCP. |
+| `summer memory` | Inspect project memory in `.summer`. |
+| `summer memory show <file>` | Print a project memory Markdown file. |
 | `summer run [path]` | Launch the engine. |
 | `summer open <path>` | Open a project in a running engine. |
 | `summer create <template> [name]` | Scaffold a project. |
@@ -452,7 +473,7 @@ More coming.
 Skills evolve fast. Two ways to help:
 
 1. **Open an issue** if a skill misfires. Quote the prompt and the response.
-2. **Submit a SKILL.md** for one of the `NEXT` entries in [`skills/catalog.yaml`](./skills/catalog.yaml). Run `summer:skill-test` against it before opening the PR.
+2. **Submit a new SKILL.md** under `skills/<category>/<name>/`. Register it in `.claude-plugin/plugin.json` and `src/lib/skills-registry.ts`. Run `summer:skill-test` against it before opening the PR.
 
 [`docs/DEVELOPMENT.md`](./docs/DEVELOPMENT.md) is the contributor guide.
 

package/_persona/summer/SKILL.md

@@ -50,7 +50,7 @@ When the user invokes `/summer`, you:
 | "/summer let me play it" | `summer:scene-and-project/play` |
 | "/summer I'm stuck" or "/summer what should I work on" | `summer:scene-and-project/brainstorm-game` (back to the playable cut) |
 
-If nothing on the table fits, fall back to `summer:_meta/using-summer` and read the catalog (`skills/catalog.yaml`) to find the closest skill. Never invent a skill name; verify in the `Skill` tool's index first.
+If nothing on the table fits, fall back to `summer:using-summer` and walk the `Skill` tool's index to find the closest skill. Never invent a skill name; verify in the index first.
 
 ## Tone rules
 
@@ -64,7 +64,7 @@ If nothing on the table fits, fall back to `summer:_meta/using-summer` and read
 ## What to avoid
 
 - Don't pretend to be a different model. You're the same model with a sharper voice.
-- Don't invent Summer skills that don't exist. Check the `Skill` index and `skills/catalog.yaml` first.
+- Don't invent Summer skills that don't exist. Check the `Skill` tool's index first.
 - Don't generate without confirming cost. Ever.
 - Don't ship a 30-second response when the user wants the build started. Invoke the right skill and start producing artifacts.
 - Don't redirect users to external docs. Solve the problem in-conversation.
@@ -107,7 +107,6 @@ If `.summer/GameSoul.md` exists, read it before any creative work. It's the sour
 
 ## See also
 
-- `summer:_meta/using-summer` — base context for the Summer skill family (auto-loaded; this persona builds on top).
-- `summer:scene-and-project/brainstorm-game` — when starting from scratch or stuck.
-- `summer:scene-and-project/play` — push the build into the player's hands.
-- `skills/catalog.yaml` — full skill index when the routing table doesn't cover the request.
+- `summer:using-summer` — base context for the Summer skill family (auto-loaded; this persona builds on top).
+- `summer:brainstorm-game` — when starting from scratch or stuck.
+- `summer:play` — push the build into the player's hands.

package/commands/gameskill.md

@@ -0,0 +1,103 @@
+You are capturing what we just learned in this game-development session into Summer Engine's skill library, so the next agent (and every Summer user) gets to start where we ended.
+
+This is the meta-skill: the loop that turns ad-hoc fixes into durable, reusable expertise.
+
+## What "Summer Engine" is, so you're grounded
+
+Three repos, one ecosystem:
+
+1. **`~/development/SummerEngine`** — the desktop engine (Godot fork in C++) + the canonical CLI. The engine source lives at `editor/`, `core/`, and the Summer-specific module at `modules/1summer_engine/`. The Summer CLI lives at `tools/summer-cli/`. It ships as `npm i -g summer-engine`. It does install/login/create/run for the engine, plus `summer skills install --as-claude-skill` which writes a curated subset of skills into `~/.claude/skills/` for any agent to auto-discover.
+2. **`~/development/PublicSummerEngine`** — the web app at summerengine.com. Has its own AI skill stores at `src/lib/ai/skills/bundled/` and `public/knowledge/summer/skills/` for the in-browser chat agent. ALSO has its own MCP-style consumers of the engine API (`src/lib/bridge/direct-executor.ts`, `src/lib/ai/tools/run-and-verify.ts`) which call the same engine endpoints the CLI does.
+3. **The active game project** — usually `~/development/<game-name>` (Godot 4.6) or whatever game we were just working on. Real working code in this repo is the gold standard for examples.
+
+The skill system is the value flywheel: every game we ship teaches lessons → the lessons become skills → the next user (or AI) starts smarter. Your job here is to close that loop for what we just did.
+
+## Cross-repo change awareness — read this before any non-trivial fix
+
+When the lesson is "the engine should expose more / behave differently," the change usually crosses repo boundaries. Map the layers before you edit:
+
+```
+[active game] → calls MCP / web app
+                       ↓
+[summer-cli MCP server (TypeScript)] → calls /api/ops + /api/state/* on the engine
+                       ↓
+[Summer Engine binary (C++ in SummerEngine repo)] — source of truth for what the API can return
+
+[PublicSummerEngine web app (TypeScript)] → also calls the same engine endpoints via direct-executor or Redis bridge
+```
+
+Implications:
+
+- **A C++ change in `SummerEngine/modules/1summer_engine/` or `SummerEngine/editor/` reaches everyone** (CLI MCP, web app, future tools). Most powerful, also highest blast radius.
+- **A TypeScript change in `tools/summer-cli/src/mcp/`** only changes what the CLI exposes. The web app has its own TypeScript layer in `PublicSummerEngine/src/lib/bridge/` — same engine endpoints, different glue. Don't assume your CLI tool change is web-app-aware.
+- **A skill update in `tools/summer-cli/skills/`** affects every agent that runs `summer skills install`. The web app's skill store is separate (`PublicSummerEngine/src/lib/ai/skills/bundled/`) and currently uses a different format (template wizards, not Markdown discipline guides). Don't try to mirror skills there blindly.
+
+When you change an engine endpoint's response shape (add fields, rename fields, change semantics):
+
+1. Grep both `tools/summer-cli/src/` and `PublicSummerEngine/src/lib/` for consumers of that endpoint.
+2. Confirm the change is **additive** (new fields, no removed/renamed) so existing consumers still work without modification.
+3. If the change is breaking, update both consumers in the same logical commit set.
+4. Note in TOOLING-TODO.md what's now possible that wasn't before.
+
+Engine binary changes ship via a rebuild + new release. The user has to pull the new engine for the change to take effect. CLI/web TypeScript changes ship via npm publish or web deploy. State this delivery cost in your report so the user knows what they're getting today vs after a release.
+
+## The four skill stores (probe each before doing anything)
+
+1. **Canonical source** — `~/development/SummerEngine/tools/summer-cli/skills/`
+   - Single source of truth. Domains: `ui-and-ux`, `gameplay-mechanics`, `character-controllers`, `scripting-patterns`, `visual-effects`, `debugging`, `rendering-and-lighting`, `scene-and-project`, `level-design`, `audio`, `ai-and-npcs`, `asset-pipeline`, `performance`, `deployment`, `multiplayer-and-networking`, plus `workflow` for process skills.
+   - The `skills:` array in `.claude-plugin/plugin.json` is the registry. Sibling shared docs live at top-level `references/`; test specs at top-level `tests/`.
+2. **Claude auto-discovery** — `~/.claude/skills/` (currently 7 skills, written here by `summer skills install --as-claude-skill`).
+3. **Web-app stores** — `~/development/PublicSummerEngine/src/lib/ai/skills/` and `public/knowledge/summer/skills/`. Mirror only if the learning applies to the web chat agent too — check what's there before assuming.
+4. **The active game** — read it as ground truth. Working code from the real project beats invented examples.
+
+## What to do, in order
+
+1. **One short sentence to the user.** "Capturing learnings from this session into the skill library." That's it. No plan dump.
+
+2. **Probe the stores.** Glob each path above. Note what exists and what's empty. Print a tight summary (one line per domain with skill count).
+
+3. **Recap the session.** Look back over the conversation. Pull out the learnings that are non-obvious AND general — things a future agent or user would benefit from but couldn't derive from reading the codebase. Examples that count:
+   - A working shader (the actual code) → `visual-effects`
+   - A GDScript idiom that beat the obvious approach → `scripting-patterns`
+   - A UI layout that survived the design pass → `ui-and-ux`
+   - A bug + root cause + fix that wasn't in any docs → `debugging`
+   - A Godot 4.6 quirk (type inference, `.keys()` weirdness, signal gotchas) → `scripting-patterns`
+   - A spawning/AI/enemy pattern that worked → `ai-and-npcs` or `gameplay-mechanics`
+   - A perf fix with measured before/after → `performance`
+   - An asset-creation workflow that beat alternatives → `asset-pipeline`
+
+   Examples that DON'T count:
+   - One-off code with no general lesson
+   - Stuff already documented in `CLAUDE.md` or an existing skill
+   - Personal preference with no reasoning behind it
+   - Anything you have to manufacture to fill space
+
+4. **Decide placement.** For each learning:
+   - **Update existing skill** — name the file, quote the section, draft the addition.
+   - **Create new skill** — pick the domain, name the file, draft the full skill markdown.
+   Match the format of existing skills in the same domain exactly. Read one if you're unsure.
+
+5. **One tight pause for the user.** Five-to-ten lines max: what files you'll touch, what each one captures, what gets left out. Wait for OK or redirect. Don't ask multiple questions.
+
+6. **Apply.**
+   - Write/edit `.md` files under `tools/summer-cli/skills/<domain>/`.
+   - Register a new skill in `.claude-plugin/plugin.json` (plus `.codex-plugin/`, `.cursor-plugin/`) AND in `src/lib/skills-registry.ts` `SKILL_REGISTRY`. Both are required.
+   - If the skill belongs in the curated Claude set, also write it to `~/.claude/skills/<name>/` so it's live in the current session — and tell the user to consider adding it to the CLI's default install set.
+   - If the learning applies to the web chat agent, mirror to `PublicSummerEngine` skill stores too.
+   - Run `git status` in `~/development/SummerEngine` (and `PublicSummerEngine` if touched) so the diff is visible.
+
+7. **Report.** One short message. Files changed, the future-agent payoff in one sentence per skill, and what (if anything) is still uncaptured.
+
+## Style rules — non-negotiable
+
+- **Tight. No slop. No glazing.** Mathias hates filler.
+- **Capture the why, not just the what.** "Use X" rots. "Use X because Y breaks under Z (we hit this in PRUT chest reveal, 2026-05)" survives. Always lead skill updates with the reason.
+- **Real working code from the active project beats invented examples.** Lift from PRUT or whatever we were in.
+- **VFX is code** — shaders + GDScript + node setup. Never image-generation pipelines or Meshy prompts.
+- **No em dashes** (—) in any user-facing copy you write into skills. Use periods or restructure the sentence.
+- **`[SUMMER]` markers on core Godot engine file edits** — but skill `.md` files don't need them.
+- **Verify before claiming.** If a skill says "Summer Engine does X" or "Stripe is configured Y way", verify in the actual code/DB before writing it down.
+
+## When there's nothing worth capturing
+
+It's totally fine to come back with "session was tactical, no durable learnings worth a skill update." Don't manufacture skills from thin air. Better to ship nothing into the skill library than ship noise.