feat(setup): add first-class Bionic support

CHANGELOG.md

@@ -2,6 +2,12 @@
 
 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/).
 
+## [Unreleased]
+
+### Added
+- First-class LM Studio Bionic setup through `summer setup bionic`: public MCP discovery configuration, native Bionic Agent Skills, statically bound project-scope connections, setup aliases, diagnostics markers, tests, and a dedicated guide.
+- MCP Roots-based project routing for clients that advertise the capability, including safe rebinding on `roots/list_changed` and ambiguity protection.
+
 ## [2.8.1] — 2026-08-18 — "Scene mutations work again on engine 0.5.60+"
 
 ### Added

README.md

@@ -7,7 +7,7 @@ the templates present in the installed engine. The package does not silently
 build, host, or submit games to stores; its explicit, confirmed creator command
 can publish an already-exported Summer `.pck` to Summercraft for review.
 
-**Summer** is the MIT open-source agent layer that connects your AI coding agent to Summer Engine. It is the **Summer CLI**, the **Summer MCP** server, and the **Summer agent** skills, hooks, and plugin manifests, all in one package. First-class setup works in Claude Code, Cursor, Codex, Devin Desktop (formerly Windsurf), Cline, Roo Code, Gemini CLI, GitHub Copilot CLI, GitHub Copilot in VS Code, and OpenCode. Factory Droid uses the plugin marketplace path.
+**Summer** is the MIT open-source agent layer that connects your AI coding agent to Summer Engine. It is the **Summer CLI**, the **Summer MCP** server, and the **Summer agent** skills, hooks, and plugin manifests, all in one package. First-class setup works in Claude Code, Cursor, Codex, Devin Desktop (formerly Windsurf), Cline, Roo Code, Kilo Code, Gemini CLI, GitHub Copilot CLI, GitHub Copilot in VS Code, OpenCode, Bionic, and LM Studio. Factory Droid uses the plugin marketplace path.
 
 - **Source:** [github.com/SummerEngine/summer-engine-agent](https://github.com/SummerEngine/summer-engine-agent)
 - **CLI setup:** [www.summerengine.com/cli](https://www.summerengine.com/cli)
@@ -33,7 +33,7 @@ its own license. One setup flow wires the pieces together.
 
 ## Get started: one prompt
 
-Open your AI agent (Claude Code, Cursor, Codex, Copilot, Devin Desktop, etc.) and paste:
+Open your AI agent (Claude Code, Cursor, Codex, Copilot, Bionic, Devin Desktop, etc.) and paste:
 
 > Install Summer Engine and let's make a game. Read github.com/SummerEngine/summer-engine-agent, check what I already have installed, install whatever is missing, log me in, and scaffold a starter project so we can start building.
 
@@ -94,7 +94,7 @@ The relevant check ids are `node-version`, `cli-version`, `cli-version-current`,
 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`, `kilo-code`, `gemini`, `github-copilot`, `vscode-copilot`, `opencode`, or `lm-studio`. 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 the current Summer skill bundle 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.
+Replace `claude-code` with the user's actual agent: `codex`, `cursor`, `windsurf`, `cline`, `roo-code`, `kilo-code`, `gemini`, `github-copilot`, `vscode-copilot`, `opencode`, `bionic`, or `lm-studio`. 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. For skill-capable targets, setup writes the current Summer skill bundle to the agent's user-skill directory and writes the MCP server config. The `lm-studio` target is MCP-only and uses `summer_get_agent_playbook` for in-chat guidance; the separate `bionic` target installs native Agent Skills. The `--force` flag wipes stale skill content first, so re-runs 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.**
 
@@ -184,7 +184,7 @@ 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`, `kilo-code`, `gemini`, `github-copilot`, `vscode-copilot`, `opencode`, or `lm-studio`. (`devin` is also accepted as an alias for `windsurf`.) Skill targets vary per agent (Cursor uses `.cursor/rules/`, Devin Desktop 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.
+**Using a different agent?** Replace `claude-code` with any supported agent in Step 1: `codex`, `cursor`, `windsurf`, `cline`, `roo-code`, `kilo-code`, `gemini`, `github-copilot`, `vscode-copilot`, `opencode`, `bionic`, or `lm-studio`. (`devin` is also accepted as an alias for `windsurf`.) Skill targets vary per agent (Cursor uses `.cursor/rules/`, Devin Desktop uses `.windsurfrules`, Cline + Roo use `.clinerules/`, Copilot uses `~/.copilot/skills` or `.github/skills`, OpenCode uses agent definitions, Bionic uses `~/.lmstudio/skills`, etc.). The CLI handles the difference. After install, **Bionic users** should enable `summer-engine` under **Settings → Connected Apps** and verify Summer skills under **Settings → Skills**. **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, a global npm install is still possible. The agent flow doesn't need it.
 
@@ -483,13 +483,21 @@ npx -y summer-engine@latest setup opencode --yes
 
 Writes the MCP server entry into `opencode.json` (`~/.config/opencode/opencode.json` for user scope, `./opencode.json` for project) using the array-shaped `command: ["npx", "-y", "summer-engine@latest", "mcp"]` format. Restart OpenCode. Full guide: [`.opencode/INSTALL.md`](./.opencode/INSTALL.md).
 
+### Bionic (local models and cloud-hosted open models)
+
+```bash
+npx -y summer-engine@latest setup bionic --scope project --yes --force
+```
+
+Bionic is a separate agentic app from LM Studio. Run the command from the Summer game directory. It publishes Summer's MCP entry to `~/.lmstudio/mcp.json`, which Bionic discovers under **Settings → Connected Apps**, statically binds the global connection to that game, and installs native Agent Skills under `.agents/skills/`. Enable `summer-engine` under **Connected Apps**, then verify the Summer skills under **Settings → Skills**. Bionic currently does not pass its active Code Project to MCP servers, so re-run setup from a new game directory when switching games. User-scope setup without `--scope project` remains available for global skills when exactly one Summer editor is running. Full guide: [`docs/BIONIC.md`](docs/BIONIC.md).
+
 ### LM Studio (local models)
 
 ```bash
 npx -y summer-engine@latest setup lm-studio --yes
 ```
 
-Writes the MCP server entry into `~/.lmstudio/mcp.json` (app-global; there is no project scope). In LM Studio, toggle the `summer-engine` server on in the **Program** tab, and raise the loaded model's context length to **32k or higher** — MCP tool schemas overflow small contexts silently. LM Studio has no rules/skills folder; the MCP server's `summer_get_agent_playbook` tool covers in-chat guidance. Pair with a tool-calling-reliable local model (gpt-oss-20b on 12–16 GB VRAM, Qwen3-Coder-30B on 24 GB).
+Writes the MCP server entry into `~/.lmstudio/mcp.json` (app-global; there is no project scope). In LM Studio, toggle the `summer-engine` server on in the **Program** tab, and raise the loaded model's context length to **32k or higher** — MCP tool schemas overflow small contexts silently. The LM Studio app does not natively discover Agent Skills; the separate Bionic app does. Therefore `setup lm-studio` installs MCP only and relies on `summer_get_agent_playbook` for in-chat guidance. Pair with a tool-calling-reliable local model (gpt-oss-20b on 12–16 GB VRAM, Qwen3-Coder-30B on 24 GB).
 
 ### Ollama (local models)
 
@@ -532,7 +540,7 @@ npx -y summer-engine@latest doctor
 | `summer mcp setup <agent>` | Write MCP config for an agent. |
 | `summer setup <agent> [--yes]` | One shot: MCP config + recommended skills + doctor. |
 
-Agents: `claude-code`, `codex`, `cursor`, `windsurf`, `cline`, `roo-code`, `kilo-code`, `gemini`, `github-copilot`, `vscode-copilot`, `opencode`, `lm-studio`. (`devin` and `devin-desktop` are accepted as aliases for `windsurf`.) Scopes: `--scope user` (default), `--scope project`.
+Agents: `claude-code`, `codex`, `cursor`, `windsurf`, `cline`, `roo-code`, `kilo-code`, `gemini`, `github-copilot`, `vscode-copilot`, `opencode`, `bionic`, `lm-studio`. (`devin` and `devin-desktop` are accepted as aliases for `windsurf`; `lm-bionic` and `lm-studio-bionic` are accepted as aliases for `bionic`.) Scopes: `--scope user` (default), `--scope project`.
 
 ---
 
@@ -573,6 +581,7 @@ Skills evolve fast. Two ways to help:
 - [Claude Code](docs/CLAUDE_CODE.md)
 - [Codex](docs/CODEX.md)
 - [Cursor](docs/CURSOR.md)
+- [Bionic](docs/BIONIC.md)
 - [OpenCode](.opencode/INSTALL.md)
 - [Skills overview](docs/SKILLS.md)
 - [Templates](docs/TEMPLATES.md)

docs/BIONIC.md

@@ -0,0 +1,56 @@
+# Bionic
+
+[LM Studio Bionic](https://lmstudio.ai/docs/bionic) is a separate agentic app from LM Studio. It supports local models and cloud-hosted open models, local coding projects, MCP servers, and standard [Agent Skills](https://lmstudio.ai/docs/bionic/agent/skills).
+
+## Recommended Setup
+
+Run this from the Summer game directory:
+
+```bash
+npx -y summer-engine@latest setup bionic --scope project --yes --force
+```
+
+This performs two setup steps:
+
+- publishes the `summer-engine` stdio entry to the public [`~/.lmstudio/mcp.json`](https://lmstudio.ai/docs/app/mcp) integration file, which Bionic discovers under Connected Apps, and binds it to the current game;
+- installs Summer Agent Skills under `.agents/skills/<skill>/SKILL.md`.
+
+The published MCP registration is app-global. Bionic currently starts global MCP servers outside the active Code Project and does not advertise MCP Roots. Project-scope setup therefore pins both its stdio `cwd` and `SUMMER_ENGINE_PROJECT` to the current directory. Because Bionic does not update that global connection when its active Code Project changes, re-run the setup command from the new game directory when switching projects.
+
+If you always run exactly one Summer editor and prefer global skills, use user scope instead:
+
+```bash
+npx -y summer-engine@latest setup bionic --yes --force
+```
+
+User scope installs skills under `~/.lmstudio/skills/<skill>/SKILL.md` and leaves editor discovery automatic.
+
+Bionic owns its internal enabled/connection state; Summer does not write Bionic's private app-state files.
+
+## Enable Summer in Bionic
+
+1. Open **Settings → Connected Apps**.
+2. Enable `summer-engine` and confirm that its tools are ready.
+3. Open **Settings → Skills** and verify that the Summer skills are enabled.
+
+If the MCP entry does not appear after setup, restart Bionic and check **Connected Apps** again.
+
+## Project Skills
+
+For project skills without changing MCP configuration, run this from the project root (the recommended setup command above already does this):
+
+```bash
+npx -y summer-engine@latest skills install --recommended --agent bionic --scope project
+```
+
+This writes standard Agent Skills to `.agents/skills/<skill>/SKILL.md`, a discovery path covered by the [Bionic changelog](https://lmstudio.ai/changelog). Bionic can also expose compatible skills already installed for Codex or Claude Code through **Settings → Skills → Use skills found in other apps**.
+
+## Run Summer Engine
+
+Keep Summer Engine open on the same project while Bionic works:
+
+```bash
+npx -y summer-engine@latest run path/to/project
+```
+
+Use a model with reliable tool calling and enough context for the Summer MCP tool schemas. Bionic should use Summer MCP for project files, scene/editor operations, play mode, and diagnostics.

docs/DEVELOPMENT.md

@@ -23,7 +23,7 @@ the Summer product identity.
 2. **MCP server**: gives AI coding agents a focused tool registry, including identity-bound project files, scene manipulation, play/stop, diagnostics, and asset import/generation
 3. **Skills bundle**: the current SKILL.md playbooks that auto-trigger when the agent sees the right natural-language signal
 
-Plus lifecycle hooks, plugin manifests, and setup targets that wire all of the above into Claude Code, Cursor, Codex, Gemini, OpenCode, GitHub Copilot CLI, GitHub Copilot in VS Code, Cline, Roo Code, Factory Droid, and Devin Desktop (formerly Windsurf).
+Plus lifecycle hooks and plugin manifests. First-class setup targets wire MCP into Claude Code, Cursor, Codex, Gemini, OpenCode, GitHub Copilot CLI, GitHub Copilot in VS Code, Cline, Roo Code, Kilo Code, Devin Desktop (formerly Windsurf), Bionic, and LM Studio; skills follow each host's capabilities, so LM Studio setup is MCP-only. Factory Droid uses its plugin marketplace path.
 
 It gets published to npm as `summer-engine`. Users run it with `npx summer-engine <command>`.
 

docs/OVERVIEW.md

@@ -14,7 +14,7 @@ Three things, plus glue.
 
 **CLI.** Install the engine, log in, scaffold projects, run them, run doctor. The terminal side.
 
-The glue: **lifecycle hooks** (session-start orientation, optional pre-commit doctor), plugin manifests for plugin-capable harnesses, and `summer setup` targets for Claude Code, Cursor, Codex, Gemini, OpenCode, GitHub Copilot CLI, GitHub Copilot in VS Code, Cline, Roo Code, and Devin Desktop (formerly Windsurf).
+The glue: **lifecycle hooks** (session-start orientation, optional pre-commit doctor), plugin manifests for plugin-capable harnesses, and `summer setup` targets for Claude Code, Cursor, Codex, Gemini, OpenCode, GitHub Copilot CLI, GitHub Copilot in VS Code, Cline, Roo Code, Kilo Code, Devin Desktop (formerly Windsurf), Bionic, and LM Studio.
 
 ## Quick start
 
@@ -55,10 +55,12 @@ Each agent has its own home for SKILL.md files:
 | `cursor` | `~/.cursor/rules` (as `summer-<skill>.mdc`) | `.cursor/rules` |
 | `cline` | `~/Documents/Cline/Rules` | `.clinerules` |
 | `roo-code` | `~/Documents/Roo/Rules` | `.clinerules` |
+| `kilo-code` | `~/.kilocode/rules` | `.kilocode/rules` |
 | `gemini` | `~/.gemini/extensions/summer-engine/skills` | n/a |
 | `github-copilot` | `~/.copilot/skills` | `.github/skills` |
 | `vscode-copilot` | `~/.copilot/skills` | `.github/skills` |
 | `opencode` | `~/.config/opencode/agents/summer` | `.opencode/agents/summer` |
+| `bionic` | `~/.lmstudio/skills` | `.agents/skills` |
 | `windsurf` (Devin Desktop) | `~/.windsurfrules` (managed blocks) | `.windsurfrules` |
 
 Use `--scope project` when you want the skills committed with the game:

docs/SETUP_PROMPT.md

@@ -1,6 +1,6 @@
 # Copy-Paste Setup Prompt
 
-Use this when a human wants to install Summer Engine from Claude Code, Cursor, Codex, Devin Desktop (formerly Windsurf), Cline, Roo Code, Gemini CLI, GitHub Copilot CLI, GitHub Copilot in VS Code, or OpenCode.
+Use this when a human wants to install Summer Engine from Claude Code, Cursor, Codex, Devin Desktop (formerly Windsurf), Cline, Roo Code, Kilo Code, Gemini CLI, GitHub Copilot CLI, GitHub Copilot in VS Code, OpenCode, Bionic, or LM Studio.
 
 Source: https://github.com/SummerEngine/summer-engine-agent
 MCP setup page: https://summerengine.com/mcp
@@ -23,7 +23,7 @@ Expected agent behavior:
 6. Create and run a starter project only after choosing a stable parent directory.
 7. Use `summer:brainstorm-game` before building from a vague prompt.
 
-First-class setup targets: `claude-code`, `codex`, `cursor`, `windsurf`, `cline`, `roo-code`, `kilo-code`, `gemini`, `github-copilot`, `vscode-copilot`, `opencode`, `lm-studio`.
+First-class setup targets: `claude-code`, `codex`, `cursor`, `windsurf`, `cline`, `roo-code`, `kilo-code`, `gemini`, `github-copilot`, `vscode-copilot`, `opencode`, `bionic`, `lm-studio`.
 
 Factory Droid uses its plugin marketplace path today. Other older-school or adjacent surfaces worth watching are Continue, Aider, Zed, JetBrains AI/Junie, Goose, and Amp; do not claim first-class Summer setup support for those until a real config target exists.
 

docs/SKILLS.md

@@ -42,7 +42,7 @@ summer skills install --all --agent claude-code        # All public skills
 summer skills install --recommended --agent cursor --scope project   # Per-project
 ```
 
-Supported agents: `summer`, `codex`, `claude-code`, `cursor`, `windsurf`, `cline`, `roo-code`, `gemini`, `github-copilot`, `vscode-copilot`, `opencode`. Supported scopes: `user`, `project`.
+Supported agents: `summer`, `codex`, `claude-code`, `cursor`, `windsurf`, `cline`, `roo-code`, `kilo-code`, `gemini`, `github-copilot`, `vscode-copilot`, `opencode`, `bionic`. Supported scopes: `user`, `project`.
 
 ## Recommended set
 

package.json

@@ -1,7 +1,7 @@
 {
   "name": "summer-engine",
   "version": "2.8.1",
-  "description": "Local Summer CLI and MCP server for Summer Engine. Install and run the engine, connect Claude Code, Cursor, Codex, Gemini, and other agents, and build real games with bundled skills, hooks, and plugins.",
+  "description": "Local Summer CLI and MCP server for Summer Engine. Install and run the engine, connect Claude Code, Cursor, Codex, Bionic, Gemini, and other agents, and build real games with bundled skills, hooks, and plugins.",
   "keywords": [
     "summer-engine",
     "summer-cli",
@@ -17,6 +17,8 @@
     "claude-code",
     "cursor",
     "codex",
+    "bionic",
+    "lm-studio",
     "gamedev",
     "game-development",
     "3d",